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, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3440 createSMESHAction( 112, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_U) );
3441 createSMESHAction( 113, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3442 createSMESHAction( 114, "NUM" );
3443 createSMESHAction( 115, "IMPORT_STL" );
3444 createSMESHAction( 116, "IMPORT_CGNS" );
3445 createSMESHAction( 117, "IMPORT_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, "HIDE" );
3600 createSMESHAction( 301, "SHOW" );
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 createPopupItem( 813, OB, group ); // DEL_GROUP with contents
3966 popupMgr()->insert( separator(), -1, 0 );
3969 createPopupItem( 803, View, group ); // EDIT_GROUP
3970 createPopupItem( 804, View, elems ); // ADD
3971 createPopupItem( 805, View, elems ); // REMOVE
3973 popupMgr()->insert( separator(), -1, 0 );
3974 createPopupItem( 214, View, mesh_part ); // UPDATE
3975 createPopupItem( 900, View, mesh_part ); // ADV_INFO
3976 createPopupItem( 904, View, mesh ); // FIND_ELEM
3977 popupMgr()->insert( separator(), -1, 0 );
3979 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3980 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
3981 popupMgr()->insert( separator(), -1, 0 );
3984 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3985 QString aType = QString( "%1type in {%2}" ).arg( lc );
3986 aType = aType.arg( mesh_part );
3987 QString aMeshInVTK = aClient + "&&" + aType;
3989 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3990 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3991 QString aSelCount = QString( "%1 > 0" ).arg( dc );
3993 //-------------------------------------------------
3995 //-------------------------------------------------
3996 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3998 popupMgr()->insert( action( 9010 ), anId, -1 );
3999 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4000 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4002 popupMgr()->insert( action( 9011 ), anId, -1 );
4003 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4004 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4006 popupMgr()->insert( separator(), -1, -1 );
4008 //-------------------------------------------------
4010 //-------------------------------------------------
4011 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4013 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4014 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4015 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4017 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4018 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4019 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4021 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4022 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4023 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4025 popupMgr()->insert( separator(), anId, -1 );
4027 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4028 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4029 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4031 //-------------------------------------------------
4033 //-------------------------------------------------
4034 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4036 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4038 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4039 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4040 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4042 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4043 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4044 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4046 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4047 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4048 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4050 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4051 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4052 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4054 popupMgr()->insert( separator(), anId, -1 );
4056 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4057 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4060 //-------------------------------------------------
4061 // Representation of the 2D Quadratic elements
4062 //-------------------------------------------------
4063 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4064 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4065 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4066 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4068 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4069 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4070 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4072 //-------------------------------------------------
4073 // Orientation of faces
4074 //-------------------------------------------------
4075 popupMgr()->insert( action( 221 ), -1, -1 );
4076 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4077 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4079 //-------------------------------------------------
4081 //-------------------------------------------------
4082 popupMgr()->insert( action( 1132 ), -1, -1 );
4083 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4085 //-------------------------------------------------
4087 //-------------------------------------------------
4088 popupMgr()->insert( action( 1133 ), -1, -1 );
4089 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4091 //-------------------------------------------------
4093 //-------------------------------------------------
4095 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4096 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4097 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4098 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4100 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4102 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4103 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4105 popupMgr()->insert( separator(), anId, -1 );
4107 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4109 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4110 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4111 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4113 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4114 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4115 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4117 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4119 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4120 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4121 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4123 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4124 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4125 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4127 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4128 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4129 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4131 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4132 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4133 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4134 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4135 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4136 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4138 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4140 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4141 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4142 QtxPopupMgr::VisibleRule );
4143 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4145 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4146 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4147 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4149 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4150 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4151 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4153 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4154 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4155 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4157 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4158 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4159 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4161 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4162 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4163 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4165 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4166 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4167 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4169 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4170 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4171 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4173 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4174 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4175 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4177 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4178 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4179 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4181 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4182 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4183 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4185 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4186 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4187 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4188 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4189 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4190 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4192 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4194 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4195 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4196 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4198 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4199 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4200 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4202 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4203 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4204 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4206 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4207 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4208 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4210 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4211 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4212 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4214 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4215 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4216 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4218 popupMgr()->insert( separator(), anId, -1 );
4220 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4221 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4223 popupMgr()->insert( separator(), anId, -1 );
4225 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4227 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4228 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4230 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4231 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4232 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4234 #ifndef DISABLE_PLOT2DVIEWER
4235 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4236 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4239 //-------------------------------------------------
4241 //-------------------------------------------------
4242 popupMgr()->insert( separator(), -1, -1 );
4243 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4244 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4245 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4246 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4248 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4249 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4251 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4252 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4254 popupMgr()->insert( separator(), -1, -1 );
4256 //-------------------------------------------------
4258 //-------------------------------------------------
4259 popupMgr()->insert( action( 1134 ), -1, -1 );
4260 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4262 popupMgr()->insert( separator(), -1, -1 );
4264 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4265 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4267 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4268 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4271 //================================================================================
4273 * \brief Return true if SMESH or GEOM objects are selected.
4274 * Is called form LightApp_Module::activateModule() which clear selection if
4275 * not isSelectionCompatible()
4277 //================================================================================
4279 bool SMESHGUI::isSelectionCompatible()
4281 bool isCompatible = true;
4282 SALOME_ListIO selected;
4283 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4284 Sel->selectedObjects( selected );
4286 SALOME_ListIteratorOfListIO It( selected );
4287 for ( ; isCompatible && It.More(); It.Next())
4289 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4290 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4292 return isCompatible;
4296 bool SMESHGUI::reusableOperation( const int id )
4298 // compute, evaluate and precompute are not reusable operations
4299 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4302 bool SMESHGUI::activateModule( SUIT_Study* study )
4304 bool res = SalomeApp_Module::activateModule( study );
4306 setMenuShown( true );
4307 setToolShown( true );
4309 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4310 PyGILState_STATE gstate = PyGILState_Ensure();
4311 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4312 if(pluginsmanager==NULL)
4316 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4321 PyGILState_Release(gstate);
4322 // end of GEOM plugins loading
4324 // Reset actions accelerator keys
4325 action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4326 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4327 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4329 action( 33)->setEnabled(true); // Delete: Key_Delete
4331 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4332 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4333 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4334 if ( _PTR(Study) aStudy = s->studyDS()) {
4335 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4336 updateObjBrowser(); // objects can be removed
4339 // get all view currently opened in the study and connect their signals to
4340 // the corresponding slots of the class.
4341 SUIT_Desktop* aDesk = study->application()->desktop();
4343 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4344 SUIT_ViewWindow* wnd;
4345 foreach ( wnd, wndList )
4352 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4354 setMenuShown( false );
4355 setToolShown( false );
4357 EmitSignalCloseAllDialogs();
4359 // Unset actions accelerator keys
4360 action(111)->setShortcut(QKeySequence()); // Import DAT
4361 action(112)->setShortcut(QKeySequence()); // Import UNV
4362 action(113)->setShortcut(QKeySequence()); // Import MED
4364 action( 33)->setEnabled(false); // Delete: Key_Delete
4366 return SalomeApp_Module::deactivateModule( study );
4369 void SMESHGUI::studyClosed( SUIT_Study* s )
4371 SMESH::RemoveVisuData( s->id() );
4372 SalomeApp_Module::studyClosed( s );
4375 void SMESHGUI::OnGUIEvent()
4377 const QObject* obj = sender();
4378 if ( !obj || !obj->inherits( "QAction" ) )
4380 int id = actionId((QAction*)obj);
4385 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4387 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4388 if ( CORBA::is_nil( myComponentSMESH ) )
4390 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4392 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4393 return aGUI.myComponentSMESH;
4396 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4397 return myComponentSMESH;
4400 QString SMESHGUI::engineIOR() const
4402 CORBA::ORB_var anORB = getApp()->orb();
4403 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4404 return QString( anIOR.in() );
4407 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4409 SalomeApp_Module::contextMenuPopup( client, menu, title );
4411 selectionMgr()->selectedObjects( lst );
4412 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4413 Handle(SALOME_InteractiveObject) io = lst.First();
4414 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4415 _PTR(Study) study = appStudy->studyDS();
4416 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4418 QString aName = QString( obj->GetName().c_str() );
4419 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4420 aName.remove( (aName.length() - 1), 1 );
4426 LightApp_Selection* SMESHGUI::createSelection() const
4428 return new SMESHGUI_Selection();
4431 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4433 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4434 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4437 void SMESHGUI::viewManagers( QStringList& list ) const
4439 list.append( SVTK_Viewer::Type() );
4442 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4444 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4445 SMESH::UpdateSelectionProp( this );
4447 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4448 for(int i = 0; i < aViews.count() ; i++){
4449 SUIT_ViewWindow *sf = aViews[i];
4455 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4457 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4458 myClippingPlaneInfoMap.erase( theViewManager );
4461 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4463 theActor->AddObserver( SMESH::DeleteActorEvent,
4464 myEventCallbackCommand.GetPointer(),
4468 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4469 unsigned long theEvent,
4470 void* theClientData,
4473 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4474 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4475 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4476 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4477 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4478 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4479 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4480 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4481 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4482 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4483 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4484 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4485 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4486 if( anActor == *anIter3 ) {
4487 anActorList.erase( anIter3 );
4498 void SMESHGUI::createPreferences()
4500 // General tab ------------------------------------------------------------------------
4501 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4503 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4504 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4505 setPreferenceProperty( lim, "min", 0 );
4506 setPreferenceProperty( lim, "max", 100000000 );
4507 setPreferenceProperty( lim, "step", 1000 );
4508 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4510 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4511 setPreferenceProperty( qaGroup, "columns", 2 );
4512 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4513 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4514 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4515 setPreferenceProperty( prec, "min", 0 );
4516 setPreferenceProperty( prec, "max", 16 );
4517 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4518 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4519 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4520 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4521 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4523 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4524 setPreferenceProperty( dispgroup, "columns", 2 );
4525 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4527 modes.append( tr("MEN_WIRE") );
4528 modes.append( tr("MEN_SHADE") );
4529 modes.append( tr("MEN_NODES") );
4530 modes.append( tr("MEN_SHRINK") );
4531 QList<QVariant> indices;
4532 indices.append( 0 );
4533 indices.append( 1 );
4534 indices.append( 2 );
4535 indices.append( 3 );
4536 setPreferenceProperty( dispmode, "strings", modes );
4537 setPreferenceProperty( dispmode, "indexes", indices );
4539 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4540 setPreferenceProperty( arcgroup, "columns", 2 );
4541 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4542 QStringList quadraticModes;
4543 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4544 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4546 indices.append( 0 );
4547 indices.append( 1 );
4548 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4549 setPreferenceProperty( quadraticmode, "indexes", indices );
4551 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4552 "SMESH", "max_angle" );
4553 setPreferenceProperty( maxAngle, "min", 1 );
4554 setPreferenceProperty( maxAngle, "max", 90 );
4558 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4559 setPreferenceProperty( exportgroup, "columns", 2 );
4560 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4561 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4563 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4564 setPreferenceProperty( computeGroup, "columns", 2 );
4565 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4567 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4568 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4569 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4571 indices.append( 0 );
4572 indices.append( 1 );
4573 indices.append( 2 );
4574 setPreferenceProperty( notifyMode, "strings", modes );
4575 setPreferenceProperty( notifyMode, "indexes", indices );
4577 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4578 setPreferenceProperty( infoGroup, "columns", 4 );
4579 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4581 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4582 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4584 indices.append( 0 );
4585 indices.append( 1 );
4586 setPreferenceProperty( elemInfo, "strings", modes );
4587 setPreferenceProperty( elemInfo, "indexes", indices );
4588 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4589 setPreferenceProperty( nodesLim, "min", 0 );
4590 setPreferenceProperty( nodesLim, "max", 10000000 );
4591 setPreferenceProperty( nodesLim, "step", 10000 );
4592 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4594 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4595 setPreferenceProperty( segGroup, "columns", 2 );
4596 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4597 "SMESH", "segmentation" );
4598 setPreferenceProperty( segLen, "min", 1 );
4599 setPreferenceProperty( segLen, "max", 10000000 );
4600 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4601 "SMESH", "nb_segments_per_edge" );
4602 setPreferenceProperty( nbSeg, "min", 1 );
4603 setPreferenceProperty( nbSeg, "max", 10000000 );
4605 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4606 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4607 "SMESH", "forget_mesh_on_hyp_modif" );
4610 // Quantities with individual precision settings
4611 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4612 setPreferenceProperty( precGroup, "columns", 2 );
4614 const int nbQuantities = 6;
4615 int precs[nbQuantities], ii = 0;
4616 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4617 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4618 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4619 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4620 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4621 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4622 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4623 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4624 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4625 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4626 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4627 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4629 // Set property for precision value for spinboxes
4630 for ( ii = 0; ii < nbQuantities; ii++ ){
4631 setPreferenceProperty( precs[ii], "min", -14 );
4632 setPreferenceProperty( precs[ii], "max", 14 );
4633 setPreferenceProperty( precs[ii], "precision", 2 );
4636 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4637 setPreferenceProperty( previewGroup, "columns", 2 );
4638 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4639 setPreferenceProperty( chunkSize, "min", 0 );
4640 setPreferenceProperty( chunkSize, "max", 1000 );
4641 setPreferenceProperty( chunkSize, "step", 50 );
4643 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4644 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4646 // Mesh tab ------------------------------------------------------------------------
4647 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4648 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4649 setPreferenceProperty( nodeGroup, "columns", 3 );
4651 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4653 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4655 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4656 QList<QVariant> aMarkerTypeIndicesList;
4657 QList<QVariant> aMarkerTypeIconsList;
4658 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4659 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4660 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4661 aMarkerTypeIndicesList << i;
4662 aMarkerTypeIconsList << pixmap;
4664 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4665 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4667 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4669 QList<QVariant> aMarkerScaleIndicesList;
4670 QStringList aMarkerScaleValuesList;
4671 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4672 aMarkerScaleIndicesList << i;
4673 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4675 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4676 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4678 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4679 setPreferenceProperty( elemGroup, "columns", 2 );
4681 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4682 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4684 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4685 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4687 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4689 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4690 setPreferenceProperty( grpGroup, "columns", 2 );
4692 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4694 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4695 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4696 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4697 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4698 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4699 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4701 setPreferenceProperty( size0d, "min", 1 );
4702 setPreferenceProperty( size0d, "max", 10 );
4704 setPreferenceProperty( elemW, "min", 1 );
4705 setPreferenceProperty( elemW, "max", 5 );
4707 setPreferenceProperty( shrink, "min", 0 );
4708 setPreferenceProperty( shrink, "max", 100 );
4710 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4711 setPreferenceProperty( orientGroup, "columns", 1 );
4713 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4714 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4716 setPreferenceProperty( orientScale, "min", 0.05 );
4717 setPreferenceProperty( orientScale, "max", 0.5 );
4718 setPreferenceProperty( orientScale, "step", 0.05 );
4720 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4722 // Selection tab ------------------------------------------------------------------------
4723 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4725 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4726 setPreferenceProperty( selGroup, "columns", 2 );
4728 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4729 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4731 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4732 setPreferenceProperty( preGroup, "columns", 2 );
4734 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4736 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4737 setPreferenceProperty( precSelGroup, "columns", 2 );
4739 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4740 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4741 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4743 // Scalar Bar tab ------------------------------------------------------------------------
4744 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4745 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4746 setPreferenceProperty( fontGr, "columns", 2 );
4748 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4749 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4751 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4752 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4754 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4755 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4757 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4758 setPreferenceProperty( numcol, "min", 2 );
4759 setPreferenceProperty( numcol, "max", 256 );
4761 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4762 setPreferenceProperty( numlab, "min", 2 );
4763 setPreferenceProperty( numlab, "max", 65 );
4765 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4766 setPreferenceProperty( orientGr, "columns", 2 );
4767 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4768 QStringList orients;
4769 orients.append( tr( "SMESH_VERTICAL" ) );
4770 orients.append( tr( "SMESH_HORIZONTAL" ) );
4771 indices.clear(); indices.append( 0 ); indices.append( 1 );
4772 setPreferenceProperty( orient, "strings", orients );
4773 setPreferenceProperty( orient, "indexes", indices );
4775 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4776 setPreferenceProperty( posVSizeGr, "columns", 2 );
4777 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4778 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4779 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4780 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4781 setPreferenceProperty( xv, "step", 0.1 );
4782 setPreferenceProperty( xv, "min", 0.0 );
4783 setPreferenceProperty( xv, "max", 1.0 );
4784 setPreferenceProperty( yv, "step", 0.1 );
4785 setPreferenceProperty( yv, "min", 0.0 );
4786 setPreferenceProperty( yv, "max", 1.0 );
4787 setPreferenceProperty( wv, "step", 0.1 );
4788 setPreferenceProperty( wv, "min", 0.0 );
4789 setPreferenceProperty( wv, "max", 1.0 );
4790 setPreferenceProperty( hv, "min", 0.0 );
4791 setPreferenceProperty( hv, "max", 1.0 );
4792 setPreferenceProperty( hv, "step", 0.1 );
4794 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4795 setPreferenceProperty( posHSizeGr, "columns", 2 );
4796 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4797 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4798 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4799 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4800 setPreferenceProperty( xv, "min", 0.0 );
4801 setPreferenceProperty( xv, "max", 1.0 );
4802 setPreferenceProperty( xv, "step", 0.1 );
4803 setPreferenceProperty( xh, "min", 0.0 );
4804 setPreferenceProperty( xh, "max", 1.0 );
4805 setPreferenceProperty( xh, "step", 0.1 );
4806 setPreferenceProperty( yh, "min", 0.0 );
4807 setPreferenceProperty( yh, "max", 1.0 );
4808 setPreferenceProperty( yh, "step", 0.1 );
4809 setPreferenceProperty( wh, "min", 0.0 );
4810 setPreferenceProperty( wh, "max", 1.0 );
4811 setPreferenceProperty( wh, "step", 0.1 );
4812 setPreferenceProperty( hh, "min", 0.0 );
4813 setPreferenceProperty( hh, "max", 1.0 );
4814 setPreferenceProperty( hh, "step", 0.1 );
4816 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4817 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4818 setPreferenceProperty( distributionGr, "columns", 3 );
4820 types.append( tr( "SMESH_MONOCOLOR" ) );
4821 types.append( tr( "SMESH_MULTICOLOR" ) );
4822 indices.clear(); indices.append( 0 ); indices.append( 1 );
4823 setPreferenceProperty( coloringType, "strings", types );
4824 setPreferenceProperty( coloringType, "indexes", indices );
4825 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4829 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4831 if( sect=="SMESH" ) {
4832 float sbX1,sbY1,sbW,sbH;
4833 float aTol = 1.00000009999999;
4834 std::string aWarning;
4835 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4836 if( name=="selection_object_color" || name=="selection_element_color" ||
4837 name=="highlight_color" ||
4838 name=="selection_precision_node" || name=="selection_precision_element" ||
4839 name=="selection_precision_object")
4840 SMESH::UpdateSelectionProp( this );
4841 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4842 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4843 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4844 if(sbX1+sbW > aTol){
4845 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4848 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4849 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4852 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4853 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4854 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4855 if(sbY1+sbH > aTol){
4856 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4857 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4858 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4861 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4862 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4863 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4864 if(sbX1+sbW > aTol){
4865 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4868 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4869 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4872 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4873 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4874 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4875 if(sbY1+sbH > aTol){
4876 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4879 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4880 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4883 else if ( name == "segmentation" ) {
4884 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4885 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4887 else if ( name == "nb_segments_per_edge" ) {
4888 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4889 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4891 else if ( name == "historical_python_dump" ||
4892 name == "forget_mesh_on_hyp_modif") {
4893 QString val = aResourceMgr->stringValue( "SMESH", name );
4894 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
4897 if(aWarning.size() != 0){
4898 aWarning += "The default values are applied instead.";
4899 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4900 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4901 QObject::tr(aWarning.c_str()));
4906 //================================================================================
4908 * \brief Update something in accordance with update flags
4909 * \param theFlags - update flags
4911 * Update viewer or/and object browser etc. in accordance with update flags ( see
4912 * LightApp_UpdateFlags enumeration ).
4914 //================================================================================
4915 void SMESHGUI::update( const int flags )
4917 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4918 SMESH::UpdateView();
4920 SalomeApp_Module::update( flags );
4923 //================================================================================
4925 * \brief Set default selection mode
4927 * SLOT called when operation commited. Sets default selection mode
4929 //================================================================================
4930 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4932 SVTK_ViewWindow* vtkWnd =
4933 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4935 vtkWnd->SetSelectionMode( ActorSelection );
4938 //================================================================================
4940 * \brief Set default selection mode
4942 * SLOT called when operation aborted. Sets default selection mode
4944 //================================================================================
4945 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4947 SVTK_ViewWindow* vtkWnd =
4948 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4950 vtkWnd->SetSelectionMode( ActorSelection );
4953 //================================================================================
4955 * \brief Creates operation with given identifier
4956 * \param id - identifier of operation to be started
4957 * \return Pointer on created operation or NULL if operation is not created
4959 * Virtual method redefined from the base class creates operation with given id.
4960 * It is called called automatically from startOperation method of base class.
4962 //================================================================================
4963 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4965 LightApp_Operation* op = 0;
4966 // to do : create operation here
4969 case 417: //convert to quadratic
4970 op = new SMESHGUI_ConvToQuadOp();
4972 case 418: // create 2D mesh as boundary on 3D
4973 op = new SMESHGUI_Make2DFrom3DOp();
4975 case 701: // Compute mesh
4976 op = new SMESHGUI_ComputeOp();
4978 case 702: // Create mesh
4979 op = new SMESHGUI_MeshOp( true, true );
4981 case 703: // Create sub-mesh
4982 op = new SMESHGUI_MeshOp( true, false );
4984 case 704: // Edit mesh/sub-mesh
4985 op = new SMESHGUI_MeshOp( false );
4987 case 711: // Precompute mesh
4988 op = new SMESHGUI_PrecomputeOp();
4990 case 712: // Evaluate mesh
4991 op = new SMESHGUI_EvaluateOp();
4993 case 713: // Evaluate mesh
4994 op = new SMESHGUI_MeshOrderOp();
4996 case 806: // Create group on geom
4997 op = new SMESHGUI_GroupOnShapeOp();
4999 case 904: // Find element
5000 op = new SMESHGUI_FindElemByPointOp();
5002 case 4067: // make mesh pass through point
5003 op = new SMESHGUI_MakeNodeAtPointOp();
5010 op = SalomeApp_Module::createOperation( id );
5014 //================================================================================
5016 * \brief Stops current operations and starts a given one
5017 * \param id - The id of the operation to start
5019 //================================================================================
5021 void SMESHGUI::switchToOperation(int id)
5023 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5024 activeStudy()->abortAllOperations();
5025 startOperation( id );
5028 LightApp_Displayer* SMESHGUI::displayer()
5031 myDisplayer = new SMESHGUI_Displayer( getApp() );
5035 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5038 int aTolerance = 64;
5039 int anIterations = 0;
5045 if( anIterations % aPeriod == 0 )
5048 if( aTolerance < 1 )
5052 aHue = (int)( 360.0 * rand() / RAND_MAX );
5055 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5056 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5057 for( ; it != itEnd; ++it )
5059 SALOMEDS::Color anAutoColor = *it;
5060 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5063 aQColor.getHsv( &h, &s, &v );
5064 if( abs( h - aHue ) < aTolerance )
5076 aColor.setHsv( aHue, 255, 255 );
5078 SALOMEDS::Color aSColor;
5079 aSColor.R = (double)aColor.red() / 255.0;
5080 aSColor.G = (double)aColor.green() / 255.0;
5081 aSColor.B = (double)aColor.blue() / 255.0;
5086 const char gSeparator = '_'; // character used to separate parameter names
5087 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5088 const char gPathSep = '|'; // character used to separate paths
5091 * \brief Store visual parameters
5093 * This method is called just before the study document is saved.
5094 * Store visual parameters in AttributeParameter attribue(s)
5096 void SMESHGUI::storeVisualParameters (int savePoint)
5098 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5099 if (!appStudy || !appStudy->studyDS())
5101 _PTR(Study) studyDS = appStudy->studyDS();
5103 // componentName is used for encoding of entries when storing them in IParameters
5104 std::string componentName = myComponentSMESH->ComponentDataType();
5105 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5106 //if (!aSComponent) return;
5109 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5110 componentName.c_str(),
5112 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5114 // store map of custom markers
5115 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5116 if( !aMarkerMap.empty() )
5118 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5119 for( ; anIter != aMarkerMap.end(); anIter++ )
5121 int anId = anIter->first;
5122 VTK::MarkerData aMarkerData = anIter->second;
5123 std::string aMarkerFileName = aMarkerData.first;
5124 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5125 if( aMarkerTexture.size() < 3 )
5126 continue; // should contain at least width, height and the first value
5128 QString aPropertyName( "texture" );
5129 aPropertyName += gSeparator;
5130 aPropertyName += QString::number( anId );
5132 QString aPropertyValue = aMarkerFileName.c_str();
5133 aPropertyValue += gPathSep;
5135 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5136 ushort aWidth = *aTextureIter++;
5137 ushort aHeight = *aTextureIter++;
5138 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5139 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5140 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5141 aPropertyValue += QString::number( *aTextureIter );
5143 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5147 // viewers counters are used for storing view_numbers in IParameters
5150 // main cycle to store parameters of displayed objects
5151 QList<SUIT_ViewManager*> lst;
5152 QList<SUIT_ViewManager*>::Iterator it;
5153 getApp()->viewManagers(lst);
5154 for (it = lst.begin(); it != lst.end(); it++)
5156 SUIT_ViewManager* vman = *it;
5157 QString vType = vman->getType();
5159 // saving VTK actors properties
5160 if (vType == SVTK_Viewer::Type())
5162 // store the clipping planes attached to the view manager
5163 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5164 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5165 if( anIter != myClippingPlaneInfoMap.end() )
5166 aClippingPlaneInfoList = anIter->second;
5168 if( !aClippingPlaneInfoList.empty() ) {
5169 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5170 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5172 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5173 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5175 QString aPropertyName( "ClippingPlane" );
5176 aPropertyName += gSeparator;
5177 aPropertyName += QString::number( vtkViewers );
5178 aPropertyName += gSeparator;
5179 aPropertyName += QString::number( anId );
5181 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5182 aPropertyValue += gDigitsSep;
5183 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5184 aPropertyValue += gDigitsSep;
5185 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5186 aPropertyValue += gDigitsSep;
5187 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5189 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5193 QVector<SUIT_ViewWindow*> views = vman->getViews();
5194 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5196 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5198 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5199 vtkActorCollection* allActors = aCopy.GetActors();
5200 allActors->InitTraversal();
5201 while (vtkActor* actor = allActors->GetNextActor())
5203 if (actor->GetVisibility()) // store only visible actors
5205 SMESH_Actor* aSmeshActor = 0;
5206 if (actor->IsA("SMESH_Actor"))
5207 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5208 if (aSmeshActor && aSmeshActor->hasIO())
5210 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5213 // entry is "encoded" = it does NOT contain component adress,
5214 // since it is a subject to change on next component loading
5215 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5217 std::string param, vtkParam = vType.toLatin1().data();
5218 vtkParam += gSeparator;
5219 vtkParam += QString::number(vtkViewers).toLatin1().data();
5220 vtkParam += gSeparator;
5223 param = vtkParam + "Visibility";
5224 ip->setParameter(entry, param, "On");
5227 param = vtkParam + "Representation";
5228 ip->setParameter(entry, param, QString::number
5229 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5232 param = vtkParam + "IsShrunk";
5233 ip->setParameter(entry, param, QString::number
5234 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5236 // Displayed entities
5237 unsigned int aMode = aSmeshActor->GetEntityMode();
5238 bool isE = aMode & SMESH_Actor::eEdges;
5239 bool isF = aMode & SMESH_Actor::eFaces;
5240 bool isV = aMode & SMESH_Actor::eVolumes;
5242 QString modeStr ("e");
5243 modeStr += gDigitsSep; modeStr += QString::number(isE);
5244 modeStr += gDigitsSep; modeStr += "f";
5245 modeStr += gDigitsSep; modeStr += QString::number(isF);
5246 modeStr += gDigitsSep; modeStr += "v";
5247 modeStr += gDigitsSep; modeStr += QString::number(isV);
5249 param = vtkParam + "Entities";
5250 ip->setParameter(entry, param, modeStr.toLatin1().data());
5252 // Colors (surface:edge:)
5253 vtkFloatingPointType r, g, b;
5256 aSmeshActor->GetSufaceColor(r, g, b, delta);
5257 QString colorStr ("surface");
5258 colorStr += gDigitsSep; colorStr += QString::number(r);
5259 colorStr += gDigitsSep; colorStr += QString::number(g);
5260 colorStr += gDigitsSep; colorStr += QString::number(b);
5262 colorStr += gDigitsSep; colorStr += "backsurface";
5263 colorStr += gDigitsSep; colorStr += QString::number(delta);
5266 aSmeshActor->GetEdgeColor(r, g, b);
5267 colorStr += gDigitsSep; colorStr += "edge";
5268 colorStr += gDigitsSep; colorStr += QString::number(r);
5269 colorStr += gDigitsSep; colorStr += QString::number(g);
5270 colorStr += gDigitsSep; colorStr += QString::number(b);
5272 aSmeshActor->GetNodeColor(r, g, b);
5273 colorStr += gDigitsSep; colorStr += "node";
5274 colorStr += gDigitsSep; colorStr += QString::number(r);
5275 colorStr += gDigitsSep; colorStr += QString::number(g);
5276 colorStr += gDigitsSep; colorStr += QString::number(b);
5278 aSmeshActor->GetOutlineColor(r, g, b);
5279 colorStr += gDigitsSep; colorStr += "outline";
5280 colorStr += gDigitsSep; colorStr += QString::number(r);
5281 colorStr += gDigitsSep; colorStr += QString::number(g);
5282 colorStr += gDigitsSep; colorStr += QString::number(b);
5284 param = vtkParam + "Colors";
5285 ip->setParameter(entry, param, colorStr.toLatin1().data());
5287 // Sizes of lines and points
5288 QString sizeStr ("line");
5289 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5290 sizeStr += gDigitsSep; sizeStr += "shrink";
5291 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5293 param = vtkParam + "Sizes";
5294 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5299 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5300 if( aMarkerType == VTK::MT_USER ) {
5301 markerStr += "custom";
5302 markerStr += gDigitsSep;
5303 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5307 markerStr += gDigitsSep;
5308 markerStr += QString::number( (int)aMarkerType );
5309 markerStr += gDigitsSep;
5310 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5313 param = vtkParam + "PointMarker";
5314 ip->setParameter(entry, param, markerStr.toLatin1().data());
5317 param = vtkParam + "Opacity";
5318 ip->setParameter(entry, param,
5319 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5322 param = vtkParam + "ClippingPlane";
5324 if( !aClippingPlaneInfoList.empty() ) {
5325 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5326 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5328 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5329 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5330 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5331 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5332 if( aSmeshActor == *anIter2 ) {
5333 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5334 QString::number( anId ).toLatin1().constData() );
5341 ip->setParameter( entry, param, "Off" );
5342 } // if (io->hasEntry())
5343 } // SMESH_Actor && hasIO
5345 } // while.. actors traversal
5349 } // if (SVTK view model)
5350 } // for (viewManagers)
5353 // data structures for clipping planes processing
5356 vtkIdType Orientation;
5357 vtkFloatingPointType Distance;
5358 vtkFloatingPointType Angle[2];
5360 typedef std::list<TPlaneData> TPlaneDataList;
5361 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5363 typedef std::list<vtkActor*> TActorList;
5366 TActorList ActorList;
5367 SUIT_ViewManager* ViewManager;
5369 typedef std::list<TPlaneInfo> TPlaneInfoList;
5370 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5373 * \brief Restore visual parameters
5375 * This method is called after the study document is opened.
5376 * Restore visual parameters from AttributeParameter attribue(s)
5378 void SMESHGUI::restoreVisualParameters (int savePoint)
5380 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5381 if (!appStudy || !appStudy->studyDS())
5383 _PTR(Study) studyDS = appStudy->studyDS();
5385 // componentName is used for encoding of entries when storing them in IParameters
5386 std::string componentName = myComponentSMESH->ComponentDataType();
5387 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5388 //if (!aSComponent) return;
5391 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5392 componentName.c_str(),
5394 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5396 // restore map of custom markers and map of clipping planes
5397 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5398 TPlaneDataMap aPlaneDataMap;
5400 std::vector<std::string> properties = ip->getProperties();
5401 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5403 std::string property = *propIt;
5404 QString aPropertyName( property.c_str() );
5405 QString aPropertyValue( ip->getProperty( property ).c_str() );
5407 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5408 if( aPropertyNameList.isEmpty() )
5411 QString aPropertyType = aPropertyNameList[0];
5412 if( aPropertyType == "texture" )
5414 if( aPropertyNameList.size() != 2 )
5418 int anId = aPropertyNameList[1].toInt( &ok );
5419 if( !ok || anId < 1 )
5422 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5423 if( aPropertyValueList.size() != 2 )
5426 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5427 QString aMarkerTextureString = aPropertyValueList[1];
5428 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5429 if( aMarkerTextureStringList.size() != 3 )
5433 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5438 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5442 VTK::MarkerTexture aMarkerTexture;
5443 aMarkerTexture.push_back( aWidth );
5444 aMarkerTexture.push_back( aHeight );
5446 QString aMarkerTextureData = aMarkerTextureStringList[2];
5447 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5449 QChar aChar = aMarkerTextureData.at( i );
5450 if( aChar.isDigit() )
5451 aMarkerTexture.push_back( aChar.digitValue() );
5454 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5456 else if( aPropertyType == "ClippingPlane" )
5458 if( aPropertyNameList.size() != 3 )
5462 int aViewId = aPropertyNameList[1].toInt( &ok );
5463 if( !ok || aViewId < 0 )
5467 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5468 if( !ok || aClippingPlaneId < 0 )
5471 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5472 if( aPropertyValueList.size() != 4 )
5475 TPlaneData aPlaneData;
5476 aPlaneData.Id = aClippingPlaneId;
5479 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5484 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5489 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5494 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5498 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5499 aPlaneDataList.push_back( aPlaneData );
5503 TPlaneInfoMap aPlaneInfoMap;
5505 std::vector<std::string> entries = ip->getEntries();
5507 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5509 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5510 QString entry (ip->decodeEntry(*entIt).c_str());
5512 // Check that the entry corresponds to a real object in the Study
5513 // as the object may be deleted or modified after the visual state is saved.
5514 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5515 if (!so) continue; //Skip the not existent entry
5517 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5518 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5520 std::vector<std::string>::iterator namesIt = paramNames.begin();
5521 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5523 // actors are stored in a map after displaying of them for
5524 // quicker access in the future: map < viewID to actor >
5525 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5527 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5529 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5530 // '_' is used as separator and should not be used in viewer type or parameter names.
5531 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5532 if (lst.size() != 3)
5535 QString viewerTypStr = lst[0];
5536 QString viewIndexStr = lst[1];
5537 QString paramNameStr = lst[2];
5540 int viewIndex = viewIndexStr.toUInt(&ok);
5541 if (!ok) // bad conversion of view index to integer
5545 if (viewerTypStr == SVTK_Viewer::Type())
5547 SMESH_Actor* aSmeshActor = 0;
5548 if (vtkActors.IsBound(viewIndex))
5549 aSmeshActor = vtkActors.Find(viewIndex);
5551 QList<SUIT_ViewManager*> lst;
5552 getApp()->viewManagers(viewerTypStr, lst);
5554 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5555 SUIT_ViewManager* vman = NULL;
5556 if (viewIndex >= 0 && viewIndex < lst.count())
5557 vman = lst.at(viewIndex);
5559 if (paramNameStr == "Visibility")
5561 if (!aSmeshActor && displayer() && vman)
5563 SUIT_ViewModel* vmodel = vman->getViewModel();
5564 // SVTK view model can be casted to SALOME_View
5565 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5567 // store displayed actor in a temporary map for quicker
5568 // access later when restoring other parameters
5569 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5570 vtkRenderer* Renderer = vtkView->getRenderer();
5571 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5572 vtkActorCollection* theActors = aCopy.GetActors();
5573 theActors->InitTraversal();
5574 bool isFound = false;
5575 vtkActor *ac = theActors->GetNextActor();
5576 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5577 if (ac->IsA("SMESH_Actor")) {
5578 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5579 if (aGeomAc->hasIO()) {
5580 Handle(SALOME_InteractiveObject) io =
5581 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5582 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5584 vtkActors.Bind(viewIndex, aGeomAc);
5590 } // if (paramNameStr == "Visibility")
5593 // the rest properties "work" with SMESH_Actor
5596 QString val ((*valuesIt).c_str());
5599 if (paramNameStr == "Representation") {
5600 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5603 else if (paramNameStr == "IsShrunk") {
5605 if (!aSmeshActor->IsShrunk())
5606 aSmeshActor->SetShrink();
5609 if (aSmeshActor->IsShrunk())
5610 aSmeshActor->UnShrink();
5613 // Displayed entities
5614 else if (paramNameStr == "Entities") {
5615 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5616 if (mode.count() == 6) {
5617 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5618 MESSAGE("Invalid order of data in Entities, must be: "
5619 "e:0/1:f:0/1:v:0/1");
5622 unsigned int aMode = aSmeshActor->GetEntityMode();
5623 unsigned int aNewMode =
5624 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5625 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5626 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5627 if (aNewMode != aMode)
5628 aSmeshActor->SetEntityMode(aNewMode);
5633 else if (paramNameStr == "Colors") {
5634 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5635 if (colors.count() == 16 || colors.count() == 18 ) {
5636 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5637 (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5638 (colors.count() == 18 && colors[14] != "outline")) {
5639 MESSAGE("Invalid order of data in Colors, must be: "
5640 "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");
5646 vtkFloatingPointType otr,otg,otb;
5647 //Old case backsurface color is independent
5648 if( colors.count() == 16 ) {
5650 SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5651 er = colors[9].toFloat();
5652 eg = colors[10].toFloat();
5653 eb = colors[11].toFloat();
5655 nr = colors[13].toFloat();
5656 ng = colors[14].toFloat();
5657 nb = colors[15].toFloat();
5658 SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5660 //New case backsurface color depends on surface color
5661 delta = colors[5].toInt();
5663 er = colors[7].toFloat();
5664 eg = colors[8].toFloat();
5665 eb = colors[9].toFloat();
5667 nr = colors[11].toFloat();
5668 ng = colors[12].toFloat();
5669 nb = colors[13].toFloat();
5671 otr = colors[15].toFloat();
5672 otg = colors[16].toFloat();
5673 otb = colors[17].toFloat();
5675 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5676 aSmeshActor->SetEdgeColor(er,eg,eb);
5677 aSmeshActor->SetNodeColor(nr,ng,nb);
5678 aSmeshActor->SetOutlineColor(otr,otg,otb);
5682 // Sizes of lines and points
5683 else if (paramNameStr == "Sizes") {
5684 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5685 if (sizes.count() == 4) {
5686 if (sizes[0] != "line" || sizes[2] != "shrink") {
5687 MESSAGE("Invalid order of data in Sizes, must be: "
5688 "line:int:shrink:float");
5691 aSmeshActor->SetLineWidth(sizes[1].toInt());
5692 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5695 else if (sizes.count() == 6) { // just to support old format
5696 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5697 MESSAGE("Invalid order of data in Sizes, must be: "
5698 "line:int:node:int:shrink:float");
5701 aSmeshActor->SetLineWidth(sizes[1].toInt());
5702 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5703 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5708 else if (paramNameStr == "PointMarker") {
5709 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5710 if( data.count() >= 2 ) {
5712 int aParam1 = data[1].toInt( &ok );
5714 if( data[0] == "std" && data.count() == 3 ) {
5715 int aParam2 = data[2].toInt( &ok );
5716 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5718 else if( data[0] == "custom" ) {
5719 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5720 if( markerIt != aMarkerMap.end() ) {
5721 VTK::MarkerData aMarkerData = markerIt->second;
5722 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5729 else if (paramNameStr == "Opacity") {
5730 aSmeshActor->SetOpacity(val.toFloat());
5733 else if (paramNameStr.startsWith("ClippingPlane")) {
5734 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5735 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5736 // new format - val looks like "Off" or "0" (plane id)
5737 // (note: in new format "Off" value is used only for consistency,
5738 // so it is processed together with values in old format)
5739 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5740 if( anIsOldFormat ) {
5741 if (paramNameStr == "ClippingPlane1" || val == "Off")
5742 aSmeshActor->RemoveAllClippingPlanes();
5744 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5745 double aDistance = vals[1].toFloat();
5746 vtkFloatingPointType anAngle[2];
5747 anAngle[0] = vals[2].toFloat();
5748 anAngle[1] = vals[3].toFloat();
5750 QList<SUIT_ViewManager*> lst;
5751 getApp()->viewManagers(viewerTypStr, lst);
5752 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5753 if (viewIndex >= 0 && viewIndex < lst.count()) {
5754 SUIT_ViewManager* vman = lst.at(viewIndex);
5755 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5757 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5759 SMESH::TActorList anActorList;
5760 anActorList.push_back( aSmeshActor );
5761 SMESH::OrientedPlane* aPlane =
5762 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5764 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5765 aClippingPlaneInfo.Plane = aPlane;
5766 aClippingPlaneInfo.ActorList = anActorList;
5767 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5774 int aPlaneId = val.toInt( &ok );
5775 if( ok && aPlaneId >= 0 ) {
5776 bool anIsDefinedPlane = false;
5777 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5778 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5779 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5780 TPlaneInfo& aPlaneInfo = *anIter;
5781 if( aPlaneInfo.PlaneId == aPlaneId ) {
5782 aPlaneInfo.ActorList.push_back( aSmeshActor );
5783 anIsDefinedPlane = true;
5787 if( !anIsDefinedPlane ) {
5788 TPlaneInfo aPlaneInfo;
5789 aPlaneInfo.PlaneId = aPlaneId;
5790 aPlaneInfo.ActorList.push_back( aSmeshActor );
5791 aPlaneInfo.ViewManager = vman;
5793 // to make the list sorted by plane id
5794 anIter = aPlaneInfoList.begin();
5795 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5796 const TPlaneInfo& aPlaneInfoRef = *anIter;
5797 if( aPlaneInfoRef.PlaneId > aPlaneId )
5800 aPlaneInfoList.insert( anIter, aPlaneInfo );
5805 } // if (aSmeshActor)
5806 } // other parameters than Visibility
5808 } // for names/parameters iterator
5809 } // for entries iterator
5811 // take into account planes with empty list of actors referred to them
5812 QList<SUIT_ViewManager*> aVMList;
5813 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5815 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5816 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5817 int aViewId = aPlaneDataIter->first;
5818 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5819 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5821 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5823 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5824 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5825 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5826 const TPlaneData& aPlaneData = *anIter2;
5827 int aPlaneId = aPlaneData.Id;
5829 bool anIsFound = false;
5830 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5831 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5832 const TPlaneInfo& aPlaneInfo = *anIter3;
5833 if( aPlaneInfo.PlaneId == aPlaneId ) {
5840 TPlaneInfo aPlaneInfo; // ActorList field is empty
5841 aPlaneInfo.PlaneId = aPlaneId;
5842 aPlaneInfo.ViewManager = aViewManager;
5844 // to make the list sorted by plane id
5845 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5846 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5847 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5848 if( aPlaneInfoRef.PlaneId > aPlaneId )
5851 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5857 // add clipping planes to actors according to the restored parameters
5858 // and update the clipping plane map
5859 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5860 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5861 int aViewId = anIter1->first;
5862 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5864 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5865 if( anIter2 == aPlaneDataMap.end() )
5867 const TPlaneDataList& aPlaneDataList = anIter2->second;
5869 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5870 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5871 const TPlaneInfo& aPlaneInfo = *anIter3;
5872 int aPlaneId = aPlaneInfo.PlaneId;
5873 const TActorList& anActorList = aPlaneInfo.ActorList;
5874 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5878 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5882 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5884 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5885 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5886 const TPlaneData& aPlaneData = *anIter4;
5887 if( aPlaneData.Id == aPlaneId ) {
5888 SMESH::OrientedPlane* aPlane =
5889 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5891 (SMESH::Orientation)aPlaneData.Orientation,
5892 aPlaneData.Distance,
5895 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5896 aClippingPlaneInfo.Plane = aPlane;
5897 aClippingPlaneInfo.ActorList = anActorList;
5898 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5906 // update all VTK views
5907 QList<SUIT_ViewManager*> lst;
5908 getApp()->viewManagers(lst);
5909 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5910 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5911 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5912 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5913 vtkView->getRenderer()->ResetCameraClippingRange();
5920 \brief Adds preferences for dfont of VTK viewer
5922 \param pIf group identifier
5923 \param param parameter
5924 \return identifier of preferences
5926 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5928 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5930 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5933 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5934 fam.append( tr( "SMESH_FONT_COURIER" ) );
5935 fam.append( tr( "SMESH_FONT_TIMES" ) );
5937 setPreferenceProperty( tfont, "fonts", fam );
5939 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5940 setPreferenceProperty( tfont, "features", f );
5946 \brief Actions after hypothesis edition
5947 Updates object browser after hypothesis edition
5949 void SMESHGUI::onHypothesisEdit( int result )
5952 SMESHGUI::Modified();
5953 updateObjBrowser( true );
5958 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5959 \param pview view being closed
5961 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5962 #ifndef DISABLE_PLOT2DVIEWER
5963 //Crear all Plot2d Viewers if need.
5964 SMESH::ClearPlot2Viewers(pview);
5968 void SMESHGUI::message( const QString& msg )
5971 QStringList data = msg.split("/");
5972 if ( data.count() > 0 ) {
5973 if ( data.first() == "mesh_loading" ) {
5975 QString entry = data.count() > 1 ? data[1] : QString();
5976 if ( entry.isEmpty() )
5979 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
5981 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
5984 name = obj->GetName().c_str();
5985 if ( name.isEmpty() )
5988 if ( data.last() == "stop" )
5989 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
5991 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
5992 QApplication::processEvents();
5998 \brief Connects or disconnects signals about activating and cloning view on the module slots
5999 \param pview view which is connected/disconnected
6001 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6005 SUIT_ViewManager* viewMgr = pview->getViewManager();
6007 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6008 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6010 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6011 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6016 \brief Return \c true if object can be renamed
6018 bool SMESHGUI::renameAllowed( const QString& entry) const {
6019 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6023 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6027 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6032 if(appStudy->isComponent(entry) || obj->isReference())
6035 // check type to prevent renaming of inappropriate objects
6036 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6037 if (aType == MESH || aType == GROUP ||
6038 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6039 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6040 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6041 aType == HYPOTHESIS || aType == ALGORITHM)
6048 Rename object by entry.
6049 \param entry entry of the object
6050 \param name new name of the object
6051 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6053 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6055 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6059 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6064 _PTR(Study) aStudy = appStudy->studyDS();
6069 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6071 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6076 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6077 _PTR(GenericAttribute) anAttr;
6078 _PTR(AttributeName) aName;
6080 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6082 // check type to prevent renaming of inappropriate objects
6083 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6084 if (aType == MESH || aType == GROUP ||
6085 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6086 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6087 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6088 aType == HYPOTHESIS || aType == ALGORITHM) {
6089 if ( !name.isEmpty() ) {
6090 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6092 // update name of group object and its actor
6093 Handle(SALOME_InteractiveObject) IObject =
6094 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6096 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6097 if( !aGroupObject->_is_nil() ) {
6098 aGroupObject->SetName( qPrintable(name) );
6099 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6100 anActor->setName( qPrintable(name) );