1 // Copyright (C) 2007-2011 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>
103 #include <LightApp_DataOwner.h>
104 #include <LightApp_Preferences.h>
105 #include <LightApp_SelectionMgr.h>
106 #include <LightApp_UpdateFlags.h>
107 #include <LightApp_NameDlg.h>
109 #include <SVTK_ViewWindow.h>
110 #include <SVTK_ViewModel.h>
111 #include <SVTK_ViewManager.h>
113 #include <VTKViewer_Algorithm.h>
115 #include <SUIT_MessageBox.h>
116 #include <SUIT_ResourceMgr.h>
117 #include <SUIT_FileDlg.h>
118 #include <SUIT_Desktop.h>
119 #include <SUIT_OverrideCursor.h>
120 #include <SUIT_Session.h>
122 #include <QtxPopupMgr.h>
123 #include <QtxFontEdit.h>
125 #include <SALOME_ListIO.hxx>
126 #include <SALOME_ListIteratorOfListIO.hxx>
128 #ifndef DISABLE_PLOT2DVIEWER
129 #include <SPlot2d_ViewModel.h>
130 #include <SPlot2d_Histogram.h>
134 #include <SALOMEconfig.h>
135 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
136 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
137 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
140 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
142 #include <QTextStream>
145 #include <boost/shared_ptr.hpp>
148 #include <vtkCamera.h>
149 #include <vtkRenderer.h>
150 #include <vtkPlane.h>
151 #include <vtkCallbackCommand.h>
152 #include <vtkLookupTable.h>
154 // SALOME KERNEL includes
155 #include <SALOMEDS_Study.hxx>
156 #include <SALOMEDSClient_StudyBuilder.hxx>
157 #include <SALOMEDSClient_SComponent.hxx>
158 #include <SALOMEDSClient_ClientFactory.hxx>
159 #include <SALOMEDSClient_IParameters.hxx>
162 #include <Standard_ErrorHandler.hxx>
163 #include <NCollection_DataMap.hxx>
165 //To disable automatic genericobj management, the following line should be commented.
166 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
167 #define WITHGENERICOBJ
171 //=============================================================
172 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
175 void ExportMeshToFile(int theCommandID);
177 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
179 void SetDisplayEntity(int theCommandID);
181 void Control( int theCommandID );
185 //=============================================================
186 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
190 std::string myExtension;
192 if ( theCommandID == 113 ) {
193 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
194 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
196 else if ( theCommandID == 112 ) {
197 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
199 else if ( theCommandID == 111 ) {
200 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
202 else if ( theCommandID == 115 ) {
203 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
205 else if ( theCommandID == 116 ) {
206 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
208 else if ( theCommandID == 117 ) {
209 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
210 filter.append( QObject::tr( "All files (*)" ) );
213 QString anInitialPath = "";
214 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
215 anInitialPath = QDir::currentPath();
217 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
220 QObject::tr( "SMESH_IMPORT_MESH" ) );
221 if ( filenames.count() > 0 ) {
222 SUIT_OverrideCursor wc;
223 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
226 QStringList anEntryList;
227 bool isEmpty = false;
228 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
229 QString filename = *it;
230 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
232 switch ( theCommandID ) {
235 // DAT format (currently unsupported)
236 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
237 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
243 aMeshes->length( 1 );
244 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
245 if ( aMeshes[0]->_is_nil() )
246 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
247 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
253 SMESH::DriverMED_ReadStatus res;
254 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
255 if ( res != SMESH::DRS_OK ) {
256 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
257 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
264 aMeshes->length( 1 );
265 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
266 if ( aMeshes[0]->_is_nil() ) {
267 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
268 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
275 SMESH::DriverMED_ReadStatus res;
276 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
277 if ( res != SMESH::DRS_OK ) {
278 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
279 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
286 SMESH::DriverMED_ReadStatus res;
287 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
288 if ( res != SMESH::DRS_OK ) {
289 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
290 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
296 catch ( const SALOME::SALOME_Exception& S_ex ) {
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
301 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
302 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
304 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
305 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
306 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
307 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
308 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
310 anEntryList.append( aMeshSO->GetID().c_str() );
312 #ifdef WITHGENERICOBJ
313 // obj has been published in study. Its refcount has been incremented.
314 // It is safe to decrement its refcount
315 // so that it will be destroyed when the entry in study will be removed
316 aMeshes[i]->UnRegister();
325 // update Object browser
326 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
328 // browse to the published meshes
329 if( LightApp_Application* anApp =
330 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
331 anApp->browseObjects( anEntryList );
333 // show Error message box if there were errors
334 if ( errors.count() > 0 ) {
335 SUIT_MessageBox::critical( SMESHGUI::desktop(),
336 QObject::tr( "SMESH_ERROR" ),
337 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
340 // show warning message box, if some imported mesh is empty
342 SUIT_MessageBox::warning( SMESHGUI::desktop(),
343 QObject::tr( "SMESH_WRN_WARNING" ),
344 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
349 //================================================================================
351 * \brief Export selected meshes or groups into a file
353 //================================================================================
355 void ExportMeshToFile( int theCommandID )
357 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
358 SALOME_ListIO selected;
360 aSel->selectedObjects( selected );
362 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
363 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
364 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
365 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
366 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
367 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
369 // actually, the following condition can't be met (added for insurance)
370 if( selected.Extent() == 0 ||
371 ( selected.Extent() > 1 && !isMED && !isSTL ))
374 // get mesh object from selection and check duplication of their names
375 bool hasDuplicatedMeshNames = false;
376 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
377 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
378 SALOME_ListIteratorOfListIO It( selected );
379 for( ; It.More(); It.Next() )
381 Handle(SALOME_InteractiveObject) anIObject = It.Value();
382 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
383 if ( aMeshItem->_is_nil() ) {
384 SUIT_MessageBox::warning( SMESHGUI::desktop(),
385 QObject::tr( "SMESH_WRN_WARNING" ),
386 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
390 QString aMeshName = anIObject->getName();
392 // check for name duplications
393 if ( !hasDuplicatedMeshNames )
394 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
395 if( aMeshName == (*aMeshIter).second ) {
396 hasDuplicatedMeshNames = true;
401 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
404 if( hasDuplicatedMeshNames && isMED ) {
405 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
406 QObject::tr("SMESH_WRN_WARNING"),
407 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
408 QObject::tr("SMESH_BUT_YES"),
409 QObject::tr("SMESH_BUT_NO"), 0, 1);
414 aMeshIter = aMeshList.begin();
415 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
416 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
417 QString aMeshName = (*aMeshIter).second;
419 if ( isMED || isCGNS || isSAUV )
421 // check for equal group names within each mesh
422 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
423 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
424 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
425 int aRet = SUIT_MessageBox::warning
426 (SMESHGUI::desktop(),
427 QObject::tr("SMESH_WRN_WARNING"),
428 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
429 QObject::tr("SMESH_BUT_YES"),
430 QObject::tr("SMESH_BUT_NO"), 0, 1);
438 // warn the user about presence of not supported elements
439 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
440 int nbNotSupported = ( nbElems[ SMESH::Entity_Pyramid ] +
441 nbElems[ SMESH::Entity_Quad_Pyramid ] +
442 nbElems[ SMESH::Entity_Hexagonal_Prism ] +
443 nbElems[ SMESH::Entity_Polygon ] +
444 nbElems[ SMESH::Entity_Polyhedra ] );
445 if ( nbNotSupported > 0 ) {
446 int aRet = SUIT_MessageBox::warning
447 (SMESHGUI::desktop(),
448 QObject::tr("SMESH_WRN_WARNING"),
449 QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
450 QObject::tr("SMESH_BUT_YES"),
451 QObject::tr("SMESH_BUT_NO"), 0, 1);
457 // Get parameters of export operation
460 SMESH::MED_VERSION aFormat;
461 // Init the parameters with the default values
462 bool aIsASCII_STL = true;
463 bool toCreateGroups = false;
464 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
466 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
467 bool toOverwrite = true;
469 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
470 QString anInitialPath = "";
471 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
472 anInitialPath = QDir::currentPath();
474 if ( isUNV || isDAT )
477 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
479 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
480 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
481 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
482 anInitialPath + QString("/") + aMeshName,
483 aFilter, aTitle, false);
485 else if ( isCGNS )// Export to CGNS
487 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
488 fd->setWindowTitle( aTitle );
489 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
490 if ( !anInitialPath.isEmpty() )
491 fd->setDirectory( anInitialPath );
492 fd->selectFile(aMeshName);
493 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
494 fd->setValidator( fv );
497 aFilename = fd->selectedFile();
498 toOverwrite = fv->isOverwrite();
502 else if ( isSTL ) // Export to STL
504 QMap<QString, int> aFilterMap;
505 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
506 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
509 QMap<QString, int>::const_iterator it = aFilterMap.begin();
510 for ( ; it != aFilterMap.end(); ++it )
511 filters.push_back( it.key() );
513 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
514 fd->setWindowTitle( aTitle );
515 fd->setNameFilters( filters );
516 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
517 if ( !anInitialPath.isEmpty() )
518 fd->setDirectory( anInitialPath );
519 fd->selectFile(aMeshName);
523 aFilename = fd->selectedFile();
524 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
529 else if ( isMED || isSAUV ) // Export to MED or SAUV
531 QMap<QString, SMESH::MED_VERSION> aFilterMap;
532 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
534 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
535 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
536 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
539 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
540 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
541 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
545 QString aDefaultFilter;
546 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
547 for ( ; it != aFilterMap.end(); ++it ) {
548 filters.push_back( it.key() );
549 if (it.value() == SMESH::MED_V2_2)
550 aDefaultFilter = it.key();
553 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
554 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
555 fd->setWindowTitle( aTitle );
556 fd->setNameFilters( filters );
557 fd->selectNameFilter(aDefaultFilter);
558 fd->SetChecked(toCreateGroups);
559 if ( !anInitialPath.isEmpty() )
560 fd->setDirectory( anInitialPath );
561 fd->selectFile(aMeshName);
563 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
564 fd->setValidator( fv );
569 aFilename = fd->selectedFile();
571 aFilename = QString::null;
574 aFormat = aFilterMap[fd->selectedNameFilter()];
575 toOverwrite = fv->isOverwrite();
577 if ( !aFilename.isEmpty() ) {
578 // med-2.1 does not support poly elements
579 if ( aFormat==SMESH::MED_V2_1 )
580 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
581 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
582 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
583 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
584 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
586 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
587 QObject::tr("SMESH_WRN_WARNING"),
588 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
589 QObject::tr("SMESH_BUT_YES"),
590 QObject::tr("SMESH_BUT_NO"), 0, 1);
598 // can't append to an existing using other format
599 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
600 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
601 if( !isVersionOk || aVersion != aFormat ) {
602 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
603 QObject::tr("SMESH_WRN_WARNING"),
604 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
605 QObject::tr("SMESH_BUT_YES"),
606 QObject::tr("SMESH_BUT_NO"), 0, 1);
613 QStringList aMeshNamesCollisionList;
614 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
615 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
616 QString anExistingMeshName( aMeshNames[ i ] );
617 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
618 QString anExportMeshName = (*aMeshIter).second;
619 if( anExportMeshName == anExistingMeshName ) {
620 aMeshNamesCollisionList.append( anExportMeshName );
625 if( !aMeshNamesCollisionList.isEmpty() ) {
626 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
627 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
628 QObject::tr("SMESH_WRN_WARNING"),
629 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
630 QObject::tr("SMESH_BUT_YES"),
631 QObject::tr("SMESH_BUT_NO"),
632 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
641 toCreateGroups = fd->IsChecked();
651 if ( !aFilename.isEmpty() ) {
652 // Check whether the file already exists and delete it if yes
653 QFile aFile( aFilename );
654 if ( aFile.exists() && toOverwrite )
656 SUIT_OverrideCursor wc;
659 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
660 // bool Renumber = false;
661 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
663 // Renumber= resMgr->booleanValue("SMESH","renumbering");
665 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
666 // aMeshEditor->RenumberNodes();
667 // aMeshEditor->RenumberElements();
668 // if ( SMESHGUI::automaticUpdate() )
669 // SMESH::UpdateView();
673 aMeshIter = aMeshList.begin();
674 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
676 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
677 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
678 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
679 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
680 aFormat, toOverwrite && aMeshIndex == 0 );
682 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
683 aFormat, toOverwrite && aMeshIndex == 0 );
688 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
690 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
691 if( !aMeshItem->_is_nil() )
692 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
697 if ( aMeshOrGroup->_is_equivalent( aMesh ))
698 aMesh->ExportDAT( aFilename.toLatin1().data() );
700 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
704 if ( aMeshOrGroup->_is_equivalent( aMesh ))
705 aMesh->ExportUNV( aFilename.toLatin1().data() );
707 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
711 if ( aMeshOrGroup->_is_equivalent( aMesh ))
712 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
714 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
718 aMeshIter = aMeshList.begin();
719 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
721 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
722 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
723 aMeshItem->ExportCGNS( aMeshOrGroup,
724 aFilename.toLatin1().data(),
725 toOverwrite && aMeshIndex == 0 );
729 catch (const SALOME::SALOME_Exception& S_ex){
731 SUIT_MessageBox::warning(SMESHGUI::desktop(),
732 QObject::tr("SMESH_WRN_WARNING"),
733 QObject::tr("SMESH_EXPORT_FAILED"));
739 inline void InverseEntityMode(unsigned int& theOutputMode,
740 unsigned int theMode)
742 bool anIsNotPresent = ~theOutputMode & theMode;
744 theOutputMode |= theMode;
746 theOutputMode &= ~theMode;
749 void SetDisplayEntity(int theCommandID){
750 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
751 SALOME_ListIO selected;
753 aSel->selectedObjects( selected );
755 if(selected.Extent() >= 1){
756 SALOME_ListIteratorOfListIO It( selected );
757 for( ; It.More(); It.Next()){
758 Handle(SALOME_InteractiveObject) IObject = It.Value();
759 if(IObject->hasEntry()){
760 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
761 unsigned int aMode = anActor->GetEntityMode();
762 switch(theCommandID){
764 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
767 InverseEntityMode(aMode,SMESH_Actor::eEdges);
770 InverseEntityMode(aMode,SMESH_Actor::eFaces);
773 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
776 aMode = SMESH_Actor::eAllEntity;
780 anActor->SetEntityMode(aMode);
788 SALOME_ListIO selected;
789 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
793 LightApp_SelectionMgr* aSel = app->selectionMgr();
794 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
795 if( !aSel || !appStudy )
798 aSel->selectedObjects( selected );
799 if( selected.IsEmpty() )
802 Handle(SALOME_InteractiveObject) anIObject = selected.First();
804 _PTR(Study) aStudy = appStudy->studyDS();
805 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
806 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
807 if( aMainObject->_is_nil() )
810 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
812 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
813 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
815 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
816 SALOMEDS::Color aColor = aGroupObject->GetColor();
817 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
819 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
820 if( aGroupObject->GetType() == SMESH::NODE )
821 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B );
822 else if( aGroupObject->GetType() == SMESH::EDGE )
823 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
824 else if( aGroupObject->GetType() == SMESH::ELEM0D )
825 anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
829 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
830 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
836 SMESH::RepaintCurrentView();
839 QString functorToString( SMESH::Controls::FunctorPtr f )
841 QString type = QObject::tr( "UNKNOWN_CONTROL" );
842 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
843 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
844 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
845 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
846 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
847 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
848 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
849 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
850 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
851 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
852 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
853 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
854 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
855 type = QObject::tr( "WARP_ELEMENTS" );
856 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
857 type = QObject::tr( "TAPER_ELEMENTS" );
858 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
859 type = QObject::tr( "SKEW_ELEMENTS" );
860 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
861 type = QObject::tr( "AREA_ELEMENTS" );
862 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
863 type = QObject::tr( "LENGTH_EDGES" );
864 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
865 type = QObject::tr( "LENGTH2D_EDGES" );
866 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
867 type = QObject::tr( "MULTI_BORDERS" );
868 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
869 type = QObject::tr( "MULTI2D_BORDERS" );
870 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
871 type = QObject::tr( "FREE_NODES" );
872 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
873 type = QObject::tr( "FREE_EDGES" );
874 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
875 type = QObject::tr( "FREE_BORDERS" );
876 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
877 type = QObject::tr( "FREE_FACES" );
878 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
879 type = QObject::tr( "BARE_BORDER_VOLUME" );
880 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
881 type = QObject::tr( "BARE_BORDER_FACE" );
882 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
883 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
884 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
885 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
886 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
887 type = QObject::tr( "EQUAL_NODE" );
888 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
889 type = QObject::tr( "EQUAL_EDGE" );
890 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
891 type = QObject::tr( "EQUAL_FACE" );
892 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
893 type = QObject::tr( "EQUAL_VOLUME" );
897 void SaveDistribution()
899 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
900 SALOME_ListIO selected;
902 aSel->selectedObjects( selected );
904 if ( selected.Extent() == 1 ) {
905 Handle(SALOME_InteractiveObject) anIO = selected.First();
906 if ( anIO->hasEntry() ) {
907 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
908 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
909 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
910 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
911 if ( aScalarBarActor && aFunctor ) {
912 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
914 std::vector<int> elements;
915 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
916 if ( mesh->_is_nil() ) {
917 SMESH::SMESH_IDSource_var idSource =
918 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
919 if ( !idSource->_is_nil() )
921 SMESH::long_array_var ids = idSource->GetIDs();
922 elements.resize( ids->length() );
923 for ( unsigned i = 0; i < elements.size(); ++i )
924 elements[i] = ids[i];
927 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
928 vtkLookupTable* lookupTable =
929 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
930 double * minmax = lookupTable->GetRange();
931 std::vector<int> nbEvents;
932 std::vector<double> funValues;
933 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
934 QString anInitialPath = "";
935 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
936 anInitialPath = QDir::currentPath();
937 QString aMeshName = anIO->getName();
939 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
940 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
941 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
942 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
943 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
946 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
948 if ( !aFilename.isEmpty() ) {
949 QFile f( aFilename );
950 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
951 QTextStream out( &f );
952 out << "# Mesh: " << aMeshName << endl;
953 out << "# Control: " << functorToString( aFunctor ) << endl;
955 out.setFieldWidth( 10 );
956 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
957 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
968 void ShowDistribution() {
969 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
970 SALOME_ListIO selected;
972 aSel->selectedObjects( selected );
974 if ( selected.Extent() == 1 ) {
975 Handle(SALOME_InteractiveObject) anIO = selected.First();
976 if ( anIO->hasEntry() ) {
977 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
978 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
979 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
980 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
986 #ifndef DISABLE_PLOT2DVIEWER
987 void PlotDistribution() {
988 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
992 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
993 SALOME_ListIO selected;
995 aSel->selectedObjects( selected );
997 if ( selected.Extent() == 1 ) {
998 Handle(SALOME_InteractiveObject) anIO = selected.First();
999 if ( anIO->hasEntry() ) {
1000 //Find Actor by entry before getting Plot2d viewer,
1001 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1002 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1004 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1009 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1013 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1017 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1018 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1019 QString functorName = functorToString( anActor->GetFunctor());
1020 QString aHistogramName("%1 : %2");
1021 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1022 aHistogram->setName(aHistogramName);
1023 aHistogram->setHorTitle(functorName);
1024 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1025 aPlot->displayObject(aHistogram, true);
1030 #endif //DISABLE_PLOT2DVIEWER
1032 void DisableAutoColor(){
1033 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1034 SALOME_ListIO selected;
1036 aSel->selectedObjects( selected );
1038 if(selected.Extent()){
1039 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1040 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1041 if ( !aMesh->_is_nil() ) {
1042 aMesh->SetAutoColor( false );
1047 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){
1048 SALOME_ListIO selected;
1049 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1053 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1054 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1055 if( !aSel || !appStudy )
1058 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1059 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1060 aModule->EmitSignalDeactivateDialog();
1061 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1062 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1067 _PTR(Study) aStudy = appStudy->studyDS();
1069 aSel->selectedObjects( selected );
1071 if(selected.Extent() >= 1){
1072 switch(theCommandID){
1074 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1075 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1079 QColor c, e, b, n, c0D, o, outl, selection, preselection;
1083 vtkFloatingPointType Shrink = 0.0;
1084 vtkFloatingPointType faces_orientation_scale = 0.0;
1085 bool faces_orientation_3dvectors = false;
1087 VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE;
1088 VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE;
1089 int aMarkerTextureCurrent = 0;
1091 SALOME_ListIteratorOfListIO It( selected );
1092 for( ; It.More(); It.Next()){
1093 Handle(SALOME_InteractiveObject) IObject = It.Value();
1094 if(IObject->hasEntry()){
1095 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1096 vtkFloatingPointType color[3];
1097 anActor->GetSufaceColor(color[0], color[1], color[2],delta);
1098 int c0 = int (color[0] * 255);
1099 int c1 = int (color[1] * 255);
1100 int c2 = int (color[2] * 255);
1101 c.setRgb(c0, c1, c2);
1103 vtkFloatingPointType edgecolor[3];
1104 anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1105 c0 = int (edgecolor[0] * 255);
1106 c1 = int (edgecolor[1] * 255);
1107 c2 = int (edgecolor[2] * 255);
1108 e.setRgb(c0, c1, c2);
1110 vtkFloatingPointType nodecolor[3];
1111 anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1112 c0 = int (nodecolor[0] * 255);
1113 c1 = int (nodecolor[1] * 255);
1114 c2 = int (nodecolor[2] * 255);
1115 n.setRgb(c0, c1, c2);
1117 vtkFloatingPointType color0D[3];
1118 anActor->Get0DColor(color0D[0], color0D[1], color0D[2]);
1119 c0 = int (color0D[0] * 255);
1120 c1 = int (color0D[1] * 255);
1121 c2 = int (color0D[2] * 255);
1122 c0D.setRgb(c0, c1, c2);
1124 vtkFloatingPointType outlineColor[3];
1125 anActor->GetOutlineColor(outlineColor[0], outlineColor[1], outlineColor[2]);
1126 c0 = int (outlineColor[0] * 255);
1127 c1 = int (outlineColor[1] * 255);
1128 c2 = int (outlineColor[2] * 255);
1129 outl.setRgb(c0, c1, c2);
1131 vtkFloatingPointType hColor[3];
1132 anActor->GetHighlightColor(hColor[0], hColor[1], hColor[2]);
1133 c0 = int (hColor[0] * 255);
1134 c1 = int (hColor[1] * 255);
1135 c2 = int (hColor[2] * 255);
1136 selection.setRgb(c0, c1, c2);
1138 vtkFloatingPointType phColor[3];
1139 anActor->GetPreHighlightColor(phColor[0], phColor[1], phColor[2]);
1140 c0 = int (phColor[0] * 255);
1141 c1 = int (phColor[1] * 255);
1142 c2 = int (phColor[2] * 255);
1143 preselection.setRgb(c0, c1, c2);
1145 size0D = (int)anActor->Get0DSize();
1148 Edgewidth = (int)anActor->GetLineWidth();
1151 Shrink = anActor->GetShrinkFactor();
1153 vtkFloatingPointType faces_orientation_color[3];
1154 anActor->GetFacesOrientationColor(faces_orientation_color);
1155 c0 = int (faces_orientation_color[0] * 255);
1156 c1 = int (faces_orientation_color[1] * 255);
1157 c2 = int (faces_orientation_color[2] * 255);
1158 o.setRgb(c0, c1, c2);
1160 faces_orientation_scale = anActor->GetFacesOrientationScale();
1161 faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors();
1163 aMarkerTypeCurrent = anActor->GetMarkerType();
1164 aMarkerScaleCurrent = anActor->GetMarkerScale();
1165 aMarkerTextureCurrent = anActor->GetMarkerTexture();
1167 // even if there are multiple objects in the selection,
1168 // we need only the first one to get values for the dialog
1174 SMESHGUI_Preferences_ColorDlg *aDlg =
1175 new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() );
1176 aDlg->SetColor(1, c);
1177 aDlg->SetColor(2, e);
1178 aDlg->SetColor(3, n);
1179 aDlg->SetColor(4, outl);
1180 aDlg->SetDeltaBrightness(delta);
1181 aDlg->SetColor(5, c0D);
1182 aDlg->SetColor(6, o);
1183 aDlg->SetIntValue(1, Edgewidth);
1184 aDlg->SetIntValue(2, int(Shrink*100.));
1185 aDlg->SetIntValue(3, size0D);
1186 aDlg->SetDoubleValue(1, faces_orientation_scale);
1187 aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
1188 aDlg->SetColor(7, selection);
1189 aDlg->SetColor(8, preselection);
1191 aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
1193 if( aMarkerTypeCurrent != VTK::MT_USER )
1194 aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent );
1196 aDlg->setCustomMarker( aMarkerTextureCurrent );
1199 QColor color = aDlg->GetColor(1);
1200 QColor edgecolor = aDlg->GetColor(2);
1201 QColor nodecolor = aDlg->GetColor(3);
1202 QColor outlinecolor = aDlg->GetColor(4);
1203 QColor color0D = aDlg->GetColor(5);
1204 QColor faces_orientation_color = aDlg->GetColor(6);
1205 QColor selectioncolor = aDlg->GetColor(7);
1206 QColor preSelectioncolor = aDlg->GetColor(8);
1207 int delta = aDlg->GetDeltaBrightness();
1210 theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
1212 SALOME_ListIteratorOfListIO It( selected );
1213 for( ; It.More(); It.Next()){
1214 Handle(SALOME_InteractiveObject) IObject = It.Value();
1215 if(IObject->hasEntry()){
1216 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1217 /* actor color and backface color */
1218 anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
1219 vtkFloatingPointType (color.green()) / 255.,
1220 vtkFloatingPointType (color.blue()) / 255.,
1223 anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
1224 vtkFloatingPointType (edgecolor.green()) / 255.,
1225 vtkFloatingPointType (edgecolor.blue()) / 255.);
1227 anActor->SetOutlineColor(vtkFloatingPointType (outlinecolor.red()) / 255.,
1228 vtkFloatingPointType (outlinecolor.green()) / 255.,
1229 vtkFloatingPointType (outlinecolor.blue()) / 255.);
1232 anActor->SetHighlightColor(vtkFloatingPointType (selectioncolor.red()) / 255.,
1233 vtkFloatingPointType (selectioncolor.green()) / 255.,
1234 vtkFloatingPointType (selectioncolor.blue()) / 255.);
1236 anActor->SetPreHighlightColor(vtkFloatingPointType (preSelectioncolor.red()) / 255.,
1237 vtkFloatingPointType (preSelectioncolor.green()) / 255.,
1238 vtkFloatingPointType (preSelectioncolor.blue()) / 255.);
1241 /* Shrink factor and size edges */
1242 anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
1243 anActor->SetLineWidth(aDlg->GetIntValue(1));
1245 /* Nodes color and size */
1246 anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
1247 vtkFloatingPointType (nodecolor.green()) / 255.,
1248 vtkFloatingPointType (nodecolor.blue()) / 255.);
1251 anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255.,
1252 vtkFloatingPointType (color0D.green()) / 255.,
1253 vtkFloatingPointType (color0D.blue()) / 255.);
1254 anActor->Set0DSize(aDlg->GetIntValue(3));
1256 /* Faces orientation */
1257 vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()),
1258 vtkFloatingPointType(faces_orientation_color.greenF()),
1259 vtkFloatingPointType(faces_orientation_color.blueF())};
1260 anActor->SetFacesOrientationColor(c);
1261 anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1));
1262 anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1));
1264 VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType();
1265 VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale();
1266 int aMarkerTextureNew = aDlg->getCustomMarkerID();
1267 if( aMarkerTypeNew != VTK::MT_USER )
1268 anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew );
1270 const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ];
1271 VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew );
1272 if( anIter != aMarkerMap.end() )
1273 anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second );
1276 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1277 if( !aGroupObject->_is_nil() )
1279 SMESH::ElementType anElementType = aGroupObject->GetType();
1281 switch( anElementType )
1283 case SMESH::NODE: aColor = nodecolor; break;
1284 case SMESH::EDGE: aColor = edgecolor; break;
1285 default: aColor = color; break;
1288 SALOMEDS::Color aGroupColor;
1289 aGroupColor.R = (float)aColor.red() / 255.0;
1290 aGroupColor.G = (float)aColor.green() / 255.0;
1291 aGroupColor.B = (float)aColor.blue() / 255.0;
1292 aGroupObject->SetColor( aGroupColor );
1297 SMESH::RepaintCurrentView();
1303 SALOME_ListIteratorOfListIO It( selected );
1304 for( ; It.More(); It.Next()){
1305 Handle(SALOME_InteractiveObject) IObject = It.Value();
1306 if(IObject->hasEntry()){
1307 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1308 switch(theCommandID){
1310 anActor->SetRepresentation(SMESH_Actor::eEdge);
1313 anActor->SetRepresentation(SMESH_Actor::eSurface);
1316 if(anActor->IsShrunk())
1317 anActor->UnShrink();
1319 anActor->SetShrink();
1322 anActor->SetRepresentation(SMESH_Actor::ePoint);
1325 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1326 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1329 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1330 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1336 SMESH::RepaintCurrentView();
1340 void Control( int theCommandID )
1342 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1343 SALOME_ListIO selected;
1345 aSel->selectedObjects( selected );
1347 if( !selected.IsEmpty() ){
1348 Handle(SALOME_InteractiveObject) anIO = selected.First();
1350 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1351 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1352 switch ( theCommandID ){
1354 aControl = SMESH_Actor::eLength;
1357 aControl = SMESH_Actor::eLength2D;
1360 aControl = SMESH_Actor::eFreeEdges;
1363 aControl = SMESH_Actor::eFreeBorders;
1366 aControl = SMESH_Actor::eMultiConnection;
1369 aControl = SMESH_Actor::eFreeNodes;
1372 aControl = SMESH_Actor::eMultiConnection2D;
1375 aControl = SMESH_Actor::eArea;
1378 aControl = SMESH_Actor::eTaper;
1381 aControl = SMESH_Actor::eAspectRatio;
1384 aControl = SMESH_Actor::eAspectRatio3D;
1387 aControl = SMESH_Actor::eMinimumAngle;
1390 aControl = SMESH_Actor::eWarping;
1393 aControl = SMESH_Actor::eSkew;
1396 aControl = SMESH_Actor::eVolume3D;
1399 aControl = SMESH_Actor::eFreeFaces;
1402 aControl = SMESH_Actor::eMaxElementLength2D;
1405 aControl = SMESH_Actor::eMaxElementLength3D;
1408 aControl = SMESH_Actor::eBareBorderVolume;
1411 aControl = SMESH_Actor::eBareBorderFace;
1414 aControl = SMESH_Actor::eOverConstrainedVolume;
1417 aControl = SMESH_Actor::eOverConstrainedFace;
1420 aControl = SMESH_Actor::eCoincidentNodes;
1423 aControl = SMESH_Actor::eCoincidentElems1D;
1426 aControl = SMESH_Actor:: eCoincidentElems2D;
1429 aControl = SMESH_Actor::eCoincidentElems3D;
1433 anActor->SetControlMode(aControl);
1434 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1435 SMESH::RepaintCurrentView();
1436 #ifndef DISABLE_PLOT2DVIEWER
1437 if(anActor->GetPlot2Histogram()) {
1438 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1439 QString functorName = functorToString( anActor->GetFunctor());
1440 QString aHistogramName("%1 : %2");
1441 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1442 aHistogram->setName(aHistogramName);
1443 aHistogram->setHorTitle(functorName);
1444 SMESH::ProcessIn2DViewers(anActor);
1453 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1454 MeshObjectType theType,
1455 const QString theInTypeName,
1456 QString & theOutTypeName)
1458 SMESH_TypeFilter aTypeFilter( theType );
1460 if( !theIO.IsNull() )
1462 entry = theIO->getEntry();
1463 LightApp_DataOwner owner( entry );
1464 if ( aTypeFilter.isOk( &owner )) {
1465 theOutTypeName = theInTypeName;
1473 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1475 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1476 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1478 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1479 CORBA::String_var anID = aSComp->GetID().c_str();
1480 if (!strcmp(anID.in(),theIO->getEntry()))
1486 CheckOIType ( theIO, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1487 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1488 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1489 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1490 CheckOIType ( theIO, GROUP, "Group", aTypeName )
1498 QString CheckHomogeneousSelection()
1500 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1501 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1502 SALOME_ListIO selected;
1504 aSel->selectedObjects( selected );
1506 QString RefType = CheckTypeObject(selected.First());
1507 SALOME_ListIteratorOfListIO It(selected);
1508 for ( ; It.More(); It.Next())
1510 Handle(SALOME_InteractiveObject) IObject = It.Value();
1511 QString Type = CheckTypeObject(IObject);
1512 if (Type.compare(RefType) != 0)
1513 return "Heterogeneous Selection";
1520 void SMESHGUI::OnEditDelete()
1522 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1523 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1524 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1526 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1527 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1528 _PTR(GenericAttribute) anAttr;
1529 _PTR(AttributeIOR) anIOR;
1531 int objectCount = 0;
1533 QString aParentComponent = QString::null;
1534 Handle(SALOME_InteractiveObject) anIO;
1535 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1537 anIO = anIt.Value();
1538 QString cur = anIO->getComponentDataType();
1539 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1541 // check if object is reference
1542 _PTR(SObject) aRefSObj;
1543 aNameList.append("\n - ");
1544 if ( aSO->ReferencedObject( aRefSObj ) ) {
1545 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1546 aNameList.append( aRefName );
1547 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1550 aNameList.append(anIO->getName());
1554 if( aParentComponent.isNull() )
1555 aParentComponent = cur;
1556 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1557 aParentComponent = "";
1560 if ( objectCount == 0 )
1561 return; // No Valid Objects Selected
1563 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1564 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1565 QObject::tr("ERR_ERROR"),
1566 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1569 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1570 if (SUIT_MessageBox::warning
1571 (SMESHGUI::desktop(),
1572 QObject::tr("SMESH_WRN_WARNING"),
1573 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1574 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1575 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1578 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1580 SALOME_ListIteratorOfListIO It(selected);
1582 aStudyBuilder->NewCommand(); // There is a transaction
1583 for( ; It.More(); It.Next()){ // loop on selected IO's
1584 Handle(SALOME_InteractiveObject) IObject = It.Value();
1585 if(IObject->hasEntry()) {
1586 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1588 // disable removal of "SMESH" component object
1589 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1591 if ( engineIOR() == anIOR->Value().c_str() )
1594 //Check the referenced object
1595 _PTR(SObject) aRefSObject;
1596 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1597 aSO = aRefSObject; // Delete main Object instead of reference
1599 // put the whole hierarchy of sub-objects of the selected SO into a list and
1600 // then treat them all starting from the deepest objects (at list back)
1602 std::list< _PTR(SObject) > listSO;
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() );
1611 // treat SO's in the list starting from the back
1613 std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin();
1614 for ( ; ritSO != listSO.rend(); ++ritSO ) {
1615 _PTR(SObject) SO = *ritSO;
1616 if ( !SO ) continue;
1617 std::string anEntry = SO->GetID();
1619 /** Erase graphical object **/
1620 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1621 ViewManagerList aViewMenegers = anApp->viewManagers();
1622 ViewManagerList::const_iterator it = aViewMenegers.begin();
1623 for( ; it != aViewMenegers.end(); it++) {
1624 SUIT_ViewManager* vm = *it;
1625 int nbSf = vm ? vm->getViewsCount() : 0;
1627 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1628 for(int i = 0; i < nbSf; i++){
1629 SUIT_ViewWindow *sf = aViews[i];
1630 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1631 SMESH::RemoveActor(sf,anActor);
1637 /** Remove an object from data structures **/
1638 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1639 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1640 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1641 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1642 aMesh->RemoveGroup( aGroup );
1644 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1645 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1646 aMesh->RemoveSubMesh( aSubMesh );
1648 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1650 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1653 IObject = new SALOME_InteractiveObject
1654 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1655 QString objType = CheckTypeObject(IObject);
1656 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1657 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1658 aStudyBuilder->RemoveObjectWithChildren( SO );
1660 else {// default action: remove SObject from the study
1661 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1662 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1664 aStudyBuilder->RemoveObjectWithChildren( SO );
1668 } /* listSO back loop */
1669 } /* IObject->hasEntry() */
1672 aStudyBuilder->CommitCommand();
1674 /* Clear any previous selection */
1676 aSel->setSelectedObjects( l1 );
1678 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1683 SMESHGUI_EXPORT CAM_Module* createModule()
1685 return new SMESHGUI();
1688 SMESHGUI_EXPORT char* getModuleVersion() {
1689 return (char*)SMESH_VERSION_STR;
1693 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1695 //=============================================================================
1699 //=============================================================================
1700 SMESHGUI::SMESHGUI() :
1701 SalomeApp_Module( "SMESH" ),
1702 LightApp_Module( "SMESH" )
1704 if ( CORBA::is_nil( myComponentSMESH ) )
1706 CORBA::Boolean anIsEmbeddedMode;
1707 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1708 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1710 // 0019923: EDF 765 SMESH : default values of hypothesis
1711 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1712 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1713 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1714 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1715 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1716 if ( aResourceMgr->hasValue( "SMESH", "historical_python_dump" ))
1718 QString val = aResourceMgr->stringValue( "SMESH", "historical_python_dump" );
1719 myComponentSMESH->SetOption( "historical_python_dump", val.toLatin1().constData() );
1723 myActiveDialogBox = 0;
1724 myFilterLibraryDlg = 0;
1728 myEventCallbackCommand = vtkCallbackCommand::New();
1729 myEventCallbackCommand->Delete();
1730 myEventCallbackCommand->SetClientData( this );
1731 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1734 SMESH::GetFilterManager();
1735 SMESH::GetPattern();
1736 SMESH::GetMeasurements();
1738 /* load resources for all available meshers */
1739 SMESH::InitAvailableHypotheses();
1742 //=============================================================================
1746 //=============================================================================
1747 SMESHGUI::~SMESHGUI()
1749 #ifdef WITHGENERICOBJ
1750 SMESH::GetFilterManager()->UnRegister();
1751 SMESH::GetMeasurements()->UnRegister();
1753 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1754 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1757 //=============================================================================
1761 //=============================================================================
1762 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1764 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1766 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1771 //=============================================================================
1775 //=============================================================================
1776 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1778 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1782 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1783 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1784 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1785 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1786 return autoUpdate && !exceeded;
1789 //=============================================================================
1793 //=============================================================================
1794 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1796 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1799 //=============================================================================
1803 //=============================================================================
1804 SMESHGUI* SMESHGUI::GetSMESHGUI()
1806 SMESHGUI* smeshMod = 0;
1807 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1810 CAM_Module* module = app->module( "Mesh" );
1811 smeshMod = dynamic_cast<SMESHGUI*>( module );
1814 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1816 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1819 _PTR(Study) aStudy = study->studyDS();
1821 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1830 Standard_EXPORT SMESHGUI* GetComponentGUI()
1832 return SMESHGUI::GetSMESHGUI();
1836 //=============================================================================
1840 //=============================================================================
1841 void SMESHGUI::SetState(int aState)
1846 //=============================================================================
1850 //=============================================================================
1851 void SMESHGUI::ResetState()
1856 //=============================================================================
1860 //=============================================================================
1861 void SMESHGUI::EmitSignalDeactivateDialog()
1863 emit SignalDeactivateActiveDialog();
1866 //=============================================================================
1870 //=============================================================================
1871 void SMESHGUI::EmitSignalStudyFrameChanged()
1873 emit SignalStudyFrameChanged();
1876 //=============================================================================
1880 //=============================================================================
1881 void SMESHGUI::EmitSignalCloseAllDialogs()
1883 emit SignalCloseAllDialogs();
1886 //=============================================================================
1890 //=============================================================================
1891 void SMESHGUI::EmitSignalVisibilityChanged()
1893 emit SignalVisibilityChanged();
1896 //=============================================================================
1900 //=============================================================================
1901 QDialog *SMESHGUI::GetActiveDialogBox()
1903 return myActiveDialogBox;
1906 //=============================================================================
1910 //=============================================================================
1911 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
1913 myActiveDialogBox = (QDialog *) aDlg;
1917 //=============================================================================
1921 //=============================================================================
1922 SUIT_Desktop* SMESHGUI::desktop()
1924 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1926 return app->desktop();
1931 //=============================================================================
1935 //=============================================================================
1936 SalomeApp_Study* SMESHGUI::activeStudy()
1938 SUIT_Application* app = SUIT_Session::session()->activeApplication();
1940 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1945 //=============================================================================
1949 //=============================================================================
1950 void SMESHGUI::Modified( bool theIsUpdateActions )
1952 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
1953 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
1954 appStudy->Modified();
1955 if( theIsUpdateActions )
1956 app->updateActions();
1961 //=============================================================================
1965 //=============================================================================
1966 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
1968 /* Here the position is on the bottom right corner - 10 */
1969 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
1971 SUIT_Desktop *PP = desktop();
1972 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
1973 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
1977 //=============================================================================
1981 //=============================================================================
1982 static int isStudyLocked(_PTR(Study) theStudy){
1983 return theStudy->GetProperties()->IsLocked();
1986 static bool checkLock(_PTR(Study) theStudy) {
1987 if (isStudyLocked(theStudy)) {
1988 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1989 QObject::tr("WRN_WARNING"),
1990 QObject::tr("WRN_STUDY_LOCKED") );
1996 //=======================================================================
1997 //function : CheckActiveStudyLocked
1999 //=======================================================================
2001 bool SMESHGUI::isActiveStudyLocked()
2003 _PTR(Study) aStudy = activeStudy()->studyDS();
2004 return checkLock( aStudy );
2007 //=============================================================================
2011 //=============================================================================
2012 bool SMESHGUI::OnGUIEvent( int theCommandID )
2014 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2018 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2019 SUIT_ResourceMgr* mgr = resourceMgr();
2023 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2024 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2027 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2028 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2030 //QAction* act = action( theCommandID );
2032 switch (theCommandID) {
2034 if(checkLock(aStudy)) break;
2045 if(checkLock(aStudy)) break;
2046 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2050 case 150: //MED FILE INFORMATION
2052 SALOME_ListIO selected;
2053 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2055 aSel->selectedObjects( selected );
2056 if( selected.Extent() )
2058 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2059 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2060 if ( !aMesh->_is_nil() )
2062 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2069 case 122: // EXPORT MED
2082 ::ExportMeshToFile(theCommandID);
2086 case 200: // SCALAR BAR
2088 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2089 SALOME_ListIO selected;
2091 aSel->selectedObjects( selected );
2093 if( selected.Extent() ) {
2094 Handle(SALOME_InteractiveObject) anIO = selected.First();
2095 if( anIO->hasEntry() ) {
2096 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2097 anActor->SetControlMode( SMESH_Actor::eNone );
2098 #ifndef DISABLE_PLOT2DVIEWER
2099 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2108 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2113 // dump control distribution data to the text file
2114 ::SaveDistribution();
2120 // show/ distribution
2121 ::ShowDistribution();
2125 #ifndef DISABLE_PLOT2DVIEWER
2128 // plot distribution
2129 ::PlotDistribution();
2140 ::DisableAutoColor();
2143 case 1134: // Clipping
2144 case 1133: // Tranparency
2145 case 1132: // Colors / Size
2152 ::SetDisplayMode(theCommandID, myMarkerMap);
2155 //2D quadratic representation
2158 ::SetDisplayMode(theCommandID, myMarkerMap);
2162 case 216: // 0D elements
2165 case 219: // Volumes
2166 case 220: // All Entity
2167 ::SetDisplayEntity(theCommandID);
2170 case 221: // Orientation of faces
2172 LightApp_SelectionMgr* mgr = selectionMgr();
2173 SALOME_ListIO selected; mgr->selectedObjects( selected );
2175 SALOME_ListIteratorOfListIO it(selected);
2176 for( ; it.More(); it.Next()) {
2177 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2178 if(anIObject->hasEntry()) {
2179 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2180 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2189 if(checkLock(aStudy)) break;
2191 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2194 SMESH::UpdateView();
2196 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2197 SMESH::OnVisuException();
2199 catch (...) { // PAL16774 (Crash after display of many groups)
2200 SMESH::OnVisuException();
2204 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2205 aSel->selectedObjects( l );
2206 aSel->setSelectedObjects( l );
2211 case 301: // DISPLAY
2212 case 302: // DISPLAY ONLY
2214 SMESH::EDisplaing anAction;
2215 switch (theCommandID) {
2216 case 300: anAction = SMESH::eErase; break;
2217 case 301: anAction = SMESH::eDisplay; break;
2218 case 302: anAction = SMESH::eDisplayOnly; break;
2221 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2222 SALOME_ListIO sel_objects, to_process;
2224 aSel->selectedObjects( sel_objects );
2226 if( theCommandID==302 )
2228 MESSAGE("anAction = SMESH::eDisplayOnly");
2229 startOperation( myEraseAll );
2232 extractContainers( sel_objects, to_process );
2235 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2239 SALOME_ListIteratorOfListIO It( to_process );
2240 for ( ; It.More(); It.Next()) {
2242 Handle(SALOME_InteractiveObject) IOS = It.Value();
2243 if (IOS->hasEntry()) {
2245 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2246 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2247 break; // PAL16774 (Crash after display of many groups)
2249 if (anAction == SMESH::eDisplayOnly)
2251 MESSAGE("anAction = SMESH::eDisplayOnly");
2252 anAction = SMESH::eDisplay;
2258 // PAL13338 + PAL15161 -->
2259 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2260 MESSAGE("anAction = SMESH::eDisplayOnly");
2261 SMESH::UpdateView();
2262 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2264 // PAL13338 + PAL15161 <--
2266 catch (...) { // PAL16774 (Crash after display of many groups)
2267 SMESH::OnVisuException();
2270 if (anAction == SMESH::eErase) {
2271 MESSAGE("anAction == SMESH::eErase");
2273 aSel->setSelectedObjects( l1 );
2276 aSel->setSelectedObjects( to_process );
2283 if(checkLock(aStudy)) break;
2286 EmitSignalDeactivateDialog();
2288 ( new SMESHGUI_NodesDlg( this ) )->show();
2291 SUIT_MessageBox::warning(desktop(),
2292 tr("SMESH_WRN_WARNING"),
2293 tr("SMESH_WRN_VIEWER_VTK"));
2298 case 2151: // FILTER
2302 EmitSignalDeactivateDialog();
2303 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2308 case 701: // COMPUTE MESH
2309 case 711: // PRECOMPUTE MESH
2310 case 712: // EVALUATE MESH
2311 case 713: // MESH ORDER
2313 if (checkLock(aStudy)) break;
2314 startOperation( theCommandID );
2318 case 702: // Create mesh
2319 case 703: // Create sub-mesh
2320 case 704: // Edit mesh/sub-mesh
2321 startOperation( theCommandID );
2323 case 705: // copy mesh
2325 if (checkLock(aStudy)) break;
2326 EmitSignalDeactivateDialog();
2327 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2330 case 710: // Build compound mesh
2332 if (checkLock(aStudy)) break;
2333 EmitSignalDeactivateDialog();
2334 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2338 case 407: // DIAGONAL INVERSION
2339 case 408: // Delete diagonal
2343 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2344 tr( "NOT_A_VTK_VIEWER" ) );
2348 if ( checkLock( aStudy ) )
2351 /*Standard_Boolean aRes;
2352 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2353 if ( aMesh->_is_nil() )
2355 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2356 tr( "SMESH_BAD_SELECTION" ) );
2360 EmitSignalDeactivateDialog();
2361 if ( theCommandID == 407 )
2362 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2364 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2367 case 409: // Change orientation
2368 case 410: // Union of triangles
2369 case 411: // Cutting of quadrangles
2370 case 419: // Splitting volumes into tetrahedra
2374 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2375 tr( "NOT_A_VTK_VIEWER" ) );
2379 if ( checkLock( aStudy ) )
2382 EmitSignalDeactivateDialog();
2383 SMESHGUI_MultiEditDlg* aDlg = NULL;
2384 if ( theCommandID == 409 )
2385 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2386 else if ( theCommandID == 410 )
2387 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2388 else if ( theCommandID == 419 )
2389 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2391 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2396 case 412: // Smoothing
2398 if(checkLock(aStudy)) break;
2400 EmitSignalDeactivateDialog();
2401 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2404 SUIT_MessageBox::warning(desktop(),
2405 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2409 case 413: // Extrusion
2411 if (checkLock(aStudy)) break;
2413 EmitSignalDeactivateDialog();
2414 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2416 SUIT_MessageBox::warning(desktop(),
2417 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2421 case 414: // Revolution
2423 if(checkLock(aStudy)) break;
2425 EmitSignalDeactivateDialog();
2426 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2429 SUIT_MessageBox::warning(desktop(),
2430 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2434 case 415: // Pattern mapping
2436 if ( checkLock( aStudy ) )
2440 EmitSignalDeactivateDialog();
2441 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2444 SUIT_MessageBox::warning(desktop(),
2445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2449 case 416: // Extrusion along a path
2451 if (checkLock(aStudy)) break;
2453 EmitSignalDeactivateDialog();
2454 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2456 SUIT_MessageBox::warning(desktop(),
2457 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2461 case 417: // Convert mesh to quadratic
2463 startOperation( 417 );
2464 /* if (checkLock(aStudy)) break;
2466 EmitSignalDeactivateDialog();
2467 new SMESHGUI_ConvToQuadDlg();
2469 SUIT_MessageBox::warning(desktop(),
2470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2474 case 418: // create 2D mesh from 3D
2476 startOperation( 418 );
2479 case 806: // CREATE GEO GROUP
2481 startOperation( 806 );
2484 case 801: // CREATE GROUP
2488 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2489 tr( "NOT_A_VTK_VIEWER" ) );
2493 if(checkLock(aStudy)) break;
2494 EmitSignalDeactivateDialog();
2495 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2497 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2498 SALOME_ListIO selected;
2500 aSel->selectedObjects( selected );
2502 int nbSel = selected.Extent();
2504 // check if mesh is selected
2505 aMesh = SMESH::GetMeshByIO( selected.First() );
2507 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2512 case 802: // CONSTRUCT GROUP
2516 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2517 tr( "NOT_A_VTK_VIEWER" ) );
2521 if(checkLock(aStudy)) break;
2522 EmitSignalDeactivateDialog();
2524 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2525 SALOME_ListIO selected;
2527 aSel->selectedObjects( selected );
2529 int nbSel = selected.Extent();
2531 // check if submesh is selected
2532 Handle(SALOME_InteractiveObject) IObject = selected.First();
2533 if (IObject->hasEntry()) {
2534 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2536 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2537 if (!aSubMesh->_is_nil()) {
2539 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2540 // get submesh elements list by types
2541 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2542 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2543 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2544 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2545 // create group for each type o elements
2546 QString aName = IObject->getName();
2547 QStringList anEntryList;
2548 if (aNodes->length() > 0) {
2549 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2550 aGroup->Add(aNodes.inout());
2551 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2552 anEntryList.append( aSObject->GetID().c_str() );
2554 if (aEdges->length() > 0) {
2555 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2556 aGroup->Add(aEdges.inout());
2557 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2558 anEntryList.append( aSObject->GetID().c_str() );
2560 if (aFaces->length() > 0) {
2561 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2562 aGroup->Add(aFaces.inout());
2563 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2564 anEntryList.append( aSObject->GetID().c_str() );
2566 if (aVolumes->length() > 0) {
2567 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2568 aGroup->Add(aVolumes.inout());
2569 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2570 anEntryList.append( aSObject->GetID().c_str() );
2573 anApp->browseObjects( anEntryList );
2575 catch(const SALOME::SALOME_Exception & S_ex){
2576 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2583 SUIT_MessageBox::warning(desktop(),
2584 tr("SMESH_WRN_WARNING"),
2585 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2590 case 803: // EDIT GROUP
2594 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2595 tr( "NOT_A_VTK_VIEWER" ) );
2599 if(checkLock(aStudy)) break;
2600 EmitSignalDeactivateDialog();
2602 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2603 SALOME_ListIO selected;
2605 aSel->selectedObjects( selected );
2607 SALOME_ListIteratorOfListIO It (selected);
2608 int nbSelectedGroups = 0;
2609 for ( ; It.More(); It.Next() )
2611 SMESH::SMESH_GroupBase_var aGroup =
2612 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2613 if (!aGroup->_is_nil()) {
2615 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2619 if (nbSelectedGroups == 0)
2621 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2627 case 804: // Add elements to group
2629 if(checkLock(aStudy)) break;
2630 if (myState == 800) {
2631 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2632 if (aDlg) aDlg->onAdd();
2637 case 805: // Remove elements from group
2639 if(checkLock(aStudy)) break;
2640 if (myState == 800) {
2641 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2642 if (aDlg) aDlg->onRemove();
2647 case 815: // Edit GEOM GROUP as standalone
2651 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2652 tr( "NOT_A_VTK_VIEWER" ) );
2656 if(checkLock(aStudy)) break;
2657 EmitSignalDeactivateDialog();
2659 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2660 SALOME_ListIO selected;
2662 aSel->selectedObjects( selected );
2664 SALOME_ListIteratorOfListIO It (selected);
2665 for ( ; It.More(); It.Next() )
2667 SMESH::SMESH_GroupOnGeom_var aGroup =
2668 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2669 if (!aGroup->_is_nil()) {
2670 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2675 SMESH::SMESH_GroupOnFilter_var aGroup =
2676 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2677 if (!aGroup->_is_nil()) {
2678 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2686 case 810: // Union Groups
2687 case 811: // Intersect groups
2688 case 812: // Cut groups
2692 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2693 tr( "NOT_A_VTK_VIEWER" ) );
2697 if ( checkLock( aStudy ) )
2700 EmitSignalDeactivateDialog();
2702 SMESHGUI_GroupOpDlg* aDlg = 0;
2703 if ( theCommandID == 810 )
2704 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2705 else if ( theCommandID == 811 )
2706 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2708 aDlg = new SMESHGUI_CutGroupsDlg( this );
2715 case 814: // Create groups of entities from existing groups of superior dimensions
2717 if ( checkLock( aStudy ) )
2720 EmitSignalDeactivateDialog();
2721 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2727 case 813: // Delete groups with their contents
2731 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2732 tr( "NOT_A_VTK_VIEWER" ) );
2736 if ( checkLock( aStudy ) )
2739 EmitSignalDeactivateDialog();
2741 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2745 case 900: // MESH INFOS
2746 case 903: // WHAT IS
2748 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2749 EmitSignalDeactivateDialog();
2750 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2751 SALOME_ListIO selected;
2753 aSel->selectedObjects( selected );
2755 if ( selected.Extent() > 1 ) { // a dlg for each IO
2756 SALOME_ListIteratorOfListIO It( selected );
2757 for ( ; It.More(); It.Next() ) {
2758 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2759 dlg->showInfo( It.Value() );
2764 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2770 case 904: // FIND ELEM
2772 startOperation( theCommandID );
2776 case 1100: // EDIT HYPOTHESIS
2778 if(checkLock(aStudy)) break;
2780 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2781 SALOME_ListIO selected;
2783 aSel->selectedObjects( selected );
2785 int nbSel = selected.Extent();
2788 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2789 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2791 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2792 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2793 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2794 if ( !aHypothesis->_is_nil() )
2797 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2798 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2800 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2810 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2812 if(checkLock(aStudy)) break;
2813 SUIT_OverrideCursor wc;
2815 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2816 SALOME_ListIO selected;
2818 aSel->selectedObjects( selected, QString::null, false );
2820 SALOME_ListIteratorOfListIO It(selected);
2821 for (int i = 0; It.More(); It.Next(), i++) {
2822 Handle(SALOME_InteractiveObject) IObject = It.Value();
2823 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2826 aSel->setSelectedObjects( l1 );
2831 case 4009: // ELEM0D
2833 case 4021: // TRIANGLE
2835 case 4023: // POLYGON
2839 case 4134: // PYRAMID
2840 case 4135: // OCTA12
2842 if(checkLock(aStudy)) break;
2844 EmitSignalDeactivateDialog();
2845 SMDSAbs_EntityType type = SMDSEntity_Edge;
2846 switch (theCommandID) {
2848 type = SMDSEntity_0D; break;
2850 type = SMDSEntity_Triangle; break;
2852 type = SMDSEntity_Quadrangle; break;
2854 type = SMDSEntity_Tetra; break;
2856 type = SMDSEntity_Polygon; break;
2858 type = SMDSEntity_Hexa; break;
2860 type = SMDSEntity_Penta; break;
2862 type = SMDSEntity_Pyramid; break;
2864 type = SMDSEntity_Hexagonal_Prism; break;
2867 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2870 SUIT_MessageBox::warning(desktop(),
2871 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2875 case 4033: // POLYHEDRON
2877 if(checkLock(aStudy)) break;
2879 EmitSignalDeactivateDialog();
2880 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2883 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2884 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2888 case 4034: // QUADRATIC EDGE
2889 case 4035: // QUADRATIC TRIANGLE
2890 case 4036: // QUADRATIC QUADRANGLE
2891 case 4136: // BIQUADRATIC QUADRANGLE
2892 case 4037: // QUADRATIC TETRAHEDRON
2893 case 4038: // QUADRATIC PYRAMID
2894 case 4039: // QUADRATIC PENTAHEDRON
2895 case 4040: // QUADRATIC HEXAHEDRON
2896 case 4140: // TRIQUADRATIC HEXAHEDRON
2898 if(checkLock(aStudy)) break;
2900 EmitSignalDeactivateDialog();
2901 SMDSAbs_EntityType type;
2903 switch (theCommandID) {
2905 type = SMDSEntity_Quad_Edge; break;
2907 type = SMDSEntity_Quad_Triangle; break;
2909 type = SMDSEntity_Quad_Quadrangle; break;
2911 type = SMDSEntity_BiQuad_Quadrangle; break;
2913 type = SMDSEntity_Quad_Tetra; break;
2915 type = SMDSEntity_Quad_Pyramid; break;
2917 type = SMDSEntity_Quad_Penta; break;
2919 type = SMDSEntity_Quad_Hexa;
2921 type = SMDSEntity_TriQuad_Hexa;
2925 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2928 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2929 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2933 case 4041: // REMOVES NODES
2935 if(checkLock(aStudy)) break;
2937 EmitSignalDeactivateDialog();
2938 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2941 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2942 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2946 case 4042: // REMOVES ELEMENTS
2948 if(checkLock(aStudy)) break;
2950 EmitSignalDeactivateDialog();
2951 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2955 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2956 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2960 case 4043: { // CLEAR_MESH
2962 if(checkLock(aStudy)) break;
2964 SALOME_ListIO selected;
2965 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2966 aSel->selectedObjects( selected );
2968 SUIT_OverrideCursor wc;
2969 SALOME_ListIteratorOfListIO It (selected);
2970 for ( ; It.More(); It.Next() )
2972 Handle(SALOME_InteractiveObject) IOS = It.Value();
2973 SMESH::SMESH_Mesh_var aMesh =
2974 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2975 if ( aMesh->_is_nil()) continue;
2977 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
2979 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
2980 SMESH::ModifiedMesh( aMeshSObj, false, true);
2981 // hide groups and submeshes
2982 _PTR(ChildIterator) anIter =
2983 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
2984 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
2986 _PTR(SObject) so = anIter->Value();
2987 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
2990 catch (const SALOME::SALOME_Exception& S_ex){
2992 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2996 SMESH::UpdateView();
3000 case 4044: // REMOVE ORPHAN NODES
3002 if(checkLock(aStudy)) break;
3003 SALOME_ListIO selected;
3004 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3005 aSel->selectedObjects( selected );
3006 if ( selected.Extent() == 1 ) {
3007 Handle(SALOME_InteractiveObject) anIO = selected.First();
3008 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3009 if ( !aMesh->_is_nil() ) {
3010 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3011 tr( "SMESH_WARNING" ),
3012 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3013 SUIT_MessageBox::Yes |
3014 SUIT_MessageBox::No,
3015 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3018 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3019 int removed = aMeshEditor->RemoveOrphanNodes();
3020 SUIT_MessageBox::information(SMESHGUI::desktop(),
3021 tr("SMESH_INFORMATION"),
3022 tr("NB_NODES_REMOVED").arg(removed));
3023 if ( removed > 0 ) {
3024 SMESH::UpdateView();
3025 SMESHGUI::Modified();
3028 catch (const SALOME::SALOME_Exception& S_ex) {
3029 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3038 case 4051: // RENUMBERING NODES
3040 if(checkLock(aStudy)) break;
3042 EmitSignalDeactivateDialog();
3043 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3047 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3048 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3052 case 4052: // RENUMBERING ELEMENTS
3054 if(checkLock(aStudy)) break;
3056 EmitSignalDeactivateDialog();
3057 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3061 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3062 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3066 case 4061: // TRANSLATION
3068 if(checkLock(aStudy)) break;
3070 EmitSignalDeactivateDialog();
3071 ( new SMESHGUI_TranslationDlg( this ) )->show();
3074 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3075 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3079 case 4062: // ROTATION
3081 if(checkLock(aStudy)) break;
3083 EmitSignalDeactivateDialog();
3084 ( new SMESHGUI_RotationDlg( this ) )->show();
3087 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3088 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3092 case 4063: // SYMMETRY
3094 if(checkLock(aStudy)) break;
3096 EmitSignalDeactivateDialog();
3097 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3100 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3101 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3105 case 4064: // SEWING
3107 if(checkLock(aStudy)) break;
3109 EmitSignalDeactivateDialog();
3110 ( new SMESHGUI_SewingDlg( this ) )->show();
3113 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3114 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3118 case 4065: // MERGE NODES
3120 if(checkLock(aStudy)) break;
3122 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3126 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3127 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3131 case 4066: // MERGE EQUAL ELEMENTS
3133 if (checkLock(aStudy)) break;
3135 EmitSignalDeactivateDialog();
3136 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3138 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3139 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3144 case 4067: // MAKE MESH PASS THROUGH POINT
3145 startOperation( 4067 );
3150 if(checkLock(aStudy)) break;
3152 EmitSignalDeactivateDialog();
3153 ( new SMESHGUI_ScaleDlg( this ) )->show();
3156 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3157 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3162 case 4069: // DUPLICATE NODES
3164 if(checkLock(aStudy)) break;
3166 EmitSignalDeactivateDialog();
3167 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3170 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3171 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3176 case 5105: // Library of selection filters
3178 static QList<int> aTypes;
3179 if ( aTypes.isEmpty() )
3181 aTypes.append( SMESH::NODE );
3182 aTypes.append( SMESH::EDGE );
3183 aTypes.append( SMESH::FACE );
3184 aTypes.append( SMESH::VOLUME );
3186 if (!myFilterLibraryDlg)
3187 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3188 else if (myFilterLibraryDlg->isHidden())
3189 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3190 myFilterLibraryDlg->raise();
3194 case 6017: // CONTROLS
3222 LightApp_SelectionMgr* mgr = selectionMgr();
3223 SALOME_ListIO selected; mgr->selectedObjects( selected );
3225 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3226 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3228 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3229 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3230 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3231 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3232 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3233 ::Control( theCommandID );
3238 SUIT_MessageBox::warning(desktop(),
3239 tr( "SMESH_WRN_WARNING" ),
3240 tr( "SMESH_BAD_SELECTION" ) );
3244 SUIT_MessageBox::warning(desktop(),
3245 tr( "SMESH_WRN_WARNING" ),
3246 tr( "NOT_A_VTK_VIEWER" ) );
3251 LightApp_SelectionMgr* mgr = selectionMgr();
3252 SALOME_ListIO selected; mgr->selectedObjects( selected );
3254 SALOME_ListIteratorOfListIO it(selected);
3255 for( ; it.More(); it.Next()) {
3256 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3257 if(anIObject->hasEntry()) {
3258 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3259 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3267 LightApp_SelectionMgr* mgr = selectionMgr();
3268 SALOME_ListIO selected; mgr->selectedObjects( selected );
3270 SALOME_ListIteratorOfListIO it(selected);
3271 for( ; it.More(); it.Next()) {
3272 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3273 if(anIObject->hasEntry())
3274 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3275 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3283 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3284 EmitSignalDeactivateDialog();
3285 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3291 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3292 //updateObjBrowser();
3296 //=============================================================================
3300 //=============================================================================
3301 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3306 //=============================================================================
3310 //=============================================================================
3311 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3316 //=============================================================================
3320 //=============================================================================
3321 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3326 //=============================================================================
3327 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3328 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3330 //=============================================================================
3331 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3332 SUIT_ViewWindow* wnd )
3334 if(theIO->hasEntry()){
3335 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3336 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3340 //=======================================================================
3341 // function : createSMESHAction
3343 //=======================================================================
3344 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3345 const int key, const bool toggle, const QString& shortcutAction )
3348 QWidget* parent = application()->desktop();
3349 SUIT_ResourceMgr* resMgr = resourceMgr();
3351 if ( !icon_id.isEmpty() )
3352 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3354 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3355 if ( !pix.isNull() )
3356 icon = QIcon( pix );
3358 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3359 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3360 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3362 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3363 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3366 //=======================================================================
3367 // function : createPopupItem
3369 //=======================================================================
3370 void SMESHGUI::createPopupItem( const int id,
3371 const QString& clients,
3372 const QString& types,
3373 const QString& theRule,
3378 parentId = popupMgr()->actionId( action( pId ) );
3380 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3381 popupMgr()->insert( action( id ), parentId, 0 );
3383 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3384 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3385 QString rule = "(%1) and (%2) and (%3)";
3386 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3387 if( clients.isEmpty() )
3388 rule = rule.arg( QString( "true" ) );
3390 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3391 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3394 bool cont = myRules.contains( id );
3396 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3398 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3399 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3402 //=======================================================================
3403 // function : initialize
3405 //=======================================================================
3406 void SMESHGUI::initialize( CAM_Application* app )
3408 SalomeApp_Module::initialize( app );
3410 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3412 /* Automatic Update flag */
3413 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3415 // ----- create actions --------------
3417 createSMESHAction( 111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3418 createSMESHAction( 112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3419 createSMESHAction( 113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3420 createSMESHAction( 114, "NUM" );
3421 createSMESHAction( 115, "STL" );
3422 createSMESHAction( 116, "CGNS" );
3423 createSMESHAction( 117, "SAUV" );
3424 createSMESHAction( 121, "DAT" );
3425 createSMESHAction( 122, "MED" );
3426 createSMESHAction( 123, "UNV" );
3427 createSMESHAction( 140, "STL" );
3428 createSMESHAction( 142, "CGNS" );
3429 createSMESHAction( 144, "SAUV" );
3430 createSMESHAction( 124, "EXPORT_DAT" );
3431 createSMESHAction( 125, "EXPORT_MED" );
3432 createSMESHAction( 126, "EXPORT_UNV" );
3433 createSMESHAction( 141, "EXPORT_STL" );
3434 createSMESHAction( 143, "EXPORT_CGNS" );
3435 createSMESHAction( 145, "EXPORT_SAUV" );
3436 createSMESHAction( 150, "FILE_INFO" );
3437 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3438 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3439 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3440 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3441 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3442 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3443 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3444 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3445 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3446 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3447 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3448 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3449 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3450 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3451 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3452 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3453 createSMESHAction( 804, "ADD" );
3454 createSMESHAction( 805, "REMOVE" );
3455 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3456 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3457 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3458 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3459 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3460 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3461 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3462 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3463 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3464 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3465 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3466 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3467 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3468 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3469 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3470 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3471 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3472 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3473 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3474 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3475 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3476 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3477 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3478 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3479 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3480 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3481 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3482 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3483 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3484 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3485 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3486 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3487 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3488 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3489 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3490 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3491 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3492 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3493 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3494 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3495 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3496 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3497 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3498 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3499 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3500 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3501 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3502 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3503 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3504 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3505 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3506 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3507 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3508 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3509 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3510 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3511 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3512 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3513 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3514 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3515 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3516 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3517 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3518 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3519 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3520 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3521 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3522 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3523 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3524 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3525 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3526 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3527 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3528 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3529 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3530 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3531 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3532 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3533 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3534 createSMESHAction( 415, "MAP", "ICON_MAP" );
3535 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3536 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3537 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3538 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3539 createSMESHAction( 200, "RESET" );
3540 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3541 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3542 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3543 #ifndef DISABLE_PLOT2DVIEWER
3544 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3546 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3547 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3548 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3549 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3550 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3551 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3552 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3553 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3554 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3555 createSMESHAction( 220, "ALL" );
3556 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3558 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3559 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3561 createSMESHAction( 1100, "EDIT_HYPO" );
3562 createSMESHAction( 1102, "UNASSIGN" );
3563 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3564 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3565 createSMESHAction( 1131, "DISPMODE" );
3566 createSMESHAction( 1132, "COLORS" );
3567 createSMESHAction( 1133, "TRANSP" );
3568 createSMESHAction( 1134, "CLIP" );
3569 createSMESHAction( 1135, "DISP_ENT" );
3570 createSMESHAction( 1136, "AUTO_COLOR" );
3571 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3572 createSMESHAction( 2000, "CTRL" );
3574 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3575 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3577 createSMESHAction( 300, "ERASE" );
3578 createSMESHAction( 301, "DISPLAY" );
3579 createSMESHAction( 302, "DISPLAY_ONLY" );
3581 // ----- create menu --------------
3582 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3583 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3584 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3585 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3586 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3587 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3588 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3589 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3591 createMenu( separator(), fileId );
3593 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3594 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3595 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3596 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3597 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3598 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3599 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3600 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3601 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3602 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3604 createMenu( 111, importId, -1 );
3605 createMenu( 112, importId, -1 );
3606 createMenu( 113, importId, -1 );
3607 createMenu( 115, importId, -1 );
3609 createMenu( 116, importId, -1 );
3611 createMenu( 117, importId, -1 );
3612 createMenu( 121, exportId, -1 );
3613 createMenu( 122, exportId, -1 );
3614 createMenu( 123, exportId, -1 );
3615 createMenu( 140, exportId, -1 ); // export to STL
3617 createMenu( 142, exportId, -1 ); // export to CGNS
3619 createMenu( 144, exportId, -1 ); // export to SAUV
3620 createMenu( separator(), fileId, 10 );
3622 createMenu( 33, editId, -1 );
3624 createMenu( 5105, toolsId, -1 );
3626 createMenu( 702, meshId, -1 ); // "Mesh" menu
3627 createMenu( 703, meshId, -1 );
3628 createMenu( 704, meshId, -1 );
3629 createMenu( 710, meshId, -1 );
3630 createMenu( 705, meshId, -1 );
3631 createMenu( separator(), meshId, -1 );
3632 createMenu( 701, meshId, -1 );
3633 createMenu( 711, meshId, -1 );
3634 createMenu( 712, meshId, -1 );
3635 createMenu( 713, meshId, -1 );
3636 createMenu( separator(), meshId, -1 );
3637 createMenu( 801, meshId, -1 );
3638 createMenu( 806, meshId, -1 );
3639 createMenu( 802, meshId, -1 );
3640 createMenu( 803, meshId, -1 );
3641 createMenu( 815, meshId, -1 );
3642 createMenu( separator(), meshId, -1 );
3643 createMenu( 810, meshId, -1 );
3644 createMenu( 811, meshId, -1 );
3645 createMenu( 812, meshId, -1 );
3646 createMenu( separator(), meshId, -1 );
3647 createMenu( 814, meshId, -1 );
3648 createMenu( separator(), meshId, -1 );
3649 createMenu( 900, meshId, -1 );
3650 //createMenu( 902, meshId, -1 );
3651 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3652 createMenu( 904, meshId, -1 );
3653 createMenu( separator(), meshId, -1 );
3655 createMenu( 6005, nodeId, -1 );
3656 createMenu( 6028, nodeId, -1 );
3657 createMenu( 6002, edgeId, -1 );
3658 createMenu( 6003, edgeId, -1 );
3659 createMenu( 6001, edgeId, -1 );
3660 createMenu( 6004, edgeId, -1 );
3661 createMenu( 6029, edgeId, -1 );
3662 createMenu( 6021, faceId, -1 );
3663 createMenu( 6025, faceId, -1 );
3664 createMenu( 6027, faceId, -1 );
3665 createMenu( 6018, faceId, -1 );
3666 createMenu( 6019, faceId, -1 );
3667 createMenu( 6011, faceId, -1 );
3668 createMenu( 6012, faceId, -1 );
3669 createMenu( 6013, faceId, -1 );
3670 createMenu( 6014, faceId, -1 );
3671 createMenu( 6015, faceId, -1 );
3672 createMenu( 6016, faceId, -1 );
3673 createMenu( 6022, faceId, -1 );
3674 createMenu( 6030, faceId, -1 );
3675 createMenu( 6017, volumeId, -1 );
3676 createMenu( 6009, volumeId, -1 );
3677 createMenu( 6023, volumeId, -1 );
3678 createMenu( 6024, volumeId, -1 );
3679 createMenu( 6026, volumeId, -1 );
3680 createMenu( 6031, volumeId, -1 );
3682 createMenu( 4000, addId, -1 );
3683 createMenu( 4009, addId, -1 );
3684 createMenu( 4010, addId, -1 );
3685 createMenu( 4021, addId, -1 );
3686 createMenu( 4022, addId, -1 );
3687 createMenu( 4023, addId, -1 );
3688 createMenu( 4031, addId, -1 );
3689 createMenu( 4032, addId, -1 );
3690 createMenu( 4133, addId, -1 );
3691 createMenu( 4134, addId, -1 );
3692 createMenu( 4135, addId, -1 );
3693 createMenu( 4033, addId, -1 );
3694 createMenu( separator(), addId, -1 );
3695 createMenu( 4034, addId, -1 );
3696 createMenu( 4035, addId, -1 );
3697 createMenu( 4036, addId, -1 );
3698 createMenu( 4136, addId, -1 );
3699 createMenu( 4037, addId, -1 );
3700 createMenu( 4038, addId, -1 );
3701 createMenu( 4039, addId, -1 );
3702 createMenu( 4040, addId, -1 );
3703 createMenu( 4140, addId, -1 );
3705 createMenu( 4041, removeId, -1 );
3706 createMenu( 4042, removeId, -1 );
3707 createMenu( 4044, removeId, -1 );
3708 createMenu( separator(), removeId, -1 );
3709 createMenu( 813, removeId, -1 );
3710 createMenu( separator(), removeId, -1 );
3711 createMenu( 4043, removeId, -1 );
3713 createMenu( 4051, renumId, -1 );
3714 createMenu( 4052, renumId, -1 );
3716 createMenu( 4061, transfId, -1 );
3717 createMenu( 4062, transfId, -1 );
3718 createMenu( 4063, transfId, -1 );
3719 createMenu( 4068, transfId, -1 );
3720 createMenu( 4064, transfId, -1 );
3721 createMenu( 4065, transfId, -1 );
3722 createMenu( 4066, transfId, -1 );
3723 createMenu( 4069, transfId, -1 );
3725 createMenu( 4067,modifyId, -1 );
3726 createMenu( 407, modifyId, -1 );
3727 createMenu( 408, modifyId, -1 );
3728 createMenu( 409, modifyId, -1 );
3729 createMenu( 410, modifyId, -1 );
3730 createMenu( 411, modifyId, -1 );
3731 createMenu( 419, modifyId, -1 );
3732 createMenu( 412, modifyId, -1 );
3733 createMenu( 413, modifyId, -1 );
3734 createMenu( 416, modifyId, -1 );
3735 createMenu( 414, modifyId, -1 );
3736 createMenu( 415, modifyId, -1 );
3737 createMenu( 417, modifyId, -1 );
3738 createMenu( 418, modifyId, -1 );
3740 createMenu( 501, measureId, -1 );
3741 createMenu( 502, measureId, -1 );
3742 createMenu( 214, viewId, -1 );
3744 // ----- create toolbars --------------
3745 int meshTb = createTool( tr( "TB_MESH" ) ),
3746 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3747 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3748 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3749 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3751 createTool( 702, meshTb );
3752 createTool( 703, meshTb );
3753 createTool( 704, meshTb );
3754 createTool( 710, meshTb );
3755 createTool( 705, meshTb );
3756 createTool( separator(), meshTb );
3757 createTool( 701, meshTb );
3758 createTool( 711, meshTb );
3759 createTool( 712, meshTb );
3760 createTool( 713, meshTb );
3761 createTool( separator(), meshTb );
3762 createTool( 801, meshTb );
3763 createTool( 806, meshTb );
3764 createTool( 802, meshTb );
3765 createTool( 803, meshTb );
3766 //createTool( 815, meshTb );
3767 createTool( separator(), meshTb );
3768 createTool( 900, meshTb );
3769 //createTool( 902, meshTb );
3770 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3771 createTool( 904, meshTb );
3772 createTool( separator(), meshTb );
3774 createTool( 6005, ctrlTb );
3775 createTool( 6028, ctrlTb );
3776 createTool( separator(), ctrlTb );
3777 createTool( 6002, ctrlTb );
3778 createTool( 6003, ctrlTb );
3779 createTool( 6001, ctrlTb );
3780 createTool( 6004, ctrlTb );
3781 createTool( 6029, ctrlTb );
3782 createTool( separator(), ctrlTb );
3783 createTool( 6021, ctrlTb );
3784 createTool( 6025, ctrlTb );
3785 createTool( 6027, ctrlTb );
3786 createTool( 6018, ctrlTb );
3787 createTool( 6019, ctrlTb );
3788 createTool( 6011, ctrlTb );
3789 createTool( 6012, ctrlTb );
3790 createTool( 6013, ctrlTb );
3791 createTool( 6014, ctrlTb );
3792 createTool( 6015, ctrlTb );
3793 createTool( 6016, ctrlTb );
3794 createTool( 6022, ctrlTb );
3795 createTool( 6030, ctrlTb );
3796 createTool( separator(), ctrlTb );
3797 createTool( 6017, ctrlTb );
3798 createTool( 6009, ctrlTb );
3799 createTool( 6023, ctrlTb );
3800 createTool( 6024, ctrlTb );
3801 createTool( 6026, ctrlTb );
3802 createTool( 6031, ctrlTb );
3803 createTool( separator(), ctrlTb );
3805 createTool( 4000, addRemTb );
3806 createTool( 4009, addRemTb );
3807 createTool( 4010, addRemTb );
3808 createTool( 4021, addRemTb );
3809 createTool( 4022, addRemTb );
3810 createTool( 4023, addRemTb );
3811 createTool( 4031, addRemTb );
3812 createTool( 4032, addRemTb );
3813 createTool( 4133, addRemTb );
3814 createTool( 4134, addRemTb );
3815 createTool( 4135, addRemTb );
3816 createTool( 4033, addRemTb );
3817 createTool( separator(), addRemTb );
3818 createTool( 4034, addRemTb );
3819 createTool( 4035, addRemTb );
3820 createTool( 4036, addRemTb );
3821 createTool( 4136, addRemTb );
3822 createTool( 4037, addRemTb );
3823 createTool( 4038, addRemTb );
3824 createTool( 4039, addRemTb );
3825 createTool( 4040, addRemTb );
3826 createTool( 4140, addRemTb );
3827 createTool( separator(), addRemTb );
3828 createTool( 4041, addRemTb );
3829 createTool( 4042, addRemTb );
3830 createTool( 4044, addRemTb );
3831 createTool( 4043, addRemTb );
3832 createTool( separator(), addRemTb );
3833 createTool( 4051, addRemTb );
3834 createTool( 4052, addRemTb );
3835 createTool( separator(), addRemTb );
3836 createTool( 4061, addRemTb );
3837 createTool( 4062, addRemTb );
3838 createTool( 4063, addRemTb );
3839 createTool( 4068, addRemTb );
3840 createTool( 4064, addRemTb );
3841 createTool( 4065, addRemTb );
3842 createTool( 4066, addRemTb );
3843 createTool( 4069, addRemTb );
3844 createTool( separator(), addRemTb );
3846 createTool( 4067,modifyTb );
3847 createTool( 407, modifyTb );
3848 createTool( 408, modifyTb );
3849 createTool( 409, modifyTb );
3850 createTool( 410, modifyTb );
3851 createTool( 411, modifyTb );
3852 createTool( 419, modifyTb );
3853 createTool( 412, modifyTb );
3854 createTool( 413, modifyTb );
3855 createTool( 416, modifyTb );
3856 createTool( 414, modifyTb );
3857 createTool( 415, modifyTb );
3858 createTool( 417, modifyTb );
3859 createTool( 418, modifyTb );
3861 createTool( 214, dispModeTb );
3863 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3864 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3867 QString OB = "'ObjectBrowser'",
3868 View = "'" + SVTK_Viewer::Type() + "'",
3870 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3871 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3872 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3873 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3874 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3875 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3876 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3877 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3878 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3879 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3880 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3882 mesh_part = mesh + " " + subMesh + " " + group,
3883 mesh_group = mesh + " " + group,
3884 hyp_alg = hypo + " " + algo;
3886 // popup for object browser
3888 isInvisible("not( isVisible )"),
3889 isEmpty("numberOfNodes = 0"),
3890 isNotEmpty("numberOfNodes <> 0"),
3892 // has nodes, edges, etc in VISIBLE! actor
3893 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3894 hasElems("(count( elemTypes ) > 0)"),
3895 hasDifferentElems("(count( elemTypes ) > 1)"),
3896 hasElems0d("({'Elem0d'} in elemTypes)"),
3897 hasEdges("({'Edge'} in elemTypes)"),
3898 hasFaces("({'Face'} in elemTypes)"),
3899 hasVolumes("({'Volume'} in elemTypes)");
3901 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
3902 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
3903 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
3904 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
3905 createPopupItem( 803, OB, group ); // EDIT_GROUP
3906 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
3908 popupMgr()->insert( separator(), -1, 0 );
3909 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
3910 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3911 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
3912 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
3913 createPopupItem( 214, OB, mesh_part ); // UPDATE
3914 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
3915 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
3916 popupMgr()->insert( separator(), -1, 0 );
3917 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
3918 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
3919 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
3920 popupMgr()->insert( separator(), -1, 0 );
3921 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
3922 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
3923 popupMgr()->insert( separator(), -1, 0 );
3924 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
3925 popupMgr()->insert( separator(), -1, 0 );
3926 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
3927 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
3929 popupMgr()->insert( separator(), -1, 0 );
3931 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3932 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3933 QString only_one_2D = only_one_non_empty + " && dim>1";
3935 createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
3936 createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
3937 createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
3939 createPopupItem( 143, OB, mesh_group, multiple_non_empty ); // EXPORT_CGNS
3941 createPopupItem( 145, OB, mesh_group, multiple_non_empty ); // EXPORT_SAUV
3942 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
3943 popupMgr()->insert( separator(), -1, 0 );
3946 createPopupItem( 803, View, group ); // EDIT_GROUP
3947 createPopupItem( 804, View, elems ); // ADD
3948 createPopupItem( 805, View, elems ); // REMOVE
3950 popupMgr()->insert( separator(), -1, 0 );
3951 createPopupItem( 214, View, mesh_part ); // UPDATE
3952 createPopupItem( 900, View, mesh_part ); // ADV_INFO
3953 createPopupItem( 904, View, mesh ); // FIND_ELEM
3954 popupMgr()->insert( separator(), -1, 0 );
3956 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3957 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
3958 popupMgr()->insert( separator(), -1, 0 );
3961 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3962 QString aType = QString( "%1type in {%2}" ).arg( lc );
3963 aType = aType.arg( mesh_part );
3964 QString aMeshInVTK = aClient + "&&" + aType;
3966 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3967 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3968 QString aSelCount = QString( "%1 > 0" ).arg( dc );
3970 //-------------------------------------------------
3972 //-------------------------------------------------
3973 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3975 popupMgr()->insert( action( 9010 ), anId, -1 );
3976 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3977 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3979 popupMgr()->insert( action( 9011 ), anId, -1 );
3980 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3981 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3983 popupMgr()->insert( separator(), -1, -1 );
3985 //-------------------------------------------------
3987 //-------------------------------------------------
3988 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3990 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3991 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3992 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3994 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3995 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3996 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3998 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3999 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4000 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4002 popupMgr()->insert( separator(), anId, -1 );
4004 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4005 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4006 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4008 //-------------------------------------------------
4010 //-------------------------------------------------
4011 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4013 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4015 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4016 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4017 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4019 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4020 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4021 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4023 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4024 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4025 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4027 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4028 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4029 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4031 popupMgr()->insert( separator(), anId, -1 );
4033 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4034 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4037 //-------------------------------------------------
4038 // Representation of the 2D Quadratic elements
4039 //-------------------------------------------------
4040 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4041 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4042 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4043 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4045 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4046 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4047 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4049 //-------------------------------------------------
4050 // Orientation of faces
4051 //-------------------------------------------------
4052 popupMgr()->insert( action( 221 ), -1, -1 );
4053 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4054 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4056 //-------------------------------------------------
4058 //-------------------------------------------------
4059 popupMgr()->insert( action( 1132 ), -1, -1 );
4060 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4062 //-------------------------------------------------
4064 //-------------------------------------------------
4065 popupMgr()->insert( action( 1133 ), -1, -1 );
4066 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4068 //-------------------------------------------------
4070 //-------------------------------------------------
4072 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4073 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4074 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4075 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4077 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4079 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4080 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4082 popupMgr()->insert( separator(), anId, -1 );
4084 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4086 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4087 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4088 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4090 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4091 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4092 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4094 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4096 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4097 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4098 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4100 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4101 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4102 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4104 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4105 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4106 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4108 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4109 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4110 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4111 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4112 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4113 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4115 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4117 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4118 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4119 QtxPopupMgr::VisibleRule );
4120 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4122 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4123 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4124 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4126 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4127 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4128 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4130 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4131 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4132 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4134 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4135 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4136 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4138 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4139 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4140 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4142 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4143 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4144 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4146 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4147 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4148 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4150 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4151 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4152 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4154 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4155 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4156 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4158 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4159 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4160 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4162 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4163 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4164 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4165 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4166 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4167 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4169 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4171 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4172 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4173 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4175 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4176 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4177 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4179 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4180 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4181 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4183 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4184 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4185 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4187 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4188 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4189 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4191 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4192 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4193 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4195 popupMgr()->insert( separator(), anId, -1 );
4197 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4198 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4200 popupMgr()->insert( separator(), anId, -1 );
4202 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4204 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4205 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4207 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4208 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4209 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4211 #ifndef DISABLE_PLOT2DVIEWER
4212 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4213 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4216 //-------------------------------------------------
4218 //-------------------------------------------------
4219 popupMgr()->insert( separator(), -1, -1 );
4220 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4221 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4222 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4223 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4225 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4226 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4228 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4229 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4231 popupMgr()->insert( separator(), -1, -1 );
4233 //-------------------------------------------------
4235 //-------------------------------------------------
4236 popupMgr()->insert( action( 1134 ), -1, -1 );
4237 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4239 popupMgr()->insert( separator(), -1, -1 );
4241 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4242 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4244 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4245 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4248 //================================================================================
4250 * \brief Return true if SMESH or GEOM objects are selected.
4251 * Is called form LightApp_Module::activateModule() which clear selection if
4252 * not isSelectionCompatible()
4254 //================================================================================
4256 bool SMESHGUI::isSelectionCompatible()
4258 bool isCompatible = true;
4259 SALOME_ListIO selected;
4260 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4261 Sel->selectedObjects( selected );
4263 SALOME_ListIteratorOfListIO It( selected );
4264 for ( ; isCompatible && It.More(); It.Next())
4266 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4267 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4269 return isCompatible;
4273 bool SMESHGUI::reusableOperation( const int id )
4275 // compute, evaluate and precompute are not reusable operations
4276 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4279 bool SMESHGUI::activateModule( SUIT_Study* study )
4281 bool res = SalomeApp_Module::activateModule( study );
4283 setMenuShown( true );
4284 setToolShown( true );
4286 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4287 PyGILState_STATE gstate = PyGILState_Ensure();
4288 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4289 if(pluginsmanager==NULL)
4293 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4298 PyGILState_Release(gstate);
4299 // end of GEOM plugins loading
4301 // Reset actions accelerator keys
4302 action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4303 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4304 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4306 action( 33)->setEnabled(true); // Delete: Key_Delete
4308 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4309 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4310 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4311 if ( _PTR(Study) aStudy = s->studyDS()) {
4312 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4313 updateObjBrowser(); // objects can be removed
4316 // get all view currently opened in the study and connect their signals to
4317 // the corresponding slots of the class.
4318 SUIT_Desktop* aDesk = study->application()->desktop();
4320 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4321 SUIT_ViewWindow* wnd;
4322 foreach ( wnd, wndList )
4329 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4331 setMenuShown( false );
4332 setToolShown( false );
4334 EmitSignalCloseAllDialogs();
4336 // Unset actions accelerator keys
4337 action(111)->setShortcut(QKeySequence()); // Import DAT
4338 action(112)->setShortcut(QKeySequence()); // Import UNV
4339 action(113)->setShortcut(QKeySequence()); // Import MED
4341 action( 33)->setEnabled(false); // Delete: Key_Delete
4343 return SalomeApp_Module::deactivateModule( study );
4346 void SMESHGUI::studyClosed( SUIT_Study* s )
4348 SMESH::RemoveVisuData( s->id() );
4349 SalomeApp_Module::studyClosed( s );
4352 void SMESHGUI::OnGUIEvent()
4354 const QObject* obj = sender();
4355 if ( !obj || !obj->inherits( "QAction" ) )
4357 int id = actionId((QAction*)obj);
4362 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4364 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4365 if ( CORBA::is_nil( myComponentSMESH ) )
4367 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4369 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4370 return aGUI.myComponentSMESH;
4373 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4374 return myComponentSMESH;
4377 QString SMESHGUI::engineIOR() const
4379 CORBA::ORB_var anORB = getApp()->orb();
4380 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4381 return QString( anIOR.in() );
4384 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4386 SalomeApp_Module::contextMenuPopup( client, menu, title );
4388 selectionMgr()->selectedObjects( lst );
4389 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4390 Handle(SALOME_InteractiveObject) io = lst.First();
4391 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4392 _PTR(Study) study = appStudy->studyDS();
4393 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4395 QString aName = QString( obj->GetName().c_str() );
4396 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4397 aName.remove( (aName.length() - 1), 1 );
4403 LightApp_Selection* SMESHGUI::createSelection() const
4405 return new SMESHGUI_Selection();
4408 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4410 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4411 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4414 void SMESHGUI::viewManagers( QStringList& list ) const
4416 list.append( SVTK_Viewer::Type() );
4419 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4421 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4422 SMESH::UpdateSelectionProp( this );
4424 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4425 for(int i = 0; i < aViews.count() ; i++){
4426 SUIT_ViewWindow *sf = aViews[i];
4432 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4434 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4435 myClippingPlaneInfoMap.erase( theViewManager );
4438 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4440 theActor->AddObserver( SMESH::DeleteActorEvent,
4441 myEventCallbackCommand.GetPointer(),
4445 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4446 unsigned long theEvent,
4447 void* theClientData,
4450 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4451 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4452 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4453 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4454 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4455 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4456 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4457 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4458 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4459 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4460 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4461 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4462 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4463 if( anActor == *anIter3 ) {
4464 anActorList.erase( anIter3 );
4475 void SMESHGUI::createPreferences()
4477 // General tab ------------------------------------------------------------------------
4478 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4480 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4481 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4482 setPreferenceProperty( lim, "min", 0 );
4483 setPreferenceProperty( lim, "max", 100000000 );
4484 setPreferenceProperty( lim, "step", 1000 );
4485 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4487 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4488 setPreferenceProperty( qaGroup, "columns", 2 );
4489 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4490 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4491 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4492 setPreferenceProperty( prec, "min", 0 );
4493 setPreferenceProperty( prec, "max", 16 );
4494 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4495 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4496 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4497 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4498 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4500 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4501 setPreferenceProperty( dispgroup, "columns", 2 );
4502 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4504 modes.append( tr("MEN_WIRE") );
4505 modes.append( tr("MEN_SHADE") );
4506 modes.append( tr("MEN_NODES") );
4507 modes.append( tr("MEN_SHRINK") );
4508 QList<QVariant> indices;
4509 indices.append( 0 );
4510 indices.append( 1 );
4511 indices.append( 2 );
4512 indices.append( 3 );
4513 setPreferenceProperty( dispmode, "strings", modes );
4514 setPreferenceProperty( dispmode, "indexes", indices );
4516 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4517 setPreferenceProperty( arcgroup, "columns", 2 );
4518 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4519 QStringList quadraticModes;
4520 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4521 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4523 indices.append( 0 );
4524 indices.append( 1 );
4525 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4526 setPreferenceProperty( quadraticmode, "indexes", indices );
4528 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4529 "SMESH", "max_angle" );
4530 setPreferenceProperty( maxAngle, "min", 1 );
4531 setPreferenceProperty( maxAngle, "max", 90 );
4535 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4536 setPreferenceProperty( exportgroup, "columns", 2 );
4537 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4538 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4540 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4541 setPreferenceProperty( computeGroup, "columns", 2 );
4542 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4544 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4545 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4546 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4548 indices.append( 0 );
4549 indices.append( 1 );
4550 indices.append( 2 );
4551 setPreferenceProperty( notifyMode, "strings", modes );
4552 setPreferenceProperty( notifyMode, "indexes", indices );
4554 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4555 setPreferenceProperty( infoGroup, "columns", 4 );
4556 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4558 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4559 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4561 indices.append( 0 );
4562 indices.append( 1 );
4563 setPreferenceProperty( elemInfo, "strings", modes );
4564 setPreferenceProperty( elemInfo, "indexes", indices );
4565 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4566 setPreferenceProperty( nodesLim, "min", 0 );
4567 setPreferenceProperty( nodesLim, "max", 10000000 );
4568 setPreferenceProperty( nodesLim, "step", 10000 );
4569 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4571 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4572 setPreferenceProperty( segGroup, "columns", 2 );
4573 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4574 "SMESH", "segmentation" );
4575 setPreferenceProperty( segLen, "min", 1 );
4576 setPreferenceProperty( segLen, "max", 10000000 );
4577 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4578 "SMESH", "nb_segments_per_edge" );
4579 setPreferenceProperty( nbSeg, "min", 1 );
4580 setPreferenceProperty( nbSeg, "max", 10000000 );
4582 // Quantities with individual precision settings
4583 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4584 setPreferenceProperty( precGroup, "columns", 2 );
4586 const int nbQuantities = 6;
4587 int precs[nbQuantities], ii = 0;
4588 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4589 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4590 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4591 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4592 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4593 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4594 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4595 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4596 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4597 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4598 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4599 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4601 // Set property for precision value for spinboxes
4602 for ( ii = 0; ii < nbQuantities; ii++ ){
4603 setPreferenceProperty( precs[ii], "min", -14 );
4604 setPreferenceProperty( precs[ii], "max", 14 );
4605 setPreferenceProperty( precs[ii], "precision", 2 );
4608 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4609 setPreferenceProperty( previewGroup, "columns", 2 );
4610 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4611 setPreferenceProperty( chunkSize, "min", 0 );
4612 setPreferenceProperty( chunkSize, "max", 1000 );
4613 setPreferenceProperty( chunkSize, "step", 50 );
4615 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4616 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4618 // Mesh tab ------------------------------------------------------------------------
4619 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4620 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4621 setPreferenceProperty( nodeGroup, "columns", 3 );
4623 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4625 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4627 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4628 QList<QVariant> aMarkerTypeIndicesList;
4629 QList<QVariant> aMarkerTypeIconsList;
4630 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4631 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4632 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4633 aMarkerTypeIndicesList << i;
4634 aMarkerTypeIconsList << pixmap;
4636 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4637 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4639 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4641 QList<QVariant> aMarkerScaleIndicesList;
4642 QStringList aMarkerScaleValuesList;
4643 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4644 aMarkerScaleIndicesList << i;
4645 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4647 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4648 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4650 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4651 setPreferenceProperty( elemGroup, "columns", 2 );
4653 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4654 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4656 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4657 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4659 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4661 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4662 setPreferenceProperty( grpGroup, "columns", 2 );
4664 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4666 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4667 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4668 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4669 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4670 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4671 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4673 setPreferenceProperty( size0d, "min", 1 );
4674 setPreferenceProperty( size0d, "max", 10 );
4676 setPreferenceProperty( elemW, "min", 1 );
4677 setPreferenceProperty( elemW, "max", 5 );
4679 setPreferenceProperty( shrink, "min", 0 );
4680 setPreferenceProperty( shrink, "max", 100 );
4682 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4683 setPreferenceProperty( orientGroup, "columns", 1 );
4685 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4686 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4688 setPreferenceProperty( orientScale, "min", 0.05 );
4689 setPreferenceProperty( orientScale, "max", 0.5 );
4690 setPreferenceProperty( orientScale, "step", 0.05 );
4692 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4694 // Selection tab ------------------------------------------------------------------------
4695 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4697 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4698 setPreferenceProperty( selGroup, "columns", 2 );
4700 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4701 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4703 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4704 setPreferenceProperty( preGroup, "columns", 2 );
4706 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4708 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4709 setPreferenceProperty( precSelGroup, "columns", 2 );
4711 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4712 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4713 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4715 // Scalar Bar tab ------------------------------------------------------------------------
4716 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4717 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4718 setPreferenceProperty( fontGr, "columns", 2 );
4720 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4721 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4723 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4724 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4726 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4727 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4729 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4730 setPreferenceProperty( numcol, "min", 2 );
4731 setPreferenceProperty( numcol, "max", 256 );
4733 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4734 setPreferenceProperty( numlab, "min", 2 );
4735 setPreferenceProperty( numlab, "max", 65 );
4737 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4738 setPreferenceProperty( orientGr, "columns", 2 );
4739 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4740 QStringList orients;
4741 orients.append( tr( "SMESH_VERTICAL" ) );
4742 orients.append( tr( "SMESH_HORIZONTAL" ) );
4743 indices.clear(); indices.append( 0 ); indices.append( 1 );
4744 setPreferenceProperty( orient, "strings", orients );
4745 setPreferenceProperty( orient, "indexes", indices );
4747 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4748 setPreferenceProperty( posVSizeGr, "columns", 2 );
4749 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4750 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4751 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4752 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4753 setPreferenceProperty( xv, "step", 0.1 );
4754 setPreferenceProperty( xv, "min", 0.0 );
4755 setPreferenceProperty( xv, "max", 1.0 );
4756 setPreferenceProperty( yv, "step", 0.1 );
4757 setPreferenceProperty( yv, "min", 0.0 );
4758 setPreferenceProperty( yv, "max", 1.0 );
4759 setPreferenceProperty( wv, "step", 0.1 );
4760 setPreferenceProperty( wv, "min", 0.0 );
4761 setPreferenceProperty( wv, "max", 1.0 );
4762 setPreferenceProperty( hv, "min", 0.0 );
4763 setPreferenceProperty( hv, "max", 1.0 );
4764 setPreferenceProperty( hv, "step", 0.1 );
4766 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4767 setPreferenceProperty( posHSizeGr, "columns", 2 );
4768 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4769 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4770 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4771 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4772 setPreferenceProperty( xv, "min", 0.0 );
4773 setPreferenceProperty( xv, "max", 1.0 );
4774 setPreferenceProperty( xv, "step", 0.1 );
4775 setPreferenceProperty( xh, "min", 0.0 );
4776 setPreferenceProperty( xh, "max", 1.0 );
4777 setPreferenceProperty( xh, "step", 0.1 );
4778 setPreferenceProperty( yh, "min", 0.0 );
4779 setPreferenceProperty( yh, "max", 1.0 );
4780 setPreferenceProperty( yh, "step", 0.1 );
4781 setPreferenceProperty( wh, "min", 0.0 );
4782 setPreferenceProperty( wh, "max", 1.0 );
4783 setPreferenceProperty( wh, "step", 0.1 );
4784 setPreferenceProperty( hh, "min", 0.0 );
4785 setPreferenceProperty( hh, "max", 1.0 );
4786 setPreferenceProperty( hh, "step", 0.1 );
4788 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4789 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4790 setPreferenceProperty( distributionGr, "columns", 3 );
4792 types.append( tr( "SMESH_MONOCOLOR" ) );
4793 types.append( tr( "SMESH_MULTICOLOR" ) );
4794 indices.clear(); indices.append( 0 ); indices.append( 1 );
4795 setPreferenceProperty( coloringType, "strings", types );
4796 setPreferenceProperty( coloringType, "indexes", indices );
4797 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4801 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4803 if( sect=="SMESH" ) {
4804 float sbX1,sbY1,sbW,sbH;
4805 float aTol = 1.00000009999999;
4806 std::string aWarning;
4807 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4808 if( name=="selection_object_color" || name=="selection_element_color" ||
4809 name=="highlight_color" ||
4810 name=="selection_precision_node" || name=="selection_precision_element" ||
4811 name=="selection_precision_object")
4812 SMESH::UpdateSelectionProp( this );
4813 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4814 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4815 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4816 if(sbX1+sbW > aTol){
4817 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4820 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4821 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4824 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4825 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4826 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4827 if(sbY1+sbH > aTol){
4828 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4829 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4830 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4833 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4834 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4835 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4836 if(sbX1+sbW > aTol){
4837 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4840 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4841 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4844 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4845 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4846 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4847 if(sbY1+sbH > aTol){
4848 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4851 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4852 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4855 else if ( name == "segmentation" ) {
4856 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4857 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4859 else if ( name == "nb_segments_per_edge" ) {
4860 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4861 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4863 else if ( name == "historical_python_dump" ) {
4864 QString val = aResourceMgr->stringValue( "SMESH", "historical_python_dump" );
4865 myComponentSMESH->SetOption( "historical_python_dump", val.toLatin1().constData() );
4868 if(aWarning.size() != 0){
4869 aWarning += "The default values are applied instead.";
4870 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4871 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4872 QObject::tr(aWarning.c_str()));
4877 //================================================================================
4879 * \brief Update something in accordance with update flags
4880 * \param theFlags - update flags
4882 * Update viewer or/and object browser etc. in accordance with update flags ( see
4883 * LightApp_UpdateFlags enumeration ).
4885 //================================================================================
4886 void SMESHGUI::update( const int flags )
4888 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4889 SMESH::UpdateView();
4891 SalomeApp_Module::update( flags );
4894 //================================================================================
4896 * \brief Set default selection mode
4898 * SLOT called when operation commited. Sets default selection mode
4900 //================================================================================
4901 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4903 SVTK_ViewWindow* vtkWnd =
4904 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4906 vtkWnd->SetSelectionMode( ActorSelection );
4909 //================================================================================
4911 * \brief Set default selection mode
4913 * SLOT called when operation aborted. Sets default selection mode
4915 //================================================================================
4916 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4918 SVTK_ViewWindow* vtkWnd =
4919 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4921 vtkWnd->SetSelectionMode( ActorSelection );
4924 //================================================================================
4926 * \brief Creates operation with given identifier
4927 * \param id - identifier of operation to be started
4928 * \return Pointer on created operation or NULL if operation is not created
4930 * Virtual method redefined from the base class creates operation with given id.
4931 * It is called called automatically from startOperation method of base class.
4933 //================================================================================
4934 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4936 LightApp_Operation* op = 0;
4937 // to do : create operation here
4940 case 417: //convert to quadratic
4941 op = new SMESHGUI_ConvToQuadOp();
4943 case 418: // create 2D mesh as boundary on 3D
4944 op = new SMESHGUI_Make2DFrom3DOp();
4946 case 701: // Compute mesh
4947 op = new SMESHGUI_ComputeOp();
4949 case 702: // Create mesh
4950 op = new SMESHGUI_MeshOp( true, true );
4952 case 703: // Create sub-mesh
4953 op = new SMESHGUI_MeshOp( true, false );
4955 case 704: // Edit mesh/sub-mesh
4956 op = new SMESHGUI_MeshOp( false );
4958 case 711: // Precompute mesh
4959 op = new SMESHGUI_PrecomputeOp();
4961 case 712: // Evaluate mesh
4962 op = new SMESHGUI_EvaluateOp();
4964 case 713: // Evaluate mesh
4965 op = new SMESHGUI_MeshOrderOp();
4967 case 806: // Create group on geom
4968 op = new SMESHGUI_GroupOnShapeOp();
4970 case 904: // Find element
4971 op = new SMESHGUI_FindElemByPointOp();
4973 case 4067: // make mesh pass through point
4974 op = new SMESHGUI_MakeNodeAtPointOp();
4981 op = SalomeApp_Module::createOperation( id );
4985 //================================================================================
4987 * \brief Stops current operations and starts a given one
4988 * \param id - The id of the operation to start
4990 //================================================================================
4992 void SMESHGUI::switchToOperation(int id)
4994 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4995 activeStudy()->abortAllOperations();
4996 startOperation( id );
4999 LightApp_Displayer* SMESHGUI::displayer()
5002 myDisplayer = new SMESHGUI_Displayer( getApp() );
5006 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5009 int aTolerance = 64;
5010 int anIterations = 0;
5016 if( anIterations % aPeriod == 0 )
5019 if( aTolerance < 1 )
5023 aHue = (int)( 360.0 * rand() / RAND_MAX );
5026 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5027 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5028 for( ; it != itEnd; ++it )
5030 SALOMEDS::Color anAutoColor = *it;
5031 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5034 aQColor.getHsv( &h, &s, &v );
5035 if( abs( h - aHue ) < aTolerance )
5047 aColor.setHsv( aHue, 255, 255 );
5049 SALOMEDS::Color aSColor;
5050 aSColor.R = (double)aColor.red() / 255.0;
5051 aSColor.G = (double)aColor.green() / 255.0;
5052 aSColor.B = (double)aColor.blue() / 255.0;
5057 const char gSeparator = '_'; // character used to separate parameter names
5058 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5059 const char gPathSep = '|'; // character used to separate paths
5062 * \brief Store visual parameters
5064 * This method is called just before the study document is saved.
5065 * Store visual parameters in AttributeParameter attribue(s)
5067 void SMESHGUI::storeVisualParameters (int savePoint)
5069 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5070 if (!appStudy || !appStudy->studyDS())
5072 _PTR(Study) studyDS = appStudy->studyDS();
5074 // componentName is used for encoding of entries when storing them in IParameters
5075 std::string componentName = myComponentSMESH->ComponentDataType();
5076 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5077 //if (!aSComponent) return;
5080 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5081 componentName.c_str(),
5083 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5085 // store map of custom markers
5086 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5087 if( !aMarkerMap.empty() )
5089 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5090 for( ; anIter != aMarkerMap.end(); anIter++ )
5092 int anId = anIter->first;
5093 VTK::MarkerData aMarkerData = anIter->second;
5094 std::string aMarkerFileName = aMarkerData.first;
5095 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5096 if( aMarkerTexture.size() < 3 )
5097 continue; // should contain at least width, height and the first value
5099 QString aPropertyName( "texture" );
5100 aPropertyName += gSeparator;
5101 aPropertyName += QString::number( anId );
5103 QString aPropertyValue = aMarkerFileName.c_str();
5104 aPropertyValue += gPathSep;
5106 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5107 ushort aWidth = *aTextureIter++;
5108 ushort aHeight = *aTextureIter++;
5109 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5110 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5111 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5112 aPropertyValue += QString::number( *aTextureIter );
5114 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5118 // viewers counters are used for storing view_numbers in IParameters
5121 // main cycle to store parameters of displayed objects
5122 QList<SUIT_ViewManager*> lst;
5123 QList<SUIT_ViewManager*>::Iterator it;
5124 getApp()->viewManagers(lst);
5125 for (it = lst.begin(); it != lst.end(); it++)
5127 SUIT_ViewManager* vman = *it;
5128 QString vType = vman->getType();
5130 // saving VTK actors properties
5131 if (vType == SVTK_Viewer::Type())
5133 // store the clipping planes attached to the view manager
5134 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5135 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5136 if( anIter != myClippingPlaneInfoMap.end() )
5137 aClippingPlaneInfoList = anIter->second;
5139 if( !aClippingPlaneInfoList.empty() ) {
5140 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5141 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5143 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5144 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5146 QString aPropertyName( "ClippingPlane" );
5147 aPropertyName += gSeparator;
5148 aPropertyName += QString::number( vtkViewers );
5149 aPropertyName += gSeparator;
5150 aPropertyName += QString::number( anId );
5152 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5153 aPropertyValue += gDigitsSep;
5154 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5155 aPropertyValue += gDigitsSep;
5156 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5157 aPropertyValue += gDigitsSep;
5158 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5160 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5164 QVector<SUIT_ViewWindow*> views = vman->getViews();
5165 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5167 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5169 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5170 vtkActorCollection* allActors = aCopy.GetActors();
5171 allActors->InitTraversal();
5172 while (vtkActor* actor = allActors->GetNextActor())
5174 if (actor->GetVisibility()) // store only visible actors
5176 SMESH_Actor* aSmeshActor = 0;
5177 if (actor->IsA("SMESH_Actor"))
5178 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5179 if (aSmeshActor && aSmeshActor->hasIO())
5181 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5184 // entry is "encoded" = it does NOT contain component adress,
5185 // since it is a subject to change on next component loading
5186 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5188 std::string param, vtkParam = vType.toLatin1().data();
5189 vtkParam += gSeparator;
5190 vtkParam += QString::number(vtkViewers).toLatin1().data();
5191 vtkParam += gSeparator;
5194 param = vtkParam + "Visibility";
5195 ip->setParameter(entry, param, "On");
5198 param = vtkParam + "Representation";
5199 ip->setParameter(entry, param, QString::number
5200 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5203 param = vtkParam + "IsShrunk";
5204 ip->setParameter(entry, param, QString::number
5205 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5207 // Displayed entities
5208 unsigned int aMode = aSmeshActor->GetEntityMode();
5209 bool isE = aMode & SMESH_Actor::eEdges;
5210 bool isF = aMode & SMESH_Actor::eFaces;
5211 bool isV = aMode & SMESH_Actor::eVolumes;
5213 QString modeStr ("e");
5214 modeStr += gDigitsSep; modeStr += QString::number(isE);
5215 modeStr += gDigitsSep; modeStr += "f";
5216 modeStr += gDigitsSep; modeStr += QString::number(isF);
5217 modeStr += gDigitsSep; modeStr += "v";
5218 modeStr += gDigitsSep; modeStr += QString::number(isV);
5220 param = vtkParam + "Entities";
5221 ip->setParameter(entry, param, modeStr.toLatin1().data());
5223 // Colors (surface:edge:)
5224 vtkFloatingPointType r, g, b;
5227 aSmeshActor->GetSufaceColor(r, g, b, delta);
5228 QString colorStr ("surface");
5229 colorStr += gDigitsSep; colorStr += QString::number(r);
5230 colorStr += gDigitsSep; colorStr += QString::number(g);
5231 colorStr += gDigitsSep; colorStr += QString::number(b);
5233 colorStr += gDigitsSep; colorStr += "backsurface";
5234 colorStr += gDigitsSep; colorStr += QString::number(delta);
5237 aSmeshActor->GetEdgeColor(r, g, b);
5238 colorStr += gDigitsSep; colorStr += "edge";
5239 colorStr += gDigitsSep; colorStr += QString::number(r);
5240 colorStr += gDigitsSep; colorStr += QString::number(g);
5241 colorStr += gDigitsSep; colorStr += QString::number(b);
5243 aSmeshActor->GetNodeColor(r, g, b);
5244 colorStr += gDigitsSep; colorStr += "node";
5245 colorStr += gDigitsSep; colorStr += QString::number(r);
5246 colorStr += gDigitsSep; colorStr += QString::number(g);
5247 colorStr += gDigitsSep; colorStr += QString::number(b);
5249 aSmeshActor->GetOutlineColor(r, g, b);
5250 colorStr += gDigitsSep; colorStr += "outline";
5251 colorStr += gDigitsSep; colorStr += QString::number(r);
5252 colorStr += gDigitsSep; colorStr += QString::number(g);
5253 colorStr += gDigitsSep; colorStr += QString::number(b);
5255 param = vtkParam + "Colors";
5256 ip->setParameter(entry, param, colorStr.toLatin1().data());
5258 // Sizes of lines and points
5259 QString sizeStr ("line");
5260 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5261 sizeStr += gDigitsSep; sizeStr += "shrink";
5262 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5264 param = vtkParam + "Sizes";
5265 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5270 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5271 if( aMarkerType == VTK::MT_USER ) {
5272 markerStr += "custom";
5273 markerStr += gDigitsSep;
5274 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5278 markerStr += gDigitsSep;
5279 markerStr += QString::number( (int)aMarkerType );
5280 markerStr += gDigitsSep;
5281 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5284 param = vtkParam + "PointMarker";
5285 ip->setParameter(entry, param, markerStr.toLatin1().data());
5288 param = vtkParam + "Opacity";
5289 ip->setParameter(entry, param,
5290 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5293 param = vtkParam + "ClippingPlane";
5295 if( !aClippingPlaneInfoList.empty() ) {
5296 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5297 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5299 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5300 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5301 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5302 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5303 if( aSmeshActor == *anIter2 ) {
5304 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5305 QString::number( anId ).toLatin1().constData() );
5312 ip->setParameter( entry, param, "Off" );
5313 } // if (io->hasEntry())
5314 } // SMESH_Actor && hasIO
5316 } // while.. actors traversal
5320 } // if (SVTK view model)
5321 } // for (viewManagers)
5324 // data structures for clipping planes processing
5327 vtkIdType Orientation;
5328 vtkFloatingPointType Distance;
5329 vtkFloatingPointType Angle[2];
5331 typedef std::list<TPlaneData> TPlaneDataList;
5332 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5334 typedef std::list<vtkActor*> TActorList;
5337 TActorList ActorList;
5338 SUIT_ViewManager* ViewManager;
5340 typedef std::list<TPlaneInfo> TPlaneInfoList;
5341 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5344 * \brief Restore visual parameters
5346 * This method is called after the study document is opened.
5347 * Restore visual parameters from AttributeParameter attribue(s)
5349 void SMESHGUI::restoreVisualParameters (int savePoint)
5351 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5352 if (!appStudy || !appStudy->studyDS())
5354 _PTR(Study) studyDS = appStudy->studyDS();
5356 // componentName is used for encoding of entries when storing them in IParameters
5357 std::string componentName = myComponentSMESH->ComponentDataType();
5358 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5359 //if (!aSComponent) return;
5362 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5363 componentName.c_str(),
5365 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5367 // restore map of custom markers and map of clipping planes
5368 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5369 TPlaneDataMap aPlaneDataMap;
5371 std::vector<std::string> properties = ip->getProperties();
5372 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5374 std::string property = *propIt;
5375 QString aPropertyName( property.c_str() );
5376 QString aPropertyValue( ip->getProperty( property ).c_str() );
5378 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5379 if( aPropertyNameList.isEmpty() )
5382 QString aPropertyType = aPropertyNameList[0];
5383 if( aPropertyType == "texture" )
5385 if( aPropertyNameList.size() != 2 )
5389 int anId = aPropertyNameList[1].toInt( &ok );
5390 if( !ok || anId < 1 )
5393 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5394 if( aPropertyValueList.size() != 2 )
5397 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5398 QString aMarkerTextureString = aPropertyValueList[1];
5399 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5400 if( aMarkerTextureStringList.size() != 3 )
5404 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5409 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5413 VTK::MarkerTexture aMarkerTexture;
5414 aMarkerTexture.push_back( aWidth );
5415 aMarkerTexture.push_back( aHeight );
5417 QString aMarkerTextureData = aMarkerTextureStringList[2];
5418 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5420 QChar aChar = aMarkerTextureData.at( i );
5421 if( aChar.isDigit() )
5422 aMarkerTexture.push_back( aChar.digitValue() );
5425 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5427 else if( aPropertyType == "ClippingPlane" )
5429 if( aPropertyNameList.size() != 3 )
5433 int aViewId = aPropertyNameList[1].toInt( &ok );
5434 if( !ok || aViewId < 0 )
5438 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5439 if( !ok || aClippingPlaneId < 0 )
5442 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5443 if( aPropertyValueList.size() != 4 )
5446 TPlaneData aPlaneData;
5447 aPlaneData.Id = aClippingPlaneId;
5450 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5455 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5460 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5465 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5469 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5470 aPlaneDataList.push_back( aPlaneData );
5474 TPlaneInfoMap aPlaneInfoMap;
5476 std::vector<std::string> entries = ip->getEntries();
5478 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5480 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5481 QString entry (ip->decodeEntry(*entIt).c_str());
5483 // Check that the entry corresponds to a real object in the Study
5484 // as the object may be deleted or modified after the visual state is saved.
5485 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5486 if (!so) continue; //Skip the not existent entry
5488 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5489 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5491 std::vector<std::string>::iterator namesIt = paramNames.begin();
5492 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5494 // actors are stored in a map after displaying of them for
5495 // quicker access in the future: map < viewID to actor >
5496 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5498 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5500 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5501 // '_' is used as separator and should not be used in viewer type or parameter names.
5502 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5503 if (lst.size() != 3)
5506 QString viewerTypStr = lst[0];
5507 QString viewIndexStr = lst[1];
5508 QString paramNameStr = lst[2];
5511 int viewIndex = viewIndexStr.toUInt(&ok);
5512 if (!ok) // bad conversion of view index to integer
5516 if (viewerTypStr == SVTK_Viewer::Type())
5518 SMESH_Actor* aSmeshActor = 0;
5519 if (vtkActors.IsBound(viewIndex))
5520 aSmeshActor = vtkActors.Find(viewIndex);
5522 QList<SUIT_ViewManager*> lst;
5523 getApp()->viewManagers(viewerTypStr, lst);
5525 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5526 SUIT_ViewManager* vman = NULL;
5527 if (viewIndex >= 0 && viewIndex < lst.count())
5528 vman = lst.at(viewIndex);
5530 if (paramNameStr == "Visibility")
5532 if (!aSmeshActor && displayer() && vman)
5534 SUIT_ViewModel* vmodel = vman->getViewModel();
5535 // SVTK view model can be casted to SALOME_View
5536 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5538 // store displayed actor in a temporary map for quicker
5539 // access later when restoring other parameters
5540 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5541 vtkRenderer* Renderer = vtkView->getRenderer();
5542 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5543 vtkActorCollection* theActors = aCopy.GetActors();
5544 theActors->InitTraversal();
5545 bool isFound = false;
5546 vtkActor *ac = theActors->GetNextActor();
5547 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5548 if (ac->IsA("SMESH_Actor")) {
5549 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5550 if (aGeomAc->hasIO()) {
5551 Handle(SALOME_InteractiveObject) io =
5552 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5553 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5555 vtkActors.Bind(viewIndex, aGeomAc);
5561 } // if (paramNameStr == "Visibility")
5564 // the rest properties "work" with SMESH_Actor
5567 QString val ((*valuesIt).c_str());
5570 if (paramNameStr == "Representation") {
5571 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5574 else if (paramNameStr == "IsShrunk") {
5576 if (!aSmeshActor->IsShrunk())
5577 aSmeshActor->SetShrink();
5580 if (aSmeshActor->IsShrunk())
5581 aSmeshActor->UnShrink();
5584 // Displayed entities
5585 else if (paramNameStr == "Entities") {
5586 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5587 if (mode.count() == 6) {
5588 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5589 MESSAGE("Invalid order of data in Entities, must be: "
5590 "e:0/1:f:0/1:v:0/1");
5593 unsigned int aMode = aSmeshActor->GetEntityMode();
5594 unsigned int aNewMode =
5595 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5596 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5597 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5598 if (aNewMode != aMode)
5599 aSmeshActor->SetEntityMode(aNewMode);
5604 else if (paramNameStr == "Colors") {
5605 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5606 if (colors.count() == 16 || colors.count() == 18 ) {
5607 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5608 (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5609 (colors.count() == 18 && colors[14] != "outline")) {
5610 MESSAGE("Invalid order of data in Colors, must be: "
5611 "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");
5617 vtkFloatingPointType otr,otg,otb;
5618 //Old case backsurface color is independent
5619 if( colors.count() == 16 ) {
5621 SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5622 er = colors[9].toFloat();
5623 eg = colors[10].toFloat();
5624 eb = colors[11].toFloat();
5626 nr = colors[13].toFloat();
5627 ng = colors[14].toFloat();
5628 nb = colors[15].toFloat();
5629 SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5631 //New case backsurface color depends on surface color
5632 delta = colors[5].toInt();
5634 er = colors[7].toFloat();
5635 eg = colors[8].toFloat();
5636 eb = colors[9].toFloat();
5638 nr = colors[11].toFloat();
5639 ng = colors[12].toFloat();
5640 nb = colors[13].toFloat();
5642 otr = colors[15].toFloat();
5643 otg = colors[16].toFloat();
5644 otb = colors[17].toFloat();
5646 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5647 aSmeshActor->SetEdgeColor(er,eg,eb);
5648 aSmeshActor->SetNodeColor(nr,ng,nb);
5649 aSmeshActor->SetOutlineColor(otr,otg,otb);
5653 // Sizes of lines and points
5654 else if (paramNameStr == "Sizes") {
5655 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5656 if (sizes.count() == 4) {
5657 if (sizes[0] != "line" || sizes[2] != "shrink") {
5658 MESSAGE("Invalid order of data in Sizes, must be: "
5659 "line:int:shrink:float");
5662 aSmeshActor->SetLineWidth(sizes[1].toInt());
5663 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5666 else if (sizes.count() == 6) { // just to support old format
5667 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5668 MESSAGE("Invalid order of data in Sizes, must be: "
5669 "line:int:node:int:shrink:float");
5672 aSmeshActor->SetLineWidth(sizes[1].toInt());
5673 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5674 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5679 else if (paramNameStr == "PointMarker") {
5680 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5681 if( data.count() >= 2 ) {
5683 int aParam1 = data[1].toInt( &ok );
5685 if( data[0] == "std" && data.count() == 3 ) {
5686 int aParam2 = data[2].toInt( &ok );
5687 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5689 else if( data[0] == "custom" ) {
5690 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5691 if( markerIt != aMarkerMap.end() ) {
5692 VTK::MarkerData aMarkerData = markerIt->second;
5693 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5700 else if (paramNameStr == "Opacity") {
5701 aSmeshActor->SetOpacity(val.toFloat());
5704 else if (paramNameStr.startsWith("ClippingPlane")) {
5705 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5706 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5707 // new format - val looks like "Off" or "0" (plane id)
5708 // (note: in new format "Off" value is used only for consistency,
5709 // so it is processed together with values in old format)
5710 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5711 if( anIsOldFormat ) {
5712 if (paramNameStr == "ClippingPlane1" || val == "Off")
5713 aSmeshActor->RemoveAllClippingPlanes();
5715 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5716 double aDistance = vals[1].toFloat();
5717 vtkFloatingPointType anAngle[2];
5718 anAngle[0] = vals[2].toFloat();
5719 anAngle[1] = vals[3].toFloat();
5721 QList<SUIT_ViewManager*> lst;
5722 getApp()->viewManagers(viewerTypStr, lst);
5723 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5724 if (viewIndex >= 0 && viewIndex < lst.count()) {
5725 SUIT_ViewManager* vman = lst.at(viewIndex);
5726 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5728 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5730 SMESH::TActorList anActorList;
5731 anActorList.push_back( aSmeshActor );
5732 SMESH::OrientedPlane* aPlane =
5733 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5735 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5736 aClippingPlaneInfo.Plane = aPlane;
5737 aClippingPlaneInfo.ActorList = anActorList;
5738 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5745 int aPlaneId = val.toInt( &ok );
5746 if( ok && aPlaneId >= 0 ) {
5747 bool anIsDefinedPlane = false;
5748 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5749 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5750 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5751 TPlaneInfo& aPlaneInfo = *anIter;
5752 if( aPlaneInfo.PlaneId == aPlaneId ) {
5753 aPlaneInfo.ActorList.push_back( aSmeshActor );
5754 anIsDefinedPlane = true;
5758 if( !anIsDefinedPlane ) {
5759 TPlaneInfo aPlaneInfo;
5760 aPlaneInfo.PlaneId = aPlaneId;
5761 aPlaneInfo.ActorList.push_back( aSmeshActor );
5762 aPlaneInfo.ViewManager = vman;
5764 // to make the list sorted by plane id
5765 anIter = aPlaneInfoList.begin();
5766 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5767 const TPlaneInfo& aPlaneInfoRef = *anIter;
5768 if( aPlaneInfoRef.PlaneId > aPlaneId )
5771 aPlaneInfoList.insert( anIter, aPlaneInfo );
5776 } // if (aSmeshActor)
5777 } // other parameters than Visibility
5779 } // for names/parameters iterator
5780 } // for entries iterator
5782 // take into account planes with empty list of actors referred to them
5783 QList<SUIT_ViewManager*> aVMList;
5784 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5786 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5787 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5788 int aViewId = aPlaneDataIter->first;
5789 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5790 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5792 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5794 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5795 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5796 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5797 const TPlaneData& aPlaneData = *anIter2;
5798 int aPlaneId = aPlaneData.Id;
5800 bool anIsFound = false;
5801 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5802 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5803 const TPlaneInfo& aPlaneInfo = *anIter3;
5804 if( aPlaneInfo.PlaneId == aPlaneId ) {
5811 TPlaneInfo aPlaneInfo; // ActorList field is empty
5812 aPlaneInfo.PlaneId = aPlaneId;
5813 aPlaneInfo.ViewManager = aViewManager;
5815 // to make the list sorted by plane id
5816 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5817 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5818 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5819 if( aPlaneInfoRef.PlaneId > aPlaneId )
5822 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5828 // add clipping planes to actors according to the restored parameters
5829 // and update the clipping plane map
5830 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5831 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5832 int aViewId = anIter1->first;
5833 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5835 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5836 if( anIter2 == aPlaneDataMap.end() )
5838 const TPlaneDataList& aPlaneDataList = anIter2->second;
5840 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5841 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5842 const TPlaneInfo& aPlaneInfo = *anIter3;
5843 int aPlaneId = aPlaneInfo.PlaneId;
5844 const TActorList& anActorList = aPlaneInfo.ActorList;
5845 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5849 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5853 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5855 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5856 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5857 const TPlaneData& aPlaneData = *anIter4;
5858 if( aPlaneData.Id == aPlaneId ) {
5859 SMESH::OrientedPlane* aPlane =
5860 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5862 (SMESH::Orientation)aPlaneData.Orientation,
5863 aPlaneData.Distance,
5866 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5867 aClippingPlaneInfo.Plane = aPlane;
5868 aClippingPlaneInfo.ActorList = anActorList;
5869 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5877 // update all VTK views
5878 QList<SUIT_ViewManager*> lst;
5879 getApp()->viewManagers(lst);
5880 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5881 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5882 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5883 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5884 vtkView->getRenderer()->ResetCameraClippingRange();
5891 \brief Adds preferences for dfont of VTK viewer
5893 \param pIf group identifier
5894 \param param parameter
5895 \return identifier of preferences
5897 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5899 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5901 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5904 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5905 fam.append( tr( "SMESH_FONT_COURIER" ) );
5906 fam.append( tr( "SMESH_FONT_TIMES" ) );
5908 setPreferenceProperty( tfont, "fonts", fam );
5910 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5911 setPreferenceProperty( tfont, "features", f );
5917 \brief Actions after hypothesis edition
5918 Updates object browser after hypothesis edition
5920 void SMESHGUI::onHypothesisEdit( int result )
5923 SMESHGUI::Modified();
5924 updateObjBrowser( true );
5929 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5930 \param pview view being closed
5932 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5933 #ifndef DISABLE_PLOT2DVIEWER
5934 //Crear all Plot2d Viewers if need.
5935 SMESH::ClearPlot2Viewers(pview);
5940 \brief Connects or disconnects signals about activating and cloning view on the module slots
5941 \param pview view which is connected/disconnected
5943 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5947 SUIT_ViewManager* viewMgr = pview->getViewManager();
5949 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5950 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5952 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5953 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5958 \brief Return \c true if object can be renamed
5960 bool SMESHGUI::renameAllowed( const QString& entry) const {
5961 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5965 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5969 bool appRes = SalomeApp_Module::renameAllowed(entry);
5973 // check type to prevent renaming of inappropriate objects
5974 int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5975 if (aType == MESH || aType == GROUP ||
5976 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5977 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5978 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5979 aType == HYPOTHESIS || aType == ALGORITHM)
5986 Rename object by entry.
5987 \param entry entry of the object
5988 \param name new name of the object
5989 \brief Return \c true if rename operation finished successfully, \c false otherwise.
5991 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5993 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5997 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
6001 bool appRes = SalomeApp_Module::renameObject(entry,name);
6005 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6006 _PTR(GenericAttribute) anAttr;
6007 _PTR(AttributeName) aName;
6009 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6011 // check type to prevent renaming of inappropriate objects
6012 int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
6013 if (aType == MESH || aType == GROUP ||
6014 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6015 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6016 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6017 aType == HYPOTHESIS || aType == ALGORITHM) {
6018 if ( !name.isEmpty() ) {
6019 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6021 // update name of group object and its actor
6022 Handle(SALOME_InteractiveObject) IObject =
6023 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6025 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6026 if( !aGroupObject->_is_nil() ) {
6027 aGroupObject->SetName( qPrintable(name) );
6028 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6029 anActor->setName( qPrintable(name) );