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 // Mesh tab ------------------------------------------------------------------------
4400 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4401 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4402 setPreferenceProperty( nodeGroup, "columns", 3 );
4404 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4406 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4408 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4409 QList<QVariant> aMarkerTypeIndicesList;
4410 QList<QVariant> aMarkerTypeIconsList;
4411 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4412 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4413 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4414 aMarkerTypeIndicesList << i;
4415 aMarkerTypeIconsList << pixmap;
4417 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4418 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4420 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4422 QList<QVariant> aMarkerScaleIndicesList;
4423 QStringList aMarkerScaleValuesList;
4424 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4425 aMarkerScaleIndicesList << i;
4426 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4428 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4429 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4431 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4432 setPreferenceProperty( elemGroup, "columns", 2 );
4434 addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
4435 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4436 addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
4437 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4439 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4440 setPreferenceProperty( grpGroup, "columns", 2 );
4442 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4444 //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4445 //setPreferenceProperty( sp, "hstretch", 0 );
4446 //setPreferenceProperty( sp, "vstretch", 0 );
4448 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4449 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4450 int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4451 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4452 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4453 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4454 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4456 setPreferenceProperty( size0d, "min", 1 );
4457 setPreferenceProperty( size0d, "max", 10 );
4459 setPreferenceProperty( sp, "hstretch", 0 );
4460 setPreferenceProperty( sp, "vstretch", 0 );
4462 setPreferenceProperty( elemW, "min", 1 );
4463 setPreferenceProperty( elemW, "max", 5 );
4465 setPreferenceProperty( shrink, "min", 0 );
4466 setPreferenceProperty( shrink, "max", 100 );
4468 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4469 setPreferenceProperty( orientGroup, "columns", 1 );
4471 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4472 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4474 setPreferenceProperty( orientScale, "min", 0.05 );
4475 setPreferenceProperty( orientScale, "max", 0.5 );
4476 setPreferenceProperty( orientScale, "step", 0.05 );
4478 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4480 // Selection tab ------------------------------------------------------------------------
4481 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4483 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4484 setPreferenceProperty( selGroup, "columns", 2 );
4486 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4487 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4488 int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4490 setPreferenceProperty( selW, "min", 1 );
4491 setPreferenceProperty( selW, "max", 5 );
4493 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4494 setPreferenceProperty( preGroup, "columns", 2 );
4496 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4497 int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4499 setPreferenceProperty( preW, "min", 1 );
4500 setPreferenceProperty( preW, "max", 5 );
4502 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4503 setPreferenceProperty( precSelGroup, "columns", 2 );
4505 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4506 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4507 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4509 // Scalar Bar tab ------------------------------------------------------------------------
4510 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4511 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4512 setPreferenceProperty( fontGr, "columns", 2 );
4514 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4515 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4517 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4518 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4520 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4521 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4523 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4524 setPreferenceProperty( numcol, "min", 2 );
4525 setPreferenceProperty( numcol, "max", 256 );
4527 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4528 setPreferenceProperty( numlab, "min", 2 );
4529 setPreferenceProperty( numlab, "max", 65 );
4531 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4532 setPreferenceProperty( orientGr, "columns", 2 );
4533 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4534 QStringList orients;
4535 orients.append( tr( "SMESH_VERTICAL" ) );
4536 orients.append( tr( "SMESH_HORIZONTAL" ) );
4537 indices.clear(); indices.append( 0 ); indices.append( 1 );
4538 setPreferenceProperty( orient, "strings", orients );
4539 setPreferenceProperty( orient, "indexes", indices );
4541 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4542 setPreferenceProperty( posVSizeGr, "columns", 2 );
4543 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4544 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4545 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4546 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4547 setPreferenceProperty( xv, "step", 0.1 );
4548 setPreferenceProperty( xv, "min", 0.0 );
4549 setPreferenceProperty( xv, "max", 1.0 );
4550 setPreferenceProperty( yv, "step", 0.1 );
4551 setPreferenceProperty( yv, "min", 0.0 );
4552 setPreferenceProperty( yv, "max", 1.0 );
4553 setPreferenceProperty( wv, "step", 0.1 );
4554 setPreferenceProperty( wv, "min", 0.0 );
4555 setPreferenceProperty( wv, "max", 1.0 );
4556 setPreferenceProperty( hv, "min", 0.0 );
4557 setPreferenceProperty( hv, "max", 1.0 );
4558 setPreferenceProperty( hv, "step", 0.1 );
4560 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4561 setPreferenceProperty( posHSizeGr, "columns", 2 );
4562 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4563 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4564 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4565 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4566 setPreferenceProperty( xv, "min", 0.0 );
4567 setPreferenceProperty( xv, "max", 1.0 );
4568 setPreferenceProperty( xv, "step", 0.1 );
4569 setPreferenceProperty( xh, "min", 0.0 );
4570 setPreferenceProperty( xh, "max", 1.0 );
4571 setPreferenceProperty( xh, "step", 0.1 );
4572 setPreferenceProperty( yh, "min", 0.0 );
4573 setPreferenceProperty( yh, "max", 1.0 );
4574 setPreferenceProperty( yh, "step", 0.1 );
4575 setPreferenceProperty( wh, "min", 0.0 );
4576 setPreferenceProperty( wh, "max", 1.0 );
4577 setPreferenceProperty( wh, "step", 0.1 );
4578 setPreferenceProperty( hh, "min", 0.0 );
4579 setPreferenceProperty( hh, "max", 1.0 );
4580 setPreferenceProperty( hh, "step", 0.1 );
4582 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4583 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4584 setPreferenceProperty( distributionGr, "columns", 3 );
4586 types.append( tr( "SMESH_MONOCOLOR" ) );
4587 types.append( tr( "SMESH_MULTICOLOR" ) );
4588 indices.clear(); indices.append( 0 ); indices.append( 1 );
4589 setPreferenceProperty( coloringType, "strings", types );
4590 setPreferenceProperty( coloringType, "indexes", indices );
4591 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4595 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4597 if( sect=="SMESH" ) {
4598 float sbX1,sbY1,sbW,sbH;
4599 float aTol = 1.00000009999999;
4600 std::string aWarning;
4601 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4602 if( name=="selection_object_color" || name=="selection_element_color" ||
4603 name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4604 name=="selection_precision_node" || name=="selection_precision_element" ||
4605 name=="selection_precision_object")
4606 SMESH::UpdateSelectionProp( this );
4607 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4608 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4609 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4610 if(sbX1+sbW > aTol){
4611 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4614 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4615 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4618 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4619 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4620 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4621 if(sbY1+sbH > aTol){
4622 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4623 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4624 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4627 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4628 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4629 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4630 if(sbX1+sbW > aTol){
4631 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4634 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4635 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4638 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4639 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4640 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4641 if(sbY1+sbH > aTol){
4642 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4645 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4646 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4649 else if ( name == "segmentation" ) {
4650 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4651 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4653 else if ( name == "nb_segments_per_edge" ) {
4654 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4655 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4658 if(aWarning.size() != 0){
4659 aWarning += "The default values are applied instead.";
4660 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4661 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4662 QObject::tr(aWarning.c_str()));
4667 //================================================================================
4669 * \brief Update something in accordance with update flags
4670 * \param theFlags - update flags
4672 * Update viewer or/and object browser etc. in accordance with update flags ( see
4673 * LightApp_UpdateFlags enumeration ).
4675 //================================================================================
4676 void SMESHGUI::update( const int flags )
4678 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4679 SMESH::UpdateView();
4681 SalomeApp_Module::update( flags );
4684 //================================================================================
4686 * \brief Set default selection mode
4688 * SLOT called when operation commited. Sets default selection mode
4690 //================================================================================
4691 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4693 SVTK_ViewWindow* vtkWnd =
4694 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4696 vtkWnd->SetSelectionMode( ActorSelection );
4699 //================================================================================
4701 * \brief Set default selection mode
4703 * SLOT called when operation aborted. Sets default selection mode
4705 //================================================================================
4706 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4708 SVTK_ViewWindow* vtkWnd =
4709 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4711 vtkWnd->SetSelectionMode( ActorSelection );
4714 //================================================================================
4716 * \brief Creates operation with given identifier
4717 * \param id - identifier of operation to be started
4718 * \return Pointer on created operation or NULL if operation is not created
4720 * Virtual method redefined from the base class creates operation with given id.
4721 * It is called called automatically from startOperation method of base class.
4723 //================================================================================
4724 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4726 LightApp_Operation* op = 0;
4727 // to do : create operation here
4730 case 417: //convert to quadratic
4731 op = new SMESHGUI_ConvToQuadOp();
4733 case 418: // create 2D mesh as boundary on 3D
4734 op = new SMESHGUI_Make2DFrom3DOp();
4736 case 701: // Compute mesh
4737 op = new SMESHGUI_ComputeOp();
4739 case 702: // Create mesh
4740 op = new SMESHGUI_MeshOp( true, true );
4742 case 703: // Create sub-mesh
4743 op = new SMESHGUI_MeshOp( true, false );
4745 case 704: // Edit mesh/sub-mesh
4746 op = new SMESHGUI_MeshOp( false );
4748 case 711: // Precompute mesh
4749 op = new SMESHGUI_PrecomputeOp();
4751 case 712: // Evaluate mesh
4752 op = new SMESHGUI_EvaluateOp();
4754 case 713: // Evaluate mesh
4755 op = new SMESHGUI_MeshOrderOp();
4757 case 806: // Create group on geom
4758 op = new SMESHGUI_GroupOnShapeOp();
4760 case 904: // Find element
4761 op = new SMESHGUI_FindElemByPointOp();
4763 case 4067: // make mesh pass through point
4764 op = new SMESHGUI_MakeNodeAtPointOp();
4771 op = SalomeApp_Module::createOperation( id );
4775 //================================================================================
4777 * \brief Stops current operations and starts a given one
4778 * \param id - The id of the operation to start
4780 //================================================================================
4782 void SMESHGUI::switchToOperation(int id)
4784 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4785 activeStudy()->abortAllOperations();
4786 startOperation( id );
4789 LightApp_Displayer* SMESHGUI::displayer()
4792 myDisplayer = new SMESHGUI_Displayer( getApp() );
4796 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4799 int aTolerance = 64;
4800 int anIterations = 0;
4806 if( anIterations % aPeriod == 0 )
4809 if( aTolerance < 1 )
4813 aHue = (int)( 360.0 * rand() / RAND_MAX );
4816 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
4817 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
4818 for( ; it != itEnd; ++it )
4820 SALOMEDS::Color anAutoColor = *it;
4821 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
4824 aQColor.getHsv( &h, &s, &v );
4825 if( abs( h - aHue ) < aTolerance )
4837 aColor.setHsv( aHue, 255, 255 );
4839 SALOMEDS::Color aSColor;
4840 aSColor.R = (double)aColor.red() / 255.0;
4841 aSColor.G = (double)aColor.green() / 255.0;
4842 aSColor.B = (double)aColor.blue() / 255.0;
4847 const char gSeparator = '_'; // character used to separate parameter names
4848 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
4849 const char gPathSep = '|'; // character used to separate paths
4852 * \brief Store visual parameters
4854 * This method is called just before the study document is saved.
4855 * Store visual parameters in AttributeParameter attribue(s)
4857 void SMESHGUI::storeVisualParameters (int savePoint)
4859 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
4860 if (!appStudy || !appStudy->studyDS())
4862 _PTR(Study) studyDS = appStudy->studyDS();
4864 // componentName is used for encoding of entries when storing them in IParameters
4865 std::string componentName = myComponentSMESH->ComponentDataType();
4866 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
4867 //if (!aSComponent) return;
4870 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
4871 componentName.c_str(),
4873 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
4875 // store map of custom markers
4876 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
4877 if( !aMarkerMap.empty() )
4879 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
4880 for( ; anIter != aMarkerMap.end(); anIter++ )
4882 int anId = anIter->first;
4883 VTK::MarkerData aMarkerData = anIter->second;
4884 std::string aMarkerFileName = aMarkerData.first;
4885 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
4886 if( aMarkerTexture.size() < 3 )
4887 continue; // should contain at least width, height and the first value
4889 QString aPropertyName( "texture" );
4890 aPropertyName += gSeparator;
4891 aPropertyName += QString::number( anId );
4893 QString aPropertyValue = aMarkerFileName.c_str();
4894 aPropertyValue += gPathSep;
4896 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
4897 ushort aWidth = *aTextureIter++;
4898 ushort aHeight = *aTextureIter++;
4899 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
4900 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
4901 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
4902 aPropertyValue += QString::number( *aTextureIter );
4904 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4908 // viewers counters are used for storing view_numbers in IParameters
4911 // main cycle to store parameters of displayed objects
4912 QList<SUIT_ViewManager*> lst;
4913 QList<SUIT_ViewManager*>::Iterator it;
4914 getApp()->viewManagers(lst);
4915 for (it = lst.begin(); it != lst.end(); it++)
4917 SUIT_ViewManager* vman = *it;
4918 QString vType = vman->getType();
4920 // saving VTK actors properties
4921 if (vType == SVTK_Viewer::Type())
4923 // store the clipping planes attached to the view manager
4924 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
4925 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
4926 if( anIter != myClippingPlaneInfoMap.end() )
4927 aClippingPlaneInfoList = anIter->second;
4929 if( !aClippingPlaneInfoList.empty() ) {
4930 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
4931 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
4933 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
4934 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
4936 QString aPropertyName( "ClippingPlane" );
4937 aPropertyName += gSeparator;
4938 aPropertyName += QString::number( vtkViewers );
4939 aPropertyName += gSeparator;
4940 aPropertyName += QString::number( anId );
4942 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
4943 aPropertyValue += gDigitsSep;
4944 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
4945 aPropertyValue += gDigitsSep;
4946 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
4947 aPropertyValue += gDigitsSep;
4948 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
4950 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4954 QVector<SUIT_ViewWindow*> views = vman->getViews();
4955 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
4957 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
4959 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
4960 vtkActorCollection* allActors = aCopy.GetActors();
4961 allActors->InitTraversal();
4962 while (vtkActor* actor = allActors->GetNextActor())
4964 if (actor->GetVisibility()) // store only visible actors
4966 SMESH_Actor* aSmeshActor = 0;
4967 if (actor->IsA("SMESH_Actor"))
4968 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
4969 if (aSmeshActor && aSmeshActor->hasIO())
4971 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
4974 // entry is "encoded" = it does NOT contain component adress,
4975 // since it is a subject to change on next component loading
4976 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
4978 std::string param, vtkParam = vType.toLatin1().data();
4979 vtkParam += gSeparator;
4980 vtkParam += QString::number(vtkViewers).toLatin1().data();
4981 vtkParam += gSeparator;
4984 param = vtkParam + "Visibility";
4985 ip->setParameter(entry, param, "On");
4988 param = vtkParam + "Representation";
4989 ip->setParameter(entry, param, QString::number
4990 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
4993 param = vtkParam + "IsShrunk";
4994 ip->setParameter(entry, param, QString::number
4995 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
4997 // Displayed entities
4998 unsigned int aMode = aSmeshActor->GetEntityMode();
4999 bool isE = aMode & SMESH_Actor::eEdges;
5000 bool isF = aMode & SMESH_Actor::eFaces;
5001 bool isV = aMode & SMESH_Actor::eVolumes;
5003 QString modeStr ("e");
5004 modeStr += gDigitsSep; modeStr += QString::number(isE);
5005 modeStr += gDigitsSep; modeStr += "f";
5006 modeStr += gDigitsSep; modeStr += QString::number(isF);
5007 modeStr += gDigitsSep; modeStr += "v";
5008 modeStr += gDigitsSep; modeStr += QString::number(isV);
5010 param = vtkParam + "Entities";
5011 ip->setParameter(entry, param, modeStr.toLatin1().data());
5013 // Colors (surface:edge:)
5014 vtkFloatingPointType r, g, b;
5016 aSmeshActor->GetSufaceColor(r, g, b);
5017 QString colorStr ("surface");
5018 colorStr += gDigitsSep; colorStr += QString::number(r);
5019 colorStr += gDigitsSep; colorStr += QString::number(g);
5020 colorStr += gDigitsSep; colorStr += QString::number(b);
5022 aSmeshActor->GetBackSufaceColor(r, g, b);
5023 colorStr += gDigitsSep; colorStr += "backsurface";
5024 colorStr += gDigitsSep; colorStr += QString::number(r);
5025 colorStr += gDigitsSep; colorStr += QString::number(g);
5026 colorStr += gDigitsSep; colorStr += QString::number(b);
5028 aSmeshActor->GetEdgeColor(r, g, b);
5029 colorStr += gDigitsSep; colorStr += "edge";
5030 colorStr += gDigitsSep; colorStr += QString::number(r);
5031 colorStr += gDigitsSep; colorStr += QString::number(g);
5032 colorStr += gDigitsSep; colorStr += QString::number(b);
5034 aSmeshActor->GetNodeColor(r, g, b);
5035 colorStr += gDigitsSep; colorStr += "node";
5036 colorStr += gDigitsSep; colorStr += QString::number(r);
5037 colorStr += gDigitsSep; colorStr += QString::number(g);
5038 colorStr += gDigitsSep; colorStr += QString::number(b);
5040 param = vtkParam + "Colors";
5041 ip->setParameter(entry, param, colorStr.toLatin1().data());
5043 // Sizes of lines and points
5044 QString sizeStr ("line");
5045 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5046 sizeStr += gDigitsSep; sizeStr += "shrink";
5047 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5049 param = vtkParam + "Sizes";
5050 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5055 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5056 if( aMarkerType == VTK::MT_USER ) {
5057 markerStr += "custom";
5058 markerStr += gDigitsSep;
5059 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5063 markerStr += gDigitsSep;
5064 markerStr += QString::number( (int)aMarkerType );
5065 markerStr += gDigitsSep;
5066 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5069 param = vtkParam + "PointMarker";
5070 ip->setParameter(entry, param, markerStr.toLatin1().data());
5073 param = vtkParam + "Opacity";
5074 ip->setParameter(entry, param,
5075 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5078 param = vtkParam + "ClippingPlane";
5080 if( !aClippingPlaneInfoList.empty() ) {
5081 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5082 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5084 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5085 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5086 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5087 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5088 if( aSmeshActor == *anIter2 ) {
5089 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5090 QString::number( anId ).toLatin1().constData() );
5097 ip->setParameter( entry, param, "Off" );
5098 } // if (io->hasEntry())
5099 } // SMESH_Actor && hasIO
5101 } // while.. actors traversal
5105 } // if (SVTK view model)
5106 } // for (viewManagers)
5109 // data structures for clipping planes processing
5112 vtkIdType Orientation;
5113 vtkFloatingPointType Distance;
5114 vtkFloatingPointType Angle[2];
5116 typedef std::list<TPlaneData> TPlaneDataList;
5117 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5119 typedef std::list<vtkActor*> TActorList;
5122 TActorList ActorList;
5123 SUIT_ViewManager* ViewManager;
5125 typedef std::list<TPlaneInfo> TPlaneInfoList;
5126 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5129 * \brief Restore visual parameters
5131 * This method is called after the study document is opened.
5132 * Restore visual parameters from AttributeParameter attribue(s)
5134 void SMESHGUI::restoreVisualParameters (int savePoint)
5136 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5137 if (!appStudy || !appStudy->studyDS())
5139 _PTR(Study) studyDS = appStudy->studyDS();
5141 // componentName is used for encoding of entries when storing them in IParameters
5142 std::string componentName = myComponentSMESH->ComponentDataType();
5143 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5144 //if (!aSComponent) return;
5147 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5148 componentName.c_str(),
5150 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5152 // restore map of custom markers and map of clipping planes
5153 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5154 TPlaneDataMap aPlaneDataMap;
5156 std::vector<std::string> properties = ip->getProperties();
5157 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5159 std::string property = *propIt;
5160 QString aPropertyName( property.c_str() );
5161 QString aPropertyValue( ip->getProperty( property ).c_str() );
5163 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5164 if( aPropertyNameList.isEmpty() )
5167 QString aPropertyType = aPropertyNameList[0];
5168 if( aPropertyType == "texture" )
5170 if( aPropertyNameList.size() != 2 )
5174 int anId = aPropertyNameList[1].toInt( &ok );
5175 if( !ok || anId < 1 )
5178 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5179 if( aPropertyValueList.size() != 2 )
5182 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5183 QString aMarkerTextureString = aPropertyValueList[1];
5184 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5185 if( aMarkerTextureStringList.size() != 3 )
5189 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5194 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5198 VTK::MarkerTexture aMarkerTexture;
5199 aMarkerTexture.push_back( aWidth );
5200 aMarkerTexture.push_back( aHeight );
5202 QString aMarkerTextureData = aMarkerTextureStringList[2];
5203 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5205 QChar aChar = aMarkerTextureData.at( i );
5206 if( aChar.isDigit() )
5207 aMarkerTexture.push_back( aChar.digitValue() );
5210 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5212 else if( aPropertyType == "ClippingPlane" )
5214 if( aPropertyNameList.size() != 3 )
5218 int aViewId = aPropertyNameList[1].toInt( &ok );
5219 if( !ok || aViewId < 0 )
5223 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5224 if( !ok || aClippingPlaneId < 0 )
5227 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5228 if( aPropertyValueList.size() != 4 )
5231 TPlaneData aPlaneData;
5232 aPlaneData.Id = aClippingPlaneId;
5235 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5240 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5245 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5250 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5254 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5255 aPlaneDataList.push_back( aPlaneData );
5259 TPlaneInfoMap aPlaneInfoMap;
5261 std::vector<std::string> entries = ip->getEntries();
5263 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5265 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5266 QString entry (ip->decodeEntry(*entIt).c_str());
5268 // Check that the entry corresponds to a real object in the Study
5269 // as the object may be deleted or modified after the visual state is saved.
5270 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5271 if (!so) continue; //Skip the not existent entry
5273 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5274 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5276 std::vector<std::string>::iterator namesIt = paramNames.begin();
5277 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5279 // actors are stored in a map after displaying of them for
5280 // quicker access in the future: map < viewID to actor >
5281 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5283 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5285 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5286 // '_' is used as separator and should not be used in viewer type or parameter names.
5287 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5288 if (lst.size() != 3)
5291 QString viewerTypStr = lst[0];
5292 QString viewIndexStr = lst[1];
5293 QString paramNameStr = lst[2];
5296 int viewIndex = viewIndexStr.toUInt(&ok);
5297 if (!ok) // bad conversion of view index to integer
5301 if (viewerTypStr == SVTK_Viewer::Type())
5303 SMESH_Actor* aSmeshActor = 0;
5304 if (vtkActors.IsBound(viewIndex))
5305 aSmeshActor = vtkActors.Find(viewIndex);
5307 QList<SUIT_ViewManager*> lst;
5308 getApp()->viewManagers(viewerTypStr, lst);
5310 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5311 SUIT_ViewManager* vman = NULL;
5312 if (viewIndex >= 0 && viewIndex < lst.count())
5313 vman = lst.at(viewIndex);
5315 if (paramNameStr == "Visibility")
5317 if (!aSmeshActor && displayer() && vman)
5319 SUIT_ViewModel* vmodel = vman->getViewModel();
5320 // SVTK view model can be casted to SALOME_View
5321 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5323 // store displayed actor in a temporary map for quicker
5324 // access later when restoring other parameters
5325 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5326 vtkRenderer* Renderer = vtkView->getRenderer();
5327 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5328 vtkActorCollection* theActors = aCopy.GetActors();
5329 theActors->InitTraversal();
5330 bool isFound = false;
5331 vtkActor *ac = theActors->GetNextActor();
5332 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5333 if (ac->IsA("SMESH_Actor")) {
5334 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5335 if (aGeomAc->hasIO()) {
5336 Handle(SALOME_InteractiveObject) io =
5337 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5338 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5340 vtkActors.Bind(viewIndex, aGeomAc);
5346 } // if (paramNameStr == "Visibility")
5349 // the rest properties "work" with SMESH_Actor
5352 QString val ((*valuesIt).c_str());
5355 if (paramNameStr == "Representation") {
5356 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5359 else if (paramNameStr == "IsShrunk") {
5361 if (!aSmeshActor->IsShrunk())
5362 aSmeshActor->SetShrink();
5365 if (aSmeshActor->IsShrunk())
5366 aSmeshActor->UnShrink();
5369 // Displayed entities
5370 else if (paramNameStr == "Entities") {
5371 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5372 if (mode.count() == 6) {
5373 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5374 MESSAGE("Invalid order of data in Entities, must be: "
5375 "e:0/1:f:0/1:v:0/1");
5378 unsigned int aMode = aSmeshActor->GetEntityMode();
5379 unsigned int aNewMode =
5380 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5381 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5382 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5383 if (aNewMode != aMode)
5384 aSmeshActor->SetEntityMode(aNewMode);
5389 else if (paramNameStr == "Colors") {
5390 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5391 if (colors.count() == 16) {
5392 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5393 colors[8] != "edge" || colors[12] != "node") {
5394 MESSAGE("Invalid order of data in Colors, must be: "
5395 "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
5398 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
5399 aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
5400 aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
5401 aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
5405 // Sizes of lines and points
5406 else if (paramNameStr == "Sizes") {
5407 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5408 if (sizes.count() == 4) {
5409 if (sizes[0] != "line" || sizes[2] != "shrink") {
5410 MESSAGE("Invalid order of data in Sizes, must be: "
5411 "line:int:shrink:float");
5414 aSmeshActor->SetLineWidth(sizes[1].toInt());
5415 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5418 else if (sizes.count() == 6) { // just to support old format
5419 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5420 MESSAGE("Invalid order of data in Sizes, must be: "
5421 "line:int:node:int:shrink:float");
5424 aSmeshActor->SetLineWidth(sizes[1].toInt());
5425 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5426 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5431 else if (paramNameStr == "PointMarker") {
5432 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5433 if( data.count() >= 2 ) {
5435 int aParam1 = data[1].toInt( &ok );
5437 if( data[0] == "std" && data.count() == 3 ) {
5438 int aParam2 = data[2].toInt( &ok );
5439 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5441 else if( data[0] == "custom" ) {
5442 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5443 if( markerIt != aMarkerMap.end() ) {
5444 VTK::MarkerData aMarkerData = markerIt->second;
5445 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5452 else if (paramNameStr == "Opacity") {
5453 aSmeshActor->SetOpacity(val.toFloat());
5456 else if (paramNameStr.startsWith("ClippingPlane")) {
5457 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5458 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5459 // new format - val looks like "Off" or "0" (plane id)
5460 // (note: in new format "Off" value is used only for consistency,
5461 // so it is processed together with values in old format)
5462 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5463 if( anIsOldFormat ) {
5464 if (paramNameStr == "ClippingPlane1" || val == "Off")
5465 aSmeshActor->RemoveAllClippingPlanes();
5467 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5468 double aDistance = vals[1].toFloat();
5469 vtkFloatingPointType anAngle[2];
5470 anAngle[0] = vals[2].toFloat();
5471 anAngle[1] = vals[3].toFloat();
5473 QList<SUIT_ViewManager*> lst;
5474 getApp()->viewManagers(viewerTypStr, lst);
5475 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5476 if (viewIndex >= 0 && viewIndex < lst.count()) {
5477 SUIT_ViewManager* vman = lst.at(viewIndex);
5478 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5480 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5482 SMESH::TActorList anActorList;
5483 anActorList.push_back( aSmeshActor );
5484 SMESH::OrientedPlane* aPlane =
5485 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5487 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5488 aClippingPlaneInfo.Plane = aPlane;
5489 aClippingPlaneInfo.ActorList = anActorList;
5490 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5497 int aPlaneId = val.toInt( &ok );
5498 if( ok && aPlaneId >= 0 ) {
5499 bool anIsDefinedPlane = false;
5500 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5501 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5502 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5503 TPlaneInfo& aPlaneInfo = *anIter;
5504 if( aPlaneInfo.PlaneId == aPlaneId ) {
5505 aPlaneInfo.ActorList.push_back( aSmeshActor );
5506 anIsDefinedPlane = true;
5510 if( !anIsDefinedPlane ) {
5511 TPlaneInfo aPlaneInfo;
5512 aPlaneInfo.PlaneId = aPlaneId;
5513 aPlaneInfo.ActorList.push_back( aSmeshActor );
5514 aPlaneInfo.ViewManager = vman;
5516 // to make the list sorted by plane id
5517 anIter = aPlaneInfoList.begin();
5518 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5519 const TPlaneInfo& aPlaneInfoRef = *anIter;
5520 if( aPlaneInfoRef.PlaneId > aPlaneId )
5523 aPlaneInfoList.insert( anIter, aPlaneInfo );
5528 } // if (aSmeshActor)
5529 } // other parameters than Visibility
5531 } // for names/parameters iterator
5532 } // for entries iterator
5534 // take into account planes with empty list of actors referred to them
5535 QList<SUIT_ViewManager*> aVMList;
5536 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5538 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5539 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5540 int aViewId = aPlaneDataIter->first;
5541 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5542 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5544 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5546 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5547 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5548 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5549 const TPlaneData& aPlaneData = *anIter2;
5550 int aPlaneId = aPlaneData.Id;
5552 bool anIsFound = false;
5553 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5554 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5555 const TPlaneInfo& aPlaneInfo = *anIter3;
5556 if( aPlaneInfo.PlaneId == aPlaneId ) {
5563 TPlaneInfo aPlaneInfo; // ActorList field is empty
5564 aPlaneInfo.PlaneId = aPlaneId;
5565 aPlaneInfo.ViewManager = aViewManager;
5567 // to make the list sorted by plane id
5568 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5569 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5570 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5571 if( aPlaneInfoRef.PlaneId > aPlaneId )
5574 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5580 // add clipping planes to actors according to the restored parameters
5581 // and update the clipping plane map
5582 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5583 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5584 int aViewId = anIter1->first;
5585 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5587 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5588 if( anIter2 == aPlaneDataMap.end() )
5590 const TPlaneDataList& aPlaneDataList = anIter2->second;
5592 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5593 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5594 const TPlaneInfo& aPlaneInfo = *anIter3;
5595 int aPlaneId = aPlaneInfo.PlaneId;
5596 const TActorList& anActorList = aPlaneInfo.ActorList;
5597 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5601 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5605 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5607 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5608 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5609 const TPlaneData& aPlaneData = *anIter4;
5610 if( aPlaneData.Id == aPlaneId ) {
5611 SMESH::OrientedPlane* aPlane =
5612 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5614 (SMESH::Orientation)aPlaneData.Orientation,
5615 aPlaneData.Distance,
5618 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5619 aClippingPlaneInfo.Plane = aPlane;
5620 aClippingPlaneInfo.ActorList = anActorList;
5621 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5629 // update all VTK views
5630 QList<SUIT_ViewManager*> lst;
5631 getApp()->viewManagers(lst);
5632 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5633 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5634 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5635 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5636 vtkView->getRenderer()->ResetCameraClippingRange();
5643 \brief Adds preferences for dfont of VTK viewer
5645 \param pIf group identifier
5646 \param param parameter
5647 \return identifier of preferences
5649 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5651 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5653 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5656 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5657 fam.append( tr( "SMESH_FONT_COURIER" ) );
5658 fam.append( tr( "SMESH_FONT_TIMES" ) );
5660 setPreferenceProperty( tfont, "fonts", fam );
5662 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5663 setPreferenceProperty( tfont, "features", f );
5669 \brief Actions after hypothesis edition
5670 Updates object browser after hypothesis edition
5672 void SMESHGUI::onHypothesisEdit( int result )
5675 SMESHGUI::Modified();
5676 updateObjBrowser( true );
5681 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5682 \param pview view being closed
5684 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5685 #ifndef DISABLE_PLOT2DVIEWER
5686 //Crear all Plot2d Viewers if need.
5687 SMESH::ClearPlot2Viewers(pview);
5692 \brief Connects or disconnects signals about activating and cloning view on the module slots
5693 \param pview view which is connected/disconnected
5695 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5699 SUIT_ViewManager* viewMgr = pview->getViewManager();
5701 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5702 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5704 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5705 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5710 \brief Return \c true if object can be renamed
5712 bool SMESHGUI::renameAllowed( const QString& entry) const {
5713 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5717 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5721 bool appRes = SalomeApp_Module::renameAllowed(entry);
5725 // check type to prevent renaming of inappropriate objects
5726 int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5727 if (aType == MESH || aType == GROUP ||
5728 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5729 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5730 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5731 aType == HYPOTHESIS || aType == ALGORITHM)
5738 Rename object by entry.
5739 \param entry entry of the object
5740 \param name new name of the object
5741 \brief Return \c true if rename operation finished successfully, \c false otherwise.
5743 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5745 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5749 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5753 bool appRes = SalomeApp_Module::renameObject(entry,name);
5757 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5758 _PTR(GenericAttribute) anAttr;
5759 _PTR(AttributeName) aName;
5761 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
5763 // check type to prevent renaming of inappropriate objects
5764 int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
5765 if (aType == MESH || aType == GROUP ||
5766 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5767 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5768 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5769 aType == HYPOTHESIS || aType == ALGORITHM) {
5770 if ( !name.isEmpty() ) {
5771 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
5773 // update name of group object and its actor
5774 Handle(SALOME_InteractiveObject) IObject =
5775 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
5777 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
5778 if( !aGroupObject->_is_nil() ) {
5779 aGroupObject->SetName( qPrintable(name) );
5780 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
5781 anActor->setName( qPrintable(name) );