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
29 #include "SMESHGUI_AddMeshElementDlg.h"
30 #include "SMESHGUI_AddQuadraticElementDlg.h"
31 #include "SMESHGUI_BuildCompoundDlg.h"
32 #include "SMESHGUI_ClippingDlg.h"
33 #include "SMESHGUI_ComputeDlg.h"
34 #include "SMESHGUI_ConvToQuadOp.h"
35 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
36 #include "SMESHGUI_DeleteGroupDlg.h"
37 #include "SMESHGUI_Displayer.h"
38 #include "SMESHGUI_MergeDlg.h"
39 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
40 #include "SMESHGUI_ExtrusionDlg.h"
41 #include "SMESHGUI_FileInfoDlg.h"
42 #include "SMESHGUI_FileValidator.h"
43 #include "SMESHGUI_FilterDlg.h"
44 #include "SMESHGUI_FilterLibraryDlg.h"
45 #include "SMESHGUI_FindElemByPointDlg.h"
46 #include "SMESHGUI_GroupDlg.h"
47 #include "SMESHGUI_GroupOnShapeDlg.h"
48 #include "SMESHGUI_GroupOpDlg.h"
49 #include "SMESHGUI_Hypotheses.h"
50 #include "SMESHGUI_Make2DFrom3DOp.h"
51 #include "SMESHGUI_MakeNodeAtPointDlg.h"
52 //#include "SMESHGUI_MeshInfosDlg.h"
53 #include "SMESHGUI_Measurements.h"
54 #include "SMESHGUI_MeshInfo.h"
55 #include "SMESHGUI_MeshOp.h"
56 #include "SMESHGUI_MeshOrderOp.h"
57 #include "SMESHGUI_MeshPatternDlg.h"
58 #include "SMESHGUI_MultiEditDlg.h"
59 #include "SMESHGUI_NodesDlg.h"
60 #include "SMESHGUI_Preferences_ColorDlg.h"
61 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
62 #include "SMESHGUI_RemoveElementsDlg.h"
63 #include "SMESHGUI_RemoveNodesDlg.h"
64 #include "SMESHGUI_RenumberingDlg.h"
65 #include "SMESHGUI_RevolutionDlg.h"
66 #include "SMESHGUI_RotationDlg.h"
67 #include "SMESHGUI_Selection.h"
68 #include "SMESHGUI_SewingDlg.h"
69 #include "SMESHGUI_SingleEditDlg.h"
70 #include "SMESHGUI_SmoothingDlg.h"
71 //#include "SMESHGUI_StandardMeshInfosDlg.h"
72 #include "SMESHGUI_SymmetryDlg.h"
73 #include "SMESHGUI_TranslationDlg.h"
74 #include "SMESHGUI_ScaleDlg.h"
75 #include "SMESHGUI_TransparencyDlg.h"
76 //#include "SMESHGUI_WhatIsDlg.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_Client.hxx>
89 #include <SMESH_Actor.h>
90 #include <SMESH_ScalarBarActor.h>
91 #include <SMESH_ActorUtils.h>
92 #include <SMESH_TypeFilter.hxx>
93 #include "SMESH_ControlsDef.hxx"
95 // SALOME GUI includes
96 #include <SalomeApp_Tools.h>
97 #include <SalomeApp_Study.h>
98 #include <SalomeApp_Application.h>
99 #include <SalomeApp_CheckFileDlg.h>
101 #include <LightApp_DataOwner.h>
102 #include <LightApp_Preferences.h>
103 #include <LightApp_SelectionMgr.h>
104 #include <LightApp_UpdateFlags.h>
105 #include <LightApp_NameDlg.h>
107 #include <SVTK_ViewWindow.h>
108 #include <SVTK_ViewModel.h>
109 #include <SVTK_ViewManager.h>
111 #include <VTKViewer_Algorithm.h>
113 #include <SUIT_MessageBox.h>
114 #include <SUIT_ResourceMgr.h>
115 #include <SUIT_FileDlg.h>
116 #include <SUIT_Desktop.h>
117 #include <SUIT_OverrideCursor.h>
118 #include <SUIT_Session.h>
120 #include <QtxPopupMgr.h>
121 #include <QtxFontEdit.h>
123 #include <SALOME_ListIO.hxx>
124 #include <SALOME_ListIteratorOfListIO.hxx>
126 #ifndef DISABLE_PLOT2DVIEWER
127 #include <SPlot2d_ViewModel.h>
128 #include <SPlot2d_Histogram.h>
132 #include <SALOMEconfig.h>
133 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
134 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
135 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
138 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
140 #include <QTextStream>
143 #include <boost/shared_ptr.hpp>
146 #include <vtkCamera.h>
147 #include <vtkRenderer.h>
148 #include <vtkPlane.h>
149 #include <vtkCallbackCommand.h>
150 #include <vtkLookupTable.h>
152 // SALOME KERNEL includes
153 #include <SALOMEDS_Study.hxx>
154 #include <SALOMEDSClient_StudyBuilder.hxx>
155 #include <SALOMEDSClient_SComponent.hxx>
156 #include <SALOMEDSClient_ClientFactory.hxx>
157 #include <SALOMEDSClient_IParameters.hxx>
160 #include <Standard_ErrorHandler.hxx>
161 #include <NCollection_DataMap.hxx>
163 //To disable automatic genericobj management, the following line should be commented.
164 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
165 #define WITHGENERICOBJ
169 //=============================================================
170 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
173 void ExportMeshToFile(int theCommandID);
175 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
177 void SetDisplayEntity(int theCommandID);
179 void Control( int theCommandID );
183 //=============================================================
184 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
188 std::string myExtension;
190 if ( theCommandID == 113 ) {
191 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
192 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
194 else if ( theCommandID == 112 ) {
195 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
197 else if ( theCommandID == 111 ) {
198 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
200 else if ( theCommandID == 140 ) {
201 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
204 QString anInitialPath = "";
205 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
206 anInitialPath = QDir::currentPath();
208 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
211 QObject::tr( "SMESH_IMPORT_MESH" ) );
212 if ( filenames.count() > 0 ) {
213 SUIT_OverrideCursor wc;
214 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
217 QStringList anEntryList;
218 bool isEmpty = false;
219 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
220 QString filename = *it;
221 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
223 switch ( theCommandID ) {
226 // DAT format (currently unsupported)
227 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
228 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
234 aMeshes->length( 1 );
235 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
236 if ( aMeshes[0]->_is_nil() )
237 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
238 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
244 SMESH::DriverMED_ReadStatus res;
245 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
246 if ( res != SMESH::DRS_OK ) {
247 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
248 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
255 aMeshes->length( 1 );
256 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
257 if ( aMeshes[0]->_is_nil() ) {
258 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
259 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
265 catch ( const SALOME::SALOME_Exception& S_ex ) {
266 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
267 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
270 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
271 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
273 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
274 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
275 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
276 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
277 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
279 anEntryList.append( aMeshSO->GetID().c_str() );
281 #ifdef WITHGENERICOBJ
282 // obj has been published in study. Its refcount has been incremented.
283 // It is safe to decrement its refcount
284 // so that it will be destroyed when the entry in study will be removed
285 aMeshes[i]->UnRegister();
294 // update Object browser
295 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
297 // browse to the published meshes
298 if( LightApp_Application* anApp =
299 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
300 anApp->browseObjects( anEntryList );
302 // show Error message box if there were errors
303 if ( errors.count() > 0 ) {
304 SUIT_MessageBox::critical( SMESHGUI::desktop(),
305 QObject::tr( "SMESH_ERROR" ),
306 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
309 // show warning message box, if some imported mesh is empty
311 SUIT_MessageBox::warning( SMESHGUI::desktop(),
312 QObject::tr( "SMESH_WRN_WARNING" ),
313 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
318 //================================================================================
320 * \brief Export selected meshes or groups into a file
322 //================================================================================
324 void ExportMeshToFile( int theCommandID )
326 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
327 SALOME_ListIO selected;
329 aSel->selectedObjects( selected );
331 // actually, the following condition can't be met (added for insurance)
332 if( selected.Extent() == 0 ||
333 ( selected.Extent() > 1 && theCommandID != 122 && theCommandID != 125 ) )
336 bool hasDuplicatedMeshNames = false;
337 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
338 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
339 SALOME_ListIteratorOfListIO It( selected );
340 for( ; It.More(); It.Next() ) {
341 Handle(SALOME_InteractiveObject) anIObject = It.Value();
342 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
343 if ( aMeshItem->_is_nil() ) {
344 SUIT_MessageBox::warning( SMESHGUI::desktop(),
345 QObject::tr( "SMESH_WRN_WARNING" ),
346 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
350 QString aMeshName = anIObject->getName();
352 // check for duplications
353 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
354 if( aMeshName == (*aMeshIter).second ) {
355 hasDuplicatedMeshNames = true;
360 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
363 if( hasDuplicatedMeshNames ) {
364 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
365 QObject::tr("SMESH_WRN_WARNING"),
366 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
367 QObject::tr("SMESH_BUT_YES"),
368 QObject::tr("SMESH_BUT_NO"), 0, 1);
373 aMeshIter = aMeshList.begin();
374 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
375 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
376 QString aMeshName = (*aMeshIter).second;
378 QList<SALOMEDS::Color> aReservedColors;
380 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
381 QMap<QString, SMESH::MED_VERSION> aFilterMap;
382 QMap<QString, int> aFilterMapSTL;
383 switch ( theCommandID ) {
387 // check for equal group names within each mesh
388 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
389 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
390 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
391 int aRet = SUIT_MessageBox::warning
392 (SMESHGUI::desktop(),
393 QObject::tr("SMESH_WRN_WARNING"),
394 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
395 QObject::tr("SMESH_BUT_YES"),
396 QObject::tr("SMESH_BUT_NO"), 0, 1);
401 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
402 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
403 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
404 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
409 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
414 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
415 int nbPyramids = nbElems[ SMESH::Entity_Pyramid ] + nbElems[ SMESH::Entity_Quad_Pyramid ];
416 if ( nbPyramids > 0 ) {
417 int aRet = SUIT_MessageBox::warning
418 (SMESHGUI::desktop(),
419 QObject::tr("SMESH_WRN_WARNING"),
420 QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
421 QObject::tr("SMESH_BUT_YES"),
422 QObject::tr("SMESH_BUT_NO"), 0, 1);
426 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
432 aFilterMapSTL.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 ); // 1 - ASCII mode
433 aFilterMapSTL.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 ); // 0 - Binary mode
441 SMESH::MED_VERSION aFormat;
442 // Init the parameters with the default values
443 bool aIsASCII_STL = true;
444 bool toCreateGroups = false;
445 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
447 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
448 bool toOverwrite = true;
450 QString anInitialPath = "";
451 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
452 anInitialPath = QDir::currentPath();
454 if ( theCommandID != 122 && theCommandID != 125 && theCommandID != 141) // neither MED nor STL
456 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
457 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
458 anInitialPath + QString("/") + aMeshName,
459 aFilter, aTitle, false);
461 else if(theCommandID == 141) // Export to STL
464 QMap<QString, int>::const_iterator it = aFilterMapSTL.begin();
465 for ( ; it != aFilterMapSTL.end(); ++it )
466 filters.push_back( it.key() );
468 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
469 fd->setWindowTitle( aTitle );
470 fd->setNameFilters( filters );
471 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
472 if ( !anInitialPath.isEmpty() )
473 fd->setDirectory( anInitialPath );
474 fd->selectFile(aMeshName);
478 aFilename = fd->selectedFile();
479 aIsASCII_STL = (aFilterMapSTL[fd->selectedNameFilter()]) == 1 ? true: false;
484 else // Export to MED
487 QString aDefaultFilter;
488 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
489 for ( ; it != aFilterMap.end(); ++it ) {
490 filters.push_back( it.key() );
491 if (it.value() == SMESH::MED_V2_2)
492 aDefaultFilter = it.key();
495 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
496 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
497 fd->setWindowTitle( aTitle );
498 fd->setNameFilters( filters );
499 fd->selectNameFilter(aDefaultFilter);
500 fd->SetChecked(toCreateGroups);
501 if ( !anInitialPath.isEmpty() )
502 fd->setDirectory( anInitialPath );
503 fd->selectFile(aMeshName);
505 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
506 fd->setValidator( fv );
511 aFilename = fd->selectedFile();
513 aFilename = QString::null;
516 aFormat = aFilterMap[fd->selectedNameFilter()];
517 toOverwrite = fv->isOverwrite();
519 if ( !aFilename.isEmpty() ) {
520 // med-2.1 does not support poly elements
521 if ( aFormat==SMESH::MED_V2_1 )
522 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
523 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
524 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
525 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
526 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
528 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
529 QObject::tr("SMESH_WRN_WARNING"),
530 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
531 QObject::tr("SMESH_BUT_YES"),
532 QObject::tr("SMESH_BUT_NO"), 0, 1);
540 // can't append to an existing using other format
541 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
542 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
543 if( !isVersionOk || aVersion != aFormat ) {
544 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
545 QObject::tr("SMESH_WRN_WARNING"),
546 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
547 QObject::tr("SMESH_BUT_YES"),
548 QObject::tr("SMESH_BUT_NO"), 0, 1);
555 QStringList aMeshNamesCollisionList;
556 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
557 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
558 QString anExistingMeshName( aMeshNames[ i ] );
559 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
560 QString anExportMeshName = (*aMeshIter).second;
561 if( anExportMeshName == anExistingMeshName ) {
562 aMeshNamesCollisionList.append( anExportMeshName );
567 if( !aMeshNamesCollisionList.isEmpty() ) {
568 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
569 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
570 QObject::tr("SMESH_WRN_WARNING"),
571 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
572 QObject::tr("SMESH_BUT_YES"),
573 QObject::tr("SMESH_BUT_NO"),
574 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
583 toCreateGroups = fd->IsChecked();
586 if ( !aFilename.isEmpty() ) {
587 // Check whether the file already exists and delete it if yes
588 QFile aFile( aFilename );
589 if ( aFile.exists() && toOverwrite )
591 SUIT_OverrideCursor wc;
594 bool Renumber = false;
595 // PAL 14172 : Check of we have to renumber or not from the preferences before export
597 Renumber= resMgr->booleanValue("SMESH","renumbering");
599 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
600 aMeshEditor->RenumberNodes();
601 aMeshEditor->RenumberElements();
602 if ( SMESHGUI::automaticUpdate() )
605 switch ( theCommandID ) {
608 aMeshIter = aMeshList.begin();
609 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
611 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
612 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
613 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
614 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
615 aFormat, toOverwrite && aMeshIndex == 0 );
617 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
618 aFormat, toOverwrite && aMeshIndex == 0 );
623 if ( aMeshOrGroup->_is_equivalent( aMesh ))
624 aMesh->ExportDAT( aFilename.toLatin1().data() );
626 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
630 if ( aMeshOrGroup->_is_equivalent( aMesh ))
631 aMesh->ExportUNV( aFilename.toLatin1().data() );
633 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
636 if ( aMeshOrGroup->_is_equivalent( aMesh ))
637 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
639 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
645 catch (const SALOME::SALOME_Exception& S_ex){
647 SUIT_MessageBox::warning(SMESHGUI::desktop(),
648 QObject::tr("SMESH_WRN_WARNING"),
649 QObject::tr("SMESH_EXPORT_FAILED"));
655 inline void InverseEntityMode(unsigned int& theOutputMode,
656 unsigned int theMode)
658 bool anIsNotPresent = ~theOutputMode & theMode;
660 theOutputMode |= theMode;
662 theOutputMode &= ~theMode;
665 void SetDisplayEntity(int theCommandID){
666 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
667 SALOME_ListIO selected;
669 aSel->selectedObjects( selected );
671 if(selected.Extent() >= 1){
672 SALOME_ListIteratorOfListIO It( selected );
673 for( ; It.More(); It.Next()){
674 Handle(SALOME_InteractiveObject) IObject = It.Value();
675 if(IObject->hasEntry()){
676 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
677 unsigned int aMode = anActor->GetEntityMode();
678 switch(theCommandID){
680 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
683 InverseEntityMode(aMode,SMESH_Actor::eEdges);
686 InverseEntityMode(aMode,SMESH_Actor::eFaces);
689 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
692 aMode = SMESH_Actor::eAllEntity;
696 anActor->SetEntityMode(aMode);
704 SALOME_ListIO selected;
705 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
709 LightApp_SelectionMgr* aSel = app->selectionMgr();
710 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
711 if( !aSel || !appStudy )
714 aSel->selectedObjects( selected );
715 if( selected.IsEmpty() )
718 Handle(SALOME_InteractiveObject) anIObject = selected.First();
720 _PTR(Study) aStudy = appStudy->studyDS();
721 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
722 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
723 if( aMainObject->_is_nil() )
726 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
728 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
729 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
731 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
732 SALOMEDS::Color aColor = aGroupObject->GetColor();
733 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
735 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
736 if( aGroupObject->GetType() == SMESH::NODE )
737 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B );
738 else if( aGroupObject->GetType() == SMESH::EDGE )
739 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
740 else if( aGroupObject->GetType() == SMESH::ELEM0D )
741 anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
743 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B );
748 SMESH::RepaintCurrentView();
751 QString functorToString( SMESH::Controls::FunctorPtr f )
753 QString type = QObject::tr( "UNKNOWN_CONTROL" );
754 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
755 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
756 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
757 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
758 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
759 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
760 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
761 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
762 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
763 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
764 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
765 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
766 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
767 type = QObject::tr( "WARP_ELEMENTS" );
768 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
769 type = QObject::tr( "TAPER_ELEMENTS" );
770 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
771 type = QObject::tr( "SKEW_ELEMENTS" );
772 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
773 type = QObject::tr( "AREA_ELEMENTS" );
774 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
775 type = QObject::tr( "LENGTH_EDGES" );
776 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
777 type = QObject::tr( "LENGTH2D_EDGES" );
778 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
779 type = QObject::tr( "MULTI_BORDERS" );
780 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
781 type = QObject::tr( "MULTI2D_BORDERS" );
782 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
783 type = QObject::tr( "FREE_NODES" );
784 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
785 type = QObject::tr( "FREE_EDGES" );
786 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
787 type = QObject::tr( "FREE_BORDERS" );
788 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
789 type = QObject::tr( "FREE_FACES" );
790 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
791 type = QObject::tr( "BARE_BORDER_VOLUME" );
792 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
793 type = QObject::tr( "BARE_BORDER_FACE" );
794 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
795 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
796 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
797 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
801 void SaveDistribution()
803 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
804 SALOME_ListIO selected;
806 aSel->selectedObjects( selected );
808 if ( selected.Extent() == 1 ) {
809 Handle(SALOME_InteractiveObject) anIO = selected.First();
810 if ( anIO->hasEntry() ) {
811 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
812 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
813 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
814 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
815 if ( aScalarBarActor && aFunctor ) {
816 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
818 std::vector<int> elements;
819 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
820 if ( mesh->_is_nil() ) {
821 SMESH::SMESH_IDSource_var idSource =
822 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
823 if ( !idSource->_is_nil() )
825 SMESH::long_array_var ids = idSource->GetIDs();
826 elements.resize( ids->length() );
827 for ( unsigned i = 0; i < elements.size(); ++i )
828 elements[i] = ids[i];
831 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
832 vtkLookupTable* lookupTable =
833 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
834 double * minmax = lookupTable->GetRange();
835 std::vector<int> nbEvents;
836 std::vector<double> funValues;
837 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
838 QString anInitialPath = "";
839 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
840 anInitialPath = QDir::currentPath();
841 QString aMeshName = anIO->getName();
843 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
844 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
845 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
846 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
847 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
850 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
852 if ( !aFilename.isEmpty() ) {
853 QFile f( aFilename );
854 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
855 QTextStream out( &f );
856 out << "# Mesh: " << aMeshName << endl;
857 out << "# Control: " << functorToString( aFunctor ) << endl;
859 out.setFieldWidth( 10 );
860 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
861 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
872 void ShowDistribution() {
873 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
874 SALOME_ListIO selected;
876 aSel->selectedObjects( selected );
878 if ( selected.Extent() == 1 ) {
879 Handle(SALOME_InteractiveObject) anIO = selected.First();
880 if ( anIO->hasEntry() ) {
881 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
882 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
883 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
884 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
890 #ifndef DISABLE_PLOT2DVIEWER
891 void PlotDistribution() {
892 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
896 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
897 SALOME_ListIO selected;
899 aSel->selectedObjects( selected );
901 if ( selected.Extent() == 1 ) {
902 Handle(SALOME_InteractiveObject) anIO = selected.First();
903 if ( anIO->hasEntry() ) {
904 //Find Actor by entry before getting Plot2d viewer,
905 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
906 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
908 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
913 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
917 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
921 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
922 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
923 QString functorName = functorToString( anActor->GetFunctor());
924 QString aHistogramName("%1 : %2");
925 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
926 aHistogram->setName(aHistogramName);
927 aHistogram->setHorTitle(functorName);
928 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
929 aPlot->displayObject(aHistogram, true);
934 #endif //DISABLE_PLOT2DVIEWER
936 void DisableAutoColor(){
937 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
938 SALOME_ListIO selected;
940 aSel->selectedObjects( selected );
942 if(selected.Extent()){
943 Handle(SALOME_InteractiveObject) anIObject = selected.First();
944 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
945 if ( !aMesh->_is_nil() ) {
946 aMesh->SetAutoColor( false );
951 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){
952 SALOME_ListIO selected;
953 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
957 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
958 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
959 if( !aSel || !appStudy )
962 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
963 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
964 aModule->EmitSignalDeactivateDialog();
965 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
966 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
971 _PTR(Study) aStudy = appStudy->studyDS();
973 aSel->selectedObjects( selected );
975 if(selected.Extent() >= 1){
976 switch(theCommandID){
978 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
979 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
983 QColor c, e, b, n, c0D, o;
986 vtkFloatingPointType Shrink = 0.0;
987 vtkFloatingPointType faces_orientation_scale = 0.0;
988 bool faces_orientation_3dvectors = false;
990 VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE;
991 VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE;
992 int aMarkerTextureCurrent = 0;
994 SALOME_ListIteratorOfListIO It( selected );
995 for( ; It.More(); It.Next()){
996 Handle(SALOME_InteractiveObject) IObject = It.Value();
997 if(IObject->hasEntry()){
998 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
999 vtkFloatingPointType color[3];
1000 anActor->GetSufaceColor(color[0], color[1], color[2]);
1001 int c0 = int (color[0] * 255);
1002 int c1 = int (color[1] * 255);
1003 int c2 = int (color[2] * 255);
1004 c.setRgb(c0, c1, c2);
1006 vtkFloatingPointType edgecolor[3];
1007 anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1008 c0 = int (edgecolor[0] * 255);
1009 c1 = int (edgecolor[1] * 255);
1010 c2 = int (edgecolor[2] * 255);
1011 e.setRgb(c0, c1, c2);
1013 vtkFloatingPointType backfacecolor[3];
1014 anActor->GetBackSufaceColor(backfacecolor[0], backfacecolor[1], backfacecolor[2]);
1015 c0 = int (backfacecolor[0] * 255);
1016 c1 = int (backfacecolor[1] * 255);
1017 c2 = int (backfacecolor[2] * 255);
1018 b.setRgb(c0, c1, c2);
1020 vtkFloatingPointType nodecolor[3];
1021 anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1022 c0 = int (nodecolor[0] * 255);
1023 c1 = int (nodecolor[1] * 255);
1024 c2 = int (nodecolor[2] * 255);
1025 n.setRgb(c0, c1, c2);
1027 vtkFloatingPointType color0D[3];
1028 anActor->Get0DColor(color0D[0], color0D[1], color0D[2]);
1029 c0 = int (color0D[0] * 255);
1030 c1 = int (color0D[1] * 255);
1031 c2 = int (color0D[2] * 255);
1032 c0D.setRgb(c0, c1, c2);
1034 size0D = (int)anActor->Get0DSize();
1037 Edgewidth = (int)anActor->GetLineWidth();
1040 Shrink = anActor->GetShrinkFactor();
1042 vtkFloatingPointType faces_orientation_color[3];
1043 anActor->GetFacesOrientationColor(faces_orientation_color);
1044 c0 = int (faces_orientation_color[0] * 255);
1045 c1 = int (faces_orientation_color[1] * 255);
1046 c2 = int (faces_orientation_color[2] * 255);
1047 o.setRgb(c0, c1, c2);
1049 faces_orientation_scale = anActor->GetFacesOrientationScale();
1050 faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors();
1052 aMarkerTypeCurrent = anActor->GetMarkerType();
1053 aMarkerScaleCurrent = anActor->GetMarkerScale();
1054 aMarkerTextureCurrent = anActor->GetMarkerTexture();
1056 // even if there are multiple objects in the selection,
1057 // we need only the first one to get values for the dialog
1063 SMESHGUI_Preferences_ColorDlg *aDlg =
1064 new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() );
1065 aDlg->SetColor(1, c);
1066 aDlg->SetColor(2, e);
1067 aDlg->SetColor(3, n);
1068 aDlg->SetColor(4, b);
1069 aDlg->SetColor(5, c0D);
1070 aDlg->SetColor(6, o);
1071 aDlg->SetIntValue(1, Edgewidth);
1072 aDlg->SetIntValue(2, int(Shrink*100.));
1073 aDlg->SetIntValue(3, size0D);
1074 aDlg->SetDoubleValue(1, faces_orientation_scale);
1075 aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
1077 aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
1079 if( aMarkerTypeCurrent != VTK::MT_USER )
1080 aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent );
1082 aDlg->setCustomMarker( aMarkerTextureCurrent );
1085 QColor color = aDlg->GetColor(1);
1086 QColor edgecolor = aDlg->GetColor(2);
1087 QColor nodecolor = aDlg->GetColor(3);
1088 QColor backfacecolor = aDlg->GetColor(4);
1089 QColor color0D = aDlg->GetColor(5);
1090 QColor faces_orientation_color = aDlg->GetColor(6);
1093 theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
1095 SALOME_ListIteratorOfListIO It( selected );
1096 for( ; It.More(); It.Next()){
1097 Handle(SALOME_InteractiveObject) IObject = It.Value();
1098 if(IObject->hasEntry()){
1099 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1100 /* actor color and backface color */
1101 anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
1102 vtkFloatingPointType (color.green()) / 255.,
1103 vtkFloatingPointType (color.blue()) / 255.);
1104 anActor->SetBackSufaceColor(vtkFloatingPointType (backfacecolor.red()) / 255.,
1105 vtkFloatingPointType (backfacecolor.green()) / 255.,
1106 vtkFloatingPointType (backfacecolor.blue()) / 255.);
1109 anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
1110 vtkFloatingPointType (edgecolor.green()) / 255.,
1111 vtkFloatingPointType (edgecolor.blue()) / 255.);
1113 /* Shrink factor and size edges */
1114 anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
1115 anActor->SetLineWidth(aDlg->GetIntValue(1));
1117 /* Nodes color and size */
1118 anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
1119 vtkFloatingPointType (nodecolor.green()) / 255.,
1120 vtkFloatingPointType (nodecolor.blue()) / 255.);
1123 anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255.,
1124 vtkFloatingPointType (color0D.green()) / 255.,
1125 vtkFloatingPointType (color0D.blue()) / 255.);
1126 anActor->Set0DSize(aDlg->GetIntValue(3));
1128 /* Faces orientation */
1129 vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()),
1130 vtkFloatingPointType(faces_orientation_color.greenF()),
1131 vtkFloatingPointType(faces_orientation_color.blueF())};
1132 anActor->SetFacesOrientationColor(c);
1133 anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1));
1134 anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1));
1136 VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType();
1137 VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale();
1138 int aMarkerTextureNew = aDlg->getCustomMarkerID();
1139 if( aMarkerTypeNew != VTK::MT_USER )
1140 anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew );
1142 const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ];
1143 VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew );
1144 if( anIter != aMarkerMap.end() )
1145 anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second );
1148 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1149 if( !aGroupObject->_is_nil() )
1151 SMESH::ElementType anElementType = aGroupObject->GetType();
1153 switch( anElementType )
1155 case SMESH::NODE: aColor = nodecolor; break;
1156 case SMESH::EDGE: aColor = edgecolor; break;
1157 default: aColor = color; break;
1160 SALOMEDS::Color aGroupColor;
1161 aGroupColor.R = (float)aColor.red() / 255.0;
1162 aGroupColor.G = (float)aColor.green() / 255.0;
1163 aGroupColor.B = (float)aColor.blue() / 255.0;
1164 aGroupObject->SetColor( aGroupColor );
1169 SMESH::RepaintCurrentView();
1175 SALOME_ListIteratorOfListIO It( selected );
1176 for( ; It.More(); It.Next()){
1177 Handle(SALOME_InteractiveObject) IObject = It.Value();
1178 if(IObject->hasEntry()){
1179 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1180 switch(theCommandID){
1182 anActor->SetRepresentation(SMESH_Actor::eEdge);
1185 anActor->SetRepresentation(SMESH_Actor::eSurface);
1188 if(anActor->IsShrunk())
1189 anActor->UnShrink();
1191 anActor->SetShrink();
1194 anActor->SetRepresentation(SMESH_Actor::ePoint);
1197 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1198 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1201 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1202 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1208 SMESH::RepaintCurrentView();
1212 void Control( int theCommandID )
1214 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1215 SALOME_ListIO selected;
1217 aSel->selectedObjects( selected );
1219 if( !selected.IsEmpty() ){
1220 Handle(SALOME_InteractiveObject) anIO = selected.First();
1222 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1223 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())){
1224 switch ( theCommandID ){
1226 aControl = SMESH_Actor::eLength;
1229 aControl = SMESH_Actor::eLength2D;
1232 aControl = SMESH_Actor::eFreeEdges;
1235 aControl = SMESH_Actor::eFreeBorders;
1238 aControl = SMESH_Actor::eMultiConnection;
1241 aControl = SMESH_Actor::eFreeNodes;
1244 aControl = SMESH_Actor::eMultiConnection2D;
1247 aControl = SMESH_Actor::eArea;
1250 aControl = SMESH_Actor::eTaper;
1253 aControl = SMESH_Actor::eAspectRatio;
1256 aControl = SMESH_Actor::eAspectRatio3D;
1259 aControl = SMESH_Actor::eMinimumAngle;
1262 aControl = SMESH_Actor::eWarping;
1265 aControl = SMESH_Actor::eSkew;
1268 aControl = SMESH_Actor::eVolume3D;
1271 aControl = SMESH_Actor::eFreeFaces;
1274 aControl = SMESH_Actor::eMaxElementLength2D;
1277 aControl = SMESH_Actor::eMaxElementLength3D;
1280 aControl = SMESH_Actor::eBareBorderVolume;
1283 aControl = SMESH_Actor::eBareBorderFace;
1286 aControl = SMESH_Actor::eOverConstrainedVolume;
1289 aControl = SMESH_Actor::eOverConstrainedFace;
1292 anActor->SetControlMode(aControl);
1293 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1294 SMESH::RepaintCurrentView();
1295 #ifndef DISABLE_PLOT2DVIEWER
1296 if(anActor->GetPlot2Histogram()) {
1297 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1298 QString functorName = functorToString( anActor->GetFunctor());
1299 QString aHistogramName("%1 : %2");
1300 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1301 aHistogram->setName(aHistogramName);
1302 aHistogram->setHorTitle(functorName);
1303 SMESH::ProcessIn2DViewers(anActor);
1312 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1313 MeshObjectType theType,
1314 const QString theInTypeName,
1315 QString & theOutTypeName)
1317 SMESH_TypeFilter aTypeFilter( theType );
1319 if( !theIO.IsNull() )
1321 entry = theIO->getEntry();
1322 LightApp_DataOwner owner( entry );
1323 if ( aTypeFilter.isOk( &owner )) {
1324 theOutTypeName = theInTypeName;
1332 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1334 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1335 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1337 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1338 CORBA::String_var anID = aSComp->GetID().c_str();
1339 if (!strcmp(anID.in(),theIO->getEntry()))
1345 CheckOIType ( theIO, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1346 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1347 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1348 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1349 CheckOIType ( theIO, GROUP, "Group", aTypeName )
1357 QString CheckHomogeneousSelection()
1359 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1360 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1361 SALOME_ListIO selected;
1363 aSel->selectedObjects( selected );
1365 QString RefType = CheckTypeObject(selected.First());
1366 SALOME_ListIteratorOfListIO It(selected);
1367 for ( ; It.More(); It.Next())
1369 Handle(SALOME_InteractiveObject) IObject = It.Value();
1370 QString Type = CheckTypeObject(IObject);
1371 if (Type.compare(RefType) != 0)
1372 return "Heterogeneous Selection";
1379 void SMESHGUI::OnEditDelete()
1381 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1382 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1383 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1385 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1386 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1387 _PTR(GenericAttribute) anAttr;
1388 _PTR(AttributeIOR) anIOR;
1390 int objectCount = 0;
1392 QString aParentComponent = QString::null;
1393 Handle(SALOME_InteractiveObject) anIO;
1394 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1396 anIO = anIt.Value();
1397 QString cur = anIO->getComponentDataType();
1398 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1400 // check if object is reference
1401 _PTR(SObject) aRefSObj;
1402 aNameList.append("\n - ");
1403 if ( aSO->ReferencedObject( aRefSObj ) ) {
1404 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1405 aNameList.append( aRefName );
1406 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1409 aNameList.append(anIO->getName());
1413 if( aParentComponent.isNull() )
1414 aParentComponent = cur;
1415 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1416 aParentComponent = "";
1419 if ( objectCount == 0 )
1420 return; // No Valid Objects Selected
1422 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1423 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1424 QObject::tr("ERR_ERROR"),
1425 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1428 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1429 if (SUIT_MessageBox::warning
1430 (SMESHGUI::desktop(),
1431 QObject::tr("SMESH_WRN_WARNING"),
1432 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1433 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1434 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1437 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1439 SALOME_ListIteratorOfListIO It(selected);
1441 aStudyBuilder->NewCommand(); // There is a transaction
1442 for( ; It.More(); It.Next()){ // loop on selected IO's
1443 Handle(SALOME_InteractiveObject) IObject = It.Value();
1444 if(IObject->hasEntry()) {
1445 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1447 // disable removal of "SMESH" component object
1448 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1450 if ( engineIOR() == anIOR->Value().c_str() )
1453 //Check the referenced object
1454 _PTR(SObject) aRefSObject;
1455 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1456 aSO = aRefSObject; // Delete main Object instead of reference
1458 // put the whole hierarchy of sub-objects of the selected SO into a list and
1459 // then treat them all starting from the deepest objects (at list back)
1461 std::list< _PTR(SObject) > listSO;
1462 listSO.push_back( aSO );
1463 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1464 for ( ; itSO != listSO.end(); ++itSO ) {
1465 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1466 for (it->InitEx(false); it->More(); it->Next())
1467 listSO.push_back( it->Value() );
1470 // treat SO's in the list starting from the back
1472 std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin();
1473 for ( ; ritSO != listSO.rend(); ++ritSO ) {
1474 _PTR(SObject) SO = *ritSO;
1475 if ( !SO ) continue;
1476 std::string anEntry = SO->GetID();
1478 /** Erase graphical object **/
1479 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1480 ViewManagerList aViewMenegers = anApp->viewManagers();
1481 ViewManagerList::const_iterator it = aViewMenegers.begin();
1482 for( ; it != aViewMenegers.end(); it++) {
1483 SUIT_ViewManager* vm = *it;
1484 int nbSf = vm ? vm->getViewsCount() : 0;
1486 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1487 for(int i = 0; i < nbSf; i++){
1488 SUIT_ViewWindow *sf = aViews[i];
1489 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1490 SMESH::RemoveActor(sf,anActor);
1496 /** Remove an object from data structures **/
1497 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1498 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1499 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1500 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1501 aMesh->RemoveGroup( aGroup );
1503 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1504 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1505 aMesh->RemoveSubMesh( aSubMesh );
1507 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1509 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1512 IObject = new SALOME_InteractiveObject
1513 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1514 QString objType = CheckTypeObject(IObject);
1515 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1516 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1517 aStudyBuilder->RemoveObjectWithChildren( SO );
1519 else {// default action: remove SObject from the study
1520 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1521 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1523 aStudyBuilder->RemoveObjectWithChildren( SO );
1527 } /* listSO back loop */
1528 } /* IObject->hasEntry() */
1531 aStudyBuilder->CommitCommand();
1533 /* Clear any previous selection */
1535 aSel->setSelectedObjects( l1 );
1537 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1542 SMESHGUI_EXPORT CAM_Module* createModule()
1544 return new SMESHGUI();
1548 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1550 //=============================================================================
1554 //=============================================================================
1555 SMESHGUI::SMESHGUI() :
1556 SalomeApp_Module( "SMESH" ),
1557 LightApp_Module( "SMESH" )
1559 if ( CORBA::is_nil( myComponentSMESH ) )
1561 CORBA::Boolean anIsEmbeddedMode;
1562 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1563 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1565 // 0019923: EDF 765 SMESH : default values of hypothesis
1566 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1567 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1568 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1569 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1570 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1573 myActiveDialogBox = 0;
1574 myFilterLibraryDlg = 0;
1578 myEventCallbackCommand = vtkCallbackCommand::New();
1579 myEventCallbackCommand->Delete();
1580 myEventCallbackCommand->SetClientData( this );
1581 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1584 SMESH::GetFilterManager();
1585 SMESH::GetPattern();
1586 SMESH::GetMeasurements();
1588 /* load resources for all available meshers */
1589 SMESH::InitAvailableHypotheses();
1592 //=============================================================================
1596 //=============================================================================
1597 SMESHGUI::~SMESHGUI()
1599 #ifdef WITHGENERICOBJ
1600 SMESH::GetFilterManager()->UnRegister();
1601 SMESH::GetMeasurements()->UnRegister();
1603 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1604 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1607 //=============================================================================
1611 //=============================================================================
1612 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1614 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1616 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1621 //=============================================================================
1625 //=============================================================================
1626 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1628 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1632 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1633 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1634 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1635 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1636 return autoUpdate && !exceeded;
1639 //=============================================================================
1643 //=============================================================================
1644 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1646 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1649 //=============================================================================
1653 //=============================================================================
1654 SMESHGUI* SMESHGUI::GetSMESHGUI()
1656 SMESHGUI* smeshMod = 0;
1657 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1660 CAM_Module* module = app->module( "Mesh" );
1661 smeshMod = dynamic_cast<SMESHGUI*>( module );
1664 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1666 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1669 _PTR(Study) aStudy = study->studyDS();
1671 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1680 Standard_EXPORT SMESHGUI* GetComponentGUI()
1682 return SMESHGUI::GetSMESHGUI();
1686 //=============================================================================
1690 //=============================================================================
1691 void SMESHGUI::SetState(int aState)
1696 //=============================================================================
1700 //=============================================================================
1701 void SMESHGUI::ResetState()
1706 //=============================================================================
1710 //=============================================================================
1711 void SMESHGUI::EmitSignalDeactivateDialog()
1713 emit SignalDeactivateActiveDialog();
1716 //=============================================================================
1720 //=============================================================================
1721 void SMESHGUI::EmitSignalStudyFrameChanged()
1723 emit SignalStudyFrameChanged();
1726 //=============================================================================
1730 //=============================================================================
1731 void SMESHGUI::EmitSignalCloseAllDialogs()
1733 emit SignalCloseAllDialogs();
1736 //=============================================================================
1740 //=============================================================================
1741 void SMESHGUI::EmitSignalVisibilityChanged()
1743 emit SignalVisibilityChanged();
1746 //=============================================================================
1750 //=============================================================================
1751 QDialog *SMESHGUI::GetActiveDialogBox()
1753 return myActiveDialogBox;
1756 //=============================================================================
1760 //=============================================================================
1761 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
1763 myActiveDialogBox = (QDialog *) aDlg;
1767 //=============================================================================
1771 //=============================================================================
1772 SUIT_Desktop* SMESHGUI::desktop()
1774 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1776 return app->desktop();
1781 //=============================================================================
1785 //=============================================================================
1786 SalomeApp_Study* SMESHGUI::activeStudy()
1788 SUIT_Application* app = SUIT_Session::session()->activeApplication();
1790 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1795 //=============================================================================
1799 //=============================================================================
1800 void SMESHGUI::Modified( bool theIsUpdateActions )
1802 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
1803 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
1804 appStudy->Modified();
1805 if( theIsUpdateActions )
1806 app->updateActions();
1811 //=============================================================================
1815 //=============================================================================
1816 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
1818 /* Here the position is on the bottom right corner - 10 */
1819 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
1821 SUIT_Desktop *PP = desktop();
1822 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
1823 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
1827 //=============================================================================
1831 //=============================================================================
1832 static int isStudyLocked(_PTR(Study) theStudy){
1833 return theStudy->GetProperties()->IsLocked();
1836 static bool checkLock(_PTR(Study) theStudy) {
1837 if (isStudyLocked(theStudy)) {
1838 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1839 QObject::tr("WRN_WARNING"),
1840 QObject::tr("WRN_STUDY_LOCKED") );
1846 //=======================================================================
1847 //function : CheckActiveStudyLocked
1849 //=======================================================================
1851 bool SMESHGUI::isActiveStudyLocked()
1853 _PTR(Study) aStudy = activeStudy()->studyDS();
1854 return checkLock( aStudy );
1857 //=============================================================================
1861 //=============================================================================
1862 bool SMESHGUI::OnGUIEvent( int theCommandID )
1864 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
1868 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
1869 SUIT_ResourceMgr* mgr = resourceMgr();
1873 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
1874 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
1877 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
1878 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
1880 //QAction* act = action( theCommandID );
1882 switch (theCommandID) {
1884 if(checkLock(aStudy)) break;
1893 if(checkLock(aStudy)) break;
1894 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
1898 case 150: //MED FILE INFORMATION
1900 SALOME_ListIO selected;
1901 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1903 aSel->selectedObjects( selected );
1904 if( selected.Extent() )
1906 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1907 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1908 if ( !aMesh->_is_nil() )
1910 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
1917 case 122: // EXPORT MED
1925 ::ExportMeshToFile(theCommandID);
1929 case 200: // SCALAR BAR
1931 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1932 SALOME_ListIO selected;
1934 aSel->selectedObjects( selected );
1936 if( selected.Extent() ) {
1937 Handle(SALOME_InteractiveObject) anIO = selected.First();
1938 if( anIO->hasEntry() ) {
1939 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
1940 anActor->SetControlMode( SMESH_Actor::eNone );
1941 #ifndef DISABLE_PLOT2DVIEWER
1942 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
1951 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
1956 // dump control distribution data to the text file
1957 ::SaveDistribution();
1963 // show/ distribution
1964 ::ShowDistribution();
1968 #ifndef DISABLE_PLOT2DVIEWER
1971 // plot distribution
1972 ::PlotDistribution();
1983 ::DisableAutoColor();
1986 case 1134: // Clipping
1987 case 1133: // Tranparency
1988 case 1132: // Colors / Size
1995 ::SetDisplayMode(theCommandID, myMarkerMap);
1998 //2D quadratic representation
2001 ::SetDisplayMode(theCommandID, myMarkerMap);
2005 case 216: // 0D elements
2008 case 219: // Volumes
2009 case 220: // All Entity
2010 ::SetDisplayEntity(theCommandID);
2013 case 221: // Orientation of faces
2015 LightApp_SelectionMgr* mgr = selectionMgr();
2016 SALOME_ListIO selected; mgr->selectedObjects( selected );
2018 SALOME_ListIteratorOfListIO it(selected);
2019 for( ; it.More(); it.Next()) {
2020 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2021 if(anIObject->hasEntry()) {
2022 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2023 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2032 if(checkLock(aStudy)) break;
2034 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2037 SMESH::UpdateView();
2039 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2040 SMESH::OnVisuException();
2042 catch (...) { // PAL16774 (Crash after display of many groups)
2043 SMESH::OnVisuException();
2047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2048 aSel->selectedObjects( l );
2049 aSel->setSelectedObjects( l );
2054 case 301: // DISPLAY
2055 case 302: // DISPLAY ONLY
2057 SMESH::EDisplaing anAction;
2058 switch (theCommandID) {
2059 case 300: anAction = SMESH::eErase; break;
2060 case 301: anAction = SMESH::eDisplay; break;
2061 case 302: anAction = SMESH::eDisplayOnly; break;
2064 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2065 SALOME_ListIO sel_objects, to_process;
2067 aSel->selectedObjects( sel_objects );
2069 if( theCommandID==302 )
2071 MESSAGE("anAction = SMESH::eDisplayOnly");
2072 startOperation( myEraseAll );
2075 extractContainers( sel_objects, to_process );
2078 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2082 SALOME_ListIteratorOfListIO It( to_process );
2083 for ( ; It.More(); It.Next()) {
2085 Handle(SALOME_InteractiveObject) IOS = It.Value();
2086 if (IOS->hasEntry()) {
2088 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2089 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2090 break; // PAL16774 (Crash after display of many groups)
2092 if (anAction == SMESH::eDisplayOnly)
2094 MESSAGE("anAction = SMESH::eDisplayOnly");
2095 anAction = SMESH::eDisplay;
2101 // PAL13338 + PAL15161 -->
2102 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2103 MESSAGE("anAction = SMESH::eDisplayOnly");
2104 SMESH::UpdateView();
2105 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2107 // PAL13338 + PAL15161 <--
2109 catch (...) { // PAL16774 (Crash after display of many groups)
2110 SMESH::OnVisuException();
2113 if (anAction == SMESH::eErase) {
2114 MESSAGE("anAction == SMESH::eErase");
2116 aSel->setSelectedObjects( l1 );
2119 aSel->setSelectedObjects( to_process );
2126 if(checkLock(aStudy)) break;
2129 EmitSignalDeactivateDialog();
2131 ( new SMESHGUI_NodesDlg( this ) )->show();
2134 SUIT_MessageBox::warning(desktop(),
2135 tr("SMESH_WRN_WARNING"),
2136 tr("SMESH_WRN_VIEWER_VTK"));
2141 case 2151: // FILTER
2145 EmitSignalDeactivateDialog();
2146 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2151 case 701: // COMPUTE MESH
2152 case 711: // PRECOMPUTE MESH
2153 case 712: // EVALUATE MESH
2154 case 713: // MESH ORDER
2156 if (checkLock(aStudy)) break;
2157 startOperation( theCommandID );
2161 case 702: // Create mesh
2162 case 703: // Create sub-mesh
2163 case 704: // Edit mesh/sub-mesh
2164 startOperation( theCommandID );
2166 case 705: // copy mesh
2168 if (checkLock(aStudy)) break;
2169 EmitSignalDeactivateDialog();
2170 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2173 case 710: // Build compound mesh
2175 if (checkLock(aStudy)) break;
2176 EmitSignalDeactivateDialog();
2177 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2181 case 407: // DIAGONAL INVERSION
2182 case 408: // Delete diagonal
2186 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2187 tr( "NOT_A_VTK_VIEWER" ) );
2191 if ( checkLock( aStudy ) )
2194 /*Standard_Boolean aRes;
2195 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2196 if ( aMesh->_is_nil() )
2198 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2199 tr( "SMESH_BAD_SELECTION" ) );
2203 EmitSignalDeactivateDialog();
2204 if ( theCommandID == 407 )
2205 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2207 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2210 case 409: // Change orientation
2211 case 410: // Union of triangles
2212 case 411: // Cutting of quadrangles
2213 case 419: // Splitting volumes into tetrahedra
2217 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2218 tr( "NOT_A_VTK_VIEWER" ) );
2222 if ( checkLock( aStudy ) )
2225 EmitSignalDeactivateDialog();
2226 SMESHGUI_MultiEditDlg* aDlg = NULL;
2227 if ( theCommandID == 409 )
2228 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2229 else if ( theCommandID == 410 )
2230 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2231 else if ( theCommandID == 419 )
2232 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2234 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2239 case 412: // Smoothing
2241 if(checkLock(aStudy)) break;
2243 EmitSignalDeactivateDialog();
2244 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2247 SUIT_MessageBox::warning(desktop(),
2248 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2252 case 413: // Extrusion
2254 if (checkLock(aStudy)) break;
2256 EmitSignalDeactivateDialog();
2257 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2259 SUIT_MessageBox::warning(desktop(),
2260 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2264 case 414: // Revolution
2266 if(checkLock(aStudy)) break;
2268 EmitSignalDeactivateDialog();
2269 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2272 SUIT_MessageBox::warning(desktop(),
2273 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2277 case 415: // Pattern mapping
2279 if ( checkLock( aStudy ) )
2283 EmitSignalDeactivateDialog();
2284 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2287 SUIT_MessageBox::warning(desktop(),
2288 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2292 case 416: // Extrusion along a path
2294 if (checkLock(aStudy)) break;
2296 EmitSignalDeactivateDialog();
2297 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2299 SUIT_MessageBox::warning(desktop(),
2300 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2304 case 417: // Convert mesh to quadratic
2306 startOperation( 417 );
2307 /* if (checkLock(aStudy)) break;
2309 EmitSignalDeactivateDialog();
2310 new SMESHGUI_ConvToQuadDlg();
2312 SUIT_MessageBox::warning(desktop(),
2313 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2317 case 418: // create 2D mesh from 3D
2319 startOperation( 418 );
2322 case 806: // CREATE GEO GROUP
2324 startOperation( 806 );
2327 case 801: // CREATE GROUP
2331 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2332 tr( "NOT_A_VTK_VIEWER" ) );
2336 if(checkLock(aStudy)) break;
2337 EmitSignalDeactivateDialog();
2338 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2340 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2341 SALOME_ListIO selected;
2343 aSel->selectedObjects( selected );
2345 int nbSel = selected.Extent();
2347 // check if mesh is selected
2348 aMesh = SMESH::GetMeshByIO( selected.First() );
2350 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2355 case 802: // CONSTRUCT GROUP
2359 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2360 tr( "NOT_A_VTK_VIEWER" ) );
2364 if(checkLock(aStudy)) break;
2365 EmitSignalDeactivateDialog();
2367 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2368 SALOME_ListIO selected;
2370 aSel->selectedObjects( selected );
2372 int nbSel = selected.Extent();
2374 // check if submesh is selected
2375 Handle(SALOME_InteractiveObject) IObject = selected.First();
2376 if (IObject->hasEntry()) {
2377 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2379 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2380 if (!aSubMesh->_is_nil()) {
2382 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2383 // get submesh elements list by types
2384 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2385 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2386 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2387 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2388 // create group for each type o elements
2389 QString aName = IObject->getName();
2390 QStringList anEntryList;
2391 if (aNodes->length() > 0) {
2392 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2393 aGroup->Add(aNodes.inout());
2394 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2395 anEntryList.append( aSObject->GetID().c_str() );
2397 if (aEdges->length() > 0) {
2398 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2399 aGroup->Add(aEdges.inout());
2400 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2401 anEntryList.append( aSObject->GetID().c_str() );
2403 if (aFaces->length() > 0) {
2404 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2405 aGroup->Add(aFaces.inout());
2406 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2407 anEntryList.append( aSObject->GetID().c_str() );
2409 if (aVolumes->length() > 0) {
2410 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2411 aGroup->Add(aVolumes.inout());
2412 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2413 anEntryList.append( aSObject->GetID().c_str() );
2416 anApp->browseObjects( anEntryList );
2418 catch(const SALOME::SALOME_Exception & S_ex){
2419 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2426 SUIT_MessageBox::warning(desktop(),
2427 tr("SMESH_WRN_WARNING"),
2428 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2433 case 803: // EDIT GROUP
2437 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2438 tr( "NOT_A_VTK_VIEWER" ) );
2442 if(checkLock(aStudy)) break;
2443 EmitSignalDeactivateDialog();
2445 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2446 SALOME_ListIO selected;
2448 aSel->selectedObjects( selected );
2450 SALOME_ListIteratorOfListIO It (selected);
2451 int nbSelectedGroups = 0;
2452 for ( ; It.More(); It.Next() )
2454 SMESH::SMESH_GroupBase_var aGroup =
2455 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2456 if (!aGroup->_is_nil()) {
2458 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2462 if (nbSelectedGroups == 0)
2464 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2470 case 804: // Add elements to group
2472 if(checkLock(aStudy)) break;
2473 if (myState == 800) {
2474 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2475 if (aDlg) aDlg->onAdd();
2480 case 805: // Remove elements from group
2482 if(checkLock(aStudy)) break;
2483 if (myState == 800) {
2484 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2485 if (aDlg) aDlg->onRemove();
2490 case 815: // Edit GEOM GROUP as standalone
2494 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2495 tr( "NOT_A_VTK_VIEWER" ) );
2499 if(checkLock(aStudy)) break;
2500 EmitSignalDeactivateDialog();
2502 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2503 SALOME_ListIO selected;
2505 aSel->selectedObjects( selected );
2507 SALOME_ListIteratorOfListIO It (selected);
2508 for ( ; It.More(); It.Next() )
2510 SMESH::SMESH_GroupOnGeom_var aGroup =
2511 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2512 if (!aGroup->_is_nil()) {
2513 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2518 SMESH::SMESH_GroupOnFilter_var aGroup =
2519 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2520 if (!aGroup->_is_nil()) {
2521 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2529 case 810: // Union Groups
2530 case 811: // Intersect groups
2531 case 812: // Cut groups
2535 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2536 tr( "NOT_A_VTK_VIEWER" ) );
2540 if ( checkLock( aStudy ) )
2543 EmitSignalDeactivateDialog();
2545 SMESHGUI_GroupOpDlg* aDlg = 0;
2546 if ( theCommandID == 810 )
2547 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2548 else if ( theCommandID == 811 )
2549 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2551 aDlg = new SMESHGUI_CutGroupsDlg( this );
2558 case 814: // Create groups of entities from existing groups of superior dimensions
2560 if ( checkLock( aStudy ) )
2563 EmitSignalDeactivateDialog();
2564 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2570 case 813: // Delete groups with their contents
2574 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2575 tr( "NOT_A_VTK_VIEWER" ) );
2579 if ( checkLock( aStudy ) )
2582 EmitSignalDeactivateDialog();
2584 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2588 case 900: // MESH INFOS
2589 case 903: // WHAT IS
2591 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2592 EmitSignalDeactivateDialog();
2593 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2594 SALOME_ListIO selected;
2596 aSel->selectedObjects( selected );
2598 if ( selected.Extent() > 1 ) { // a dlg for each IO
2599 SALOME_ListIteratorOfListIO It( selected );
2600 for ( ; It.More(); It.Next() ) {
2601 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2602 dlg->showInfo( It.Value() );
2607 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2613 case 902: // STANDARD MESH INFOS
2615 EmitSignalDeactivateDialog();
2616 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2617 SALOME_ListIO selected;
2619 aSel->selectedObjects( selected );
2621 if ( selected.Extent() > 1 ) { // a dlg for each IO
2623 SALOME_ListIteratorOfListIO It (selected);
2624 for ( ; It.More(); It.Next() ) {
2626 IOs.Append( It.Value() );
2627 aSel->setSelectedObjects( IOs );
2628 ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2630 // restore selection
2631 aSel->setSelectedObjects( selected );
2634 ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2637 case 903: // WHAT IS
2639 EmitSignalDeactivateDialog();
2640 ( new SMESHGUI_WhatIsDlg( this ) )->show();
2645 case 904: // FIND ELEM
2647 startOperation( theCommandID );
2651 case 1100: // EDIT HYPOTHESIS
2653 if(checkLock(aStudy)) break;
2655 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2656 SALOME_ListIO selected;
2658 aSel->selectedObjects( selected );
2660 int nbSel = selected.Extent();
2663 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2664 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2666 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2667 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2668 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2669 if ( !aHypothesis->_is_nil() )
2672 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2673 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2675 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2685 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2687 if(checkLock(aStudy)) break;
2688 SUIT_OverrideCursor wc;
2690 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2691 SALOME_ListIO selected;
2693 aSel->selectedObjects( selected, QString::null, false );
2695 SALOME_ListIteratorOfListIO It(selected);
2696 for (int i = 0; It.More(); It.Next(), i++) {
2697 Handle(SALOME_InteractiveObject) IObject = It.Value();
2698 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2701 aSel->setSelectedObjects( l1 );
2706 case 4009: // ELEM0D
2707 case 4010: // GEOM::EDGE
2708 case 4021: // TRIANGLE
2710 case 4023: // POLYGON
2714 if(checkLock(aStudy)) break;
2716 EmitSignalDeactivateDialog();
2717 SMDSAbs_ElementType type = SMDSAbs_Edge;
2719 switch (theCommandID) {
2720 case 4009: // ELEM0D
2721 type = SMDSAbs_0DElement; nbNodes = 1; break;
2722 case 4021: // TRIANGLE
2723 type = SMDSAbs_Face; nbNodes = 3; break;
2725 type = SMDSAbs_Face; nbNodes = 4; break;
2727 type = SMDSAbs_Volume; nbNodes = 4; break;
2728 case 4023: // POLYGON
2729 type = SMDSAbs_Face; nbNodes = 5; break; // 5 - identificator for POLYGON
2731 type = SMDSAbs_Volume; nbNodes = 8; break;
2732 case 4033: // POLYHEDRE
2733 type = SMDSAbs_Volume; nbNodes = 9; break; // 9 - identificator for POLYHEDRE
2736 ( new SMESHGUI_AddMeshElementDlg( this, type, nbNodes ) )->show();
2739 SUIT_MessageBox::warning(desktop(),
2740 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2744 case 4033: // POLYHEDRON
2746 if(checkLock(aStudy)) break;
2748 EmitSignalDeactivateDialog();
2749 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2752 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2753 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2757 case 4034: // QUADRATIC EDGE
2758 case 4035: // QUADRATIC TRIANGLE
2759 case 4036: // QUADRATIC QUADRANGLE
2760 case 4037: // QUADRATIC TETRAHEDRON
2761 case 4038: // QUADRATIC PYRAMID
2762 case 4039: // QUADRATIC PENTAHEDRON
2763 case 4040: // QUADRATIC HEXAHEDRON
2765 if(checkLock(aStudy)) break;
2767 EmitSignalDeactivateDialog();
2770 switch (theCommandID) {
2772 type = QUAD_EDGE; break;
2774 type = QUAD_TRIANGLE; break;
2776 type = QUAD_QUADRANGLE; break;
2778 type = QUAD_TETRAHEDRON; break;
2780 type = QUAD_PYRAMID; break;
2782 type = QUAD_PENTAHEDRON; break;
2784 type = QUAD_HEXAHEDRON;
2788 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2791 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2792 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2796 case 4041: // REMOVES NODES
2798 if(checkLock(aStudy)) break;
2800 EmitSignalDeactivateDialog();
2801 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2804 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2805 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2809 case 4042: // REMOVES ELEMENTS
2811 if(checkLock(aStudy)) break;
2813 EmitSignalDeactivateDialog();
2814 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2818 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2819 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2823 case 4043: { // CLEAR_MESH
2825 if(checkLock(aStudy)) break;
2827 SALOME_ListIO selected;
2828 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2829 aSel->selectedObjects( selected );
2831 SUIT_OverrideCursor wc;
2832 SALOME_ListIteratorOfListIO It (selected);
2833 for ( ; It.More(); It.Next() )
2835 Handle(SALOME_InteractiveObject) IOS = It.Value();
2836 SMESH::SMESH_Mesh_var aMesh =
2837 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2838 if ( aMesh->_is_nil()) continue;
2840 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
2842 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
2843 SMESH::ModifiedMesh( aMeshSObj, false, true);
2844 // hide groups and submeshes
2845 _PTR(ChildIterator) anIter =
2846 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
2847 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
2849 _PTR(SObject) so = anIter->Value();
2850 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
2853 catch (const SALOME::SALOME_Exception& S_ex){
2855 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2859 SMESH::UpdateView();
2863 case 4044: // REMOVE ORPHAN NODES
2865 if(checkLock(aStudy)) break;
2866 SALOME_ListIO selected;
2867 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2868 aSel->selectedObjects( selected );
2869 if ( selected.Extent() == 1 ) {
2870 Handle(SALOME_InteractiveObject) anIO = selected.First();
2871 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
2872 if ( !aMesh->_is_nil() ) {
2873 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
2874 tr( "SMESH_WARNING" ),
2875 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
2876 SUIT_MessageBox::Yes |
2877 SUIT_MessageBox::No,
2878 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
2881 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
2882 int removed = aMeshEditor->RemoveOrphanNodes();
2883 SUIT_MessageBox::information(SMESHGUI::desktop(),
2884 tr("SMESH_INFORMATION"),
2885 tr("NB_NODES_REMOVED").arg(removed));
2886 if ( removed > 0 ) {
2887 SMESH::UpdateView();
2888 SMESHGUI::Modified();
2891 catch (const SALOME::SALOME_Exception& S_ex) {
2892 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2901 case 4051: // RENUMBERING NODES
2903 if(checkLock(aStudy)) break;
2905 EmitSignalDeactivateDialog();
2906 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
2910 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2911 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2915 case 4052: // RENUMBERING ELEMENTS
2917 if(checkLock(aStudy)) break;
2919 EmitSignalDeactivateDialog();
2920 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
2924 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2925 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2929 case 4061: // TRANSLATION
2931 if(checkLock(aStudy)) break;
2933 EmitSignalDeactivateDialog();
2934 ( new SMESHGUI_TranslationDlg( this ) )->show();
2937 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2938 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2942 case 4062: // ROTATION
2944 if(checkLock(aStudy)) break;
2946 EmitSignalDeactivateDialog();
2947 ( new SMESHGUI_RotationDlg( this ) )->show();
2950 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2951 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2955 case 4063: // SYMMETRY
2957 if(checkLock(aStudy)) break;
2959 EmitSignalDeactivateDialog();
2960 ( new SMESHGUI_SymmetryDlg( this ) )->show();
2963 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2964 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2968 case 4064: // SEWING
2970 if(checkLock(aStudy)) break;
2972 EmitSignalDeactivateDialog();
2973 ( new SMESHGUI_SewingDlg( this ) )->show();
2976 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2977 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2981 case 4065: // MERGE NODES
2983 if(checkLock(aStudy)) break;
2985 EmitSignalDeactivateDialog();
2986 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
2989 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2990 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2994 case 4066: // MERGE EQUAL ELEMENTS
2996 if (checkLock(aStudy)) break;
2998 EmitSignalDeactivateDialog();
2999 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3001 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3002 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3007 case 4067: // MAKE MESH PASS THROUGH POINT
3008 startOperation( 4067 );
3013 if(checkLock(aStudy)) break;
3015 EmitSignalDeactivateDialog();
3016 ( new SMESHGUI_ScaleDlg( this ) )->show();
3019 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3020 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3025 case 4069: // DUPLICATE NODES
3027 if(checkLock(aStudy)) break;
3029 EmitSignalDeactivateDialog();
3030 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3033 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3034 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3039 case 5105: // Library of selection filters
3041 static QList<int> aTypes;
3042 if ( aTypes.isEmpty() )
3044 aTypes.append( SMESH::NODE );
3045 aTypes.append( SMESH::EDGE );
3046 aTypes.append( SMESH::FACE );
3047 aTypes.append( SMESH::VOLUME );
3049 if (!myFilterLibraryDlg)
3050 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3051 else if (myFilterLibraryDlg->isHidden())
3052 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3053 myFilterLibraryDlg->raise();
3057 case 6017: // CONTROLS
3081 LightApp_SelectionMgr* mgr = selectionMgr();
3082 SALOME_ListIO selected; mgr->selectedObjects( selected );
3084 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3085 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3087 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3088 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3089 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3090 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3091 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3092 ::Control( theCommandID );
3097 SUIT_MessageBox::warning(desktop(),
3098 tr( "SMESH_WRN_WARNING" ),
3099 tr( "SMESH_BAD_SELECTION" ) );
3103 SUIT_MessageBox::warning(desktop(),
3104 tr( "SMESH_WRN_WARNING" ),
3105 tr( "NOT_A_VTK_VIEWER" ) );
3110 LightApp_SelectionMgr* mgr = selectionMgr();
3111 SALOME_ListIO selected; mgr->selectedObjects( selected );
3113 SALOME_ListIteratorOfListIO it(selected);
3114 for( ; it.More(); it.Next()) {
3115 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3116 if(anIObject->hasEntry()) {
3117 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3118 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3126 LightApp_SelectionMgr* mgr = selectionMgr();
3127 SALOME_ListIO selected; mgr->selectedObjects( selected );
3129 SALOME_ListIteratorOfListIO it(selected);
3130 for( ; it.More(); it.Next()) {
3131 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3132 if(anIObject->hasEntry())
3133 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3134 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3142 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3143 EmitSignalDeactivateDialog();
3144 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3150 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3151 //updateObjBrowser();
3155 //=============================================================================
3159 //=============================================================================
3160 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3165 //=============================================================================
3169 //=============================================================================
3170 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3175 //=============================================================================
3179 //=============================================================================
3180 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3185 //=============================================================================
3186 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3187 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3189 //=============================================================================
3190 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3191 SUIT_ViewWindow* wnd )
3193 if(theIO->hasEntry()){
3194 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3195 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3199 //=======================================================================
3200 // function : createSMESHAction
3202 //=======================================================================
3203 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3204 const int key, const bool toggle, const QString& shortcutAction )
3207 QWidget* parent = application()->desktop();
3208 SUIT_ResourceMgr* resMgr = resourceMgr();
3210 if ( !icon_id.isEmpty() )
3211 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3213 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3214 if ( !pix.isNull() )
3215 icon = QIcon( pix );
3217 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3218 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3219 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3221 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3222 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3225 //=======================================================================
3226 // function : createPopupItem
3228 //=======================================================================
3229 void SMESHGUI::createPopupItem( const int id,
3230 const QString& clients,
3231 const QString& types,
3232 const QString& theRule,
3237 parentId = popupMgr()->actionId( action( pId ) );
3239 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3240 popupMgr()->insert( action( id ), parentId, 0 );
3242 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3243 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3244 QString rule = "(%1) and (%2) and (%3)";
3245 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3246 if( clients.isEmpty() )
3247 rule = rule.arg( QString( "true" ) );
3249 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3250 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3253 bool cont = myRules.contains( id );
3255 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3257 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3258 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3261 //=======================================================================
3262 // function : initialize
3264 //=======================================================================
3265 void SMESHGUI::initialize( CAM_Application* app )
3267 SalomeApp_Module::initialize( app );
3269 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3271 /* Automatic Update flag */
3272 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3274 // ----- create actions --------------
3276 createSMESHAction( 111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3277 createSMESHAction( 112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3278 createSMESHAction( 113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3279 createSMESHAction( 114, "NUM" );
3280 createSMESHAction( 121, "DAT" );
3281 createSMESHAction( 122, "MED" );
3282 createSMESHAction( 123, "UNV" );
3283 createSMESHAction( 140, "STL" );
3284 createSMESHAction( 124, "EXPORT_DAT" );
3285 createSMESHAction( 125, "EXPORT_MED" );
3286 createSMESHAction( 126, "EXPORT_UNV" );
3287 createSMESHAction( 141, "EXPORT_STL" );
3288 createSMESHAction( 150, "FILE_INFO" );
3289 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3290 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3291 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3292 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3293 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3294 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3295 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3296 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3297 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3298 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3299 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3300 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3301 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3302 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3303 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3304 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3305 createSMESHAction( 804, "ADD" );
3306 createSMESHAction( 805, "REMOVE" );
3307 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3308 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3309 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3310 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3311 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3312 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3313 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3314 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3315 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3316 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3317 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3318 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3319 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3320 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3321 createSMESHAction( 6024, "BARE_BORDER_VOLUME","ICON_BARE_BORDER_VOLUME", 0, true );
3322 createSMESHAction( 6025, "BARE_BORDER_FACE","ICON_BARE_BORDER_FACE", 0, true );
3323 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3324 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE","ICON_OVER_CONSTRAINED_FACE", 0, true );
3325 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3326 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3327 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3328 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3329 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3330 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3331 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3332 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3333 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3334 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3335 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3336 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3337 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3338 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3339 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3340 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3341 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3342 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3343 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3344 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3345 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3346 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3347 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3348 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3349 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3350 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3351 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3352 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3353 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3354 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3355 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3356 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3357 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3358 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3359 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3360 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3361 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3362 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3363 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3364 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3365 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3366 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3367 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3368 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3369 createSMESHAction( 415, "MAP", "ICON_MAP" );
3370 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3371 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3372 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3373 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3374 createSMESHAction( 200, "RESET" );
3375 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3376 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3377 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3378 #ifndef DISABLE_PLOT2DVIEWER
3379 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3381 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3382 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3383 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3384 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3385 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3386 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3387 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3388 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3389 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3390 createSMESHAction( 220, "ALL" );
3391 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3393 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3394 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3396 createSMESHAction( 1100, "EDIT_HYPO" );
3397 createSMESHAction( 1102, "UNASSIGN" );
3398 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3399 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3400 createSMESHAction( 1131, "DISPMODE" );
3401 createSMESHAction( 1132, "COLORS" );
3402 createSMESHAction( 1133, "TRANSP" );
3403 createSMESHAction( 1134, "CLIP" );
3404 createSMESHAction( 1135, "DISP_ENT" );
3405 createSMESHAction( 1136, "AUTO_COLOR" );
3406 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3407 createSMESHAction( 2000, "CTRL" );
3409 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3410 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3412 createSMESHAction( 300, "ERASE" );
3413 createSMESHAction( 301, "DISPLAY" );
3414 createSMESHAction( 302, "DISPLAY_ONLY" );
3415 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3416 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3417 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3418 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3419 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3420 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3421 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3422 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3424 // ----- create menu --------------
3425 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3426 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3427 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3428 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3429 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3430 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3431 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3432 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3434 createMenu( separator(), fileId );
3436 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3437 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3438 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3439 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3440 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3441 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3442 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3443 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3444 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3445 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3447 createMenu( 111, importId, -1 );
3448 createMenu( 112, importId, -1 );
3449 createMenu( 113, importId, -1 );
3450 createMenu( 140, importId, -1 );
3452 createMenu( 121, exportId, -1 );
3453 createMenu( 122, exportId, -1 );
3454 createMenu( 123, exportId, -1 );
3455 createMenu( 141, exportId, -1 ); // export to stl STL
3457 createMenu( separator(), fileId, 10 );
3459 createMenu( 33, editId, -1 );
3461 createMenu( 5105, toolsId, -1 );
3463 createMenu( 702, meshId, -1 ); // "Mesh" menu
3464 createMenu( 703, meshId, -1 );
3465 createMenu( 704, meshId, -1 );
3466 createMenu( 710, meshId, -1 );
3467 createMenu( 705, meshId, -1 );
3468 createMenu( separator(), meshId, -1 );
3469 createMenu( 701, meshId, -1 );
3470 createMenu( 711, meshId, -1 );
3471 createMenu( 712, meshId, -1 );
3472 createMenu( 713, meshId, -1 );
3473 createMenu( separator(), meshId, -1 );
3474 createMenu( 801, meshId, -1 );
3475 createMenu( 806, meshId, -1 );
3476 createMenu( 802, meshId, -1 );
3477 createMenu( 803, meshId, -1 );
3478 createMenu( 815, meshId, -1 );
3479 createMenu( separator(), meshId, -1 );
3480 createMenu( 810, meshId, -1 );
3481 createMenu( 811, meshId, -1 );
3482 createMenu( 812, meshId, -1 );
3483 createMenu( separator(), meshId, -1 );
3484 createMenu( 814, meshId, -1 );
3485 createMenu( separator(), meshId, -1 );
3486 createMenu( 900, meshId, -1 );
3487 //createMenu( 902, meshId, -1 );
3488 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3489 createMenu( 904, meshId, -1 );
3490 createMenu( separator(), meshId, -1 );
3492 createMenu( 6005, nodeId, -1 );
3493 createMenu( 6002, edgeId, -1 );
3494 createMenu( 6003, edgeId, -1 );
3495 createMenu( 6001, edgeId, -1 );
3496 createMenu( 6004, edgeId, -1 );
3497 createMenu( 6021, faceId, -1 );
3498 createMenu( 6025, faceId, -1 );
3499 createMenu( 6027, faceId, -1 );
3500 createMenu( 6018, faceId, -1 );
3501 createMenu( 6019, faceId, -1 );
3502 createMenu( 6011, faceId, -1 );
3503 createMenu( 6012, faceId, -1 );
3504 createMenu( 6013, faceId, -1 );
3505 createMenu( 6014, faceId, -1 );
3506 createMenu( 6015, faceId, -1 );
3507 createMenu( 6016, faceId, -1 );
3508 createMenu( 6022, faceId, -1 );
3509 createMenu( 6017, volumeId, -1 );
3510 createMenu( 6009, volumeId, -1 );
3511 createMenu( 6023, volumeId, -1 );
3512 createMenu( 6024, volumeId, -1 );
3513 createMenu( 6026, volumeId, -1 );
3515 createMenu( 4000, addId, -1 );
3516 createMenu( 4009, addId, -1 );
3517 createMenu( 4010, addId, -1 );
3518 createMenu( 4021, addId, -1 );
3519 createMenu( 4022, addId, -1 );
3520 createMenu( 4023, addId, -1 );
3521 createMenu( 4031, addId, -1 );
3522 createMenu( 4032, addId, -1 );
3523 createMenu( 4033, addId, -1 );
3524 createMenu( separator(), addId, -1 );
3525 createMenu( 4034, addId, -1 );
3526 createMenu( 4035, addId, -1 );
3527 createMenu( 4036, addId, -1 );
3528 createMenu( 4037, addId, -1 );
3529 createMenu( 4038, addId, -1 );
3530 createMenu( 4039, addId, -1 );
3531 createMenu( 4040, addId, -1 );
3533 createMenu( 4041, removeId, -1 );
3534 createMenu( 4042, removeId, -1 );
3535 createMenu( 4044, removeId, -1 );
3536 createMenu( separator(), removeId, -1 );
3537 createMenu( 813, removeId, -1 );
3538 createMenu( separator(), removeId, -1 );
3539 createMenu( 4043, removeId, -1 );
3541 createMenu( 4051, renumId, -1 );
3542 createMenu( 4052, renumId, -1 );
3544 createMenu( 4061, transfId, -1 );
3545 createMenu( 4062, transfId, -1 );
3546 createMenu( 4063, transfId, -1 );
3547 createMenu( 4068, transfId, -1 );
3548 createMenu( 4064, transfId, -1 );
3549 createMenu( 4065, transfId, -1 );
3550 createMenu( 4066, transfId, -1 );
3551 createMenu( 4069, transfId, -1 );
3553 createMenu( 4067,modifyId, -1 );
3554 createMenu( 407, modifyId, -1 );
3555 createMenu( 408, modifyId, -1 );
3556 createMenu( 409, modifyId, -1 );
3557 createMenu( 410, modifyId, -1 );
3558 createMenu( 411, modifyId, -1 );
3559 createMenu( 419, modifyId, -1 );
3560 createMenu( 412, modifyId, -1 );
3561 createMenu( 413, modifyId, -1 );
3562 createMenu( 416, modifyId, -1 );
3563 createMenu( 414, modifyId, -1 );
3564 createMenu( 415, modifyId, -1 );
3565 createMenu( 417, modifyId, -1 );
3566 createMenu( 418, modifyId, -1 );
3568 createMenu( 501, measureId, -1 );
3569 createMenu( 502, measureId, -1 );
3570 createMenu( 214, viewId, -1 );
3572 // ----- create toolbars --------------
3573 int meshTb = createTool( tr( "TB_MESH" ) ),
3574 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3575 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3576 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3577 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3579 createTool( 702, meshTb );
3580 createTool( 703, meshTb );
3581 createTool( 704, meshTb );
3582 createTool( 710, meshTb );
3583 createTool( 705, meshTb );
3584 createTool( separator(), meshTb );
3585 createTool( 701, meshTb );
3586 createTool( 711, meshTb );
3587 createTool( 712, meshTb );
3588 createTool( 713, meshTb );
3589 createTool( separator(), meshTb );
3590 createTool( 801, meshTb );
3591 createTool( 806, meshTb );
3592 createTool( 802, meshTb );
3593 createTool( 803, meshTb );
3594 //createTool( 815, meshTb );
3595 createTool( separator(), meshTb );
3596 createTool( 900, meshTb );
3597 //createTool( 902, meshTb );
3598 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3599 createTool( 904, meshTb );
3600 createTool( separator(), meshTb );
3602 createTool( 6005, ctrlTb );
3603 createTool( separator(), ctrlTb );
3604 createTool( 6002, ctrlTb );
3605 createTool( 6003, ctrlTb );
3606 createTool( 6001, ctrlTb );
3607 createTool( 6004, ctrlTb );
3608 createTool( separator(), ctrlTb );
3609 createTool( 6021, ctrlTb );
3610 createTool( 6025, ctrlTb );
3611 createTool( 6027, ctrlTb );
3612 createTool( 6018, ctrlTb );
3613 createTool( 6019, ctrlTb );
3614 createTool( 6011, ctrlTb );
3615 createTool( 6012, ctrlTb );
3616 createTool( 6013, ctrlTb );
3617 createTool( 6014, ctrlTb );
3618 createTool( 6015, ctrlTb );
3619 createTool( 6016, ctrlTb );
3620 createTool( 6022, ctrlTb );
3621 createTool( separator(), ctrlTb );
3622 createTool( 6017, ctrlTb );
3623 createTool( 6009, ctrlTb );
3624 createTool( 6023, ctrlTb );
3625 createTool( 6024, ctrlTb );
3626 createTool( 6026, ctrlTb );
3627 createTool( separator(), ctrlTb );
3629 createTool( 4000, addRemTb );
3630 createTool( 4009, addRemTb );
3631 createTool( 4010, addRemTb );
3632 createTool( 4021, addRemTb );
3633 createTool( 4022, addRemTb );
3634 createTool( 4023, addRemTb );
3635 createTool( 4031, addRemTb );
3636 createTool( 4032, addRemTb );
3637 createTool( 4033, addRemTb );
3638 createTool( separator(), addRemTb );
3639 createTool( 4034, addRemTb );
3640 createTool( 4035, addRemTb );
3641 createTool( 4036, addRemTb );
3642 createTool( 4037, addRemTb );
3643 createTool( 4038, addRemTb );
3644 createTool( 4039, addRemTb );
3645 createTool( 4040, addRemTb );
3646 createTool( separator(), addRemTb );
3647 createTool( 4041, addRemTb );
3648 createTool( 4042, addRemTb );
3649 createTool( 4044, addRemTb );
3650 createTool( 4043, addRemTb );
3651 createTool( separator(), addRemTb );
3652 createTool( 4051, addRemTb );
3653 createTool( 4052, addRemTb );
3654 createTool( separator(), addRemTb );
3655 createTool( 4061, addRemTb );
3656 createTool( 4062, addRemTb );
3657 createTool( 4063, addRemTb );
3658 createTool( 4068, addRemTb );
3659 createTool( 4064, addRemTb );
3660 createTool( 4065, addRemTb );
3661 createTool( 4066, addRemTb );
3662 createTool( 4069, addRemTb );
3663 createTool( separator(), addRemTb );
3665 createTool( 4067,modifyTb );
3666 createTool( 407, modifyTb );
3667 createTool( 408, modifyTb );
3668 createTool( 409, modifyTb );
3669 createTool( 410, modifyTb );
3670 createTool( 411, modifyTb );
3671 createTool( 419, modifyTb );
3672 createTool( 412, modifyTb );
3673 createTool( 413, modifyTb );
3674 createTool( 416, modifyTb );
3675 createTool( 414, modifyTb );
3676 createTool( 415, modifyTb );
3677 createTool( 417, modifyTb );
3678 createTool( 418, modifyTb );
3680 createTool( 214, dispModeTb );
3682 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3683 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3686 QString OB = "'ObjectBrowser'",
3687 View = "'" + SVTK_Viewer::Type() + "'",
3689 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3690 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3691 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3692 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3693 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3694 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3695 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3696 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3697 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3698 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3699 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3701 mesh_part = mesh + " " + subMesh + " " + group,
3702 mesh_group = mesh + " " + group,
3703 hyp_alg = hypo + " " + algo;
3705 // popup for object browser
3707 isInvisible("not( isVisible )"),
3708 isEmpty("numberOfNodes = 0"),
3709 isNotEmpty("numberOfNodes <> 0"),
3711 // has nodes, edges, etc in VISIBLE! actor
3712 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3713 hasElems("(count( elemTypes ) > 0)"),
3714 hasDifferentElems("(count( elemTypes ) > 1)"),
3715 hasElems0d("({'Elem0d'} in elemTypes)"),
3716 hasEdges("({'Edge'} in elemTypes)"),
3717 hasFaces("({'Face'} in elemTypes)"),
3718 hasVolumes("({'Volume'} in elemTypes)");
3720 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
3721 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
3722 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
3723 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
3724 createPopupItem( 803, OB, group ); // EDIT_GROUP
3725 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
3727 popupMgr()->insert( separator(), -1, 0 );
3728 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
3729 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3730 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
3731 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
3732 createPopupItem( 214, OB, mesh_part ); // UPDATE
3733 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
3734 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
3735 popupMgr()->insert( separator(), -1, 0 );
3736 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
3737 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
3738 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
3739 popupMgr()->insert( separator(), -1, 0 );
3740 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
3741 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
3742 popupMgr()->insert( separator(), -1, 0 );
3743 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
3744 popupMgr()->insert( separator(), -1, 0 );
3745 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
3746 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
3748 popupMgr()->insert( separator(), -1, 0 );
3750 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3751 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3752 QString only_one_2D = only_one_non_empty + " && dim>1";
3754 createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
3755 createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
3756 createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
3757 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
3758 popupMgr()->insert( separator(), -1, 0 );
3761 createPopupItem( 803, View, group ); // EDIT_GROUP
3762 createPopupItem( 804, View, elems ); // ADD
3763 createPopupItem( 805, View, elems ); // REMOVE
3765 popupMgr()->insert( separator(), -1, 0 );
3766 createPopupItem( 214, View, mesh_part ); // UPDATE
3767 createPopupItem( 900, View, mesh_part ); // ADV_INFO
3768 createPopupItem( 904, View, mesh ); // FIND_ELEM
3769 popupMgr()->insert( separator(), -1, 0 );
3771 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3772 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
3773 popupMgr()->insert( separator(), -1, 0 );
3776 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3777 QString aType = QString( "%1type in {%2}" ).arg( lc );
3778 aType = aType.arg( mesh_part );
3779 QString aMeshInVTK = aClient + "&&" + aType;
3781 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3782 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3783 QString aSelCount = QString( "%1 > 0" ).arg( dc );
3785 //-------------------------------------------------
3787 //-------------------------------------------------
3788 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3790 popupMgr()->insert( action( 9010 ), anId, -1 );
3791 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3792 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3794 popupMgr()->insert( action( 9011 ), anId, -1 );
3795 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3796 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3798 popupMgr()->insert( separator(), -1, -1 );
3800 //-------------------------------------------------
3802 //-------------------------------------------------
3803 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3805 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3806 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3807 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3809 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3810 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3811 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3813 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3814 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
3815 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
3817 popupMgr()->insert( separator(), anId, -1 );
3819 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
3820 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
3821 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
3823 //-------------------------------------------------
3825 //-------------------------------------------------
3826 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
3828 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
3830 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
3831 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
3832 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
3834 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
3835 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
3836 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
3838 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
3839 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
3840 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
3842 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
3843 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
3844 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
3846 popupMgr()->insert( separator(), anId, -1 );
3848 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
3849 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
3852 //-------------------------------------------------
3853 // Representation of the 2D Quadratic elements
3854 //-------------------------------------------------
3855 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
3856 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
3857 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
3858 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
3860 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
3861 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
3862 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
3864 //-------------------------------------------------
3865 // Orientation of faces
3866 //-------------------------------------------------
3867 popupMgr()->insert( action( 221 ), -1, -1 );
3868 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
3869 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
3871 //-------------------------------------------------
3873 //-------------------------------------------------
3874 popupMgr()->insert( action( 1132 ), -1, -1 );
3875 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3877 //-------------------------------------------------
3879 //-------------------------------------------------
3880 popupMgr()->insert( action( 1133 ), -1, -1 );
3881 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3883 //-------------------------------------------------
3885 //-------------------------------------------------
3887 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
3888 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
3889 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
3890 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
3892 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
3894 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
3895 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3897 popupMgr()->insert( separator(), anId, -1 );
3899 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
3901 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
3902 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
3903 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
3905 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
3907 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
3908 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3909 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
3911 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
3912 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3913 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
3915 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
3916 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3917 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
3919 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
3920 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3921 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
3923 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
3925 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
3926 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
3927 QtxPopupMgr::VisibleRule );
3928 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
3930 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
3931 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3932 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
3934 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
3935 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3936 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
3938 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
3939 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3940 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
3942 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
3943 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3944 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
3946 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
3947 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3948 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
3950 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
3951 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3952 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
3954 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
3955 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3956 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
3958 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
3959 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3960 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
3962 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
3963 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3964 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
3966 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
3967 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3968 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
3970 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
3971 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3972 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
3974 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
3976 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
3977 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3978 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
3980 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
3981 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3982 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
3984 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
3985 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3986 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
3988 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
3989 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3990 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
3992 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
3993 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3994 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
3996 popupMgr()->insert( separator(), anId, -1 );
3998 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
3999 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4001 popupMgr()->insert( separator(), anId, -1 );
4003 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4005 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4006 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4008 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4009 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4010 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4012 #ifndef DISABLE_PLOT2DVIEWER
4013 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4014 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4017 //-------------------------------------------------
4019 //-------------------------------------------------
4020 popupMgr()->insert( separator(), -1, -1 );
4021 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4022 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4023 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4024 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4026 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4027 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4029 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4030 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4032 popupMgr()->insert( separator(), -1, -1 );
4034 //-------------------------------------------------
4036 //-------------------------------------------------
4037 popupMgr()->insert( action( 1134 ), -1, -1 );
4038 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4040 popupMgr()->insert( separator(), -1, -1 );
4042 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4043 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4045 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4046 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4049 //================================================================================
4051 * \brief Return true if SMESH or GEOM objects are selected.
4052 * Is called form LightApp_Module::activateModule() which clear selection if
4053 * not isSelectionCompatible()
4055 //================================================================================
4057 bool SMESHGUI::isSelectionCompatible()
4059 bool isCompatible = true;
4060 SALOME_ListIO selected;
4061 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4062 Sel->selectedObjects( selected );
4064 SALOME_ListIteratorOfListIO It( selected );
4065 for ( ; isCompatible && It.More(); It.Next())
4067 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4068 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4070 return isCompatible;
4074 bool SMESHGUI::reusableOperation( const int id )
4076 // compute, evaluate and precompute are not reusable operations
4077 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4080 bool SMESHGUI::activateModule( SUIT_Study* study )
4082 bool res = SalomeApp_Module::activateModule( study );
4084 setMenuShown( true );
4085 setToolShown( true );
4087 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4088 PyGILState_STATE gstate = PyGILState_Ensure();
4089 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4090 if(pluginsmanager==NULL)
4094 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4099 PyGILState_Release(gstate);
4100 // end of GEOM plugins loading
4102 // Reset actions accelerator keys
4103 action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4104 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4105 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4107 action( 33)->setEnabled(true); // Delete: Key_Delete
4109 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4110 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4111 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4112 if ( _PTR(Study) aStudy = s->studyDS()) {
4113 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4114 updateObjBrowser(); // objects can be removed
4117 // get all view currently opened in the study and connect their signals to
4118 // the corresponding slots of the class.
4119 SUIT_Desktop* aDesk = study->application()->desktop();
4121 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4122 SUIT_ViewWindow* wnd;
4123 foreach ( wnd, wndList )
4130 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4132 setMenuShown( false );
4133 setToolShown( false );
4135 EmitSignalCloseAllDialogs();
4137 // Unset actions accelerator keys
4138 action(111)->setShortcut(QKeySequence()); // Import DAT
4139 action(112)->setShortcut(QKeySequence()); // Import UNV
4140 action(113)->setShortcut(QKeySequence()); // Import MED
4142 action( 33)->setEnabled(false); // Delete: Key_Delete
4144 return SalomeApp_Module::deactivateModule( study );
4147 void SMESHGUI::studyClosed( SUIT_Study* s )
4149 SMESH::RemoveVisuData( s->id() );
4150 SalomeApp_Module::studyClosed( s );
4153 void SMESHGUI::OnGUIEvent()
4155 const QObject* obj = sender();
4156 if ( !obj || !obj->inherits( "QAction" ) )
4158 int id = actionId((QAction*)obj);
4163 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4165 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4166 if ( CORBA::is_nil( myComponentSMESH ) )
4168 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4170 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4171 return aGUI.myComponentSMESH;
4174 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4175 return myComponentSMESH;
4178 QString SMESHGUI::engineIOR() const
4180 CORBA::ORB_var anORB = getApp()->orb();
4181 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4182 return QString( anIOR.in() );
4185 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4187 SalomeApp_Module::contextMenuPopup( client, menu, title );
4189 selectionMgr()->selectedObjects( lst );
4190 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4191 Handle(SALOME_InteractiveObject) io = lst.First();
4192 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4193 _PTR(Study) study = appStudy->studyDS();
4194 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4196 QString aName = QString( obj->GetName().c_str() );
4197 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4198 aName.remove( (aName.length() - 1), 1 );
4204 LightApp_Selection* SMESHGUI::createSelection() const
4206 return new SMESHGUI_Selection();
4209 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4211 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4212 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4215 void SMESHGUI::viewManagers( QStringList& list ) const
4217 list.append( SVTK_Viewer::Type() );
4220 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4222 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4223 SMESH::UpdateSelectionProp( this );
4225 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4226 for(int i = 0; i < aViews.count() ; i++){
4227 SUIT_ViewWindow *sf = aViews[i];
4233 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4235 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4236 myClippingPlaneInfoMap.erase( theViewManager );
4239 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4241 theActor->AddObserver( SMESH::DeleteActorEvent,
4242 myEventCallbackCommand.GetPointer(),
4246 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4247 unsigned long theEvent,
4248 void* theClientData,
4251 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4252 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4253 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4254 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4255 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4256 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4257 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4258 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4259 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4260 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4261 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4262 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4263 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4264 if( anActor == *anIter3 ) {
4265 anActorList.erase( anIter3 );
4276 void SMESHGUI::createPreferences()
4278 // General tab ------------------------------------------------------------------------
4279 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4281 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4282 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4283 setPreferenceProperty( lim, "min", 0 );
4284 setPreferenceProperty( lim, "max", 100000000 );
4285 setPreferenceProperty( lim, "step", 1000 );
4286 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4288 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4289 setPreferenceProperty( qaGroup, "columns", 2 );
4290 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4291 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4292 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4293 setPreferenceProperty( prec, "min", 0 );
4294 setPreferenceProperty( prec, "max", 16 );
4296 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4297 setPreferenceProperty( dispgroup, "columns", 2 );
4298 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4300 modes.append( "Wireframe" );
4301 modes.append( "Shading" );
4302 modes.append( "Nodes" );
4303 modes.append( "Shrink" );
4304 QList<QVariant> indices;
4305 indices.append( 0 );
4306 indices.append( 1 );
4307 indices.append( 2 );
4308 indices.append( 3 );
4309 setPreferenceProperty( dispmode, "strings", modes );
4310 setPreferenceProperty( dispmode, "indexes", indices );
4312 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4313 setPreferenceProperty( arcgroup, "columns", 2 );
4314 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4315 QStringList quadraticModes;
4316 quadraticModes.append("Lines");
4317 quadraticModes.append("Arcs");
4319 indices.append( 0 );
4320 indices.append( 1 );
4321 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4322 setPreferenceProperty( quadraticmode, "indexes", indices );
4324 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4325 "SMESH", "max_angle" );
4326 setPreferenceProperty( maxAngle, "min", 1 );
4327 setPreferenceProperty( maxAngle, "max", 90 );
4331 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4332 setPreferenceProperty( exportgroup, "columns", 2 );
4333 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4334 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4336 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4337 setPreferenceProperty( computeGroup, "columns", 2 );
4338 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4340 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4341 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4342 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4344 indices.append( 0 );
4345 indices.append( 1 );
4346 indices.append( 2 );
4347 setPreferenceProperty( notifyMode, "strings", modes );
4348 setPreferenceProperty( notifyMode, "indexes", indices );
4350 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4351 setPreferenceProperty( computeGroup, "columns", 2 );
4352 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4354 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4355 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4357 indices.append( 0 );
4358 indices.append( 1 );
4359 setPreferenceProperty( elemInfo, "strings", modes );
4360 setPreferenceProperty( elemInfo, "indexes", indices );
4362 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4363 setPreferenceProperty( segGroup, "columns", 2 );
4364 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4365 "SMESH", "segmentation" );
4366 setPreferenceProperty( segLen, "min", 1 );
4367 setPreferenceProperty( segLen, "max", 10000000 );
4368 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4369 "SMESH", "nb_segments_per_edge" );
4370 setPreferenceProperty( nbSeg, "min", 1 );
4371 setPreferenceProperty( nbSeg, "max", 10000000 );
4373 // Quantities with individual precision settings
4374 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4375 setPreferenceProperty( precGroup, "columns", 2 );
4377 const int nbQuantities = 6;
4378 int precs[nbQuantities], ii = 0;
4379 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4380 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4381 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4382 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4383 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4384 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4385 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4386 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4387 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4388 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4389 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4390 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4392 // Set property for precision value for spinboxes
4393 for ( ii = 0; ii < nbQuantities; ii++ ){
4394 setPreferenceProperty( precs[ii], "min", -14 );
4395 setPreferenceProperty( precs[ii], "max", 14 );
4396 setPreferenceProperty( precs[ii], "precision", 2 );
4399 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4400 setPreferenceProperty( previewGroup, "columns", 2 );
4401 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4402 setPreferenceProperty( chunkSize, "min", 0 );
4403 setPreferenceProperty( chunkSize, "max", 1000 );
4404 setPreferenceProperty( chunkSize, "step", 50 );
4406 // Mesh tab ------------------------------------------------------------------------
4407 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4408 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4409 setPreferenceProperty( nodeGroup, "columns", 3 );
4411 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4413 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4415 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4416 QList<QVariant> aMarkerTypeIndicesList;
4417 QList<QVariant> aMarkerTypeIconsList;
4418 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4419 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4420 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4421 aMarkerTypeIndicesList << i;
4422 aMarkerTypeIconsList << pixmap;
4424 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4425 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4427 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4429 QList<QVariant> aMarkerScaleIndicesList;
4430 QStringList aMarkerScaleValuesList;
4431 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4432 aMarkerScaleIndicesList << i;
4433 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4435 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4436 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4438 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4439 setPreferenceProperty( elemGroup, "columns", 2 );
4441 addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
4442 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4443 addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
4444 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4446 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4447 setPreferenceProperty( grpGroup, "columns", 2 );
4449 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4451 //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4452 //setPreferenceProperty( sp, "hstretch", 0 );
4453 //setPreferenceProperty( sp, "vstretch", 0 );
4455 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4456 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4457 int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4458 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4459 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4460 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4461 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4463 setPreferenceProperty( size0d, "min", 1 );
4464 setPreferenceProperty( size0d, "max", 10 );
4466 setPreferenceProperty( sp, "hstretch", 0 );
4467 setPreferenceProperty( sp, "vstretch", 0 );
4469 setPreferenceProperty( elemW, "min", 1 );
4470 setPreferenceProperty( elemW, "max", 5 );
4472 setPreferenceProperty( shrink, "min", 0 );
4473 setPreferenceProperty( shrink, "max", 100 );
4475 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4476 setPreferenceProperty( orientGroup, "columns", 1 );
4478 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4479 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4481 setPreferenceProperty( orientScale, "min", 0.05 );
4482 setPreferenceProperty( orientScale, "max", 0.5 );
4483 setPreferenceProperty( orientScale, "step", 0.05 );
4485 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4487 // Selection tab ------------------------------------------------------------------------
4488 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4490 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4491 setPreferenceProperty( selGroup, "columns", 2 );
4493 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4494 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4495 int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4497 setPreferenceProperty( selW, "min", 1 );
4498 setPreferenceProperty( selW, "max", 5 );
4500 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4501 setPreferenceProperty( preGroup, "columns", 2 );
4503 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4504 int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4506 setPreferenceProperty( preW, "min", 1 );
4507 setPreferenceProperty( preW, "max", 5 );
4509 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4510 setPreferenceProperty( precSelGroup, "columns", 2 );
4512 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4513 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4514 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4516 // Scalar Bar tab ------------------------------------------------------------------------
4517 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4518 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4519 setPreferenceProperty( fontGr, "columns", 2 );
4521 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4522 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4524 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4525 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4527 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4528 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4530 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4531 setPreferenceProperty( numcol, "min", 2 );
4532 setPreferenceProperty( numcol, "max", 256 );
4534 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4535 setPreferenceProperty( numlab, "min", 2 );
4536 setPreferenceProperty( numlab, "max", 65 );
4538 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4539 setPreferenceProperty( orientGr, "columns", 2 );
4540 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4541 QStringList orients;
4542 orients.append( tr( "SMESH_VERTICAL" ) );
4543 orients.append( tr( "SMESH_HORIZONTAL" ) );
4544 indices.clear(); indices.append( 0 ); indices.append( 1 );
4545 setPreferenceProperty( orient, "strings", orients );
4546 setPreferenceProperty( orient, "indexes", indices );
4548 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4549 setPreferenceProperty( posVSizeGr, "columns", 2 );
4550 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4551 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4552 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4553 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4554 setPreferenceProperty( xv, "step", 0.1 );
4555 setPreferenceProperty( xv, "min", 0.0 );
4556 setPreferenceProperty( xv, "max", 1.0 );
4557 setPreferenceProperty( yv, "step", 0.1 );
4558 setPreferenceProperty( yv, "min", 0.0 );
4559 setPreferenceProperty( yv, "max", 1.0 );
4560 setPreferenceProperty( wv, "step", 0.1 );
4561 setPreferenceProperty( wv, "min", 0.0 );
4562 setPreferenceProperty( wv, "max", 1.0 );
4563 setPreferenceProperty( hv, "min", 0.0 );
4564 setPreferenceProperty( hv, "max", 1.0 );
4565 setPreferenceProperty( hv, "step", 0.1 );
4567 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4568 setPreferenceProperty( posHSizeGr, "columns", 2 );
4569 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4570 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4571 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4572 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4573 setPreferenceProperty( xv, "min", 0.0 );
4574 setPreferenceProperty( xv, "max", 1.0 );
4575 setPreferenceProperty( xv, "step", 0.1 );
4576 setPreferenceProperty( xh, "min", 0.0 );
4577 setPreferenceProperty( xh, "max", 1.0 );
4578 setPreferenceProperty( xh, "step", 0.1 );
4579 setPreferenceProperty( yh, "min", 0.0 );
4580 setPreferenceProperty( yh, "max", 1.0 );
4581 setPreferenceProperty( yh, "step", 0.1 );
4582 setPreferenceProperty( wh, "min", 0.0 );
4583 setPreferenceProperty( wh, "max", 1.0 );
4584 setPreferenceProperty( wh, "step", 0.1 );
4585 setPreferenceProperty( hh, "min", 0.0 );
4586 setPreferenceProperty( hh, "max", 1.0 );
4587 setPreferenceProperty( hh, "step", 0.1 );
4589 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4590 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4591 setPreferenceProperty( distributionGr, "columns", 3 );
4593 types.append( tr( "SMESH_MONOCOLOR" ) );
4594 types.append( tr( "SMESH_MULTICOLOR" ) );
4595 indices.clear(); indices.append( 0 ); indices.append( 1 );
4596 setPreferenceProperty( coloringType, "strings", types );
4597 setPreferenceProperty( coloringType, "indexes", indices );
4598 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4602 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4604 if( sect=="SMESH" ) {
4605 float sbX1,sbY1,sbW,sbH;
4606 float aTol = 1.00000009999999;
4607 std::string aWarning;
4608 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4609 if( name=="selection_object_color" || name=="selection_element_color" ||
4610 name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4611 name=="selection_precision_node" || name=="selection_precision_element" ||
4612 name=="selection_precision_object")
4613 SMESH::UpdateSelectionProp( this );
4614 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4615 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4616 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4617 if(sbX1+sbW > aTol){
4618 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4621 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4622 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4625 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4626 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4627 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4628 if(sbY1+sbH > aTol){
4629 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4630 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4631 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4634 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4635 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4636 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4637 if(sbX1+sbW > aTol){
4638 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4641 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4642 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4645 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4646 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4647 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4648 if(sbY1+sbH > aTol){
4649 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4652 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4653 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4656 else if ( name == "segmentation" ) {
4657 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4658 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4660 else if ( name == "nb_segments_per_edge" ) {
4661 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4662 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4665 if(aWarning.size() != 0){
4666 aWarning += "The default values are applied instead.";
4667 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4668 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4669 QObject::tr(aWarning.c_str()));
4674 //================================================================================
4676 * \brief Update something in accordance with update flags
4677 * \param theFlags - update flags
4679 * Update viewer or/and object browser etc. in accordance with update flags ( see
4680 * LightApp_UpdateFlags enumeration ).
4682 //================================================================================
4683 void SMESHGUI::update( const int flags )
4685 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4686 SMESH::UpdateView();
4688 SalomeApp_Module::update( flags );
4691 //================================================================================
4693 * \brief Set default selection mode
4695 * SLOT called when operation commited. Sets default selection mode
4697 //================================================================================
4698 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4700 SVTK_ViewWindow* vtkWnd =
4701 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4703 vtkWnd->SetSelectionMode( ActorSelection );
4706 //================================================================================
4708 * \brief Set default selection mode
4710 * SLOT called when operation aborted. Sets default selection mode
4712 //================================================================================
4713 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4715 SVTK_ViewWindow* vtkWnd =
4716 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4718 vtkWnd->SetSelectionMode( ActorSelection );
4721 //================================================================================
4723 * \brief Creates operation with given identifier
4724 * \param id - identifier of operation to be started
4725 * \return Pointer on created operation or NULL if operation is not created
4727 * Virtual method redefined from the base class creates operation with given id.
4728 * It is called called automatically from startOperation method of base class.
4730 //================================================================================
4731 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4733 LightApp_Operation* op = 0;
4734 // to do : create operation here
4737 case 417: //convert to quadratic
4738 op = new SMESHGUI_ConvToQuadOp();
4740 case 418: // create 2D mesh as boundary on 3D
4741 op = new SMESHGUI_Make2DFrom3DOp();
4743 case 701: // Compute mesh
4744 op = new SMESHGUI_ComputeOp();
4746 case 702: // Create mesh
4747 op = new SMESHGUI_MeshOp( true, true );
4749 case 703: // Create sub-mesh
4750 op = new SMESHGUI_MeshOp( true, false );
4752 case 704: // Edit mesh/sub-mesh
4753 op = new SMESHGUI_MeshOp( false );
4755 case 711: // Precompute mesh
4756 op = new SMESHGUI_PrecomputeOp();
4758 case 712: // Evaluate mesh
4759 op = new SMESHGUI_EvaluateOp();
4761 case 713: // Evaluate mesh
4762 op = new SMESHGUI_MeshOrderOp();
4764 case 806: // Create group on geom
4765 op = new SMESHGUI_GroupOnShapeOp();
4767 case 904: // Find element
4768 op = new SMESHGUI_FindElemByPointOp();
4770 case 4067: // make mesh pass through point
4771 op = new SMESHGUI_MakeNodeAtPointOp();
4778 op = SalomeApp_Module::createOperation( id );
4782 //================================================================================
4784 * \brief Stops current operations and starts a given one
4785 * \param id - The id of the operation to start
4787 //================================================================================
4789 void SMESHGUI::switchToOperation(int id)
4791 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4792 activeStudy()->abortAllOperations();
4793 startOperation( id );
4796 LightApp_Displayer* SMESHGUI::displayer()
4799 myDisplayer = new SMESHGUI_Displayer( getApp() );
4803 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4806 int aTolerance = 64;
4807 int anIterations = 0;
4813 if( anIterations % aPeriod == 0 )
4816 if( aTolerance < 1 )
4820 aHue = (int)( 360.0 * rand() / RAND_MAX );
4823 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
4824 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
4825 for( ; it != itEnd; ++it )
4827 SALOMEDS::Color anAutoColor = *it;
4828 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
4831 aQColor.getHsv( &h, &s, &v );
4832 if( abs( h - aHue ) < aTolerance )
4844 aColor.setHsv( aHue, 255, 255 );
4846 SALOMEDS::Color aSColor;
4847 aSColor.R = (double)aColor.red() / 255.0;
4848 aSColor.G = (double)aColor.green() / 255.0;
4849 aSColor.B = (double)aColor.blue() / 255.0;
4854 const char gSeparator = '_'; // character used to separate parameter names
4855 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
4856 const char gPathSep = '|'; // character used to separate paths
4859 * \brief Store visual parameters
4861 * This method is called just before the study document is saved.
4862 * Store visual parameters in AttributeParameter attribue(s)
4864 void SMESHGUI::storeVisualParameters (int savePoint)
4866 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
4867 if (!appStudy || !appStudy->studyDS())
4869 _PTR(Study) studyDS = appStudy->studyDS();
4871 // componentName is used for encoding of entries when storing them in IParameters
4872 std::string componentName = myComponentSMESH->ComponentDataType();
4873 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
4874 //if (!aSComponent) return;
4877 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
4878 componentName.c_str(),
4880 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
4882 // store map of custom markers
4883 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
4884 if( !aMarkerMap.empty() )
4886 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
4887 for( ; anIter != aMarkerMap.end(); anIter++ )
4889 int anId = anIter->first;
4890 VTK::MarkerData aMarkerData = anIter->second;
4891 std::string aMarkerFileName = aMarkerData.first;
4892 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
4893 if( aMarkerTexture.size() < 3 )
4894 continue; // should contain at least width, height and the first value
4896 QString aPropertyName( "texture" );
4897 aPropertyName += gSeparator;
4898 aPropertyName += QString::number( anId );
4900 QString aPropertyValue = aMarkerFileName.c_str();
4901 aPropertyValue += gPathSep;
4903 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
4904 ushort aWidth = *aTextureIter++;
4905 ushort aHeight = *aTextureIter++;
4906 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
4907 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
4908 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
4909 aPropertyValue += QString::number( *aTextureIter );
4911 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4915 // viewers counters are used for storing view_numbers in IParameters
4918 // main cycle to store parameters of displayed objects
4919 QList<SUIT_ViewManager*> lst;
4920 QList<SUIT_ViewManager*>::Iterator it;
4921 getApp()->viewManagers(lst);
4922 for (it = lst.begin(); it != lst.end(); it++)
4924 SUIT_ViewManager* vman = *it;
4925 QString vType = vman->getType();
4927 // saving VTK actors properties
4928 if (vType == SVTK_Viewer::Type())
4930 // store the clipping planes attached to the view manager
4931 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
4932 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
4933 if( anIter != myClippingPlaneInfoMap.end() )
4934 aClippingPlaneInfoList = anIter->second;
4936 if( !aClippingPlaneInfoList.empty() ) {
4937 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
4938 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
4940 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
4941 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
4943 QString aPropertyName( "ClippingPlane" );
4944 aPropertyName += gSeparator;
4945 aPropertyName += QString::number( vtkViewers );
4946 aPropertyName += gSeparator;
4947 aPropertyName += QString::number( anId );
4949 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
4950 aPropertyValue += gDigitsSep;
4951 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
4952 aPropertyValue += gDigitsSep;
4953 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
4954 aPropertyValue += gDigitsSep;
4955 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
4957 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4961 QVector<SUIT_ViewWindow*> views = vman->getViews();
4962 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
4964 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
4966 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
4967 vtkActorCollection* allActors = aCopy.GetActors();
4968 allActors->InitTraversal();
4969 while (vtkActor* actor = allActors->GetNextActor())
4971 if (actor->GetVisibility()) // store only visible actors
4973 SMESH_Actor* aSmeshActor = 0;
4974 if (actor->IsA("SMESH_Actor"))
4975 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
4976 if (aSmeshActor && aSmeshActor->hasIO())
4978 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
4981 // entry is "encoded" = it does NOT contain component adress,
4982 // since it is a subject to change on next component loading
4983 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
4985 std::string param, vtkParam = vType.toLatin1().data();
4986 vtkParam += gSeparator;
4987 vtkParam += QString::number(vtkViewers).toLatin1().data();
4988 vtkParam += gSeparator;
4991 param = vtkParam + "Visibility";
4992 ip->setParameter(entry, param, "On");
4995 param = vtkParam + "Representation";
4996 ip->setParameter(entry, param, QString::number
4997 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5000 param = vtkParam + "IsShrunk";
5001 ip->setParameter(entry, param, QString::number
5002 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5004 // Displayed entities
5005 unsigned int aMode = aSmeshActor->GetEntityMode();
5006 bool isE = aMode & SMESH_Actor::eEdges;
5007 bool isF = aMode & SMESH_Actor::eFaces;
5008 bool isV = aMode & SMESH_Actor::eVolumes;
5010 QString modeStr ("e");
5011 modeStr += gDigitsSep; modeStr += QString::number(isE);
5012 modeStr += gDigitsSep; modeStr += "f";
5013 modeStr += gDigitsSep; modeStr += QString::number(isF);
5014 modeStr += gDigitsSep; modeStr += "v";
5015 modeStr += gDigitsSep; modeStr += QString::number(isV);
5017 param = vtkParam + "Entities";
5018 ip->setParameter(entry, param, modeStr.toLatin1().data());
5020 // Colors (surface:edge:)
5021 vtkFloatingPointType r, g, b;
5023 aSmeshActor->GetSufaceColor(r, g, b);
5024 QString colorStr ("surface");
5025 colorStr += gDigitsSep; colorStr += QString::number(r);
5026 colorStr += gDigitsSep; colorStr += QString::number(g);
5027 colorStr += gDigitsSep; colorStr += QString::number(b);
5029 aSmeshActor->GetBackSufaceColor(r, g, b);
5030 colorStr += gDigitsSep; colorStr += "backsurface";
5031 colorStr += gDigitsSep; colorStr += QString::number(r);
5032 colorStr += gDigitsSep; colorStr += QString::number(g);
5033 colorStr += gDigitsSep; colorStr += QString::number(b);
5035 aSmeshActor->GetEdgeColor(r, g, b);
5036 colorStr += gDigitsSep; colorStr += "edge";
5037 colorStr += gDigitsSep; colorStr += QString::number(r);
5038 colorStr += gDigitsSep; colorStr += QString::number(g);
5039 colorStr += gDigitsSep; colorStr += QString::number(b);
5041 aSmeshActor->GetNodeColor(r, g, b);
5042 colorStr += gDigitsSep; colorStr += "node";
5043 colorStr += gDigitsSep; colorStr += QString::number(r);
5044 colorStr += gDigitsSep; colorStr += QString::number(g);
5045 colorStr += gDigitsSep; colorStr += QString::number(b);
5047 param = vtkParam + "Colors";
5048 ip->setParameter(entry, param, colorStr.toLatin1().data());
5050 // Sizes of lines and points
5051 QString sizeStr ("line");
5052 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5053 sizeStr += gDigitsSep; sizeStr += "shrink";
5054 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5056 param = vtkParam + "Sizes";
5057 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5062 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5063 if( aMarkerType == VTK::MT_USER ) {
5064 markerStr += "custom";
5065 markerStr += gDigitsSep;
5066 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5070 markerStr += gDigitsSep;
5071 markerStr += QString::number( (int)aMarkerType );
5072 markerStr += gDigitsSep;
5073 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5076 param = vtkParam + "PointMarker";
5077 ip->setParameter(entry, param, markerStr.toLatin1().data());
5080 param = vtkParam + "Opacity";
5081 ip->setParameter(entry, param,
5082 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5085 param = vtkParam + "ClippingPlane";
5087 if( !aClippingPlaneInfoList.empty() ) {
5088 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5089 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5091 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5092 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5093 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5094 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5095 if( aSmeshActor == *anIter2 ) {
5096 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5097 QString::number( anId ).toLatin1().constData() );
5104 ip->setParameter( entry, param, "Off" );
5105 } // if (io->hasEntry())
5106 } // SMESH_Actor && hasIO
5108 } // while.. actors traversal
5112 } // if (SVTK view model)
5113 } // for (viewManagers)
5116 // data structures for clipping planes processing
5119 vtkIdType Orientation;
5120 vtkFloatingPointType Distance;
5121 vtkFloatingPointType Angle[2];
5123 typedef std::list<TPlaneData> TPlaneDataList;
5124 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5126 typedef std::list<vtkActor*> TActorList;
5129 TActorList ActorList;
5130 SUIT_ViewManager* ViewManager;
5132 typedef std::list<TPlaneInfo> TPlaneInfoList;
5133 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5136 * \brief Restore visual parameters
5138 * This method is called after the study document is opened.
5139 * Restore visual parameters from AttributeParameter attribue(s)
5141 void SMESHGUI::restoreVisualParameters (int savePoint)
5143 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5144 if (!appStudy || !appStudy->studyDS())
5146 _PTR(Study) studyDS = appStudy->studyDS();
5148 // componentName is used for encoding of entries when storing them in IParameters
5149 std::string componentName = myComponentSMESH->ComponentDataType();
5150 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5151 //if (!aSComponent) return;
5154 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5155 componentName.c_str(),
5157 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5159 // restore map of custom markers and map of clipping planes
5160 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5161 TPlaneDataMap aPlaneDataMap;
5163 std::vector<std::string> properties = ip->getProperties();
5164 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5166 std::string property = *propIt;
5167 QString aPropertyName( property.c_str() );
5168 QString aPropertyValue( ip->getProperty( property ).c_str() );
5170 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5171 if( aPropertyNameList.isEmpty() )
5174 QString aPropertyType = aPropertyNameList[0];
5175 if( aPropertyType == "texture" )
5177 if( aPropertyNameList.size() != 2 )
5181 int anId = aPropertyNameList[1].toInt( &ok );
5182 if( !ok || anId < 1 )
5185 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5186 if( aPropertyValueList.size() != 2 )
5189 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5190 QString aMarkerTextureString = aPropertyValueList[1];
5191 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5192 if( aMarkerTextureStringList.size() != 3 )
5196 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5201 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5205 VTK::MarkerTexture aMarkerTexture;
5206 aMarkerTexture.push_back( aWidth );
5207 aMarkerTexture.push_back( aHeight );
5209 QString aMarkerTextureData = aMarkerTextureStringList[2];
5210 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5212 QChar aChar = aMarkerTextureData.at( i );
5213 if( aChar.isDigit() )
5214 aMarkerTexture.push_back( aChar.digitValue() );
5217 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5219 else if( aPropertyType == "ClippingPlane" )
5221 if( aPropertyNameList.size() != 3 )
5225 int aViewId = aPropertyNameList[1].toInt( &ok );
5226 if( !ok || aViewId < 0 )
5230 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5231 if( !ok || aClippingPlaneId < 0 )
5234 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5235 if( aPropertyValueList.size() != 4 )
5238 TPlaneData aPlaneData;
5239 aPlaneData.Id = aClippingPlaneId;
5242 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5247 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5252 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5257 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5261 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5262 aPlaneDataList.push_back( aPlaneData );
5266 TPlaneInfoMap aPlaneInfoMap;
5268 std::vector<std::string> entries = ip->getEntries();
5270 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5272 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5273 QString entry (ip->decodeEntry(*entIt).c_str());
5275 // Check that the entry corresponds to a real object in the Study
5276 // as the object may be deleted or modified after the visual state is saved.
5277 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5278 if (!so) continue; //Skip the not existent entry
5280 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5281 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5283 std::vector<std::string>::iterator namesIt = paramNames.begin();
5284 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5286 // actors are stored in a map after displaying of them for
5287 // quicker access in the future: map < viewID to actor >
5288 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5290 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5292 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5293 // '_' is used as separator and should not be used in viewer type or parameter names.
5294 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5295 if (lst.size() != 3)
5298 QString viewerTypStr = lst[0];
5299 QString viewIndexStr = lst[1];
5300 QString paramNameStr = lst[2];
5303 int viewIndex = viewIndexStr.toUInt(&ok);
5304 if (!ok) // bad conversion of view index to integer
5308 if (viewerTypStr == SVTK_Viewer::Type())
5310 SMESH_Actor* aSmeshActor = 0;
5311 if (vtkActors.IsBound(viewIndex))
5312 aSmeshActor = vtkActors.Find(viewIndex);
5314 QList<SUIT_ViewManager*> lst;
5315 getApp()->viewManagers(viewerTypStr, lst);
5317 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5318 SUIT_ViewManager* vman = NULL;
5319 if (viewIndex >= 0 && viewIndex < lst.count())
5320 vman = lst.at(viewIndex);
5322 if (paramNameStr == "Visibility")
5324 if (!aSmeshActor && displayer() && vman)
5326 SUIT_ViewModel* vmodel = vman->getViewModel();
5327 // SVTK view model can be casted to SALOME_View
5328 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5330 // store displayed actor in a temporary map for quicker
5331 // access later when restoring other parameters
5332 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5333 vtkRenderer* Renderer = vtkView->getRenderer();
5334 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5335 vtkActorCollection* theActors = aCopy.GetActors();
5336 theActors->InitTraversal();
5337 bool isFound = false;
5338 vtkActor *ac = theActors->GetNextActor();
5339 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5340 if (ac->IsA("SMESH_Actor")) {
5341 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5342 if (aGeomAc->hasIO()) {
5343 Handle(SALOME_InteractiveObject) io =
5344 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5345 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5347 vtkActors.Bind(viewIndex, aGeomAc);
5353 } // if (paramNameStr == "Visibility")
5356 // the rest properties "work" with SMESH_Actor
5359 QString val ((*valuesIt).c_str());
5362 if (paramNameStr == "Representation") {
5363 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5366 else if (paramNameStr == "IsShrunk") {
5368 if (!aSmeshActor->IsShrunk())
5369 aSmeshActor->SetShrink();
5372 if (aSmeshActor->IsShrunk())
5373 aSmeshActor->UnShrink();
5376 // Displayed entities
5377 else if (paramNameStr == "Entities") {
5378 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5379 if (mode.count() == 6) {
5380 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5381 MESSAGE("Invalid order of data in Entities, must be: "
5382 "e:0/1:f:0/1:v:0/1");
5385 unsigned int aMode = aSmeshActor->GetEntityMode();
5386 unsigned int aNewMode =
5387 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5388 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5389 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5390 if (aNewMode != aMode)
5391 aSmeshActor->SetEntityMode(aNewMode);
5396 else if (paramNameStr == "Colors") {
5397 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5398 if (colors.count() == 16) {
5399 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5400 colors[8] != "edge" || colors[12] != "node") {
5401 MESSAGE("Invalid order of data in Colors, must be: "
5402 "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
5405 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
5406 aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
5407 aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
5408 aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
5412 // Sizes of lines and points
5413 else if (paramNameStr == "Sizes") {
5414 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5415 if (sizes.count() == 4) {
5416 if (sizes[0] != "line" || sizes[2] != "shrink") {
5417 MESSAGE("Invalid order of data in Sizes, must be: "
5418 "line:int:shrink:float");
5421 aSmeshActor->SetLineWidth(sizes[1].toInt());
5422 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5425 else if (sizes.count() == 6) { // just to support old format
5426 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5427 MESSAGE("Invalid order of data in Sizes, must be: "
5428 "line:int:node:int:shrink:float");
5431 aSmeshActor->SetLineWidth(sizes[1].toInt());
5432 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5433 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5438 else if (paramNameStr == "PointMarker") {
5439 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5440 if( data.count() >= 2 ) {
5442 int aParam1 = data[1].toInt( &ok );
5444 if( data[0] == "std" && data.count() == 3 ) {
5445 int aParam2 = data[2].toInt( &ok );
5446 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5448 else if( data[0] == "custom" ) {
5449 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5450 if( markerIt != aMarkerMap.end() ) {
5451 VTK::MarkerData aMarkerData = markerIt->second;
5452 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5459 else if (paramNameStr == "Opacity") {
5460 aSmeshActor->SetOpacity(val.toFloat());
5463 else if (paramNameStr.startsWith("ClippingPlane")) {
5464 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5465 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5466 // new format - val looks like "Off" or "0" (plane id)
5467 // (note: in new format "Off" value is used only for consistency,
5468 // so it is processed together with values in old format)
5469 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5470 if( anIsOldFormat ) {
5471 if (paramNameStr == "ClippingPlane1" || val == "Off")
5472 aSmeshActor->RemoveAllClippingPlanes();
5474 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5475 double aDistance = vals[1].toFloat();
5476 vtkFloatingPointType anAngle[2];
5477 anAngle[0] = vals[2].toFloat();
5478 anAngle[1] = vals[3].toFloat();
5480 QList<SUIT_ViewManager*> lst;
5481 getApp()->viewManagers(viewerTypStr, lst);
5482 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5483 if (viewIndex >= 0 && viewIndex < lst.count()) {
5484 SUIT_ViewManager* vman = lst.at(viewIndex);
5485 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5487 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5489 SMESH::TActorList anActorList;
5490 anActorList.push_back( aSmeshActor );
5491 SMESH::OrientedPlane* aPlane =
5492 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5494 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5495 aClippingPlaneInfo.Plane = aPlane;
5496 aClippingPlaneInfo.ActorList = anActorList;
5497 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5504 int aPlaneId = val.toInt( &ok );
5505 if( ok && aPlaneId >= 0 ) {
5506 bool anIsDefinedPlane = false;
5507 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5508 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5509 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5510 TPlaneInfo& aPlaneInfo = *anIter;
5511 if( aPlaneInfo.PlaneId == aPlaneId ) {
5512 aPlaneInfo.ActorList.push_back( aSmeshActor );
5513 anIsDefinedPlane = true;
5517 if( !anIsDefinedPlane ) {
5518 TPlaneInfo aPlaneInfo;
5519 aPlaneInfo.PlaneId = aPlaneId;
5520 aPlaneInfo.ActorList.push_back( aSmeshActor );
5521 aPlaneInfo.ViewManager = vman;
5523 // to make the list sorted by plane id
5524 anIter = aPlaneInfoList.begin();
5525 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5526 const TPlaneInfo& aPlaneInfoRef = *anIter;
5527 if( aPlaneInfoRef.PlaneId > aPlaneId )
5530 aPlaneInfoList.insert( anIter, aPlaneInfo );
5535 } // if (aSmeshActor)
5536 } // other parameters than Visibility
5538 } // for names/parameters iterator
5539 } // for entries iterator
5541 // take into account planes with empty list of actors referred to them
5542 QList<SUIT_ViewManager*> aVMList;
5543 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5545 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5546 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5547 int aViewId = aPlaneDataIter->first;
5548 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5549 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5551 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5553 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5554 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5555 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5556 const TPlaneData& aPlaneData = *anIter2;
5557 int aPlaneId = aPlaneData.Id;
5559 bool anIsFound = false;
5560 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5561 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5562 const TPlaneInfo& aPlaneInfo = *anIter3;
5563 if( aPlaneInfo.PlaneId == aPlaneId ) {
5570 TPlaneInfo aPlaneInfo; // ActorList field is empty
5571 aPlaneInfo.PlaneId = aPlaneId;
5572 aPlaneInfo.ViewManager = aViewManager;
5574 // to make the list sorted by plane id
5575 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5576 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5577 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5578 if( aPlaneInfoRef.PlaneId > aPlaneId )
5581 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5587 // add clipping planes to actors according to the restored parameters
5588 // and update the clipping plane map
5589 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5590 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5591 int aViewId = anIter1->first;
5592 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5594 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5595 if( anIter2 == aPlaneDataMap.end() )
5597 const TPlaneDataList& aPlaneDataList = anIter2->second;
5599 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5600 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5601 const TPlaneInfo& aPlaneInfo = *anIter3;
5602 int aPlaneId = aPlaneInfo.PlaneId;
5603 const TActorList& anActorList = aPlaneInfo.ActorList;
5604 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5608 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5612 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5614 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5615 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5616 const TPlaneData& aPlaneData = *anIter4;
5617 if( aPlaneData.Id == aPlaneId ) {
5618 SMESH::OrientedPlane* aPlane =
5619 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5621 (SMESH::Orientation)aPlaneData.Orientation,
5622 aPlaneData.Distance,
5625 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5626 aClippingPlaneInfo.Plane = aPlane;
5627 aClippingPlaneInfo.ActorList = anActorList;
5628 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5636 // update all VTK views
5637 QList<SUIT_ViewManager*> lst;
5638 getApp()->viewManagers(lst);
5639 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5640 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5641 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5642 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5643 vtkView->getRenderer()->ResetCameraClippingRange();
5650 \brief Adds preferences for dfont of VTK viewer
5652 \param pIf group identifier
5653 \param param parameter
5654 \return identifier of preferences
5656 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5658 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5660 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5663 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5664 fam.append( tr( "SMESH_FONT_COURIER" ) );
5665 fam.append( tr( "SMESH_FONT_TIMES" ) );
5667 setPreferenceProperty( tfont, "fonts", fam );
5669 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5670 setPreferenceProperty( tfont, "features", f );
5676 \brief Actions after hypothesis edition
5677 Updates object browser after hypothesis edition
5679 void SMESHGUI::onHypothesisEdit( int result )
5682 SMESHGUI::Modified();
5683 updateObjBrowser( true );
5688 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5689 \param pview view being closed
5691 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5692 #ifndef DISABLE_PLOT2DVIEWER
5693 //Crear all Plot2d Viewers if need.
5694 SMESH::ClearPlot2Viewers(pview);
5699 \brief Connects or disconnects signals about activating and cloning view on the module slots
5700 \param pview view which is connected/disconnected
5702 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5706 SUIT_ViewManager* viewMgr = pview->getViewManager();
5708 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5709 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5711 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5712 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5717 \brief Return \c true if object can be renamed
5719 bool SMESHGUI::renameAllowed( const QString& entry) const {
5720 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5724 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5728 bool appRes = SalomeApp_Module::renameAllowed(entry);
5732 // check type to prevent renaming of inappropriate objects
5733 int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5734 if (aType == MESH || aType == GROUP ||
5735 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5736 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5737 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5738 aType == HYPOTHESIS || aType == ALGORITHM)
5745 Rename object by entry.
5746 \param entry entry of the object
5747 \param name new name of the object
5748 \brief Return \c true if rename operation finished successfully, \c false otherwise.
5750 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5752 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5756 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5760 bool appRes = SalomeApp_Module::renameObject(entry,name);
5764 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5765 _PTR(GenericAttribute) anAttr;
5766 _PTR(AttributeName) aName;
5768 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
5770 // check type to prevent renaming of inappropriate objects
5771 int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
5772 if (aType == MESH || aType == GROUP ||
5773 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5774 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5775 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5776 aType == HYPOTHESIS || aType == ALGORITHM) {
5777 if ( !name.isEmpty() ) {
5778 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
5780 // update name of group object and its actor
5781 Handle(SALOME_InteractiveObject) IObject =
5782 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
5784 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
5785 if( !aGroupObject->_is_nil() ) {
5786 aGroupObject->SetName( qPrintable(name) );
5787 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
5788 anActor->setName( qPrintable(name) );