1 // Copyright (C) 2007-2010 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 // SMESH SMESHGUI : GUI for SMESH component
23 // File : SMESHGUI.cxx
24 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
26 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
30 #include "SMESHGUI_AddMeshElementDlg.h"
31 #include "SMESHGUI_AddQuadraticElementDlg.h"
32 #include "SMESHGUI_BuildCompoundDlg.h"
33 #include "SMESHGUI_ClippingDlg.h"
34 #include "SMESHGUI_ComputeDlg.h"
35 #include "SMESHGUI_ConvToQuadOp.h"
36 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
37 #include "SMESHGUI_DeleteGroupDlg.h"
38 #include "SMESHGUI_Displayer.h"
39 #include "SMESHGUI_MergeDlg.h"
40 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
41 #include "SMESHGUI_ExtrusionDlg.h"
42 #include "SMESHGUI_FileInfoDlg.h"
43 #include "SMESHGUI_FileValidator.h"
44 #include "SMESHGUI_FilterDlg.h"
45 #include "SMESHGUI_FilterLibraryDlg.h"
46 #include "SMESHGUI_FindElemByPointDlg.h"
47 #include "SMESHGUI_GroupDlg.h"
48 #include "SMESHGUI_GroupOnShapeDlg.h"
49 #include "SMESHGUI_GroupOpDlg.h"
50 #include "SMESHGUI_Hypotheses.h"
51 #include "SMESHGUI_Make2DFrom3DOp.h"
52 #include "SMESHGUI_MakeNodeAtPointDlg.h"
53 //#include "SMESHGUI_MeshInfosDlg.h"
54 #include "SMESHGUI_Measurements.h"
55 #include "SMESHGUI_MeshInfo.h"
56 #include "SMESHGUI_MeshOp.h"
57 #include "SMESHGUI_MeshOrderOp.h"
58 #include "SMESHGUI_MeshPatternDlg.h"
59 #include "SMESHGUI_MultiEditDlg.h"
60 #include "SMESHGUI_NodesDlg.h"
61 #include "SMESHGUI_Preferences_ColorDlg.h"
62 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
63 #include "SMESHGUI_RemoveElementsDlg.h"
64 #include "SMESHGUI_RemoveNodesDlg.h"
65 #include "SMESHGUI_RenumberingDlg.h"
66 #include "SMESHGUI_RevolutionDlg.h"
67 #include "SMESHGUI_RotationDlg.h"
68 #include "SMESHGUI_Selection.h"
69 #include "SMESHGUI_SewingDlg.h"
70 #include "SMESHGUI_SingleEditDlg.h"
71 #include "SMESHGUI_SmoothingDlg.h"
72 //#include "SMESHGUI_StandardMeshInfosDlg.h"
73 #include "SMESHGUI_SymmetryDlg.h"
74 #include "SMESHGUI_TranslationDlg.h"
75 #include "SMESHGUI_ScaleDlg.h"
76 #include "SMESHGUI_TransparencyDlg.h"
77 //#include "SMESHGUI_WhatIsDlg.h"
78 #include "SMESHGUI_DuplicateNodesDlg.h"
79 #include "SMESHGUI_CopyMeshDlg.h"
81 #include "SMESHGUI_Utils.h"
82 #include "SMESHGUI_MeshUtils.h"
83 #include "SMESHGUI_GroupUtils.h"
84 #include "SMESHGUI_FilterUtils.h"
85 #include "SMESHGUI_PatternUtils.h"
86 #include "SMESHGUI_VTKUtils.h"
87 #include "SMESHGUI_HypothesesUtils.h"
89 #include <SMESH_Client.hxx>
90 #include <SMESH_Actor.h>
91 #include <SMESH_ScalarBarActor.h>
92 #include <SMESH_ActorUtils.h>
93 #include <SMESH_TypeFilter.hxx>
94 #include "SMESH_ControlsDef.hxx"
96 // SALOME GUI includes
97 #include <SalomeApp_Tools.h>
98 #include <SalomeApp_Study.h>
99 #include <SalomeApp_Application.h>
100 #include <SalomeApp_CheckFileDlg.h>
102 #include <LightApp_DataOwner.h>
103 #include <LightApp_Preferences.h>
104 #include <LightApp_SelectionMgr.h>
105 #include <LightApp_UpdateFlags.h>
106 #include <LightApp_NameDlg.h>
108 #include <SVTK_ViewWindow.h>
109 #include <SVTK_ViewModel.h>
110 #include <SVTK_ViewManager.h>
112 #include <VTKViewer_Algorithm.h>
114 #include <SUIT_MessageBox.h>
115 #include <SUIT_ResourceMgr.h>
116 #include <SUIT_FileDlg.h>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_OverrideCursor.h>
119 #include <SUIT_Session.h>
121 #include <QtxPopupMgr.h>
122 #include <QtxFontEdit.h>
124 #include <SALOME_ListIO.hxx>
125 #include <SALOME_ListIteratorOfListIO.hxx>
127 #ifndef DISABLE_PLOT2DVIEWER
128 #include <SPlot2d_ViewModel.h>
129 #include <SPlot2d_Histogram.h>
133 #include <SALOMEconfig.h>
134 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
135 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
136 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
139 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
141 #include <QTextStream>
144 #include <boost/shared_ptr.hpp>
147 #include <vtkCamera.h>
148 #include <vtkRenderer.h>
149 #include <vtkPlane.h>
150 #include <vtkCallbackCommand.h>
151 #include <vtkLookupTable.h>
153 // SALOME KERNEL includes
154 #include <SALOMEDS_Study.hxx>
155 #include <SALOMEDSClient_StudyBuilder.hxx>
156 #include <SALOMEDSClient_SComponent.hxx>
157 #include <SALOMEDSClient_ClientFactory.hxx>
158 #include <SALOMEDSClient_IParameters.hxx>
161 #include <Standard_ErrorHandler.hxx>
162 #include <NCollection_DataMap.hxx>
164 //To disable automatic genericobj management, the following line should be commented.
165 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
166 #define WITHGENERICOBJ
170 //=============================================================
171 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
174 void ExportMeshToFile(int theCommandID);
176 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
178 void SetDisplayEntity(int theCommandID);
180 void Control( int theCommandID );
184 //=============================================================
185 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
189 std::string myExtension;
191 if ( theCommandID == 113 ) {
192 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
193 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
195 else if ( theCommandID == 112 ) {
196 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
198 else if ( theCommandID == 111 ) {
199 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
201 else if ( theCommandID == 140 ) {
202 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
205 QString anInitialPath = "";
206 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
207 anInitialPath = QDir::currentPath();
209 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
212 QObject::tr( "SMESH_IMPORT_MESH" ) );
213 if ( filenames.count() > 0 ) {
214 SUIT_OverrideCursor wc;
215 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
218 QStringList anEntryList;
219 bool isEmpty = false;
220 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
221 QString filename = *it;
222 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
224 switch ( theCommandID ) {
227 // DAT format (currently unsupported)
228 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
229 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
235 aMeshes->length( 1 );
236 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
237 if ( aMeshes[0]->_is_nil() )
238 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
239 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
245 SMESH::DriverMED_ReadStatus res;
246 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
247 if ( res != SMESH::DRS_OK ) {
248 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
249 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
256 aMeshes->length( 1 );
257 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
258 if ( aMeshes[0]->_is_nil() ) {
259 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
260 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
266 catch ( const SALOME::SALOME_Exception& S_ex ) {
267 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
268 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
271 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
272 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
274 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
275 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
276 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
277 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
278 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
280 anEntryList.append( aMeshSO->GetID().c_str() );
282 #ifdef WITHGENERICOBJ
283 // obj has been published in study. Its refcount has been incremented.
284 // It is safe to decrement its refcount
285 // so that it will be destroyed when the entry in study will be removed
286 aMeshes[i]->UnRegister();
295 // update Object browser
296 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
298 // browse to the published meshes
299 if( LightApp_Application* anApp =
300 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
301 anApp->browseObjects( anEntryList );
303 // show Error message box if there were errors
304 if ( errors.count() > 0 ) {
305 SUIT_MessageBox::critical( SMESHGUI::desktop(),
306 QObject::tr( "SMESH_ERROR" ),
307 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
310 // show warning message box, if some imported mesh is empty
312 SUIT_MessageBox::warning( SMESHGUI::desktop(),
313 QObject::tr( "SMESH_WRN_WARNING" ),
314 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
319 void ExportMeshToFile( int theCommandID )
321 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
322 SALOME_ListIO selected;
324 aSel->selectedObjects( selected );
326 // actually, the following condition can't be met (added for insurance)
327 if( selected.Extent() == 0 ||
328 ( selected.Extent() > 1 && theCommandID != 122 && theCommandID != 125 ) )
331 bool hasDuplicatedMeshNames = false;
332 QList< QPair< SMESH::SMESH_Mesh_var, QString > > aMeshList;
333 QList< QPair< SMESH::SMESH_Mesh_var, QString > >::iterator aMeshIter;
334 SALOME_ListIteratorOfListIO It( selected );
335 for( ; It.More(); It.Next() ) {
336 Handle(SALOME_InteractiveObject) anIObject = It.Value();
337 SMESH::SMESH_Mesh_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>( anIObject );
338 if ( aMeshItem->_is_nil() ) {
339 SUIT_MessageBox::warning( SMESHGUI::desktop(),
340 QObject::tr( "SMESH_WRN_WARNING" ),
341 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
345 QString aMeshName = anIObject->getName();
347 // check for duplications
348 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
349 if( aMeshName == (*aMeshIter).second ) {
350 hasDuplicatedMeshNames = true;
355 aMeshList.append( QPair< SMESH::SMESH_Mesh_var, QString >( aMeshItem, aMeshName ) );
358 if( hasDuplicatedMeshNames ) {
359 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
360 QObject::tr("SMESH_WRN_WARNING"),
361 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
362 QObject::tr("SMESH_BUT_YES"),
363 QObject::tr("SMESH_BUT_NO"), 0, 1);
368 aMeshIter = aMeshList.begin();
369 SMESH::SMESH_Mesh_var aMesh = (*aMeshIter).first;
370 QString aMeshName = (*aMeshIter).second;
372 QList<SALOMEDS::Color> aReservedColors;
374 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
375 QMap<QString, SMESH::MED_VERSION> aFilterMap;
376 QMap<QString, int> aFilterMapSTL;
377 switch ( theCommandID ) {
381 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
382 SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
383 if (aMeshItem->HasDuplicatedGroupNamesMED()) {
384 int aRet = SUIT_MessageBox::warning
385 (SMESHGUI::desktop(),
386 QObject::tr("SMESH_WRN_WARNING"),
387 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
388 QObject::tr("SMESH_BUT_YES"),
389 QObject::tr("SMESH_BUT_NO"), 0, 1);
395 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
396 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
397 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
398 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
403 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
408 if (aMesh->NbPyramids()) {
409 int aRet = SUIT_MessageBox::warning
410 (SMESHGUI::desktop(),
411 QObject::tr("SMESH_WRN_WARNING"),
412 QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
413 QObject::tr("SMESH_BUT_YES"),
414 QObject::tr("SMESH_BUT_NO"), 0, 1);
418 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
425 there must be check on others mesh elements not equal triangles
427 // if (aMesh->NbTriangles() < 1) {
428 // SUIT_MessageBox::warning
429 // (SMESHGUI::desktop(),
430 // QObject::tr("SMESH_WRN_WARNING"),
431 // QObject::tr("SMESH_EXPORT_STL1").arg(aMeshName));
434 // if (!(aMesh->NbElements() - aMesh->NbTriangles())) {
435 // int aRet = SUIT_MessageBox::warning
436 // (SMESHGUI::desktop(),
437 // QObject::tr("SMESH_WRN_WARNING"),
438 // QObject::tr("SMESH_EXPORT_STL2").arg(aMeshName),
439 // QObject::tr("SMESH_BUT_YES"),
440 // QObject::tr("SMESH_BUT_NO"), 0, 1);
445 aFilterMapSTL.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 ); // 1 - ASCII mode
446 aFilterMapSTL.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 ); // 0 - Binary mode
454 SMESH::MED_VERSION aFormat;
455 // Init the parameter with the default value
456 bool aIsASCII_STL = true;
457 bool toCreateGroups = false;
458 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
460 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
461 bool toOverwrite = true;
463 QString anInitialPath = "";
464 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
465 anInitialPath = QDir::currentPath();
467 if ( theCommandID != 122 && theCommandID != 125 && theCommandID != 141) {
468 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
469 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(), anInitialPath + QString("/") + aMeshName,
470 aFilter, aTitle, false);
472 else if(theCommandID == 141) { // Export to STL
474 QMap<QString, int>::const_iterator it = aFilterMapSTL.begin();
475 for ( ; it != aFilterMapSTL.end(); ++it )
476 filters.push_back( it.key() );
478 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
479 fd->setWindowTitle( aTitle );
480 fd->setNameFilters( filters );
481 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
482 if ( !anInitialPath.isEmpty() )
483 fd->setDirectory( anInitialPath );
484 fd->selectFile(aMeshName);
488 aFilename = fd->selectedFile();
489 aIsASCII_STL = (aFilterMapSTL[fd->selectedNameFilter()]) == 1 ? true: false;
494 else { // Export to MED
496 QString aDefaultFilter;
497 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
498 for ( ; it != aFilterMap.end(); ++it ) {
499 filters.push_back( it.key() );
500 if (it.value() == SMESH::MED_V2_2)
501 aDefaultFilter = it.key();
504 //SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
505 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
506 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
507 fd->setWindowTitle( aTitle );
508 fd->setNameFilters( filters );
509 //fd->setSelectedNameFilter( QObject::tr("MED 2.2 (*.med)") );
510 fd->selectNameFilter(aDefaultFilter);
511 fd->SetChecked(toCreateGroups);
512 if ( !anInitialPath.isEmpty() )
513 fd->setDirectory( anInitialPath );
514 fd->selectFile(aMeshName);
516 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
517 fd->setValidator( fv );
522 aFilename = fd->selectedFile();
524 aFilename = QString::null;
527 aFormat = aFilterMap[fd->selectedNameFilter()];
528 toOverwrite = fv->isOverwrite();
530 if ( !aFilename.isEmpty() ) {
531 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
532 SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
533 if( (aMeshItem->NbPolygons()>0 || aMeshItem->NbPolyhedrons()>0)
534 && aFormat==SMESH::MED_V2_1) {
535 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
536 QObject::tr("SMESH_WRN_WARNING"),
537 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
538 QObject::tr("SMESH_BUT_YES"),
539 QObject::tr("SMESH_BUT_NO"), 0, 1);
547 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
548 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
549 if( !isVersionOk || aVersion != aFormat ) {
550 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
551 QObject::tr("SMESH_WRN_WARNING"),
552 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
553 QObject::tr("SMESH_BUT_YES"),
554 QObject::tr("SMESH_BUT_NO"), 0, 1);
561 QStringList aMeshNamesCollisionList;
562 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
563 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
564 QString anExistingMeshName( aMeshNames[ i ] );
565 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
566 QString anExportMeshName = (*aMeshIter).second;
567 if( anExportMeshName == anExistingMeshName ) {
568 aMeshNamesCollisionList.append( anExportMeshName );
574 if( !aMeshNamesCollisionList.isEmpty() ) {
575 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
576 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
577 QObject::tr("SMESH_WRN_WARNING"),
578 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
579 QObject::tr("SMESH_BUT_YES"),
580 QObject::tr("SMESH_BUT_NO"),
581 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
590 toCreateGroups = fd->IsChecked();
593 if ( !aFilename.isEmpty() ) {
594 // Check whether the file already exists and delete it if yes
595 QFile aFile( aFilename );
596 if ( aFile.exists() && toOverwrite )
598 SUIT_OverrideCursor wc;
601 bool Renumber = false;
602 // PAL 14172 : Check of we have to renumber or not from the preferences before export
604 Renumber= resMgr->booleanValue("SMESH","renumbering");
606 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
607 aMeshEditor->RenumberNodes();
608 aMeshEditor->RenumberElements();
609 if ( SMESHGUI::automaticUpdate() )
612 switch ( theCommandID ) {
616 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ ) {
617 SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
618 if( !aMeshItem->_is_nil() )
619 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups, aFormat, toOverwrite && aMeshIndex == 0 );
625 aMesh->ExportDAT( aFilename.toLatin1().data() );
629 aMesh->ExportUNV( aFilename.toLatin1().data() );
632 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
638 catch (const SALOME::SALOME_Exception& S_ex){
640 SUIT_MessageBox::warning(SMESHGUI::desktop(),
641 QObject::tr("SMESH_WRN_WARNING"),
642 QObject::tr("SMESH_EXPORT_FAILED"));
648 inline void InverseEntityMode(unsigned int& theOutputMode,
649 unsigned int theMode)
651 bool anIsNotPresent = ~theOutputMode & theMode;
653 theOutputMode |= theMode;
655 theOutputMode &= ~theMode;
658 void SetDisplayEntity(int theCommandID){
659 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
660 SALOME_ListIO selected;
662 aSel->selectedObjects( selected );
664 if(selected.Extent() >= 1){
665 SALOME_ListIteratorOfListIO It( selected );
666 for( ; It.More(); It.Next()){
667 Handle(SALOME_InteractiveObject) IObject = It.Value();
668 if(IObject->hasEntry()){
669 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
670 unsigned int aMode = anActor->GetEntityMode();
671 switch(theCommandID){
673 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
676 InverseEntityMode(aMode,SMESH_Actor::eEdges);
679 InverseEntityMode(aMode,SMESH_Actor::eFaces);
682 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
685 aMode = SMESH_Actor::eAllEntity;
689 anActor->SetEntityMode(aMode);
697 SALOME_ListIO selected;
698 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
702 LightApp_SelectionMgr* aSel = app->selectionMgr();
703 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
704 if( !aSel || !appStudy )
707 aSel->selectedObjects( selected );
708 if( selected.IsEmpty() )
711 Handle(SALOME_InteractiveObject) anIObject = selected.First();
713 _PTR(Study) aStudy = appStudy->studyDS();
714 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
715 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
716 if( aMainObject->_is_nil() )
719 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
721 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
722 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
724 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
725 SALOMEDS::Color aColor = aGroupObject->GetColor();
726 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
728 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
729 if( aGroupObject->GetType() == SMESH::NODE )
730 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B );
731 else if( aGroupObject->GetType() == SMESH::EDGE )
732 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
733 else if( aGroupObject->GetType() == SMESH::ELEM0D )
734 anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
736 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B );
741 SMESH::RepaintCurrentView();
744 QString functorToString( SMESH::Controls::FunctorPtr f )
746 QString type = QObject::tr( "UNKNOWN_CONTROL" );
747 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
748 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
749 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
750 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
751 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
752 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
753 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
754 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
755 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
756 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
757 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
758 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
759 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
760 type = QObject::tr( "WARP_ELEMENTS" );
761 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
762 type = QObject::tr( "TAPER_ELEMENTS" );
763 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
764 type = QObject::tr( "SKEW_ELEMENTS" );
765 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
766 type = QObject::tr( "AREA_ELEMENTS" );
767 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
768 type = QObject::tr( "LENGTH_EDGES" );
769 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
770 type = QObject::tr( "LENGTH2D_EDGES" );
771 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
772 type = QObject::tr( "MULTI_BORDERS" );
773 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
774 type = QObject::tr( "MULTI2D_BORDERS" );
775 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
776 type = QObject::tr( "FREE_NODES" );
777 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
778 type = QObject::tr( "FREE_EDGES" );
779 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
780 type = QObject::tr( "FREE_BORDERS" );
781 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
782 type = QObject::tr( "FREE_FACES" );
783 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
784 type = QObject::tr( "BARE_BORDER_VOLUME" );
785 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
786 type = QObject::tr( "BARE_BORDER_FACE" );
787 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
788 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
789 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
790 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
794 void SaveDistribution()
796 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
797 SALOME_ListIO selected;
799 aSel->selectedObjects( selected );
801 if ( selected.Extent() == 1 ) {
802 Handle(SALOME_InteractiveObject) anIO = selected.First();
803 if ( anIO->hasEntry() ) {
804 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
805 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
806 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
807 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
808 if ( aScalarBarActor && aFunctor ) {
809 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
811 std::vector<int> elements;
812 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
813 if ( mesh->_is_nil() ) {
814 SMESH::SMESH_IDSource_var idSource =
815 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
816 if ( !idSource->_is_nil() )
818 SMESH::long_array_var ids = idSource->GetIDs();
819 elements.resize( ids->length() );
820 for ( unsigned i = 0; i < elements.size(); ++i )
821 elements[i] = ids[i];
824 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
825 vtkLookupTable* lookupTable =
826 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
827 double * minmax = lookupTable->GetRange();
828 std::vector<int> nbEvents;
829 std::vector<double> funValues;
830 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
831 QString anInitialPath = "";
832 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
833 anInitialPath = QDir::currentPath();
834 QString aMeshName = anIO->getName();
836 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
837 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
838 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
839 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
840 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
843 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
845 if ( !aFilename.isEmpty() ) {
846 QFile f( aFilename );
847 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
848 QTextStream out( &f );
849 out << "# Mesh: " << aMeshName << endl;
850 out << "# Control: " << functorToString( aFunctor ) << endl;
852 out.setFieldWidth( 10 );
853 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
854 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
865 void ShowDistribution() {
866 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
867 SALOME_ListIO selected;
869 aSel->selectedObjects( selected );
871 if ( selected.Extent() == 1 ) {
872 Handle(SALOME_InteractiveObject) anIO = selected.First();
873 if ( anIO->hasEntry() ) {
874 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
875 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
876 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
877 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
883 #ifndef DISABLE_PLOT2DVIEWER
884 void PlotDistribution() {
885 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
889 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
890 SALOME_ListIO selected;
892 aSel->selectedObjects( selected );
894 if ( selected.Extent() == 1 ) {
895 Handle(SALOME_InteractiveObject) anIO = selected.First();
896 if ( anIO->hasEntry() ) {
897 //Find Actor by entry before getting Plot2d viewer,
898 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
899 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
901 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
906 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
910 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
914 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
915 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
916 QString functorName = functorToString( anActor->GetFunctor());
917 QString aHistogramName("%1 : %2");
918 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
919 aHistogram->setName(aHistogramName);
920 aHistogram->setHorTitle(functorName);
921 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
922 aPlot->displayObject(aHistogram, true);
927 #endif //DISABLE_PLOT2DVIEWER
929 void DisableAutoColor(){
930 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
931 SALOME_ListIO selected;
933 aSel->selectedObjects( selected );
935 if(selected.Extent()){
936 Handle(SALOME_InteractiveObject) anIObject = selected.First();
937 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
938 if ( !aMesh->_is_nil() ) {
939 aMesh->SetAutoColor( false );
944 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){
945 SALOME_ListIO selected;
946 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
950 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
951 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
952 if( !aSel || !appStudy )
955 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
956 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
957 aModule->EmitSignalDeactivateDialog();
958 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
959 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
964 _PTR(Study) aStudy = appStudy->studyDS();
966 aSel->selectedObjects( selected );
968 if(selected.Extent() >= 1){
969 switch(theCommandID){
971 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
972 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
976 QColor c, e, b, n, c0D, o;
979 vtkFloatingPointType Shrink = 0.0;
980 vtkFloatingPointType faces_orientation_scale = 0.0;
981 bool faces_orientation_3dvectors = false;
983 VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE;
984 VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE;
985 int aMarkerTextureCurrent = 0;
987 SALOME_ListIteratorOfListIO It( selected );
988 for( ; It.More(); It.Next()){
989 Handle(SALOME_InteractiveObject) IObject = It.Value();
990 if(IObject->hasEntry()){
991 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
992 vtkFloatingPointType color[3];
993 anActor->GetSufaceColor(color[0], color[1], color[2]);
994 int c0 = int (color[0] * 255);
995 int c1 = int (color[1] * 255);
996 int c2 = int (color[2] * 255);
997 c.setRgb(c0, c1, c2);
999 vtkFloatingPointType edgecolor[3];
1000 anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1001 c0 = int (edgecolor[0] * 255);
1002 c1 = int (edgecolor[1] * 255);
1003 c2 = int (edgecolor[2] * 255);
1004 e.setRgb(c0, c1, c2);
1006 vtkFloatingPointType backfacecolor[3];
1007 anActor->GetBackSufaceColor(backfacecolor[0], backfacecolor[1], backfacecolor[2]);
1008 c0 = int (backfacecolor[0] * 255);
1009 c1 = int (backfacecolor[1] * 255);
1010 c2 = int (backfacecolor[2] * 255);
1011 b.setRgb(c0, c1, c2);
1013 vtkFloatingPointType nodecolor[3];
1014 anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1015 c0 = int (nodecolor[0] * 255);
1016 c1 = int (nodecolor[1] * 255);
1017 c2 = int (nodecolor[2] * 255);
1018 n.setRgb(c0, c1, c2);
1020 vtkFloatingPointType color0D[3];
1021 anActor->Get0DColor(color0D[0], color0D[1], color0D[2]);
1022 c0 = int (color0D[0] * 255);
1023 c1 = int (color0D[1] * 255);
1024 c2 = int (color0D[2] * 255);
1025 c0D.setRgb(c0, c1, c2);
1027 size0D = (int)anActor->Get0DSize();
1030 Edgewidth = (int)anActor->GetLineWidth();
1033 Shrink = anActor->GetShrinkFactor();
1035 vtkFloatingPointType faces_orientation_color[3];
1036 anActor->GetFacesOrientationColor(faces_orientation_color);
1037 c0 = int (faces_orientation_color[0] * 255);
1038 c1 = int (faces_orientation_color[1] * 255);
1039 c2 = int (faces_orientation_color[2] * 255);
1040 o.setRgb(c0, c1, c2);
1042 faces_orientation_scale = anActor->GetFacesOrientationScale();
1043 faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors();
1045 aMarkerTypeCurrent = anActor->GetMarkerType();
1046 aMarkerScaleCurrent = anActor->GetMarkerScale();
1047 aMarkerTextureCurrent = anActor->GetMarkerTexture();
1049 // even if there are multiple objects in the selection,
1050 // we need only the first one to get values for the dialog
1056 SMESHGUI_Preferences_ColorDlg *aDlg =
1057 new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() );
1058 aDlg->SetColor(1, c);
1059 aDlg->SetColor(2, e);
1060 aDlg->SetColor(3, n);
1061 aDlg->SetColor(4, b);
1062 aDlg->SetColor(5, c0D);
1063 aDlg->SetColor(6, o);
1064 aDlg->SetIntValue(1, Edgewidth);
1065 aDlg->SetIntValue(2, int(Shrink*100.));
1066 aDlg->SetIntValue(3, size0D);
1067 aDlg->SetDoubleValue(1, faces_orientation_scale);
1068 aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
1070 aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
1072 if( aMarkerTypeCurrent != VTK::MT_USER )
1073 aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent );
1075 aDlg->setCustomMarker( aMarkerTextureCurrent );
1078 QColor color = aDlg->GetColor(1);
1079 QColor edgecolor = aDlg->GetColor(2);
1080 QColor nodecolor = aDlg->GetColor(3);
1081 QColor backfacecolor = aDlg->GetColor(4);
1082 QColor color0D = aDlg->GetColor(5);
1083 QColor faces_orientation_color = aDlg->GetColor(6);
1086 theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
1088 SALOME_ListIteratorOfListIO It( selected );
1089 for( ; It.More(); It.Next()){
1090 Handle(SALOME_InteractiveObject) IObject = It.Value();
1091 if(IObject->hasEntry()){
1092 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1093 /* actor color and backface color */
1094 anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
1095 vtkFloatingPointType (color.green()) / 255.,
1096 vtkFloatingPointType (color.blue()) / 255.);
1097 anActor->SetBackSufaceColor(vtkFloatingPointType (backfacecolor.red()) / 255.,
1098 vtkFloatingPointType (backfacecolor.green()) / 255.,
1099 vtkFloatingPointType (backfacecolor.blue()) / 255.);
1102 anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
1103 vtkFloatingPointType (edgecolor.green()) / 255.,
1104 vtkFloatingPointType (edgecolor.blue()) / 255.);
1106 /* Shrink factor and size edges */
1107 anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
1108 anActor->SetLineWidth(aDlg->GetIntValue(1));
1110 /* Nodes color and size */
1111 anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
1112 vtkFloatingPointType (nodecolor.green()) / 255.,
1113 vtkFloatingPointType (nodecolor.blue()) / 255.);
1116 anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255.,
1117 vtkFloatingPointType (color0D.green()) / 255.,
1118 vtkFloatingPointType (color0D.blue()) / 255.);
1119 anActor->Set0DSize(aDlg->GetIntValue(3));
1121 /* Faces orientation */
1122 vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()),
1123 vtkFloatingPointType(faces_orientation_color.greenF()),
1124 vtkFloatingPointType(faces_orientation_color.blueF())};
1125 anActor->SetFacesOrientationColor(c);
1126 anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1));
1127 anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1));
1129 VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType();
1130 VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale();
1131 int aMarkerTextureNew = aDlg->getCustomMarkerID();
1132 if( aMarkerTypeNew != VTK::MT_USER )
1133 anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew );
1135 const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ];
1136 VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew );
1137 if( anIter != aMarkerMap.end() )
1138 anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second );
1141 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1142 if( !aGroupObject->_is_nil() )
1144 SMESH::ElementType anElementType = aGroupObject->GetType();
1146 switch( anElementType )
1148 case SMESH::NODE: aColor = nodecolor; break;
1149 case SMESH::EDGE: aColor = edgecolor; break;
1150 default: aColor = color; break;
1153 SALOMEDS::Color aGroupColor;
1154 aGroupColor.R = (float)aColor.red() / 255.0;
1155 aGroupColor.G = (float)aColor.green() / 255.0;
1156 aGroupColor.B = (float)aColor.blue() / 255.0;
1157 aGroupObject->SetColor( aGroupColor );
1162 SMESH::RepaintCurrentView();
1168 SALOME_ListIteratorOfListIO It( selected );
1169 for( ; It.More(); It.Next()){
1170 Handle(SALOME_InteractiveObject) IObject = It.Value();
1171 if(IObject->hasEntry()){
1172 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1173 switch(theCommandID){
1175 anActor->SetRepresentation(SMESH_Actor::eEdge);
1178 anActor->SetRepresentation(SMESH_Actor::eSurface);
1181 if(anActor->IsShrunk())
1182 anActor->UnShrink();
1184 anActor->SetShrink();
1187 anActor->SetRepresentation(SMESH_Actor::ePoint);
1190 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1191 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1194 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1195 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1201 SMESH::RepaintCurrentView();
1205 void Control( int theCommandID )
1207 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1208 SALOME_ListIO selected;
1210 aSel->selectedObjects( selected );
1212 if( !selected.IsEmpty() ){
1213 Handle(SALOME_InteractiveObject) anIO = selected.First();
1215 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1216 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())){
1217 switch ( theCommandID ){
1219 aControl = SMESH_Actor::eLength;
1222 aControl = SMESH_Actor::eLength2D;
1225 aControl = SMESH_Actor::eFreeEdges;
1228 aControl = SMESH_Actor::eFreeBorders;
1231 aControl = SMESH_Actor::eMultiConnection;
1234 aControl = SMESH_Actor::eFreeNodes;
1237 aControl = SMESH_Actor::eMultiConnection2D;
1240 aControl = SMESH_Actor::eArea;
1243 aControl = SMESH_Actor::eTaper;
1246 aControl = SMESH_Actor::eAspectRatio;
1249 aControl = SMESH_Actor::eAspectRatio3D;
1252 aControl = SMESH_Actor::eMinimumAngle;
1255 aControl = SMESH_Actor::eWarping;
1258 aControl = SMESH_Actor::eSkew;
1261 aControl = SMESH_Actor::eVolume3D;
1264 aControl = SMESH_Actor::eFreeFaces;
1267 aControl = SMESH_Actor::eMaxElementLength2D;
1270 aControl = SMESH_Actor::eMaxElementLength3D;
1273 aControl = SMESH_Actor::eBareBorderVolume;
1276 aControl = SMESH_Actor::eBareBorderFace;
1279 aControl = SMESH_Actor::eOverConstrainedVolume;
1282 aControl = SMESH_Actor::eOverConstrainedFace;
1285 anActor->SetControlMode(aControl);
1286 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1287 SMESH::RepaintCurrentView();
1288 #ifndef DISABLE_PLOT2DVIEWER
1289 if(anActor->GetPlot2Histogram()) {
1290 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1291 QString functorName = functorToString( anActor->GetFunctor());
1292 QString aHistogramName("%1 : %2");
1293 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1294 aHistogram->setName(aHistogramName);
1295 aHistogram->setHorTitle(functorName);
1296 SMESH::ProcessIn2DViewers(anActor);
1305 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1306 MeshObjectType theType,
1307 const QString theInTypeName,
1308 QString & theOutTypeName)
1310 SMESH_TypeFilter aTypeFilter( theType );
1312 if( !theIO.IsNull() )
1314 entry = theIO->getEntry();
1315 LightApp_DataOwner owner( entry );
1316 if ( aTypeFilter.isOk( &owner )) {
1317 theOutTypeName = theInTypeName;
1325 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1327 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1328 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1330 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1331 CORBA::String_var anID = aSComp->GetID().c_str();
1332 if (!strcmp(anID.in(),theIO->getEntry()))
1338 CheckOIType ( theIO, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1339 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1340 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1341 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1342 CheckOIType ( theIO, GROUP, "Group", aTypeName )
1350 QString CheckHomogeneousSelection()
1352 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1353 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1354 SALOME_ListIO selected;
1356 aSel->selectedObjects( selected );
1358 QString RefType = CheckTypeObject(selected.First());
1359 SALOME_ListIteratorOfListIO It(selected);
1360 for ( ; It.More(); It.Next())
1362 Handle(SALOME_InteractiveObject) IObject = It.Value();
1363 QString Type = CheckTypeObject(IObject);
1364 if (Type.compare(RefType) != 0)
1365 return "Heterogeneous Selection";
1372 void SMESHGUI::OnEditDelete()
1374 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1375 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1376 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1378 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1379 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1380 _PTR(GenericAttribute) anAttr;
1381 _PTR(AttributeIOR) anIOR;
1383 int objectCount = 0;
1385 QString aParentComponent = QString::null;
1386 Handle(SALOME_InteractiveObject) anIO;
1387 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1389 anIO = anIt.Value();
1390 QString cur = anIO->getComponentDataType();
1391 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1393 // check if object is reference
1394 _PTR(SObject) aRefSObj;
1395 aNameList.append("\n - ");
1396 if ( aSO->ReferencedObject( aRefSObj ) ) {
1397 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1398 aNameList.append( aRefName );
1399 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1402 aNameList.append(anIO->getName());
1406 if( aParentComponent.isNull() )
1407 aParentComponent = cur;
1408 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1409 aParentComponent = "";
1412 if ( objectCount == 0 )
1413 return; // No Valid Objects Selected
1415 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1416 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1417 QObject::tr("ERR_ERROR"),
1418 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1421 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1422 if (SUIT_MessageBox::warning
1423 (SMESHGUI::desktop(),
1424 QObject::tr("SMESH_WRN_WARNING"),
1425 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1426 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1427 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1430 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1432 SALOME_ListIteratorOfListIO It(selected);
1434 aStudyBuilder->NewCommand(); // There is a transaction
1435 for( ; It.More(); It.Next()){ // loop on selected IO's
1436 Handle(SALOME_InteractiveObject) IObject = It.Value();
1437 if(IObject->hasEntry()) {
1438 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1440 // disable removal of "SMESH" component object
1441 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1443 if ( engineIOR() == anIOR->Value().c_str() )
1446 //Check the referenced object
1447 _PTR(SObject) aRefSObject;
1448 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1449 aSO = aRefSObject; // Delete main Object instead of reference
1451 // put the whole hierarchy of sub-objects of the selected SO into a list and
1452 // then treat them all starting from the deepest objects (at list back)
1454 std::list< _PTR(SObject) > listSO;
1455 listSO.push_back( aSO );
1456 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1457 for ( ; itSO != listSO.end(); ++itSO ) {
1458 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1459 for (it->InitEx(false); it->More(); it->Next())
1460 listSO.push_back( it->Value() );
1463 // treat SO's in the list starting from the back
1465 std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin();
1466 for ( ; ritSO != listSO.rend(); ++ritSO ) {
1467 _PTR(SObject) SO = *ritSO;
1468 if ( !SO ) continue;
1469 std::string anEntry = SO->GetID();
1471 /** Erase graphical object **/
1472 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1473 ViewManagerList aViewMenegers = anApp->viewManagers();
1474 ViewManagerList::const_iterator it = aViewMenegers.begin();
1475 for( ; it != aViewMenegers.end(); it++) {
1476 SUIT_ViewManager* vm = *it;
1477 int nbSf = vm ? vm->getViewsCount() : 0;
1479 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1480 for(int i = 0; i < nbSf; i++){
1481 SUIT_ViewWindow *sf = aViews[i];
1482 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1483 SMESH::RemoveActor(sf,anActor);
1489 /** Remove an object from data structures **/
1490 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1491 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1492 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1493 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1494 aMesh->RemoveGroup( aGroup );
1496 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1497 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1498 aMesh->RemoveSubMesh( aSubMesh );
1500 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1502 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1505 IObject = new SALOME_InteractiveObject
1506 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1507 QString objType = CheckTypeObject(IObject);
1508 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1509 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1510 aStudyBuilder->RemoveObjectWithChildren( SO );
1512 else {// default action: remove SObject from the study
1513 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1514 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1516 aStudyBuilder->RemoveObjectWithChildren( SO );
1520 } /* listSO back loop */
1521 } /* IObject->hasEntry() */
1524 aStudyBuilder->CommitCommand();
1526 /* Clear any previous selection */
1528 aSel->setSelectedObjects( l1 );
1530 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1535 SMESHGUI_EXPORT CAM_Module* createModule()
1537 return new SMESHGUI();
1541 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1543 //=============================================================================
1547 //=============================================================================
1548 SMESHGUI::SMESHGUI() :
1549 SalomeApp_Module( "SMESH" ),
1550 LightApp_Module( "SMESH" )
1552 if ( CORBA::is_nil( myComponentSMESH ) )
1554 CORBA::Boolean anIsEmbeddedMode;
1555 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1556 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1558 // 0019923: EDF 765 SMESH : default values of hypothesis
1559 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1560 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1561 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1562 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1563 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1566 myActiveDialogBox = 0;
1567 myFilterLibraryDlg = 0;
1571 myEventCallbackCommand = vtkCallbackCommand::New();
1572 myEventCallbackCommand->Delete();
1573 myEventCallbackCommand->SetClientData( this );
1574 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1577 SMESH::GetFilterManager();
1578 SMESH::GetPattern();
1579 SMESH::GetMeasurements();
1581 /* load resources for all available meshers */
1582 SMESH::InitAvailableHypotheses();
1585 //=============================================================================
1589 //=============================================================================
1590 SMESHGUI::~SMESHGUI()
1592 #ifdef WITHGENERICOBJ
1593 SMESH::GetFilterManager()->UnRegister();
1594 SMESH::GetMeasurements()->UnRegister();
1596 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1597 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1600 //=============================================================================
1604 //=============================================================================
1605 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1607 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1609 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1614 //=============================================================================
1618 //=============================================================================
1619 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1621 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1625 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1626 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1627 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1628 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1629 return autoUpdate && !exceeded;
1632 //=============================================================================
1636 //=============================================================================
1637 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1639 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1642 //=============================================================================
1646 //=============================================================================
1647 SMESHGUI* SMESHGUI::GetSMESHGUI()
1649 SMESHGUI* smeshMod = 0;
1650 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1653 CAM_Module* module = app->module( "Mesh" );
1654 smeshMod = dynamic_cast<SMESHGUI*>( module );
1657 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1659 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1662 _PTR(Study) aStudy = study->studyDS();
1664 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1673 Standard_EXPORT SMESHGUI* GetComponentGUI()
1675 return SMESHGUI::GetSMESHGUI();
1679 //=============================================================================
1683 //=============================================================================
1684 void SMESHGUI::SetState(int aState)
1689 //=============================================================================
1693 //=============================================================================
1694 void SMESHGUI::ResetState()
1699 //=============================================================================
1703 //=============================================================================
1704 void SMESHGUI::EmitSignalDeactivateDialog()
1706 emit SignalDeactivateActiveDialog();
1709 //=============================================================================
1713 //=============================================================================
1714 void SMESHGUI::EmitSignalStudyFrameChanged()
1716 emit SignalStudyFrameChanged();
1719 //=============================================================================
1723 //=============================================================================
1724 void SMESHGUI::EmitSignalCloseAllDialogs()
1726 emit SignalCloseAllDialogs();
1729 //=============================================================================
1733 //=============================================================================
1734 void SMESHGUI::EmitSignalVisibilityChanged()
1736 emit SignalVisibilityChanged();
1739 //=============================================================================
1743 //=============================================================================
1744 QDialog *SMESHGUI::GetActiveDialogBox()
1746 return myActiveDialogBox;
1749 //=============================================================================
1753 //=============================================================================
1754 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
1756 myActiveDialogBox = (QDialog *) aDlg;
1760 //=============================================================================
1764 //=============================================================================
1765 SUIT_Desktop* SMESHGUI::desktop()
1767 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1769 return app->desktop();
1774 //=============================================================================
1778 //=============================================================================
1779 SalomeApp_Study* SMESHGUI::activeStudy()
1781 SUIT_Application* app = SUIT_Session::session()->activeApplication();
1783 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1788 //=============================================================================
1792 //=============================================================================
1793 void SMESHGUI::Modified( bool theIsUpdateActions )
1795 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
1796 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
1797 appStudy->Modified();
1798 if( theIsUpdateActions )
1799 app->updateActions();
1804 //=============================================================================
1808 //=============================================================================
1809 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
1811 /* Here the position is on the bottom right corner - 10 */
1812 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
1814 SUIT_Desktop *PP = desktop();
1815 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
1816 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
1820 //=============================================================================
1824 //=============================================================================
1825 static int isStudyLocked(_PTR(Study) theStudy){
1826 return theStudy->GetProperties()->IsLocked();
1829 static bool checkLock(_PTR(Study) theStudy) {
1830 if (isStudyLocked(theStudy)) {
1831 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1832 QObject::tr("WRN_WARNING"),
1833 QObject::tr("WRN_STUDY_LOCKED") );
1839 //=======================================================================
1840 //function : CheckActiveStudyLocked
1842 //=======================================================================
1844 bool SMESHGUI::isActiveStudyLocked()
1846 _PTR(Study) aStudy = activeStudy()->studyDS();
1847 return checkLock( aStudy );
1850 //=============================================================================
1854 //=============================================================================
1855 bool SMESHGUI::OnGUIEvent( int theCommandID )
1857 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
1861 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
1862 SUIT_ResourceMgr* mgr = resourceMgr();
1866 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
1867 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
1870 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
1871 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
1873 //QAction* act = action( theCommandID );
1875 switch (theCommandID) {
1877 if(checkLock(aStudy)) break;
1886 if(checkLock(aStudy)) break;
1887 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
1891 case 150: //MED FILE INFORMATION
1893 SALOME_ListIO selected;
1894 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1896 aSel->selectedObjects( selected );
1897 if( selected.Extent() )
1899 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1900 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1901 if ( !aMesh->_is_nil() )
1903 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
1910 case 122: // EXPORT MED
1918 ::ExportMeshToFile(theCommandID);
1922 case 200: // SCALAR BAR
1924 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1925 SALOME_ListIO selected;
1927 aSel->selectedObjects( selected );
1929 if( selected.Extent() ) {
1930 Handle(SALOME_InteractiveObject) anIO = selected.First();
1931 if( anIO->hasEntry() ) {
1932 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
1933 anActor->SetControlMode( SMESH_Actor::eNone );
1934 #ifndef DISABLE_PLOT2DVIEWER
1935 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
1944 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
1949 // dump control distribution data to the text file
1950 ::SaveDistribution();
1956 // show/ distribution
1957 ::ShowDistribution();
1961 #ifndef DISABLE_PLOT2DVIEWER
1964 // plot distribution
1965 ::PlotDistribution();
1976 ::DisableAutoColor();
1979 case 1134: // Clipping
1980 case 1133: // Tranparency
1981 case 1132: // Colors / Size
1988 ::SetDisplayMode(theCommandID, myMarkerMap);
1991 //2D quadratic representation
1994 ::SetDisplayMode(theCommandID, myMarkerMap);
1998 case 216: // 0D elements
2001 case 219: // Volumes
2002 case 220: // All Entity
2003 ::SetDisplayEntity(theCommandID);
2006 case 221: // Orientation of faces
2008 LightApp_SelectionMgr* mgr = selectionMgr();
2009 SALOME_ListIO selected; mgr->selectedObjects( selected );
2011 SALOME_ListIteratorOfListIO it(selected);
2012 for( ; it.More(); it.Next()) {
2013 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2014 if(anIObject->hasEntry()) {
2015 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2016 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2025 if(checkLock(aStudy)) break;
2027 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2030 SMESH::UpdateView();
2032 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2033 SMESH::OnVisuException();
2035 catch (...) { // PAL16774 (Crash after display of many groups)
2036 SMESH::OnVisuException();
2040 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2041 aSel->selectedObjects( l );
2042 aSel->setSelectedObjects( l );
2047 case 301: // DISPLAY
2048 case 302: // DISPLAY ONLY
2050 SMESH::EDisplaing anAction;
2051 switch (theCommandID) {
2052 case 300: anAction = SMESH::eErase; break;
2053 case 301: anAction = SMESH::eDisplay; break;
2054 case 302: anAction = SMESH::eDisplayOnly; break;
2057 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2058 SALOME_ListIO sel_objects, to_process;
2060 aSel->selectedObjects( sel_objects );
2062 if( theCommandID==302 )
2064 MESSAGE("anAction = SMESH::eDisplayOnly");
2065 startOperation( myEraseAll );
2068 extractContainers( sel_objects, to_process );
2071 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2075 SALOME_ListIteratorOfListIO It( to_process );
2076 for ( ; It.More(); It.Next()) {
2078 Handle(SALOME_InteractiveObject) IOS = It.Value();
2079 if (IOS->hasEntry()) {
2081 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2082 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2083 break; // PAL16774 (Crash after display of many groups)
2085 if (anAction == SMESH::eDisplayOnly)
2087 MESSAGE("anAction = SMESH::eDisplayOnly");
2088 anAction = SMESH::eDisplay;
2094 // PAL13338 + PAL15161 -->
2095 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2096 MESSAGE("anAction = SMESH::eDisplayOnly");
2097 SMESH::UpdateView();
2098 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2100 // PAL13338 + PAL15161 <--
2102 catch (...) { // PAL16774 (Crash after display of many groups)
2103 SMESH::OnVisuException();
2106 if (anAction == SMESH::eErase) {
2107 MESSAGE("anAction == SMESH::eErase");
2109 aSel->setSelectedObjects( l1 );
2112 aSel->setSelectedObjects( to_process );
2119 if(checkLock(aStudy)) break;
2122 EmitSignalDeactivateDialog();
2124 ( new SMESHGUI_NodesDlg( this ) )->show();
2127 SUIT_MessageBox::warning(desktop(),
2128 tr("SMESH_WRN_WARNING"),
2129 tr("SMESH_WRN_VIEWER_VTK"));
2134 case 2151: // FILTER
2138 EmitSignalDeactivateDialog();
2139 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2144 case 701: // COMPUTE MESH
2145 case 711: // PRECOMPUTE MESH
2146 case 712: // EVALUATE MESH
2147 case 713: // MESH ORDER
2149 if (checkLock(aStudy)) break;
2150 startOperation( theCommandID );
2154 case 702: // Create mesh
2155 case 703: // Create sub-mesh
2156 case 704: // Edit mesh/sub-mesh
2157 startOperation( theCommandID );
2159 case 705: // copy mesh
2161 if (checkLock(aStudy)) break;
2162 EmitSignalDeactivateDialog();
2163 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2166 case 710: // Build compound mesh
2168 if (checkLock(aStudy)) break;
2169 EmitSignalDeactivateDialog();
2170 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2174 case 407: // DIAGONAL INVERSION
2175 case 408: // Delete diagonal
2179 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2180 tr( "NOT_A_VTK_VIEWER" ) );
2184 if ( checkLock( aStudy ) )
2187 /*Standard_Boolean aRes;
2188 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2189 if ( aMesh->_is_nil() )
2191 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2192 tr( "SMESH_BAD_SELECTION" ) );
2196 EmitSignalDeactivateDialog();
2197 if ( theCommandID == 407 )
2198 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2200 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2203 case 409: // Change orientation
2204 case 410: // Union of triangles
2205 case 411: // Cutting of quadrangles
2206 case 419: // Splitting volumes into tetrahedra
2210 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2211 tr( "NOT_A_VTK_VIEWER" ) );
2215 if ( checkLock( aStudy ) )
2218 EmitSignalDeactivateDialog();
2219 SMESHGUI_MultiEditDlg* aDlg = NULL;
2220 if ( theCommandID == 409 )
2221 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2222 else if ( theCommandID == 410 )
2223 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2224 else if ( theCommandID == 419 )
2225 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2227 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2232 case 412: // Smoothing
2234 if(checkLock(aStudy)) break;
2236 EmitSignalDeactivateDialog();
2237 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2240 SUIT_MessageBox::warning(desktop(),
2241 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2245 case 413: // Extrusion
2247 if (checkLock(aStudy)) break;
2249 EmitSignalDeactivateDialog();
2250 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2252 SUIT_MessageBox::warning(desktop(),
2253 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2257 case 414: // Revolution
2259 if(checkLock(aStudy)) break;
2261 EmitSignalDeactivateDialog();
2262 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2265 SUIT_MessageBox::warning(desktop(),
2266 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2270 case 415: // Pattern mapping
2272 if ( checkLock( aStudy ) )
2276 EmitSignalDeactivateDialog();
2277 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2280 SUIT_MessageBox::warning(desktop(),
2281 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2285 case 416: // Extrusion along a path
2287 if (checkLock(aStudy)) break;
2289 EmitSignalDeactivateDialog();
2290 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2292 SUIT_MessageBox::warning(desktop(),
2293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2297 case 417: // Convert mesh to quadratic
2299 startOperation( 417 );
2300 /* if (checkLock(aStudy)) break;
2302 EmitSignalDeactivateDialog();
2303 new SMESHGUI_ConvToQuadDlg();
2305 SUIT_MessageBox::warning(desktop(),
2306 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2310 case 418: // create 2D mesh from 3D
2312 startOperation( 418 );
2315 case 806: // CREATE GEO GROUP
2317 startOperation( 806 );
2320 case 801: // CREATE GROUP
2324 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2325 tr( "NOT_A_VTK_VIEWER" ) );
2329 if(checkLock(aStudy)) break;
2330 EmitSignalDeactivateDialog();
2331 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2333 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2334 SALOME_ListIO selected;
2336 aSel->selectedObjects( selected );
2338 int nbSel = selected.Extent();
2340 // check if mesh is selected
2341 aMesh = SMESH::GetMeshByIO( selected.First() );
2343 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2348 case 802: // CONSTRUCT GROUP
2352 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2353 tr( "NOT_A_VTK_VIEWER" ) );
2357 if(checkLock(aStudy)) break;
2358 EmitSignalDeactivateDialog();
2360 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2361 SALOME_ListIO selected;
2363 aSel->selectedObjects( selected );
2365 int nbSel = selected.Extent();
2367 // check if submesh is selected
2368 Handle(SALOME_InteractiveObject) IObject = selected.First();
2369 if (IObject->hasEntry()) {
2370 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2372 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2373 if (!aSubMesh->_is_nil()) {
2375 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2376 // get submesh elements list by types
2377 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2378 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2379 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2380 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2381 // create group for each type o elements
2382 QString aName = IObject->getName();
2383 QStringList anEntryList;
2384 if (aNodes->length() > 0) {
2385 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2386 aGroup->Add(aNodes.inout());
2387 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2388 anEntryList.append( aSObject->GetID().c_str() );
2390 if (aEdges->length() > 0) {
2391 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2392 aGroup->Add(aEdges.inout());
2393 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2394 anEntryList.append( aSObject->GetID().c_str() );
2396 if (aFaces->length() > 0) {
2397 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2398 aGroup->Add(aFaces.inout());
2399 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2400 anEntryList.append( aSObject->GetID().c_str() );
2402 if (aVolumes->length() > 0) {
2403 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2404 aGroup->Add(aVolumes.inout());
2405 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2406 anEntryList.append( aSObject->GetID().c_str() );
2409 anApp->browseObjects( anEntryList );
2411 catch(const SALOME::SALOME_Exception & S_ex){
2412 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2419 SUIT_MessageBox::warning(desktop(),
2420 tr("SMESH_WRN_WARNING"),
2421 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2426 case 803: // EDIT GROUP
2430 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2431 tr( "NOT_A_VTK_VIEWER" ) );
2435 if(checkLock(aStudy)) break;
2436 EmitSignalDeactivateDialog();
2438 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2439 SALOME_ListIO selected;
2441 aSel->selectedObjects( selected );
2443 SALOME_ListIteratorOfListIO It (selected);
2444 int nbSelectedGroups = 0;
2445 for ( ; It.More(); It.Next() )
2447 SMESH::SMESH_GroupBase_var aGroup =
2448 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2449 if (!aGroup->_is_nil()) {
2451 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2455 if (nbSelectedGroups == 0)
2457 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2463 case 804: // Add elements to group
2465 if(checkLock(aStudy)) break;
2466 if (myState == 800) {
2467 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2468 if (aDlg) aDlg->onAdd();
2473 case 805: // Remove elements from group
2475 if(checkLock(aStudy)) break;
2476 if (myState == 800) {
2477 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2478 if (aDlg) aDlg->onRemove();
2483 case 815: // Edit GEOM GROUP as standalone
2487 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2488 tr( "NOT_A_VTK_VIEWER" ) );
2492 if(checkLock(aStudy)) break;
2493 EmitSignalDeactivateDialog();
2495 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2496 SALOME_ListIO selected;
2498 aSel->selectedObjects( selected );
2500 SALOME_ListIteratorOfListIO It (selected);
2501 for ( ; It.More(); It.Next() )
2503 SMESH::SMESH_GroupOnGeom_var aGroup =
2504 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2505 if (!aGroup->_is_nil()) {
2506 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2513 case 810: // Union Groups
2514 case 811: // Intersect groups
2515 case 812: // Cut groups
2519 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2520 tr( "NOT_A_VTK_VIEWER" ) );
2524 if ( checkLock( aStudy ) )
2527 EmitSignalDeactivateDialog();
2529 SMESHGUI_GroupOpDlg* aDlg = 0;
2530 if ( theCommandID == 810 )
2531 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2532 else if ( theCommandID == 811 )
2533 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2535 aDlg = new SMESHGUI_CutGroupsDlg( this );
2542 case 814: // Create groups of entities from existing groups of superior dimensions
2544 if ( checkLock( aStudy ) )
2547 EmitSignalDeactivateDialog();
2548 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2554 case 813: // Delete groups with their contents
2558 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2559 tr( "NOT_A_VTK_VIEWER" ) );
2563 if ( checkLock( aStudy ) )
2566 EmitSignalDeactivateDialog();
2568 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2572 case 900: // MESH INFOS
2573 case 903: // WHAT IS
2575 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2576 EmitSignalDeactivateDialog();
2577 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2578 SALOME_ListIO selected;
2580 aSel->selectedObjects( selected );
2582 if ( selected.Extent() > 1 ) { // a dlg for each IO
2583 SALOME_ListIteratorOfListIO It( selected );
2584 for ( ; It.More(); It.Next() ) {
2585 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2586 dlg->showInfo( It.Value() );
2591 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2597 case 902: // STANDARD MESH INFOS
2599 EmitSignalDeactivateDialog();
2600 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2601 SALOME_ListIO selected;
2603 aSel->selectedObjects( selected );
2605 if ( selected.Extent() > 1 ) { // a dlg for each IO
2607 SALOME_ListIteratorOfListIO It (selected);
2608 for ( ; It.More(); It.Next() ) {
2610 IOs.Append( It.Value() );
2611 aSel->setSelectedObjects( IOs );
2612 ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2614 // restore selection
2615 aSel->setSelectedObjects( selected );
2618 ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
2621 case 903: // WHAT IS
2623 EmitSignalDeactivateDialog();
2624 ( new SMESHGUI_WhatIsDlg( this ) )->show();
2629 case 904: // FIND ELEM
2631 startOperation( theCommandID );
2635 case 1100: // EDIT HYPOTHESIS
2637 if(checkLock(aStudy)) break;
2639 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2640 SALOME_ListIO selected;
2642 aSel->selectedObjects( selected );
2644 int nbSel = selected.Extent();
2647 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2648 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2650 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2651 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2652 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2653 if ( !aHypothesis->_is_nil() )
2656 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2657 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2659 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2669 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2671 if(checkLock(aStudy)) break;
2672 SUIT_OverrideCursor wc;
2674 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2675 SALOME_ListIO selected;
2677 aSel->selectedObjects( selected, QString::null, false );
2679 SALOME_ListIteratorOfListIO It(selected);
2680 for (int i = 0; It.More(); It.Next(), i++) {
2681 Handle(SALOME_InteractiveObject) IObject = It.Value();
2682 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2685 aSel->setSelectedObjects( l1 );
2690 case 4009: // ELEM0D
2691 case 4010: // GEOM::EDGE
2692 case 4021: // TRIANGLE
2694 case 4023: // POLYGON
2698 if(checkLock(aStudy)) break;
2700 EmitSignalDeactivateDialog();
2701 SMDSAbs_ElementType type = SMDSAbs_Edge;
2703 switch (theCommandID) {
2704 case 4009: // ELEM0D
2705 type = SMDSAbs_0DElement; nbNodes = 1; break;
2706 case 4021: // TRIANGLE
2707 type = SMDSAbs_Face; nbNodes = 3; break;
2709 type = SMDSAbs_Face; nbNodes = 4; break;
2711 type = SMDSAbs_Volume; nbNodes = 4; break;
2712 case 4023: // POLYGON
2713 type = SMDSAbs_Face; nbNodes = 5; break; // 5 - identificator for POLYGON
2715 type = SMDSAbs_Volume; nbNodes = 8; break;
2716 case 4033: // POLYHEDRE
2717 type = SMDSAbs_Volume; nbNodes = 9; break; // 9 - identificator for POLYHEDRE
2720 ( new SMESHGUI_AddMeshElementDlg( this, type, nbNodes ) )->show();
2723 SUIT_MessageBox::warning(desktop(),
2724 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2728 case 4033: // POLYHEDRON
2730 if(checkLock(aStudy)) break;
2732 EmitSignalDeactivateDialog();
2733 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2736 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2737 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2741 case 4034: // QUADRATIC EDGE
2742 case 4035: // QUADRATIC TRIANGLE
2743 case 4036: // QUADRATIC QUADRANGLE
2744 case 4037: // QUADRATIC TETRAHEDRON
2745 case 4038: // QUADRATIC PYRAMID
2746 case 4039: // QUADRATIC PENTAHEDRON
2747 case 4040: // QUADRATIC HEXAHEDRON
2749 if(checkLock(aStudy)) break;
2751 EmitSignalDeactivateDialog();
2754 switch (theCommandID) {
2756 type = QUAD_EDGE; break;
2758 type = QUAD_TRIANGLE; break;
2760 type = QUAD_QUADRANGLE; break;
2762 type = QUAD_TETRAHEDRON; break;
2764 type = QUAD_PYRAMID; break;
2766 type = QUAD_PENTAHEDRON; break;
2768 type = QUAD_HEXAHEDRON;
2772 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2775 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2776 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2780 case 4041: // REMOVES NODES
2782 if(checkLock(aStudy)) break;
2784 EmitSignalDeactivateDialog();
2785 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2788 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2789 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2793 case 4042: // REMOVES ELEMENTS
2795 if(checkLock(aStudy)) break;
2797 EmitSignalDeactivateDialog();
2798 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2802 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2803 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2807 case 4043: { // CLEAR_MESH
2809 if(checkLock(aStudy)) break;
2811 SALOME_ListIO selected;
2812 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2813 aSel->selectedObjects( selected );
2815 SUIT_OverrideCursor wc;
2816 SALOME_ListIteratorOfListIO It (selected);
2817 for ( ; It.More(); It.Next() )
2819 Handle(SALOME_InteractiveObject) IOS = It.Value();
2820 SMESH::SMESH_Mesh_var aMesh =
2821 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2822 if ( aMesh->_is_nil()) continue;
2824 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
2826 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
2827 SMESH::ModifiedMesh( aMeshSObj, false, true);
2828 // hide groups and submeshes
2829 _PTR(ChildIterator) anIter =
2830 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
2831 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
2833 _PTR(SObject) so = anIter->Value();
2834 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
2837 catch (const SALOME::SALOME_Exception& S_ex){
2839 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2843 SMESH::UpdateView();
2847 case 4044: // REMOVE ORPHAN NODES
2849 if(checkLock(aStudy)) break;
2850 SALOME_ListIO selected;
2851 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2852 aSel->selectedObjects( selected );
2853 if ( selected.Extent() == 1 ) {
2854 Handle(SALOME_InteractiveObject) anIO = selected.First();
2855 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
2856 if ( !aMesh->_is_nil() ) {
2857 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
2858 tr( "SMESH_WARNING" ),
2859 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
2860 SUIT_MessageBox::Yes |
2861 SUIT_MessageBox::No,
2862 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
2865 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
2866 int removed = aMeshEditor->RemoveOrphanNodes();
2867 SUIT_MessageBox::information(SMESHGUI::desktop(),
2868 tr("SMESH_INFORMATION"),
2869 tr("NB_NODES_REMOVED").arg(removed));
2870 if ( removed > 0 ) {
2871 SMESH::UpdateView();
2872 SMESHGUI::Modified();
2875 catch (const SALOME::SALOME_Exception& S_ex) {
2876 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2885 case 4051: // RENUMBERING NODES
2887 if(checkLock(aStudy)) break;
2889 EmitSignalDeactivateDialog();
2890 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
2894 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2895 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2899 case 4052: // RENUMBERING ELEMENTS
2901 if(checkLock(aStudy)) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
2908 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2909 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2913 case 4061: // TRANSLATION
2915 if(checkLock(aStudy)) break;
2917 EmitSignalDeactivateDialog();
2918 ( new SMESHGUI_TranslationDlg( this ) )->show();
2921 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2922 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2926 case 4062: // ROTATION
2928 if(checkLock(aStudy)) break;
2930 EmitSignalDeactivateDialog();
2931 ( new SMESHGUI_RotationDlg( this ) )->show();
2934 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2935 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2939 case 4063: // SYMMETRY
2941 if(checkLock(aStudy)) break;
2943 EmitSignalDeactivateDialog();
2944 ( new SMESHGUI_SymmetryDlg( this ) )->show();
2947 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2948 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2952 case 4064: // SEWING
2954 if(checkLock(aStudy)) break;
2956 EmitSignalDeactivateDialog();
2957 ( new SMESHGUI_SewingDlg( this ) )->show();
2960 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2961 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2965 case 4065: // MERGE NODES
2967 if(checkLock(aStudy)) break;
2969 EmitSignalDeactivateDialog();
2970 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
2973 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2974 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2978 case 4066: // MERGE EQUAL ELEMENTS
2980 if (checkLock(aStudy)) break;
2982 EmitSignalDeactivateDialog();
2983 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
2985 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2986 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2991 case 4067: // MAKE MESH PASS THROUGH POINT
2992 startOperation( 4067 );
2997 if(checkLock(aStudy)) break;
2999 EmitSignalDeactivateDialog();
3000 ( new SMESHGUI_ScaleDlg( this ) )->show();
3003 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3004 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3009 case 4069: // DUPLICATE NODES
3011 if(checkLock(aStudy)) break;
3013 EmitSignalDeactivateDialog();
3014 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3017 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3018 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3023 case 5105: // Library of selection filters
3025 static QList<int> aTypes;
3026 if ( aTypes.isEmpty() )
3028 aTypes.append( SMESH::NODE );
3029 aTypes.append( SMESH::EDGE );
3030 aTypes.append( SMESH::FACE );
3031 aTypes.append( SMESH::VOLUME );
3033 if (!myFilterLibraryDlg)
3034 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3035 else if (myFilterLibraryDlg->isHidden())
3036 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3037 myFilterLibraryDlg->raise();
3041 case 6017: // CONTROLS
3065 LightApp_SelectionMgr* mgr = selectionMgr();
3066 SALOME_ListIO selected; mgr->selectedObjects( selected );
3068 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3069 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3071 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3072 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3073 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3074 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3075 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3076 ::Control( theCommandID );
3081 SUIT_MessageBox::warning(desktop(),
3082 tr( "SMESH_WRN_WARNING" ),
3083 tr( "SMESH_BAD_SELECTION" ) );
3087 SUIT_MessageBox::warning(desktop(),
3088 tr( "SMESH_WRN_WARNING" ),
3089 tr( "NOT_A_VTK_VIEWER" ) );
3094 LightApp_SelectionMgr* mgr = selectionMgr();
3095 SALOME_ListIO selected; mgr->selectedObjects( selected );
3097 SALOME_ListIteratorOfListIO it(selected);
3098 for( ; it.More(); it.Next()) {
3099 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3100 if(anIObject->hasEntry()) {
3101 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3102 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
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->SetCellsLabeled( !anActor->GetCellsLabeled() );
3126 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3127 EmitSignalDeactivateDialog();
3128 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3134 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3135 //updateObjBrowser();
3139 //=============================================================================
3143 //=============================================================================
3144 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3149 //=============================================================================
3153 //=============================================================================
3154 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3159 //=============================================================================
3163 //=============================================================================
3164 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3169 //=============================================================================
3170 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3171 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3173 //=============================================================================
3174 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3175 SUIT_ViewWindow* wnd )
3177 if(theIO->hasEntry()){
3178 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3179 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3183 //=======================================================================
3184 // function : createSMESHAction
3186 //=======================================================================
3187 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3188 const int key, const bool toggle, const QString& shortcutAction )
3191 QWidget* parent = application()->desktop();
3192 SUIT_ResourceMgr* resMgr = resourceMgr();
3194 if ( !icon_id.isEmpty() )
3195 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3197 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3198 if ( !pix.isNull() )
3199 icon = QIcon( pix );
3201 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3202 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3203 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3205 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3206 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3209 //=======================================================================
3210 // function : createPopupItem
3212 //=======================================================================
3213 void SMESHGUI::createPopupItem( const int id,
3214 const QString& clients,
3215 const QString& types,
3216 const QString& theRule,
3221 parentId = popupMgr()->actionId( action( pId ) );
3223 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3224 popupMgr()->insert( action( id ), parentId, 0 );
3226 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3227 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3228 QString rule = "(%1) and (%2) and (%3)";
3229 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3230 if( clients.isEmpty() )
3231 rule = rule.arg( QString( "true" ) );
3233 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3234 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3237 bool cont = myRules.contains( id );
3239 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3241 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3242 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3245 //=======================================================================
3246 // function : initialize
3248 //=======================================================================
3249 void SMESHGUI::initialize( CAM_Application* app )
3251 SalomeApp_Module::initialize( app );
3253 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3255 /* Automatic Update flag */
3256 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3258 // ----- create actions --------------
3260 createSMESHAction( 111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3261 createSMESHAction( 112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3262 createSMESHAction( 113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3263 createSMESHAction( 114, "NUM" );
3264 createSMESHAction( 121, "DAT" );
3265 createSMESHAction( 122, "MED" );
3266 createSMESHAction( 123, "UNV" );
3267 createSMESHAction( 140, "STL" );
3268 createSMESHAction( 124, "EXPORT_DAT" );
3269 createSMESHAction( 125, "EXPORT_MED" );
3270 createSMESHAction( 126, "EXPORT_UNV" );
3271 createSMESHAction( 141, "EXPORT_STL" );
3272 createSMESHAction( 150, "FILE_INFO" );
3273 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3274 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3275 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3276 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3277 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3278 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3279 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3280 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3281 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3282 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3283 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3284 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3285 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3286 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3287 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3288 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3289 createSMESHAction( 804, "ADD" );
3290 createSMESHAction( 805, "REMOVE" );
3291 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3292 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3293 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3294 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3295 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3296 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3297 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3298 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3299 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3300 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3301 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3302 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3303 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3304 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3305 createSMESHAction( 6024, "BARE_BORDER_VOLUME","ICON_BARE_BORDER_VOLUME", 0, true );
3306 createSMESHAction( 6025, "BARE_BORDER_FACE","ICON_BARE_BORDER_FACE", 0, true );
3307 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3308 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE","ICON_OVER_CONSTRAINED_FACE", 0, true );
3309 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3310 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3311 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3312 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3313 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3314 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3315 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3316 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3317 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3318 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3319 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3320 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3321 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3322 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3323 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3324 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3325 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3326 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3327 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3328 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3329 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3330 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3331 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3332 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3333 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3334 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3335 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3336 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3337 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3338 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3339 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3340 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3341 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3342 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3343 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3344 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3345 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3346 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3347 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3348 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3349 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3350 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3351 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3352 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3353 createSMESHAction( 415, "MAP", "ICON_MAP" );
3354 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3355 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3356 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3357 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3358 createSMESHAction( 200, "RESET" );
3359 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3360 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3361 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3362 #ifndef DISABLE_PLOT2DVIEWER
3363 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3365 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3366 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3367 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3368 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3369 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3370 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3371 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3372 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3373 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3374 createSMESHAction( 220, "ALL" );
3375 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3377 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3378 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3380 createSMESHAction( 1100, "EDIT_HYPO" );
3381 createSMESHAction( 1102, "UNASSIGN" );
3382 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3383 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3384 createSMESHAction( 1131, "DISPMODE" );
3385 createSMESHAction( 1132, "COLORS" );
3386 createSMESHAction( 1133, "TRANSP" );
3387 createSMESHAction( 1134, "CLIP" );
3388 createSMESHAction( 1135, "DISP_ENT" );
3389 createSMESHAction( 1136, "AUTO_COLOR" );
3390 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3391 createSMESHAction( 2000, "CTRL" );
3393 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3394 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3396 createSMESHAction( 300, "ERASE" );
3397 createSMESHAction( 301, "DISPLAY" );
3398 createSMESHAction( 302, "DISPLAY_ONLY" );
3399 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3400 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3401 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3402 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3403 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3404 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3405 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3406 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3408 // ----- create menu --------------
3409 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3410 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3411 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3412 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3413 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3414 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3415 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3416 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3418 createMenu( separator(), fileId );
3420 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3421 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3422 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3423 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3424 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3425 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3426 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3427 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3428 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3429 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3431 createMenu( 111, importId, -1 );
3432 createMenu( 112, importId, -1 );
3433 createMenu( 113, importId, -1 );
3434 createMenu( 140, importId, -1 );
3436 createMenu( 121, exportId, -1 );
3437 createMenu( 122, exportId, -1 );
3438 createMenu( 123, exportId, -1 );
3439 createMenu( 141, exportId, -1 ); // export to stl STL
3441 createMenu( separator(), fileId, 10 );
3443 createMenu( 33, editId, -1 );
3445 createMenu( 5105, toolsId, -1 );
3447 createMenu( 702, meshId, -1 ); // "Mesh" menu
3448 createMenu( 703, meshId, -1 );
3449 createMenu( 704, meshId, -1 );
3450 createMenu( 710, meshId, -1 );
3451 createMenu( 705, meshId, -1 );
3452 createMenu( separator(), meshId, -1 );
3453 createMenu( 701, meshId, -1 );
3454 createMenu( 711, meshId, -1 );
3455 createMenu( 712, meshId, -1 );
3456 createMenu( 713, meshId, -1 );
3457 createMenu( separator(), meshId, -1 );
3458 createMenu( 801, meshId, -1 );
3459 createMenu( 806, meshId, -1 );
3460 createMenu( 802, meshId, -1 );
3461 createMenu( 803, meshId, -1 );
3462 createMenu( 815, meshId, -1 );
3463 createMenu( separator(), meshId, -1 );
3464 createMenu( 810, meshId, -1 );
3465 createMenu( 811, meshId, -1 );
3466 createMenu( 812, meshId, -1 );
3467 createMenu( separator(), meshId, -1 );
3468 createMenu( 814, meshId, -1 );
3469 createMenu( separator(), meshId, -1 );
3470 createMenu( 900, meshId, -1 );
3471 //createMenu( 902, meshId, -1 );
3472 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3473 createMenu( 904, meshId, -1 );
3474 createMenu( separator(), meshId, -1 );
3476 createMenu( 6005, nodeId, -1 );
3477 createMenu( 6002, edgeId, -1 );
3478 createMenu( 6003, edgeId, -1 );
3479 createMenu( 6001, edgeId, -1 );
3480 createMenu( 6004, edgeId, -1 );
3481 createMenu( 6021, faceId, -1 );
3482 createMenu( 6025, faceId, -1 );
3483 createMenu( 6027, faceId, -1 );
3484 createMenu( 6018, faceId, -1 );
3485 createMenu( 6019, faceId, -1 );
3486 createMenu( 6011, faceId, -1 );
3487 createMenu( 6012, faceId, -1 );
3488 createMenu( 6013, faceId, -1 );
3489 createMenu( 6014, faceId, -1 );
3490 createMenu( 6015, faceId, -1 );
3491 createMenu( 6016, faceId, -1 );
3492 createMenu( 6022, faceId, -1 );
3493 createMenu( 6017, volumeId, -1 );
3494 createMenu( 6009, volumeId, -1 );
3495 createMenu( 6023, volumeId, -1 );
3496 createMenu( 6024, volumeId, -1 );
3497 createMenu( 6026, volumeId, -1 );
3499 createMenu( 4000, addId, -1 );
3500 createMenu( 4009, addId, -1 );
3501 createMenu( 4010, addId, -1 );
3502 createMenu( 4021, addId, -1 );
3503 createMenu( 4022, addId, -1 );
3504 createMenu( 4023, addId, -1 );
3505 createMenu( 4031, addId, -1 );
3506 createMenu( 4032, addId, -1 );
3507 createMenu( 4033, addId, -1 );
3508 createMenu( separator(), addId, -1 );
3509 createMenu( 4034, addId, -1 );
3510 createMenu( 4035, addId, -1 );
3511 createMenu( 4036, addId, -1 );
3512 createMenu( 4037, addId, -1 );
3513 createMenu( 4038, addId, -1 );
3514 createMenu( 4039, addId, -1 );
3515 createMenu( 4040, addId, -1 );
3517 createMenu( 4041, removeId, -1 );
3518 createMenu( 4042, removeId, -1 );
3519 createMenu( 4044, removeId, -1 );
3520 createMenu( separator(), removeId, -1 );
3521 createMenu( 813, removeId, -1 );
3522 createMenu( separator(), removeId, -1 );
3523 createMenu( 4043, removeId, -1 );
3525 createMenu( 4051, renumId, -1 );
3526 createMenu( 4052, renumId, -1 );
3528 createMenu( 4061, transfId, -1 );
3529 createMenu( 4062, transfId, -1 );
3530 createMenu( 4063, transfId, -1 );
3531 createMenu( 4068, transfId, -1 );
3532 createMenu( 4064, transfId, -1 );
3533 createMenu( 4065, transfId, -1 );
3534 createMenu( 4066, transfId, -1 );
3535 createMenu( 4069, transfId, -1 );
3537 createMenu( 4067,modifyId, -1 );
3538 createMenu( 407, modifyId, -1 );
3539 createMenu( 408, modifyId, -1 );
3540 createMenu( 409, modifyId, -1 );
3541 createMenu( 410, modifyId, -1 );
3542 createMenu( 411, modifyId, -1 );
3543 createMenu( 419, modifyId, -1 );
3544 createMenu( 412, modifyId, -1 );
3545 createMenu( 413, modifyId, -1 );
3546 createMenu( 416, modifyId, -1 );
3547 createMenu( 414, modifyId, -1 );
3548 createMenu( 415, modifyId, -1 );
3549 createMenu( 417, modifyId, -1 );
3550 createMenu( 418, modifyId, -1 );
3552 createMenu( 501, measureId, -1 );
3553 createMenu( 502, measureId, -1 );
3554 createMenu( 214, viewId, -1 );
3556 // ----- create toolbars --------------
3557 int meshTb = createTool( tr( "TB_MESH" ) ),
3558 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3559 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3560 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3561 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3563 createTool( 702, meshTb );
3564 createTool( 703, meshTb );
3565 createTool( 704, meshTb );
3566 createTool( 710, meshTb );
3567 createTool( 705, meshTb );
3568 createTool( separator(), meshTb );
3569 createTool( 701, meshTb );
3570 createTool( 711, meshTb );
3571 createTool( 712, meshTb );
3572 createTool( 713, meshTb );
3573 createTool( separator(), meshTb );
3574 createTool( 801, meshTb );
3575 createTool( 806, meshTb );
3576 createTool( 802, meshTb );
3577 createTool( 803, meshTb );
3578 //createTool( 815, meshTb );
3579 createTool( separator(), meshTb );
3580 createTool( 900, meshTb );
3581 //createTool( 902, meshTb );
3582 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3583 createTool( 904, meshTb );
3584 createTool( separator(), meshTb );
3586 createTool( 6005, ctrlTb );
3587 createTool( separator(), ctrlTb );
3588 createTool( 6002, ctrlTb );
3589 createTool( 6003, ctrlTb );
3590 createTool( 6001, ctrlTb );
3591 createTool( 6004, ctrlTb );
3592 createTool( separator(), ctrlTb );
3593 createTool( 6021, ctrlTb );
3594 createTool( 6025, ctrlTb );
3595 createTool( 6027, ctrlTb );
3596 createTool( 6018, ctrlTb );
3597 createTool( 6019, ctrlTb );
3598 createTool( 6011, ctrlTb );
3599 createTool( 6012, ctrlTb );
3600 createTool( 6013, ctrlTb );
3601 createTool( 6014, ctrlTb );
3602 createTool( 6015, ctrlTb );
3603 createTool( 6016, ctrlTb );
3604 createTool( 6022, ctrlTb );
3605 createTool( separator(), ctrlTb );
3606 createTool( 6017, ctrlTb );
3607 createTool( 6009, ctrlTb );
3608 createTool( 6023, ctrlTb );
3609 createTool( 6024, ctrlTb );
3610 createTool( 6026, ctrlTb );
3611 createTool( separator(), ctrlTb );
3613 createTool( 4000, addRemTb );
3614 createTool( 4009, addRemTb );
3615 createTool( 4010, addRemTb );
3616 createTool( 4021, addRemTb );
3617 createTool( 4022, addRemTb );
3618 createTool( 4023, addRemTb );
3619 createTool( 4031, addRemTb );
3620 createTool( 4032, addRemTb );
3621 createTool( 4033, addRemTb );
3622 createTool( separator(), addRemTb );
3623 createTool( 4034, addRemTb );
3624 createTool( 4035, addRemTb );
3625 createTool( 4036, addRemTb );
3626 createTool( 4037, addRemTb );
3627 createTool( 4038, addRemTb );
3628 createTool( 4039, addRemTb );
3629 createTool( 4040, addRemTb );
3630 createTool( separator(), addRemTb );
3631 createTool( 4041, addRemTb );
3632 createTool( 4042, addRemTb );
3633 createTool( 4044, addRemTb );
3634 createTool( 4043, addRemTb );
3635 createTool( separator(), addRemTb );
3636 createTool( 4051, addRemTb );
3637 createTool( 4052, addRemTb );
3638 createTool( separator(), addRemTb );
3639 createTool( 4061, addRemTb );
3640 createTool( 4062, addRemTb );
3641 createTool( 4063, addRemTb );
3642 createTool( 4068, addRemTb );
3643 createTool( 4064, addRemTb );
3644 createTool( 4065, addRemTb );
3645 createTool( 4066, addRemTb );
3646 createTool( 4069, addRemTb );
3647 createTool( separator(), addRemTb );
3649 createTool( 4067,modifyTb );
3650 createTool( 407, modifyTb );
3651 createTool( 408, modifyTb );
3652 createTool( 409, modifyTb );
3653 createTool( 410, modifyTb );
3654 createTool( 411, modifyTb );
3655 createTool( 419, modifyTb );
3656 createTool( 412, modifyTb );
3657 createTool( 413, modifyTb );
3658 createTool( 416, modifyTb );
3659 createTool( 414, modifyTb );
3660 createTool( 415, modifyTb );
3661 createTool( 417, modifyTb );
3662 createTool( 418, modifyTb );
3664 createTool( 214, dispModeTb );
3666 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3667 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3670 QString OB = "'ObjectBrowser'",
3671 View = "'" + SVTK_Viewer::Type() + "'",
3673 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3674 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3675 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3676 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3677 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3678 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3679 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3680 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3681 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3682 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3683 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3685 mesh_group = mesh + " " + subMesh + " " + group,
3686 hyp_alg = hypo + " " + algo;
3688 // popup for object browser
3690 isInvisible("not( isVisible )"),
3691 isEmpty("numberOfNodes = 0"),
3692 isNotEmpty("numberOfNodes <> 0"),
3694 // has nodes, edges, etc in VISIBLE! actor
3695 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3696 hasElems("(count( elemTypes ) > 0)"),
3697 hasDifferentElems("(count( elemTypes ) > 1)"),
3698 hasElems0d("({'Elem0d'} in elemTypes)"),
3699 hasEdges("({'Edge'} in elemTypes)"),
3700 hasFaces("({'Face'} in elemTypes)"),
3701 hasVolumes("({'Volume'} in elemTypes)");
3703 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
3704 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
3705 //createPopupItem( 703, OB, subMesh, "&& isComputable" ); // CREATE_SUBMESH
3706 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
3707 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
3708 createPopupItem( 803, OB, group ); // EDIT_GROUP
3709 createPopupItem( 815, OB, group, "&& groupType = 'GroupOnGeom'" ); // EDIT_GROUP
3711 popupMgr()->insert( separator(), -1, 0 );
3712 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
3713 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3714 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
3715 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
3716 createPopupItem( 214, OB, mesh_group ); // UPDATE
3717 createPopupItem( 900, OB, mesh_group ); // ADV_INFO
3718 //createPopupItem( 902, OB, mesh ); // STD_INFO
3719 //createPopupItem( 903, OB, mesh_group ); // WHAT_IS // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3720 createPopupItem( 904, OB, mesh ); // FIND_ELEM
3721 popupMgr()->insert( separator(), -1, 0 );
3722 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
3723 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
3724 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
3725 popupMgr()->insert( separator(), -1, 0 );
3726 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
3727 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
3728 popupMgr()->insert( separator(), -1, 0 );
3729 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
3730 popupMgr()->insert( separator(), -1, 0 );
3731 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
3732 createPopupItem( 418, OB, mesh/*, "&& " + hasVolumes*/); // create 2D mesh on 3D
3733 popupMgr()->insert( separator(), -1, 0 );
3735 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3736 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3738 createPopupItem( 125, OB, mesh, multiple_non_empty ); // EXPORT_MED
3739 createPopupItem( 126, OB, mesh, only_one_non_empty ); // EXPORT_UNV
3740 createPopupItem( 141, OB, mesh, only_one_non_empty ); // EXPORT_STL
3741 //createPopupItem( 33, OB, subMesh + " " + group ); // DELETE
3742 createPopupItem( 33, OB, mesh_group + " " + hyp_alg ); // DELETE
3743 popupMgr()->insert( separator(), -1, 0 );
3746 createPopupItem( 803, View, group ); // EDIT_GROUP
3747 createPopupItem( 804, View, elems ); // ADD
3748 createPopupItem( 805, View, elems ); // REMOVE
3750 popupMgr()->insert( separator(), -1, 0 );
3751 createPopupItem( 214, View, mesh_group ); // UPDATE
3752 createPopupItem( 900, View, mesh_group ); // ADV_INFO
3753 //createPopupItem( 902, View, mesh ); // STD_INFO
3754 //createPopupItem( 903, View, mesh_group ); // WHAT_IS // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3755 createPopupItem( 904, View, mesh ); // FIND_ELEM
3756 popupMgr()->insert( separator(), -1, 0 );
3758 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3759 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
3760 popupMgr()->insert( separator(), -1, 0 );
3763 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3764 QString aType = QString( "%1type in {%2}" ).arg( lc );
3765 aType = aType.arg( mesh_group );
3766 QString aMeshInVTK = aClient + "&&" + aType;
3768 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3769 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3770 QString aSelCount = QString( "%1 > 0" ).arg( dc );
3772 //-------------------------------------------------
3774 //-------------------------------------------------
3775 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3777 popupMgr()->insert( action( 9010 ), anId, -1 );
3778 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3779 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
3781 popupMgr()->insert( action( 9011 ), anId, -1 );
3782 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
3783 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
3785 popupMgr()->insert( separator(), -1, -1 );
3787 //-------------------------------------------------
3789 //-------------------------------------------------
3790 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
3792 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
3793 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
3794 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
3796 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
3797 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
3798 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
3800 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
3801 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
3802 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
3804 popupMgr()->insert( separator(), anId, -1 );
3806 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
3807 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
3808 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
3810 //-------------------------------------------------
3812 //-------------------------------------------------
3813 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
3815 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
3817 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
3818 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
3819 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
3821 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
3822 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
3823 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
3825 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
3826 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
3827 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
3829 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
3830 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
3831 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
3833 popupMgr()->insert( separator(), anId, -1 );
3835 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
3836 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
3839 //-------------------------------------------------
3840 // Representation of the 2D Quadratic elements
3841 //-------------------------------------------------
3842 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
3843 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
3844 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
3845 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
3847 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
3848 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
3849 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
3851 //-------------------------------------------------
3852 // Orientation of faces
3853 //-------------------------------------------------
3854 popupMgr()->insert( action( 221 ), -1, -1 );
3855 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
3856 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
3858 //-------------------------------------------------
3860 //-------------------------------------------------
3861 popupMgr()->insert( action( 1132 ), -1, -1 );
3862 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3864 //-------------------------------------------------
3866 //-------------------------------------------------
3867 popupMgr()->insert( action( 1133 ), -1, -1 );
3868 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
3870 //-------------------------------------------------
3872 //-------------------------------------------------
3874 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
3875 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
3876 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
3877 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
3879 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
3881 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
3882 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3884 popupMgr()->insert( separator(), anId, -1 );
3886 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
3888 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
3889 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
3890 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
3892 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
3894 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
3895 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3896 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
3898 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
3899 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3900 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
3902 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
3903 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3904 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
3906 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
3907 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
3908 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
3910 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
3912 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
3913 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
3914 QtxPopupMgr::VisibleRule );
3915 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
3917 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
3918 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3919 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
3921 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
3922 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3923 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
3925 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
3926 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3927 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
3929 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
3930 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3931 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
3933 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
3934 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3935 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
3937 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
3938 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3939 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
3941 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
3942 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3943 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
3945 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
3946 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3947 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
3949 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
3950 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3951 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
3953 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
3954 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3955 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
3957 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
3958 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
3959 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
3961 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
3963 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
3964 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3965 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
3967 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
3968 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3969 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
3971 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
3972 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3973 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
3975 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
3976 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3977 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
3979 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
3980 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
3981 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
3983 popupMgr()->insert( separator(), anId, -1 );
3985 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
3986 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
3988 popupMgr()->insert( separator(), anId, -1 );
3990 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
3992 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
3993 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
3995 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
3996 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
3997 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
3999 #ifndef DISABLE_PLOT2DVIEWER
4000 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4001 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4004 //-------------------------------------------------
4006 //-------------------------------------------------
4007 popupMgr()->insert( separator(), -1, -1 );
4008 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4009 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4010 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4011 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4013 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4014 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4016 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4017 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4019 popupMgr()->insert( separator(), -1, -1 );
4021 //-------------------------------------------------
4023 //-------------------------------------------------
4024 popupMgr()->insert( action( 1134 ), -1, -1 );
4025 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4027 popupMgr()->insert( separator(), -1, -1 );
4029 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4030 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4032 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4033 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4036 //================================================================================
4038 * \brief Return true if SMESH or GEOM objects are selected.
4039 * Is called form LightApp_Module::activateModule() which clear selection if
4040 * not isSelectionCompatible()
4042 //================================================================================
4044 bool SMESHGUI::isSelectionCompatible()
4046 bool isCompatible = true;
4047 SALOME_ListIO selected;
4048 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4049 Sel->selectedObjects( selected );
4051 SALOME_ListIteratorOfListIO It( selected );
4052 for ( ; isCompatible && It.More(); It.Next())
4054 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4055 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4057 return isCompatible;
4061 bool SMESHGUI::reusableOperation( const int id )
4063 // compute, evaluate and precompute are not reusable operations
4064 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4067 bool SMESHGUI::activateModule( SUIT_Study* study )
4069 bool res = SalomeApp_Module::activateModule( study );
4071 setMenuShown( true );
4072 setToolShown( true );
4074 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4075 PyGILState_STATE gstate = PyGILState_Ensure();
4076 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4077 if(pluginsmanager==NULL)
4081 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4086 PyGILState_Release(gstate);
4087 // end of GEOM plugins loading
4089 // Reset actions accelerator keys
4090 action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4091 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4092 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4094 action( 33)->setEnabled(true); // Delete: Key_Delete
4096 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4097 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4098 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4099 if ( _PTR(Study) aStudy = s->studyDS()) {
4100 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4101 updateObjBrowser(); // objects can be removed
4104 // get all view currently opened in the study and connect their signals to
4105 // the corresponding slots of the class.
4106 SUIT_Desktop* aDesk = study->application()->desktop();
4108 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4109 SUIT_ViewWindow* wnd;
4110 foreach ( wnd, wndList )
4117 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4119 setMenuShown( false );
4120 setToolShown( false );
4122 EmitSignalCloseAllDialogs();
4124 // Unset actions accelerator keys
4125 action(111)->setShortcut(QKeySequence()); // Import DAT
4126 action(112)->setShortcut(QKeySequence()); // Import UNV
4127 action(113)->setShortcut(QKeySequence()); // Import MED
4129 action( 33)->setEnabled(false); // Delete: Key_Delete
4131 return SalomeApp_Module::deactivateModule( study );
4134 void SMESHGUI::studyClosed( SUIT_Study* s )
4136 SMESH::RemoveVisuData( s->id() );
4137 SalomeApp_Module::studyClosed( s );
4140 void SMESHGUI::OnGUIEvent()
4142 const QObject* obj = sender();
4143 if ( !obj || !obj->inherits( "QAction" ) )
4145 int id = actionId((QAction*)obj);
4150 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4152 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4153 if ( CORBA::is_nil( myComponentSMESH ) )
4155 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4157 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4158 return aGUI.myComponentSMESH;
4161 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4162 return myComponentSMESH;
4165 QString SMESHGUI::engineIOR() const
4167 CORBA::ORB_var anORB = getApp()->orb();
4168 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4169 return QString( anIOR.in() );
4172 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4174 SalomeApp_Module::contextMenuPopup( client, menu, title );
4176 selectionMgr()->selectedObjects( lst );
4177 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4178 Handle(SALOME_InteractiveObject) io = lst.First();
4179 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4180 _PTR(Study) study = appStudy->studyDS();
4181 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4183 QString aName = QString( obj->GetName().c_str() );
4184 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4185 aName.remove( (aName.length() - 1), 1 );
4191 LightApp_Selection* SMESHGUI::createSelection() const
4193 return new SMESHGUI_Selection();
4196 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4198 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4199 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4202 void SMESHGUI::viewManagers( QStringList& list ) const
4204 list.append( SVTK_Viewer::Type() );
4207 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4209 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4210 SMESH::UpdateSelectionProp( this );
4212 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4213 for(int i = 0; i < aViews.count() ; i++){
4214 SUIT_ViewWindow *sf = aViews[i];
4220 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4222 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4223 myClippingPlaneInfoMap.erase( theViewManager );
4226 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4228 theActor->AddObserver( SMESH::DeleteActorEvent,
4229 myEventCallbackCommand.GetPointer(),
4233 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4234 unsigned long theEvent,
4235 void* theClientData,
4238 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4239 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4240 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4241 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4242 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4243 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4244 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4245 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4246 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4247 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4248 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4249 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4250 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4251 if( anActor == *anIter3 ) {
4252 anActorList.erase( anIter3 );
4263 void SMESHGUI::createPreferences()
4265 // General tab ------------------------------------------------------------------------
4266 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4268 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4269 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4270 setPreferenceProperty( lim, "min", 0 );
4271 setPreferenceProperty( lim, "max", 100000000 );
4272 setPreferenceProperty( lim, "step", 1000 );
4273 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4275 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4276 setPreferenceProperty( qaGroup, "columns", 2 );
4277 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4278 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4279 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4280 setPreferenceProperty( prec, "min", 0 );
4281 setPreferenceProperty( prec, "max", 16 );
4283 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4284 setPreferenceProperty( dispgroup, "columns", 2 );
4285 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4287 modes.append( "Wireframe" );
4288 modes.append( "Shading" );
4289 modes.append( "Nodes" );
4290 modes.append( "Shrink" );
4291 QList<QVariant> indices;
4292 indices.append( 0 );
4293 indices.append( 1 );
4294 indices.append( 2 );
4295 indices.append( 3 );
4296 setPreferenceProperty( dispmode, "strings", modes );
4297 setPreferenceProperty( dispmode, "indexes", indices );
4299 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4300 setPreferenceProperty( arcgroup, "columns", 2 );
4301 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4302 QStringList quadraticModes;
4303 quadraticModes.append("Lines");
4304 quadraticModes.append("Arcs");
4306 indices.append( 0 );
4307 indices.append( 1 );
4308 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4309 setPreferenceProperty( quadraticmode, "indexes", indices );
4311 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4312 "SMESH", "max_angle" );
4313 setPreferenceProperty( maxAngle, "min", 1 );
4314 setPreferenceProperty( maxAngle, "max", 90 );
4318 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4319 setPreferenceProperty( exportgroup, "columns", 2 );
4320 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4321 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4323 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4324 setPreferenceProperty( computeGroup, "columns", 2 );
4325 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4327 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4328 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4329 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4331 indices.append( 0 );
4332 indices.append( 1 );
4333 indices.append( 2 );
4334 setPreferenceProperty( notifyMode, "strings", modes );
4335 setPreferenceProperty( notifyMode, "indexes", indices );
4337 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4338 setPreferenceProperty( computeGroup, "columns", 2 );
4339 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4341 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4342 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4344 indices.append( 0 );
4345 indices.append( 1 );
4346 setPreferenceProperty( elemInfo, "strings", modes );
4347 setPreferenceProperty( elemInfo, "indexes", indices );
4349 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4350 setPreferenceProperty( segGroup, "columns", 2 );
4351 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4352 "SMESH", "segmentation" );
4353 setPreferenceProperty( segLen, "min", 1 );
4354 setPreferenceProperty( segLen, "max", 10000000 );
4355 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4356 "SMESH", "nb_segments_per_edge" );
4357 setPreferenceProperty( nbSeg, "min", 1 );
4358 setPreferenceProperty( nbSeg, "max", 10000000 );
4360 // Quantities with individual precision settings
4361 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4362 setPreferenceProperty( precGroup, "columns", 2 );
4364 const int nbQuantities = 6;
4365 int precs[nbQuantities], ii = 0;
4366 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4367 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4368 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4369 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4370 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4371 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4372 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4373 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4374 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4375 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4376 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4377 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4379 // Set property for precision value for spinboxes
4380 for ( ii = 0; ii < nbQuantities; ii++ ){
4381 setPreferenceProperty( precs[ii], "min", -14 );
4382 setPreferenceProperty( precs[ii], "max", 14 );
4383 setPreferenceProperty( precs[ii], "precision", 2 );
4386 // Mesh tab ------------------------------------------------------------------------
4387 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4388 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4389 setPreferenceProperty( nodeGroup, "columns", 3 );
4391 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4393 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4395 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4396 QList<QVariant> aMarkerTypeIndicesList;
4397 QList<QVariant> aMarkerTypeIconsList;
4398 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4399 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4400 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4401 aMarkerTypeIndicesList << i;
4402 aMarkerTypeIconsList << pixmap;
4404 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4405 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4407 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4409 QList<QVariant> aMarkerScaleIndicesList;
4410 QStringList aMarkerScaleValuesList;
4411 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4412 aMarkerScaleIndicesList << i;
4413 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4415 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4416 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4418 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4419 setPreferenceProperty( elemGroup, "columns", 2 );
4421 addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
4422 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4423 addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
4424 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4426 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4427 setPreferenceProperty( grpGroup, "columns", 2 );
4429 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4431 //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4432 //setPreferenceProperty( sp, "hstretch", 0 );
4433 //setPreferenceProperty( sp, "vstretch", 0 );
4435 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4436 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4437 int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
4438 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4439 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4440 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4441 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4443 setPreferenceProperty( size0d, "min", 1 );
4444 setPreferenceProperty( size0d, "max", 10 );
4446 setPreferenceProperty( sp, "hstretch", 0 );
4447 setPreferenceProperty( sp, "vstretch", 0 );
4449 setPreferenceProperty( elemW, "min", 1 );
4450 setPreferenceProperty( elemW, "max", 5 );
4452 setPreferenceProperty( shrink, "min", 0 );
4453 setPreferenceProperty( shrink, "max", 100 );
4455 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4456 setPreferenceProperty( orientGroup, "columns", 1 );
4458 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4459 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4461 setPreferenceProperty( orientScale, "min", 0.05 );
4462 setPreferenceProperty( orientScale, "max", 0.5 );
4463 setPreferenceProperty( orientScale, "step", 0.05 );
4465 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4467 // Selection tab ------------------------------------------------------------------------
4468 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4470 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4471 setPreferenceProperty( selGroup, "columns", 2 );
4473 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4474 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4475 int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );
4477 setPreferenceProperty( selW, "min", 1 );
4478 setPreferenceProperty( selW, "max", 5 );
4480 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4481 setPreferenceProperty( preGroup, "columns", 2 );
4483 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4484 int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );
4486 setPreferenceProperty( preW, "min", 1 );
4487 setPreferenceProperty( preW, "max", 5 );
4489 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4490 setPreferenceProperty( precSelGroup, "columns", 2 );
4492 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4493 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4494 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4496 // Scalar Bar tab ------------------------------------------------------------------------
4497 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4498 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4499 setPreferenceProperty( fontGr, "columns", 2 );
4501 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4502 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4504 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4505 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4507 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4508 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4510 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4511 setPreferenceProperty( numcol, "min", 2 );
4512 setPreferenceProperty( numcol, "max", 256 );
4514 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4515 setPreferenceProperty( numlab, "min", 2 );
4516 setPreferenceProperty( numlab, "max", 65 );
4518 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4519 setPreferenceProperty( orientGr, "columns", 2 );
4520 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4521 QStringList orients;
4522 orients.append( tr( "SMESH_VERTICAL" ) );
4523 orients.append( tr( "SMESH_HORIZONTAL" ) );
4524 indices.clear(); indices.append( 0 ); indices.append( 1 );
4525 setPreferenceProperty( orient, "strings", orients );
4526 setPreferenceProperty( orient, "indexes", indices );
4528 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4529 setPreferenceProperty( posVSizeGr, "columns", 2 );
4530 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4531 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4532 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4533 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4534 setPreferenceProperty( xv, "step", 0.1 );
4535 setPreferenceProperty( xv, "min", 0.0 );
4536 setPreferenceProperty( xv, "max", 1.0 );
4537 setPreferenceProperty( yv, "step", 0.1 );
4538 setPreferenceProperty( yv, "min", 0.0 );
4539 setPreferenceProperty( yv, "max", 1.0 );
4540 setPreferenceProperty( wv, "step", 0.1 );
4541 setPreferenceProperty( wv, "min", 0.0 );
4542 setPreferenceProperty( wv, "max", 1.0 );
4543 setPreferenceProperty( hv, "min", 0.0 );
4544 setPreferenceProperty( hv, "max", 1.0 );
4545 setPreferenceProperty( hv, "step", 0.1 );
4547 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4548 setPreferenceProperty( posHSizeGr, "columns", 2 );
4549 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4550 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4551 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4552 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4553 setPreferenceProperty( xv, "min", 0.0 );
4554 setPreferenceProperty( xv, "max", 1.0 );
4555 setPreferenceProperty( xv, "step", 0.1 );
4556 setPreferenceProperty( xh, "min", 0.0 );
4557 setPreferenceProperty( xh, "max", 1.0 );
4558 setPreferenceProperty( xh, "step", 0.1 );
4559 setPreferenceProperty( yh, "min", 0.0 );
4560 setPreferenceProperty( yh, "max", 1.0 );
4561 setPreferenceProperty( yh, "step", 0.1 );
4562 setPreferenceProperty( wh, "min", 0.0 );
4563 setPreferenceProperty( wh, "max", 1.0 );
4564 setPreferenceProperty( wh, "step", 0.1 );
4565 setPreferenceProperty( hh, "min", 0.0 );
4566 setPreferenceProperty( hh, "max", 1.0 );
4567 setPreferenceProperty( hh, "step", 0.1 );
4569 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4570 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4571 setPreferenceProperty( distributionGr, "columns", 3 );
4573 types.append( tr( "SMESH_MONOCOLOR" ) );
4574 types.append( tr( "SMESH_MULTICOLOR" ) );
4575 indices.clear(); indices.append( 0 ); indices.append( 1 );
4576 setPreferenceProperty( coloringType, "strings", types );
4577 setPreferenceProperty( coloringType, "indexes", indices );
4578 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4582 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4584 if( sect=="SMESH" ) {
4585 float sbX1,sbY1,sbW,sbH;
4586 float aTol = 1.00000009999999;
4587 std::string aWarning;
4588 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4589 if( name=="selection_object_color" || name=="selection_element_color" ||
4590 name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
4591 name=="selection_precision_node" || name=="selection_precision_element" ||
4592 name=="selection_precision_object")
4593 SMESH::UpdateSelectionProp( this );
4594 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4595 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4596 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4597 if(sbX1+sbW > aTol){
4598 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4601 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4602 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4605 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4606 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4607 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4608 if(sbY1+sbH > aTol){
4609 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4610 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4611 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4614 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4615 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4616 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4617 if(sbX1+sbW > aTol){
4618 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4621 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4622 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4625 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4626 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4627 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4628 if(sbY1+sbH > aTol){
4629 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4632 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4633 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4636 else if ( name == "segmentation" ) {
4637 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4638 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4640 else if ( name == "nb_segments_per_edge" ) {
4641 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4642 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4645 if(aWarning.size() != 0){
4646 aWarning += "The default values are applied instead.";
4647 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4648 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4649 QObject::tr(aWarning.c_str()));
4654 //================================================================================
4656 * \brief Update something in accordance with update flags
4657 * \param theFlags - update flags
4659 * Update viewer or/and object browser etc. in accordance with update flags ( see
4660 * LightApp_UpdateFlags enumeration ).
4662 //================================================================================
4663 void SMESHGUI::update( const int flags )
4665 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4666 SMESH::UpdateView();
4668 SalomeApp_Module::update( flags );
4671 //================================================================================
4673 * \brief Set default selection mode
4675 * SLOT called when operation commited. Sets default selection mode
4677 //================================================================================
4678 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4680 SVTK_ViewWindow* vtkWnd =
4681 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4683 vtkWnd->SetSelectionMode( ActorSelection );
4686 //================================================================================
4688 * \brief Set default selection mode
4690 * SLOT called when operation aborted. Sets default selection mode
4692 //================================================================================
4693 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4695 SVTK_ViewWindow* vtkWnd =
4696 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4698 vtkWnd->SetSelectionMode( ActorSelection );
4701 //================================================================================
4703 * \brief Creates operation with given identifier
4704 * \param id - identifier of operation to be started
4705 * \return Pointer on created operation or NULL if operation is not created
4707 * Virtual method redefined from the base class creates operation with given id.
4708 * It is called called automatically from startOperation method of base class.
4710 //================================================================================
4711 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4713 LightApp_Operation* op = 0;
4714 // to do : create operation here
4717 case 417: //convert to quadratic
4718 op = new SMESHGUI_ConvToQuadOp();
4720 case 418: // create 2D mesh as boundary on 3D
4721 op = new SMESHGUI_Make2DFrom3DOp();
4723 case 701: // Compute mesh
4724 op = new SMESHGUI_ComputeOp();
4726 case 702: // Create mesh
4727 op = new SMESHGUI_MeshOp( true, true );
4729 case 703: // Create sub-mesh
4730 op = new SMESHGUI_MeshOp( true, false );
4732 case 704: // Edit mesh/sub-mesh
4733 op = new SMESHGUI_MeshOp( false );
4735 case 711: // Precompute mesh
4736 op = new SMESHGUI_PrecomputeOp();
4738 case 712: // Evaluate mesh
4739 op = new SMESHGUI_EvaluateOp();
4741 case 713: // Evaluate mesh
4742 op = new SMESHGUI_MeshOrderOp();
4744 case 806: // Create group on geom
4745 op = new SMESHGUI_GroupOnShapeOp();
4747 case 904: // Find element
4748 op = new SMESHGUI_FindElemByPointOp();
4750 case 4067: // make mesh pass through point
4751 op = new SMESHGUI_MakeNodeAtPointOp();
4758 op = SalomeApp_Module::createOperation( id );
4762 //================================================================================
4764 * \brief Stops current operations and starts a given one
4765 * \param id - The id of the operation to start
4767 //================================================================================
4769 void SMESHGUI::switchToOperation(int id)
4771 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
4772 activeStudy()->abortAllOperations();
4773 startOperation( id );
4776 LightApp_Displayer* SMESHGUI::displayer()
4779 myDisplayer = new SMESHGUI_Displayer( getApp() );
4783 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
4786 int aTolerance = 64;
4787 int anIterations = 0;
4793 if( anIterations % aPeriod == 0 )
4796 if( aTolerance < 1 )
4800 aHue = (int)( 360.0 * rand() / RAND_MAX );
4803 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
4804 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
4805 for( ; it != itEnd; ++it )
4807 SALOMEDS::Color anAutoColor = *it;
4808 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
4811 aQColor.getHsv( &h, &s, &v );
4812 if( abs( h - aHue ) < aTolerance )
4824 aColor.setHsv( aHue, 255, 255 );
4826 SALOMEDS::Color aSColor;
4827 aSColor.R = (double)aColor.red() / 255.0;
4828 aSColor.G = (double)aColor.green() / 255.0;
4829 aSColor.B = (double)aColor.blue() / 255.0;
4834 const char gSeparator = '_'; // character used to separate parameter names
4835 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
4836 const char gPathSep = '|'; // character used to separate paths
4839 * \brief Store visual parameters
4841 * This method is called just before the study document is saved.
4842 * Store visual parameters in AttributeParameter attribue(s)
4844 void SMESHGUI::storeVisualParameters (int savePoint)
4846 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
4847 if (!appStudy || !appStudy->studyDS())
4849 _PTR(Study) studyDS = appStudy->studyDS();
4851 // componentName is used for encoding of entries when storing them in IParameters
4852 std::string componentName = myComponentSMESH->ComponentDataType();
4853 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
4854 //if (!aSComponent) return;
4857 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
4858 componentName.c_str(),
4860 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
4862 // store map of custom markers
4863 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
4864 if( !aMarkerMap.empty() )
4866 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
4867 for( ; anIter != aMarkerMap.end(); anIter++ )
4869 int anId = anIter->first;
4870 VTK::MarkerData aMarkerData = anIter->second;
4871 std::string aMarkerFileName = aMarkerData.first;
4872 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
4873 if( aMarkerTexture.size() < 3 )
4874 continue; // should contain at least width, height and the first value
4876 QString aPropertyName( "texture" );
4877 aPropertyName += gSeparator;
4878 aPropertyName += QString::number( anId );
4880 QString aPropertyValue = aMarkerFileName.c_str();
4881 aPropertyValue += gPathSep;
4883 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
4884 ushort aWidth = *aTextureIter++;
4885 ushort aHeight = *aTextureIter++;
4886 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
4887 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
4888 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
4889 aPropertyValue += QString::number( *aTextureIter );
4891 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4895 // viewers counters are used for storing view_numbers in IParameters
4898 // main cycle to store parameters of displayed objects
4899 QList<SUIT_ViewManager*> lst;
4900 QList<SUIT_ViewManager*>::Iterator it;
4901 getApp()->viewManagers(lst);
4902 for (it = lst.begin(); it != lst.end(); it++)
4904 SUIT_ViewManager* vman = *it;
4905 QString vType = vman->getType();
4907 // saving VTK actors properties
4908 if (vType == SVTK_Viewer::Type())
4910 // store the clipping planes attached to the view manager
4911 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
4912 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
4913 if( anIter != myClippingPlaneInfoMap.end() )
4914 aClippingPlaneInfoList = anIter->second;
4916 if( !aClippingPlaneInfoList.empty() ) {
4917 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
4918 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
4920 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
4921 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
4923 QString aPropertyName( "ClippingPlane" );
4924 aPropertyName += gSeparator;
4925 aPropertyName += QString::number( vtkViewers );
4926 aPropertyName += gSeparator;
4927 aPropertyName += QString::number( anId );
4929 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
4930 aPropertyValue += gDigitsSep;
4931 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
4932 aPropertyValue += gDigitsSep;
4933 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
4934 aPropertyValue += gDigitsSep;
4935 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
4937 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
4941 QVector<SUIT_ViewWindow*> views = vman->getViews();
4942 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
4944 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
4946 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
4947 vtkActorCollection* allActors = aCopy.GetActors();
4948 allActors->InitTraversal();
4949 while (vtkActor* actor = allActors->GetNextActor())
4951 if (actor->GetVisibility()) // store only visible actors
4953 SMESH_Actor* aSmeshActor = 0;
4954 if (actor->IsA("SMESH_Actor"))
4955 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
4956 if (aSmeshActor && aSmeshActor->hasIO())
4958 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
4961 // entry is "encoded" = it does NOT contain component adress,
4962 // since it is a subject to change on next component loading
4963 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
4965 std::string param, vtkParam = vType.toLatin1().data();
4966 vtkParam += gSeparator;
4967 vtkParam += QString::number(vtkViewers).toLatin1().data();
4968 vtkParam += gSeparator;
4971 param = vtkParam + "Visibility";
4972 ip->setParameter(entry, param, "On");
4975 param = vtkParam + "Representation";
4976 ip->setParameter(entry, param, QString::number
4977 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
4980 param = vtkParam + "IsShrunk";
4981 ip->setParameter(entry, param, QString::number
4982 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
4984 // Displayed entities
4985 unsigned int aMode = aSmeshActor->GetEntityMode();
4986 bool isE = aMode & SMESH_Actor::eEdges;
4987 bool isF = aMode & SMESH_Actor::eFaces;
4988 bool isV = aMode & SMESH_Actor::eVolumes;
4990 QString modeStr ("e");
4991 modeStr += gDigitsSep; modeStr += QString::number(isE);
4992 modeStr += gDigitsSep; modeStr += "f";
4993 modeStr += gDigitsSep; modeStr += QString::number(isF);
4994 modeStr += gDigitsSep; modeStr += "v";
4995 modeStr += gDigitsSep; modeStr += QString::number(isV);
4997 param = vtkParam + "Entities";
4998 ip->setParameter(entry, param, modeStr.toLatin1().data());
5000 // Colors (surface:edge:)
5001 vtkFloatingPointType r, g, b;
5003 aSmeshActor->GetSufaceColor(r, g, b);
5004 QString colorStr ("surface");
5005 colorStr += gDigitsSep; colorStr += QString::number(r);
5006 colorStr += gDigitsSep; colorStr += QString::number(g);
5007 colorStr += gDigitsSep; colorStr += QString::number(b);
5009 aSmeshActor->GetBackSufaceColor(r, g, b);
5010 colorStr += gDigitsSep; colorStr += "backsurface";
5011 colorStr += gDigitsSep; colorStr += QString::number(r);
5012 colorStr += gDigitsSep; colorStr += QString::number(g);
5013 colorStr += gDigitsSep; colorStr += QString::number(b);
5015 aSmeshActor->GetEdgeColor(r, g, b);
5016 colorStr += gDigitsSep; colorStr += "edge";
5017 colorStr += gDigitsSep; colorStr += QString::number(r);
5018 colorStr += gDigitsSep; colorStr += QString::number(g);
5019 colorStr += gDigitsSep; colorStr += QString::number(b);
5021 aSmeshActor->GetNodeColor(r, g, b);
5022 colorStr += gDigitsSep; colorStr += "node";
5023 colorStr += gDigitsSep; colorStr += QString::number(r);
5024 colorStr += gDigitsSep; colorStr += QString::number(g);
5025 colorStr += gDigitsSep; colorStr += QString::number(b);
5027 param = vtkParam + "Colors";
5028 ip->setParameter(entry, param, colorStr.toLatin1().data());
5030 // Sizes of lines and points
5031 QString sizeStr ("line");
5032 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5033 sizeStr += gDigitsSep; sizeStr += "shrink";
5034 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5036 param = vtkParam + "Sizes";
5037 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5042 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5043 if( aMarkerType == VTK::MT_USER ) {
5044 markerStr += "custom";
5045 markerStr += gDigitsSep;
5046 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5050 markerStr += gDigitsSep;
5051 markerStr += QString::number( (int)aMarkerType );
5052 markerStr += gDigitsSep;
5053 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5056 param = vtkParam + "PointMarker";
5057 ip->setParameter(entry, param, markerStr.toLatin1().data());
5060 param = vtkParam + "Opacity";
5061 ip->setParameter(entry, param,
5062 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5065 param = vtkParam + "ClippingPlane";
5067 if( !aClippingPlaneInfoList.empty() ) {
5068 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5069 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5071 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5072 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5073 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5074 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5075 if( aSmeshActor == *anIter2 ) {
5076 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5077 QString::number( anId ).toLatin1().constData() );
5084 ip->setParameter( entry, param, "Off" );
5085 } // if (io->hasEntry())
5086 } // SMESH_Actor && hasIO
5088 } // while.. actors traversal
5092 } // if (SVTK view model)
5093 } // for (viewManagers)
5096 // data structures for clipping planes processing
5099 vtkIdType Orientation;
5100 vtkFloatingPointType Distance;
5101 vtkFloatingPointType Angle[2];
5103 typedef std::list<TPlaneData> TPlaneDataList;
5104 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5106 typedef std::list<vtkActor*> TActorList;
5109 TActorList ActorList;
5110 SUIT_ViewManager* ViewManager;
5112 typedef std::list<TPlaneInfo> TPlaneInfoList;
5113 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5116 * \brief Restore visual parameters
5118 * This method is called after the study document is opened.
5119 * Restore visual parameters from AttributeParameter attribue(s)
5121 void SMESHGUI::restoreVisualParameters (int savePoint)
5123 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5124 if (!appStudy || !appStudy->studyDS())
5126 _PTR(Study) studyDS = appStudy->studyDS();
5128 // componentName is used for encoding of entries when storing them in IParameters
5129 std::string componentName = myComponentSMESH->ComponentDataType();
5130 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5131 //if (!aSComponent) return;
5134 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5135 componentName.c_str(),
5137 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5139 // restore map of custom markers and map of clipping planes
5140 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5141 TPlaneDataMap aPlaneDataMap;
5143 std::vector<std::string> properties = ip->getProperties();
5144 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5146 std::string property = *propIt;
5147 QString aPropertyName( property.c_str() );
5148 QString aPropertyValue( ip->getProperty( property ).c_str() );
5150 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5151 if( aPropertyNameList.isEmpty() )
5154 QString aPropertyType = aPropertyNameList[0];
5155 if( aPropertyType == "texture" )
5157 if( aPropertyNameList.size() != 2 )
5161 int anId = aPropertyNameList[1].toInt( &ok );
5162 if( !ok || anId < 1 )
5165 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5166 if( aPropertyValueList.size() != 2 )
5169 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5170 QString aMarkerTextureString = aPropertyValueList[1];
5171 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5172 if( aMarkerTextureStringList.size() != 3 )
5176 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5181 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5185 VTK::MarkerTexture aMarkerTexture;
5186 aMarkerTexture.push_back( aWidth );
5187 aMarkerTexture.push_back( aHeight );
5189 QString aMarkerTextureData = aMarkerTextureStringList[2];
5190 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5192 QChar aChar = aMarkerTextureData.at( i );
5193 if( aChar.isDigit() )
5194 aMarkerTexture.push_back( aChar.digitValue() );
5197 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5199 else if( aPropertyType == "ClippingPlane" )
5201 if( aPropertyNameList.size() != 3 )
5205 int aViewId = aPropertyNameList[1].toInt( &ok );
5206 if( !ok || aViewId < 0 )
5210 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5211 if( !ok || aClippingPlaneId < 0 )
5214 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5215 if( aPropertyValueList.size() != 4 )
5218 TPlaneData aPlaneData;
5219 aPlaneData.Id = aClippingPlaneId;
5222 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5227 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5232 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5237 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5241 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5242 aPlaneDataList.push_back( aPlaneData );
5246 TPlaneInfoMap aPlaneInfoMap;
5248 std::vector<std::string> entries = ip->getEntries();
5250 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5252 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5253 QString entry (ip->decodeEntry(*entIt).c_str());
5255 // Check that the entry corresponds to a real object in the Study
5256 // as the object may be deleted or modified after the visual state is saved.
5257 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5258 if (!so) continue; //Skip the not existent entry
5260 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5261 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5263 std::vector<std::string>::iterator namesIt = paramNames.begin();
5264 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5266 // actors are stored in a map after displaying of them for
5267 // quicker access in the future: map < viewID to actor >
5268 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5270 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5272 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5273 // '_' is used as separator and should not be used in viewer type or parameter names.
5274 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5275 if (lst.size() != 3)
5278 QString viewerTypStr = lst[0];
5279 QString viewIndexStr = lst[1];
5280 QString paramNameStr = lst[2];
5283 int viewIndex = viewIndexStr.toUInt(&ok);
5284 if (!ok) // bad conversion of view index to integer
5288 if (viewerTypStr == SVTK_Viewer::Type())
5290 SMESH_Actor* aSmeshActor = 0;
5291 if (vtkActors.IsBound(viewIndex))
5292 aSmeshActor = vtkActors.Find(viewIndex);
5294 QList<SUIT_ViewManager*> lst;
5295 getApp()->viewManagers(viewerTypStr, lst);
5297 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5298 SUIT_ViewManager* vman = NULL;
5299 if (viewIndex >= 0 && viewIndex < lst.count())
5300 vman = lst.at(viewIndex);
5302 if (paramNameStr == "Visibility")
5304 if (!aSmeshActor && displayer() && vman)
5306 SUIT_ViewModel* vmodel = vman->getViewModel();
5307 // SVTK view model can be casted to SALOME_View
5308 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5310 // store displayed actor in a temporary map for quicker
5311 // access later when restoring other parameters
5312 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5313 vtkRenderer* Renderer = vtkView->getRenderer();
5314 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5315 vtkActorCollection* theActors = aCopy.GetActors();
5316 theActors->InitTraversal();
5317 bool isFound = false;
5318 vtkActor *ac = theActors->GetNextActor();
5319 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5320 if (ac->IsA("SMESH_Actor")) {
5321 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5322 if (aGeomAc->hasIO()) {
5323 Handle(SALOME_InteractiveObject) io =
5324 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5325 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5327 vtkActors.Bind(viewIndex, aGeomAc);
5333 } // if (paramNameStr == "Visibility")
5336 // the rest properties "work" with SMESH_Actor
5339 QString val ((*valuesIt).c_str());
5342 if (paramNameStr == "Representation") {
5343 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5346 else if (paramNameStr == "IsShrunk") {
5348 if (!aSmeshActor->IsShrunk())
5349 aSmeshActor->SetShrink();
5352 if (aSmeshActor->IsShrunk())
5353 aSmeshActor->UnShrink();
5356 // Displayed entities
5357 else if (paramNameStr == "Entities") {
5358 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5359 if (mode.count() == 6) {
5360 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5361 MESSAGE("Invalid order of data in Entities, must be: "
5362 "e:0/1:f:0/1:v:0/1");
5365 unsigned int aMode = aSmeshActor->GetEntityMode();
5366 unsigned int aNewMode =
5367 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5368 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5369 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5370 if (aNewMode != aMode)
5371 aSmeshActor->SetEntityMode(aNewMode);
5376 else if (paramNameStr == "Colors") {
5377 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5378 if (colors.count() == 16) {
5379 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5380 colors[8] != "edge" || colors[12] != "node") {
5381 MESSAGE("Invalid order of data in Colors, must be: "
5382 "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
5385 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
5386 aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
5387 aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
5388 aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
5392 // Sizes of lines and points
5393 else if (paramNameStr == "Sizes") {
5394 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5395 if (sizes.count() == 4) {
5396 if (sizes[0] != "line" || sizes[2] != "shrink") {
5397 MESSAGE("Invalid order of data in Sizes, must be: "
5398 "line:int:shrink:float");
5401 aSmeshActor->SetLineWidth(sizes[1].toInt());
5402 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5405 else if (sizes.count() == 6) { // just to support old format
5406 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5407 MESSAGE("Invalid order of data in Sizes, must be: "
5408 "line:int:node:int:shrink:float");
5411 aSmeshActor->SetLineWidth(sizes[1].toInt());
5412 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5413 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5418 else if (paramNameStr == "PointMarker") {
5419 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5420 if( data.count() >= 2 ) {
5422 int aParam1 = data[1].toInt( &ok );
5424 if( data[0] == "std" && data.count() == 3 ) {
5425 int aParam2 = data[2].toInt( &ok );
5426 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5428 else if( data[0] == "custom" ) {
5429 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5430 if( markerIt != aMarkerMap.end() ) {
5431 VTK::MarkerData aMarkerData = markerIt->second;
5432 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5439 else if (paramNameStr == "Opacity") {
5440 aSmeshActor->SetOpacity(val.toFloat());
5443 else if (paramNameStr.startsWith("ClippingPlane")) {
5444 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5445 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5446 // new format - val looks like "Off" or "0" (plane id)
5447 // (note: in new format "Off" value is used only for consistency,
5448 // so it is processed together with values in old format)
5449 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5450 if( anIsOldFormat ) {
5451 if (paramNameStr == "ClippingPlane1" || val == "Off")
5452 aSmeshActor->RemoveAllClippingPlanes();
5454 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5455 double aDistance = vals[1].toFloat();
5456 vtkFloatingPointType anAngle[2];
5457 anAngle[0] = vals[2].toFloat();
5458 anAngle[1] = vals[3].toFloat();
5460 QList<SUIT_ViewManager*> lst;
5461 getApp()->viewManagers(viewerTypStr, lst);
5462 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5463 if (viewIndex >= 0 && viewIndex < lst.count()) {
5464 SUIT_ViewManager* vman = lst.at(viewIndex);
5465 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5467 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5469 SMESH::TActorList anActorList;
5470 anActorList.push_back( aSmeshActor );
5471 SMESH::OrientedPlane* aPlane =
5472 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5474 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5475 aClippingPlaneInfo.Plane = aPlane;
5476 aClippingPlaneInfo.ActorList = anActorList;
5477 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5484 int aPlaneId = val.toInt( &ok );
5485 if( ok && aPlaneId >= 0 ) {
5486 bool anIsDefinedPlane = false;
5487 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5488 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5489 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5490 TPlaneInfo& aPlaneInfo = *anIter;
5491 if( aPlaneInfo.PlaneId == aPlaneId ) {
5492 aPlaneInfo.ActorList.push_back( aSmeshActor );
5493 anIsDefinedPlane = true;
5497 if( !anIsDefinedPlane ) {
5498 TPlaneInfo aPlaneInfo;
5499 aPlaneInfo.PlaneId = aPlaneId;
5500 aPlaneInfo.ActorList.push_back( aSmeshActor );
5501 aPlaneInfo.ViewManager = vman;
5503 // to make the list sorted by plane id
5504 anIter = aPlaneInfoList.begin();
5505 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5506 const TPlaneInfo& aPlaneInfoRef = *anIter;
5507 if( aPlaneInfoRef.PlaneId > aPlaneId )
5510 aPlaneInfoList.insert( anIter, aPlaneInfo );
5515 } // if (aSmeshActor)
5516 } // other parameters than Visibility
5518 } // for names/parameters iterator
5519 } // for entries iterator
5521 // take into account planes with empty list of actors referred to them
5522 QList<SUIT_ViewManager*> aVMList;
5523 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5525 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5526 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5527 int aViewId = aPlaneDataIter->first;
5528 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5529 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5531 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5533 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5534 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5535 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5536 const TPlaneData& aPlaneData = *anIter2;
5537 int aPlaneId = aPlaneData.Id;
5539 bool anIsFound = false;
5540 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5541 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5542 const TPlaneInfo& aPlaneInfo = *anIter3;
5543 if( aPlaneInfo.PlaneId == aPlaneId ) {
5550 TPlaneInfo aPlaneInfo; // ActorList field is empty
5551 aPlaneInfo.PlaneId = aPlaneId;
5552 aPlaneInfo.ViewManager = aViewManager;
5554 // to make the list sorted by plane id
5555 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5556 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5557 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5558 if( aPlaneInfoRef.PlaneId > aPlaneId )
5561 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5567 // add clipping planes to actors according to the restored parameters
5568 // and update the clipping plane map
5569 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5570 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5571 int aViewId = anIter1->first;
5572 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5574 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5575 if( anIter2 == aPlaneDataMap.end() )
5577 const TPlaneDataList& aPlaneDataList = anIter2->second;
5579 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5580 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5581 const TPlaneInfo& aPlaneInfo = *anIter3;
5582 int aPlaneId = aPlaneInfo.PlaneId;
5583 const TActorList& anActorList = aPlaneInfo.ActorList;
5584 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5588 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5592 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5594 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5595 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5596 const TPlaneData& aPlaneData = *anIter4;
5597 if( aPlaneData.Id == aPlaneId ) {
5598 SMESH::OrientedPlane* aPlane =
5599 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5601 (SMESH::Orientation)aPlaneData.Orientation,
5602 aPlaneData.Distance,
5605 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5606 aClippingPlaneInfo.Plane = aPlane;
5607 aClippingPlaneInfo.ActorList = anActorList;
5608 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5616 // update all VTK views
5617 QList<SUIT_ViewManager*> lst;
5618 getApp()->viewManagers(lst);
5619 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5620 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5621 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5622 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5623 vtkView->getRenderer()->ResetCameraClippingRange();
5630 \brief Adds preferences for dfont of VTK viewer
5632 \param pIf group identifier
5633 \param param parameter
5634 \return identifier of preferences
5636 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5638 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "VISU", param );
5640 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5643 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5644 fam.append( tr( "SMESH_FONT_COURIER" ) );
5645 fam.append( tr( "SMESH_FONT_TIMES" ) );
5647 setPreferenceProperty( tfont, "fonts", fam );
5649 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5650 setPreferenceProperty( tfont, "features", f );
5656 \brief Actions after hypothesis edition
5657 Updates object browser after hypothesis edition
5659 void SMESHGUI::onHypothesisEdit( int result )
5662 SMESHGUI::Modified();
5663 updateObjBrowser( true );
5668 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5669 \param pview view being closed
5671 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5672 #ifndef DISABLE_PLOT2DVIEWER
5673 //Crear all Plot2d Viewers if need.
5674 SMESH::ClearPlot2Viewers(pview);
5679 \brief Connects or disconnects signals about activating and cloning view on the module slots
5680 \param pview view which is connected/disconnected
5682 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
5686 SUIT_ViewManager* viewMgr = pview->getViewManager();
5688 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5689 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5691 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
5692 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
5697 \brief Return \c true if object can be renamed
5699 bool SMESHGUI::renameAllowed( const QString& entry) const {
5700 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5704 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5708 bool appRes = SalomeApp_Module::renameAllowed(entry);
5712 // check type to prevent renaming of inappropriate objects
5713 int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
5714 if (aType == MESH || aType == GROUP ||
5715 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5716 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5717 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5718 aType == HYPOTHESIS || aType == ALGORITHM)
5725 Rename object by entry.
5726 \param entry entry of the object
5727 \param name new name of the object
5728 \brief Return \c true if rename operation finished successfully, \c false otherwise.
5730 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
5732 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
5736 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
5740 bool appRes = SalomeApp_Module::renameObject(entry,name);
5744 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
5745 _PTR(GenericAttribute) anAttr;
5746 _PTR(AttributeName) aName;
5748 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
5750 // check type to prevent renaming of inappropriate objects
5751 int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
5752 if (aType == MESH || aType == GROUP ||
5753 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
5754 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
5755 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
5756 aType == HYPOTHESIS || aType == ALGORITHM) {
5757 if ( !name.isEmpty() ) {
5758 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
5760 // update name of group object and its actor
5761 Handle(SALOME_InteractiveObject) IObject =
5762 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
5764 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
5765 if( !aGroupObject->_is_nil() ) {
5766 aGroupObject->SetName( qPrintable(name) );
5767 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
5768 anActor->setName( qPrintable(name) );