1 // Copyright (C) 2007-2016 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, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <QDialogButtonBox>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
178 #include <Standard_ErrorHandler.hxx>
179 #include <NCollection_DataMap.hxx>
180 #include <NCollection_DoubleMap.hxx>
182 #include <Basics_Utils.hxx>
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 int ActionToControl( int theID, bool theReversed = false );
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ||
219 theCommandID == SMESHOp::OpPopupImportMED ) {
220 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
221 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
223 else if ( theCommandID == SMESHOp::OpImportUNV ||
224 theCommandID == SMESHOp::OpPopupImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ||
228 theCommandID == SMESHOp::OpPopupImportDAT ) {
229 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
231 else if ( theCommandID == SMESHOp::OpImportSTL ||
232 theCommandID == SMESHOp::OpPopupImportSTL ) {
233 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
235 else if ( theCommandID == SMESHOp::OpImportCGNS ||
236 theCommandID == SMESHOp::OpPopupImportCGNS ) {
237 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
239 else if ( theCommandID == SMESHOp::OpImportSAUV ||
240 theCommandID == SMESHOp::OpPopupImportSAUV ) {
241 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
242 filter.append( QObject::tr( "All files (*)" ) );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportSAUV:
346 case SMESHOp::OpPopupImportSAUV:
349 SMESH::DriverMED_ReadStatus res;
350 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
351 if ( res != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
357 case SMESHOp::OpImportGMF:
358 case SMESHOp::OpPopupImportGMF:
361 SMESH::ComputeError_var res;
362 aMeshes->length( 1 );
363 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
366 if ( res->code != SMESH::DRS_OK ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
369 if ( strlen( res->comment.in() ) > 0 ) {
370 errors.back() += ": ";
371 errors.back() += res->comment.in();
378 catch ( const SALOME::SALOME_Exception& S_ex ) {
379 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
380 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
383 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
385 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
387 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
388 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
389 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
390 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
391 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
393 anEntryList.append( aMeshSO->GetID().c_str() );
401 // update Object browser
402 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
404 // browse to the published meshes
405 if( LightApp_Application* anApp =
406 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
407 anApp->browseObjects( anEntryList );
409 // show Error message box if there were errors
410 if ( errors.count() > 0 ) {
411 SUIT_MessageBox::critical( SMESHGUI::desktop(),
412 QObject::tr( "SMESH_ERROR" ),
413 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
416 // show warning message box, if some imported mesh is empty
418 SUIT_MessageBox::warning( SMESHGUI::desktop(),
419 QObject::tr( "SMESH_WRN_WARNING" ),
420 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
425 //================================================================================
427 * \brief Export selected meshes or groups into a file
429 //================================================================================
431 void ExportMeshToFile( int theCommandID )
433 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
434 SALOME_ListIO selected;
436 aSel->selectedObjects( selected );
438 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
439 theCommandID == SMESHOp::OpPopupExportDAT );
440 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
441 theCommandID == SMESHOp::OpPopupExportMED );
442 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
443 theCommandID == SMESHOp::OpPopupExportUNV );
444 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
445 theCommandID == SMESHOp::OpPopupExportSTL );
446 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
447 theCommandID == SMESHOp::OpPopupExportCGNS );
448 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
449 theCommandID == SMESHOp::OpPopupExportSAUV );
450 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
451 theCommandID == SMESHOp::OpPopupExportGMF );
453 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
454 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
456 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
457 bool aCheckWarn = true;
459 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
460 // get mesh object from selection and check duplication of their names
461 bool hasDuplicatedMeshNames = false;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
464 SALOME_ListIteratorOfListIO It( selected );
465 for( ; It.More(); It.Next() )
467 Handle(SALOME_InteractiveObject) anIObject = It.Value();
468 SMESH::SMESH_IDSource_var aMeshItem =
469 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
470 if ( aMeshItem->_is_nil() ) {
471 SUIT_MessageBox::warning( SMESHGUI::desktop(),
472 QObject::tr( "SMESH_WRN_WARNING" ),
473 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
476 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
477 if ( aCheckWarn && !aGroup->_is_nil() )
479 QMessageBox msgBox(SUIT_MessageBox::Warning,
480 QObject::tr("SMESH_WRN_WARNING"),
481 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
482 QMessageBox::StandardButton::NoButton,
483 SMESHGUI::desktop());
484 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
485 msgBox.addButton(QMessageBox::Ok);
486 msgBox.addButton(QMessageBox::Cancel);
487 msgBox.setDefaultButton(QMessageBox::Cancel);
488 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
489 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
490 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
491 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
492 if(msgBox.exec() == QMessageBox::Ok)
494 if(dontShowCheckBox.checkState() == Qt::Checked)
497 resMgr->setValue( "SMESH", "show_warning", false);
505 QString aMeshName = anIObject->getName();
507 // check for name duplications
508 if ( !hasDuplicatedMeshNames )
509 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
510 if( aMeshName == (*aMeshIter).second ) {
511 hasDuplicatedMeshNames = true;
516 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
519 if( hasDuplicatedMeshNames && isMED ) {
520 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
521 QObject::tr("SMESH_WRN_WARNING"),
522 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
523 QObject::tr("SMESH_BUT_YES"),
524 QObject::tr("SMESH_BUT_NO"), 0, 1);
529 aMeshIter = aMeshList.begin();
530 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
531 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
532 QString aMeshName = (*aMeshIter).second;
534 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
536 // check for equal group names within each mesh
537 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
538 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
539 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
540 int aRet = SUIT_MessageBox::warning
541 (SMESHGUI::desktop(),
542 QObject::tr("SMESH_WRN_WARNING"),
543 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
544 QObject::tr("SMESH_BUT_YES"),
545 QObject::tr("SMESH_BUT_NO"), 0, 1);
552 // Warn the user about presence of not supported elements
554 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
558 notSupportedElemTypes.push_back( SMESH::Entity_0D );
559 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
569 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
576 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
577 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
578 notSupportedElemTypes.push_back( SMESH::Entity_0D );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
589 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
590 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
591 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
592 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
593 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
594 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
601 notSupportedElemTypes.push_back( SMESH::Entity_0D );
602 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
606 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
607 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
608 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
609 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
610 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
612 if ( ! notSupportedElemTypes.empty() )
614 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
615 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
616 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
617 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
619 if ( !presentNotSupported.empty() )
622 const char* typeMsg[] = {
623 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
624 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
625 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
626 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
627 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
628 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
629 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
630 "SMESH_BIQUADRATIC_PENTAHEDRONS",
631 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
633 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
634 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
635 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
637 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
638 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
639 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
640 if ( iType != presentNotSupported.size() - 1 )
641 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
643 int aRet = SUIT_MessageBox::warning
644 (SMESHGUI::desktop(),
645 QObject::tr("SMESH_WRN_WARNING"),
646 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
647 QObject::tr("SMESH_BUT_YES"),
648 QObject::tr("SMESH_BUT_NO"), 0, 1);
653 // Get parameters of export operation
656 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
657 // Init the parameters with the default values
658 bool aIsASCII_STL = true;
659 bool toCreateGroups = false;
661 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
662 bool toOverwrite = true;
663 bool toFindOutDim = true;
665 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
666 QString anInitialPath = "";
667 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
668 anInitialPath = QDir::currentPath();
670 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
672 // Get a file name to write in and additional otions
673 if ( isUNV || isDAT || isGMF ) // Export w/o options
676 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
678 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
680 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
681 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
682 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
683 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
684 anInitialPath + QString("/") + aMeshName,
685 aFilter, aTitle, false);
687 else if ( isCGNS )// Export to CGNS
689 const char* theByTypeResource = "cgns_group_elems_by_type";
690 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
692 QStringList checkBoxes;
693 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
695 SalomeApp_CheckFileDlg* fd =
696 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
697 fd->setWindowTitle( aTitle );
698 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
699 if ( !anInitialPath.isEmpty() )
700 fd->setDirectory( anInitialPath );
701 fd->selectFile(aMeshName);
702 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
703 fd->setValidator( fv );
704 fd->SetChecked( toCreateGroups, 0 );
707 aFilename = fd->selectedFile();
708 toOverwrite = fv->isOverwrite();
709 toCreateGroups = fd->IsChecked(0);
710 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
714 else if ( isSTL ) // Export to STL
716 QMap<QString, int> aFilterMap;
717 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
718 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
721 QMap<QString, int>::const_iterator it = aFilterMap.begin();
722 for ( ; it != aFilterMap.end(); ++it )
723 filters.push_back( it.key() );
725 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
726 fd->setWindowTitle( aTitle );
727 fd->setNameFilters( filters );
728 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
729 if ( !anInitialPath.isEmpty() )
730 fd->setDirectory( anInitialPath );
731 fd->selectFile(aMeshName);
735 aFilename = fd->selectedFile();
736 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
741 else if ( isMED || isSAUV ) // Export to MED or SAUV
743 QMap<QString, SMESH::MED_VERSION> aFilterMap;
744 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
746 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
747 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
748 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
751 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
752 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
753 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
757 QString aDefaultFilter;
758 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
759 for ( ; it != aFilterMap.end(); ++it ) {
760 filters.push_back( it.key() );
761 if (it.value() == SMESH::MED_V2_2)
762 aDefaultFilter = it.key();
764 QStringList checkBoxes;
765 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
767 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
768 QList< QWidget* > wdgList;
769 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
770 wdgList.append( fieldSelWdg );
772 SalomeApp_CheckFileDlg* fd =
773 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
774 fd->setWindowTitle( aTitle );
775 fd->setNameFilters( filters );
776 fd->selectNameFilter( aDefaultFilter );
777 fd->SetChecked( toCreateGroups, 0 );
778 fd->SetChecked( toFindOutDim, 1 );
779 if ( !anInitialPath.isEmpty() )
780 fd->setDirectory( anInitialPath );
781 fd->selectFile(aMeshName);
784 QListView *lview = fd->findChild<QListView*>("listView");
786 lview->setMinimumHeight(200);
788 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
790 tview->setMinimumHeight(200);
793 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
794 fd->setValidator( fv );
799 aFilename = fd->selectedFile();
801 aFilename = QString::null;
804 aFormat = aFilterMap[fd->selectedNameFilter()];
805 toOverwrite = fv->isOverwrite();
807 if ( !aFilename.isEmpty() ) {
808 // med-2.1 does not support poly elements
809 if ( aFormat==SMESH::MED_V2_1 )
810 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
811 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
812 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
813 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
814 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
816 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
817 QObject::tr("SMESH_WRN_WARNING"),
818 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
819 QObject::tr("SMESH_BUT_YES"),
820 QObject::tr("SMESH_BUT_NO"), 0, 1);
828 // can't append to an existing using other format
829 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
830 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
831 if( !isVersionOk || aVersion != aFormat ) {
832 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
833 QObject::tr("SMESH_WRN_WARNING"),
834 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
835 QObject::tr("SMESH_BUT_YES"),
836 QObject::tr("SMESH_BUT_NO"), 0, 1);
843 QStringList aMeshNamesCollisionList;
844 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
845 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
846 QString anExistingMeshName( aMeshNames[ i ] );
847 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
848 QString anExportMeshName = (*aMeshIter).second;
849 if( anExportMeshName == anExistingMeshName ) {
850 aMeshNamesCollisionList.append( anExportMeshName );
855 if( !aMeshNamesCollisionList.isEmpty() ) {
856 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
857 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
858 QObject::tr("SMESH_WRN_WARNING"),
859 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
860 QObject::tr("SMESH_BUT_YES"),
861 QObject::tr("SMESH_BUT_NO"),
862 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
871 toCreateGroups = fd->IsChecked(0);
872 toFindOutDim = fd->IsChecked(1);
873 fieldSelWdg->GetSelectedFields();
874 if ( !fieldSelWdg->parent() )
885 if ( !aFilename.isEmpty() ) {
886 // Check whether the file already exists and delete it if yes
887 QFile aFile( aFilename );
888 if ( aFile.exists() && toOverwrite )
890 SUIT_OverrideCursor wc;
893 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
894 // bool Renumber = false;
895 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
897 // Renumber= resMgr->booleanValue("renumbering");
899 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
900 // aMeshEditor->RenumberNodes();
901 // aMeshEditor->RenumberElements();
902 // if ( SMESHGUI::automaticUpdate() )
903 // SMESH::UpdateView();
907 aMeshIter = aMeshList.begin();
908 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
910 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
911 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
912 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
913 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
914 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
915 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
916 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
917 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
919 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
920 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
921 fields, geoAssFields.toLatin1().data() );
926 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
928 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
929 if( !aMeshItem->_is_nil() )
930 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
935 if ( aMeshOrGroup->_is_equivalent( aMesh ))
936 aMesh->ExportDAT( aFilename.toUtf8().data() );
938 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
942 if ( aMeshOrGroup->_is_equivalent( aMesh ))
943 aMesh->ExportUNV( aFilename.toUtf8().data() );
945 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
949 if ( aMeshOrGroup->_is_equivalent( aMesh ))
950 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
952 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
956 aMeshIter = aMeshList.begin();
957 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
959 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
960 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
961 aMeshItem->ExportCGNS( aMeshOrGroup,
962 aFilename.toUtf8().data(),
963 toOverwrite && aMeshIndex == 0,
969 toCreateGroups = true;
970 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
973 catch (const SALOME::SALOME_Exception& S_ex){
975 SUIT_MessageBox::warning(SMESHGUI::desktop(),
976 QObject::tr("SMESH_WRN_WARNING"),
977 QObject::tr("SMESH_EXPORT_FAILED"));
983 inline void InverseEntityMode(unsigned int& theOutputMode,
984 unsigned int theMode)
986 bool anIsNotPresent = ~theOutputMode & theMode;
988 theOutputMode |= theMode;
990 theOutputMode &= ~theMode;
993 void SetDisplayEntity(int theCommandID)
995 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
996 SALOME_ListIO selected;
998 aSel->selectedObjects( selected );
1000 if ( selected.Extent() >= 1 ) {
1001 SUIT_OverrideCursor wc;
1002 SALOME_ListIteratorOfListIO It( selected );
1003 for( ; It.More(); It.Next()){
1004 Handle(SALOME_InteractiveObject) IObject = It.Value();
1005 if(IObject->hasEntry()){
1006 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1007 unsigned int aMode = anActor->GetEntityMode();
1008 switch(theCommandID){
1009 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1010 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1011 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1012 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1013 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1014 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1017 anActor->SetEntityMode(aMode);
1026 SalomeApp_Application* app =
1027 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1031 LightApp_SelectionMgr* aSel = app->selectionMgr();
1032 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1033 if ( !aSel || !appStudy )
1036 SALOME_ListIO selected;
1037 aSel->selectedObjects( selected );
1038 if ( selected.IsEmpty() )
1041 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1043 _PTR(Study) aStudy = appStudy->studyDS();
1044 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1045 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1046 if ( aMainObject->_is_nil() )
1049 SUIT_OverrideCursor wc;
1051 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1053 QList<SALOMEDS::Color> aReservedColors;
1055 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1056 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1058 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1060 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1061 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1062 #else // old algorithm for auto-colors
1063 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1064 aReservedColors.append( aColor );
1065 #endif // SIMPLE_AUTOCOLOR
1066 aGroupObject->SetColor( aColor );
1068 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1069 if ( aGroupSObject ) {
1072 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1073 switch ( aGroupObject->GetType ()) {
1075 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1077 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1079 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1081 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1083 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1084 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1087 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1088 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1094 SMESH::RepaintCurrentView();
1097 void OverallMeshQuality()
1099 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1100 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1101 SALOME_ListIO selected;
1103 aSel->selectedObjects( selected );
1105 if ( selected.IsEmpty() ) return;
1106 SALOME_ListIteratorOfListIO It( selected );
1107 for ( ; It.More(); It.Next() ) {
1108 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1109 ctrlDlg->showInfo( It.Value() );
1114 QString functorToString( SMESH::Controls::FunctorPtr f )
1116 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1117 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1118 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1119 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1120 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1121 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1122 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1123 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1124 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1125 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1126 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1127 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1128 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1129 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1130 type = QObject::tr( "WARP_ELEMENTS" );
1131 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1132 type = QObject::tr( "TAPER_ELEMENTS" );
1133 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1134 type = QObject::tr( "SKEW_ELEMENTS" );
1135 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1136 type = QObject::tr( "AREA_ELEMENTS" );
1137 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1138 type = QObject::tr( "LENGTH_EDGES" );
1139 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1140 type = QObject::tr( "LENGTH2D_EDGES" );
1141 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1142 type = QObject::tr( "MULTI_BORDERS" );
1143 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1144 type = QObject::tr( "MULTI2D_BORDERS" );
1145 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1146 type = QObject::tr( "FREE_NODES" );
1147 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1148 type = QObject::tr( "FREE_EDGES" );
1149 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1150 type = QObject::tr( "FREE_BORDERS" );
1151 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1152 type = QObject::tr( "FREE_FACES" );
1153 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1154 type = QObject::tr( "BARE_BORDER_VOLUME" );
1155 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1156 type = QObject::tr( "BARE_BORDER_FACE" );
1157 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1158 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1159 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1160 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1161 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1162 type = QObject::tr( "EQUAL_NODE" );
1163 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1164 type = QObject::tr( "EQUAL_EDGE" );
1165 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1166 type = QObject::tr( "EQUAL_FACE" );
1167 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1168 type = QObject::tr( "EQUAL_VOLUME" );
1169 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1170 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1174 void SaveDistribution()
1176 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1177 SALOME_ListIO selected;
1179 aSel->selectedObjects( selected );
1181 if ( selected.Extent() == 1 ) {
1182 Handle(SALOME_InteractiveObject) anIO = selected.First();
1183 if ( anIO->hasEntry() ) {
1184 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1186 anActor->GetScalarBarActor() &&
1187 anActor->GetControlMode() != SMESH_Actor::eNone )
1189 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1190 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1191 if ( aScalarBarActor && aFunctor ) {
1192 SMESH::Controls::NumericalFunctor* aNumFun =
1193 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1195 std::vector<int> elements;
1196 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1197 if ( mesh->_is_nil() ) {
1198 SMESH::SMESH_IDSource_var idSource =
1199 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1200 if ( !idSource->_is_nil() )
1202 SMESH::long_array_var ids = idSource->GetIDs();
1203 elements.resize( ids->length() );
1204 for ( unsigned i = 0; i < elements.size(); ++i )
1205 elements[i] = ids[i];
1208 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1209 vtkLookupTable* lookupTable =
1210 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1211 double * minmax = lookupTable->GetRange();
1212 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1213 std::vector<int> nbEvents;
1214 std::vector<double> funValues;
1215 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1216 elements, minmax, isLogarithmic );
1217 QString anInitialPath = "";
1218 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1219 anInitialPath = QDir::currentPath();
1220 QString aMeshName = anIO->getName();
1222 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1224 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1225 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1226 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1229 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1231 if ( !aFilename.isEmpty() ) {
1232 QFile f( aFilename );
1233 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1234 QTextStream out( &f );
1235 out << "# Mesh: " << aMeshName << endl;
1236 out << "# Control: " << functorToString( aFunctor ) << endl;
1238 out.setFieldWidth( 10 );
1239 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1240 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1251 void ShowElement( int theCommandID )
1253 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1254 SALOME_ListIO selected;
1256 aSel->selectedObjects( selected );
1258 if ( selected.Extent() == 1 ) {
1259 Handle(SALOME_InteractiveObject) anIO = selected.First();
1260 if ( anIO->hasEntry() ) {
1261 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1263 anActor->GetScalarBarActor() &&
1264 anActor->GetControlMode() != SMESH_Actor::eNone )
1266 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1267 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1268 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1270 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1271 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1278 #ifndef DISABLE_PLOT2DVIEWER
1279 void PlotDistribution()
1281 SalomeApp_Application* app =
1282 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1286 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1287 SALOME_ListIO selected;
1289 aSel->selectedObjects( selected );
1291 if ( selected.Extent() == 1 ) {
1292 Handle(SALOME_InteractiveObject) anIO = selected.First();
1293 if ( anIO->hasEntry() ) {
1294 //Find Actor by entry before getting Plot2d viewer,
1295 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1296 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1298 SUIT_ViewManager* aViewManager =
1299 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1303 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1307 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1311 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1313 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1314 QString functorName = functorToString( anActor->GetFunctor());
1315 QString aHistogramName("%1 : %2");
1316 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1317 aHistogram->setName(aHistogramName);
1318 aHistogram->setHorTitle(functorName);
1319 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1320 aPlot->displayObject(aHistogram, true);
1325 #endif //DISABLE_PLOT2DVIEWER
1327 void DisableAutoColor()
1329 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1330 SALOME_ListIO selected;
1332 aSel->selectedObjects( selected );
1334 if ( selected.Extent() ) {
1335 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1336 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1337 if ( !aMesh->_is_nil() ) {
1338 aMesh->SetAutoColor( false );
1345 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1346 SALOME_ListIO selected;
1348 aSel->selectedObjects( selected );
1349 if ( selected.Extent() )
1351 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1352 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1353 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1355 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1356 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1363 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1365 SALOME_ListIO selected;
1366 SalomeApp_Application* app =
1367 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1371 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1372 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1373 if ( !aSel || !appStudy )
1376 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1377 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1378 aModule->EmitSignalDeactivateDialog();
1379 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1380 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1385 _PTR(Study) aStudy = appStudy->studyDS();
1387 aSel->selectedObjects( selected );
1389 if ( selected.Extent() >= 1 )
1391 switch ( theCommandID ) {
1392 case SMESHOp::OpTransparency:
1394 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1395 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1398 case SMESHOp::OpProperties:
1401 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1402 QColor orientationColor, outlineColor, volumeColor;
1403 int deltaF = 0, deltaV = 0;
1406 double ballScale = 1.0;
1408 int outlineWidth = 1;
1409 double shrinkCoef = 0.0;
1410 double orientationScale = 0.0;
1411 bool orientation3d = false;
1412 VTK::MarkerType markerType = VTK::MT_NONE;
1413 VTK::MarkerScale markerScale = VTK::MS_NONE;
1415 bool hasNodes = false;
1416 int presentEntities = 0;
1417 bool firstTime = true;
1419 SALOME_ListIteratorOfListIO It( selected );
1420 for ( ; It.More(); It.Next() ) {
1421 Handle(SALOME_InteractiveObject) IObject = It.Value();
1422 if ( !IObject->hasEntry() ) continue;
1423 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1424 if ( !anActor || !anActor->GetObject() ) continue;
1427 // nodes: color, marker
1428 anActor->GetNodeColor( color[0], color[1], color[2] );
1429 nodeColor.setRgbF( color[0], color[1], color[2] );
1430 markerType = anActor->GetMarkerType();
1431 markerScale = anActor->GetMarkerScale();
1432 markerId = anActor->GetMarkerTexture();
1433 // edges: color, width
1434 anActor->GetEdgeColor( color[0], color[1], color[2] );
1435 edgeColor.setRgbF( color[0], color[1], color[2] );
1436 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1437 // faces: front color, back color (delta)
1438 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1439 faceColor.setRgbF( color[0], color[1], color[2] );
1440 // faces: front color, back color (delta)
1441 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1442 volumeColor.setRgbF( color[0], color[1], color[2] );
1443 // 0d elements: color, size
1444 anActor->Get0DColor( color[0], color[1], color[2] );
1445 elem0dColor.setRgbF( color[0], color[1], color[2] );
1446 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1447 // balls: color, size
1448 anActor->GetBallColor( color[0], color[1], color[2] );
1449 ballColor.setRgbF( color[0], color[1], color[2] );
1450 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1451 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1453 anActor->GetOutlineColor( color[0], color[1], color[2] );
1454 outlineColor.setRgbF( color[0], color[1], color[2] );
1455 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1456 // orientation vectors: color, scale, 3d flag
1457 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1458 orientationColor.setRgbF( color[0], color[1], color[2] );
1459 orientationScale = anActor->GetFacesOrientationScale();
1460 orientation3d = anActor->GetFacesOrientation3DVectors();
1462 shrinkCoef = anActor->GetShrinkFactor();
1465 firstTime = false; // we only take properties from first object (for performance reasons)
1468 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1469 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1470 presentEntities = presentEntities | SMESH_Actor::eEdges;
1471 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1472 presentEntities = presentEntities | SMESH_Actor::eFaces;
1473 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1474 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1475 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1476 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1477 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1478 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1480 // as we know that all types of elements are present, we can exit the loop
1481 if ( presentEntities == SMESH_Actor::eAllEntity )
1485 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1486 // nodes: color, marker
1487 dlg.setNodeColor( nodeColor );
1488 if( markerType != VTK::MT_USER )
1489 dlg.setNodeMarker( markerType, markerScale );
1491 dlg.setNodeCustomMarker( markerId );
1492 // edges: color, line width
1493 dlg.setEdgeColor( edgeColor );
1494 dlg.setEdgeWidth( edgeWidth );
1495 // faces: front color, back color
1496 dlg.setFaceColor( faceColor, deltaF );
1497 // volumes: normal color, reversed color
1498 dlg.setVolumeColor( volumeColor, deltaV );
1499 // outlines: color, line width
1500 dlg.setOutlineColor( outlineColor );
1501 dlg.setOutlineWidth( outlineWidth );
1502 // 0d elements: color, size
1503 dlg.setElem0dColor( elem0dColor );
1504 dlg.setElem0dSize( elem0dSize );
1505 // balls: color, size
1506 dlg.setBallColor( ballColor );
1507 //dlg.setBallSize( ballSize );
1508 dlg.setBallScale( ballScale );
1509 // orientation: color, scale, 3d flag
1510 dlg.setOrientationColor( orientationColor );
1511 dlg.setOrientationSize( int( orientationScale * 100. ) );
1512 dlg.setOrientation3d( orientation3d );
1513 // shrink: scale factor
1514 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1515 // hide unused controls
1516 dlg.showControls( presentEntities, hasNodes );
1519 nodeColor = dlg.nodeColor();
1520 markerType = dlg.nodeMarkerType();
1521 markerScale = dlg.nodeMarkerScale();
1522 markerId = dlg.nodeMarkerId();
1523 edgeColor = dlg.edgeColor();
1524 edgeWidth = dlg.edgeWidth();
1525 faceColor = dlg.faceColor();
1526 deltaF = dlg.faceColorDelta();
1527 volumeColor = dlg.volumeColor();
1528 deltaV = dlg.volumeColorDelta();
1529 outlineColor = dlg.outlineColor();
1530 outlineWidth = dlg.outlineWidth();
1531 elem0dColor = dlg.elem0dColor();
1532 elem0dSize = dlg.elem0dSize();
1533 ballColor = dlg.ballColor();
1534 // ballSize = dlg.ballSize();
1535 ballScale = dlg.ballScale();
1536 orientationColor = dlg.orientationColor();
1537 orientationScale = dlg.orientationSize() / 100.;
1538 orientation3d = dlg.orientation3d();
1539 shrinkCoef = dlg.shrinkCoef() / 100.;
1541 // store point markers map that might be changed by the user
1542 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1544 // set properties from dialog box to the presentations
1545 SALOME_ListIteratorOfListIO It( selected );
1546 for ( ; It.More(); It.Next() ) {
1547 Handle(SALOME_InteractiveObject) IObject = It.Value();
1548 if ( !IObject->hasEntry() ) continue;
1549 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1550 if ( !anActor ) continue;
1552 // nodes: color, marker
1553 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1554 if ( markerType != VTK::MT_USER ) {
1555 anActor->SetMarkerStd( markerType, markerScale );
1558 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1559 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1560 if ( iter != markerMap.end() )
1561 anActor->SetMarkerTexture( markerId, iter->second.second );
1563 // volumes: normal color, reversed color (delta)
1564 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1565 // faces: front color, back color (delta)
1566 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1567 // edges: color, width
1568 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1569 anActor->SetLineWidth( edgeWidth );
1571 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1572 anActor->SetOutlineWidth( outlineWidth );
1573 // 0D elements: color, size
1574 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1575 anActor->Set0DSize( elem0dSize );
1576 // balls: color, size
1577 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1578 // anActor->SetBallSize( ballSize );
1579 anActor->SetBallScale( ballScale );
1580 // orientation: color, scale, 3d flag
1581 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1582 anActor->SetFacesOrientationScale( orientationScale );
1583 anActor->SetFacesOrientation3DVectors( orientation3d );
1585 anActor->SetShrinkFactor( shrinkCoef );
1587 // for groups, set also proper color
1588 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1589 if ( !aGroupObject->_is_nil() ) {
1590 SMESH::ElementType anElementType = aGroupObject->GetType();
1592 switch( anElementType ) {
1594 aColor = nodeColor; break;
1596 aColor = edgeColor; break;
1598 aColor = faceColor; break;
1600 aColor = volumeColor; break;
1602 aColor = elem0dColor; break;
1604 aColor = ballColor; break;
1608 if ( aColor.isValid() ) {
1609 SALOMEDS::Color aGroupColor;
1610 aGroupColor.R = aColor.redF();
1611 aGroupColor.G = aColor.greenF();
1612 aGroupColor.B = aColor.blueF();
1613 aGroupObject->SetColor( aGroupColor );
1615 } // if ( !aGroupObject->_is_nil() )
1616 } // for ( ; It.More(); It.Next() )
1617 SMESH::RepaintCurrentView();
1618 } // if ( dlg.exec() )
1620 } // case SMESHOp::OpProperties:
1621 } // switch(theCommandID)
1622 SUIT_OverrideCursor wc;
1623 SALOME_ListIteratorOfListIO It( selected );
1624 for( ; It.More(); It.Next()){
1625 Handle(SALOME_InteractiveObject) IObject = It.Value();
1626 if(IObject->hasEntry()){
1627 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1628 switch(theCommandID){
1629 case SMESHOp::OpDMWireframe:
1630 anActor->SetRepresentation(SMESH_Actor::eEdge);
1632 case SMESHOp::OpDMShading:
1633 anActor->SetRepresentation(SMESH_Actor::eSurface);
1635 case SMESHOp::OpDMShrink:
1636 if(anActor->IsShrunk())
1637 anActor->UnShrink();
1639 anActor->SetShrink();
1641 case SMESHOp::OpDMNodes:
1642 anActor->SetRepresentation(SMESH_Actor::ePoint);
1644 case SMESHOp::OpRepresentationLines:
1645 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1646 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1648 case SMESHOp::OpRepresentationArcs:
1649 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1650 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1656 SMESH::RepaintCurrentView();
1660 int ActionToControl( int theID, bool theReversed )
1662 NCollection_DoubleMap<int,int> ActionControl;
1663 ActionControl.Bind( 0, SMESH_Actor::eNone );
1664 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1665 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1666 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1667 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1668 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1669 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1670 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1671 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1672 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1673 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1674 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1675 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1676 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1677 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1678 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1679 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1680 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1681 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1682 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1683 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1684 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1685 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1686 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1687 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1688 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1689 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1690 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1692 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1695 void Control( int theCommandID )
1697 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1698 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1700 SALOME_ListIO selected;
1701 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1702 aSel->selectedObjects( selected );
1704 if ( !selected.IsEmpty() ) {
1705 SALOME_ListIteratorOfListIO It(selected);
1706 for ( ; It.More(); It.Next())
1708 Handle(SALOME_InteractiveObject) anIO = It.Value();
1709 if ( !anIO.IsNull() ) {
1710 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1712 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1713 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1714 if ( !anIDSrc->_is_nil() ) {
1715 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1716 if (( !anActor && selected.Extent() == 1 ) &&
1717 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1719 anActor->SetControlMode( aControl );
1720 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1721 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1725 if ( anActor->GetControlMode() != aControl )
1726 anActor->SetControlMode( aControl );
1727 QString functorName = functorToString( anActor->GetFunctor() );
1728 int anEntitiesCount = anActor->GetNumberControlEntities();
1729 if (anEntitiesCount >= 0)
1730 functorName = functorName + ": " + QString::number(anEntitiesCount);
1731 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1732 SMESH::RepaintCurrentView();
1733 #ifndef DISABLE_PLOT2DVIEWER
1734 if ( anActor->GetPlot2Histogram() ) {
1735 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1736 QString aHistogramName("%1 : %2");
1737 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1738 aHistogram->setName( aHistogramName );
1739 aHistogram->setHorTitle( functorName );
1740 SMESH::ProcessIn2DViewers( anActor );
1752 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1753 SMESH::MeshObjectType theType,
1754 const QString theInTypeName,
1755 QString & theOutTypeName)
1757 SMESH_TypeFilter aTypeFilter( theType );
1759 if ( !theIO.IsNull() )
1761 entry = theIO->getEntry();
1762 LightApp_DataOwner owner( entry );
1763 if ( aTypeFilter.isOk( &owner )) {
1764 theOutTypeName = theInTypeName;
1772 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1774 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1775 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1777 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1778 CORBA::String_var anID = aSComp->GetID().c_str();
1779 if ( !strcmp(anID.in(),theIO->getEntry()) )
1785 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1786 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1787 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1788 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1789 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1797 // QString CheckHomogeneousSelection()
1799 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1800 // SALOME_ListIO selected;
1802 // aSel->selectedObjects( selected );
1804 // QString RefType = CheckTypeObject(selected.First());
1805 // SALOME_ListIteratorOfListIO It(selected);
1806 // for ( ; It.More(); It.Next())
1808 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1809 // QString Type = CheckTypeObject(IObject);
1810 // if ( Type.compare(RefType) != 0 )
1811 // return "Heterogeneous Selection";
1817 uint randomize( uint size )
1819 static bool initialized = false;
1820 if ( !initialized ) {
1821 qsrand( QDateTime::currentDateTime().toTime_t() );
1825 v = uint( (double)( v ) / RAND_MAX * size );
1826 v = qMax( uint(0), qMin ( v, size-1 ) );
1832 void SMESHGUI::OnEditDelete()
1834 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1835 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1836 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1838 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1839 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1840 _PTR(GenericAttribute) anAttr;
1841 _PTR(AttributeIOR) anIOR;
1843 int objectCount = 0;
1845 QString aParentComponent = QString::null;
1846 Handle(SALOME_InteractiveObject) anIO;
1847 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1849 anIO = anIt.Value();
1850 QString cur = anIO->getComponentDataType();
1851 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1853 // check if object is reference
1854 _PTR(SObject) aRefSObj;
1855 aNameList.append("\n - ");
1856 if ( aSO->ReferencedObject( aRefSObj ) ) {
1857 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1858 aNameList.append( aRefName );
1859 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1862 aNameList.append(anIO->getName());
1866 if( aParentComponent.isNull() )
1867 aParentComponent = cur;
1868 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1869 aParentComponent = "";
1872 if ( objectCount == 0 )
1873 return; // No Valid Objects Selected
1875 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1876 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1877 QObject::tr("ERR_ERROR"),
1878 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1881 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1882 if (SUIT_MessageBox::warning
1883 (SMESHGUI::desktop(),
1884 QObject::tr("SMESH_WRN_WARNING"),
1885 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1886 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1887 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1890 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1892 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1893 // then treat them all starting from the deepest objects (at list back)
1894 std::list< _PTR(SObject) > listSO;
1895 SALOME_ListIteratorOfListIO It(selected);
1896 for( ; It.More(); It.Next()) // loop on selected IO's
1898 Handle(SALOME_InteractiveObject) IObject = It.Value();
1899 if(IObject->hasEntry()) {
1900 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1902 // disable removal of "SMESH" component object
1903 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1905 if ( engineIOR() == anIOR->Value().c_str() )
1908 //Check the referenced object
1909 _PTR(SObject) aRefSObject;
1910 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1911 aSO = aRefSObject; // Delete main Object instead of reference
1913 listSO.push_back( aSO );
1914 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1915 for ( ; itSO != listSO.end(); ++itSO ) {
1916 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1917 for (it->InitEx(false); it->More(); it->Next())
1918 listSO.push_back( it->Value() );
1922 // Check if none of objects to delete is referred from outside
1923 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1924 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1926 _PTR(SObject) SO = *ritSO;
1927 if ( !SO ) continue;
1928 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1929 for (size_t i = 0; i < aReferences.size(); i++) {
1930 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1931 std::string type = aComponent->ComponentDataType();
1932 if ( type != "SMESH" )
1934 SUIT_MessageBox::warning( anApp->desktop(),
1935 QObject::tr("WRN_WARNING"),
1936 QObject::tr("DEP_OBJECT") );
1937 return; // outside SMESH, there is an object depending on a SMESH object
1942 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1943 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1945 Handle(SALOME_InteractiveObject) IObject = It.Value();
1946 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1947 if ( !mesh->_is_nil() )
1951 // Treat SO's in the list starting from the back
1952 aStudyBuilder->NewCommand(); // There is a transaction
1953 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1955 _PTR(SObject) SO = *ritSO;
1956 if ( !SO ) continue;
1957 std::string anEntry = SO->GetID();
1959 /** Erase graphical object and remove all its data **/
1960 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1961 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1963 /** Remove an object from data structures **/
1964 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1965 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1966 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1967 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1968 aMesh->RemoveGroup( aGroup );
1970 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1971 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1972 aMesh->RemoveSubMesh( aSubMesh );
1974 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1976 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1979 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1980 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1981 QString objType = CheckTypeObject(IObject);
1982 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1983 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1984 aStudyBuilder->RemoveObjectWithChildren( SO );
1986 else {// default action: remove SObject from the study
1987 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1988 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1990 aStudyBuilder->RemoveObjectWithChildren( SO );
1994 } /* listSO back loop */
1996 aStudyBuilder->CommitCommand();
1998 /* Clear any previous selection */
2000 aSel->setSelectedObjects( l1 );
2002 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2006 SMESHGUI_EXPORT CAM_Module* createModule()
2008 return new SMESHGUI();
2011 SMESHGUI_EXPORT char* getModuleVersion() {
2012 return (char*)SMESH_VERSION_STR;
2016 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2018 //=============================================================================
2022 //=============================================================================
2023 SMESHGUI::SMESHGUI() :
2024 SalomeApp_Module( "SMESH" )
2026 if ( CORBA::is_nil( myComponentSMESH ) )
2028 CORBA::Boolean anIsEmbeddedMode;
2029 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2030 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2032 // 0019923: EDF 765 SMESH : default values of hypothesis
2033 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2034 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2035 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2036 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2037 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2039 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2040 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2041 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2043 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2044 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2048 myActiveDialogBox = 0;
2049 myFilterLibraryDlg = 0;
2053 myEventCallbackCommand = vtkCallbackCommand::New();
2054 myEventCallbackCommand->Delete();
2055 myEventCallbackCommand->SetClientData( this );
2056 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2059 /* load resources for all available meshers */
2060 SMESH::InitAvailableHypotheses();
2063 //=============================================================================
2067 //=============================================================================
2068 SMESHGUI::~SMESHGUI()
2072 //=============================================================================
2076 //=============================================================================
2077 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2079 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2081 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2086 //=============================================================================
2090 //=============================================================================
2091 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2093 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2097 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2098 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2099 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2100 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2101 return autoUpdate && !exceeded;
2104 //=============================================================================
2108 //=============================================================================
2109 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2110 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2112 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2116 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2117 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2118 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2120 SMESH::long_array_var info = theMesh->GetMeshInfo();
2121 long nbOdElems = info[SMDSEntity_0D];
2122 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2123 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2124 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2125 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2126 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2127 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2128 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2129 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2130 info[SMDSEntity_Polyhedra] +
2131 info[SMDSEntity_Hexagonal_Prism];
2132 long nbBalls = info[SMDSEntity_Ball];
2134 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2135 *nbElements = requestedSize;
2137 *entities = SMESH_Actor::eAllEntity;
2140 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2142 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2144 if ( incrementalLimit ) {
2147 if ( nbOdElems > 0 ) {
2148 if ( total + nbOdElems > updateLimit ) {
2149 *entities = *entities & ~SMESH_Actor::e0DElements;
2150 *hidden = *hidden | SMESH_Actor::e0DElements;
2157 if ( nbEdges > 0 ) {
2158 if ( total + nbEdges > updateLimit ) {
2159 *entities = *entities & ~SMESH_Actor::eEdges;
2160 *hidden = *hidden | SMESH_Actor::eEdges;
2167 if ( nbFaces > 0 ) {
2168 if ( total + nbFaces > updateLimit ) {
2169 *entities = *entities & ~SMESH_Actor::eFaces;
2170 *hidden = *hidden | SMESH_Actor::eFaces;
2177 if ( nbVolumes > 0 ) {
2178 if ( total + nbVolumes > updateLimit ) {
2179 *entities = *entities & ~SMESH_Actor::eVolumes;
2180 *hidden = *hidden | SMESH_Actor::eVolumes;
2187 if ( nbBalls > 0 ) {
2188 if ( total + nbBalls > updateLimit ) {
2189 *entities = *entities & ~SMESH_Actor::eBallElem;
2190 *hidden = *hidden | SMESH_Actor::eBallElem;
2198 return autoUpdate && !exceeded;
2201 //=============================================================================
2205 //=============================================================================
2206 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2208 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2211 //=============================================================================
2215 //=============================================================================
2216 SMESHGUI* SMESHGUI::GetSMESHGUI()
2218 SMESHGUI* smeshMod = 0;
2219 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2222 CAM_Module* module = app->module( "Mesh" );
2223 smeshMod = dynamic_cast<SMESHGUI*>( module );
2226 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2228 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2231 _PTR(Study) aStudy = study->studyDS();
2233 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2242 Standard_EXPORT SMESHGUI* GetComponentGUI()
2244 return SMESHGUI::GetSMESHGUI();
2248 //=============================================================================
2252 //=============================================================================
2253 void SMESHGUI::SetState(int aState)
2258 //=============================================================================
2262 //=============================================================================
2263 void SMESHGUI::ResetState()
2268 //=============================================================================
2272 //=============================================================================
2273 void SMESHGUI::EmitSignalDeactivateDialog()
2275 emit SignalDeactivateActiveDialog();
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::EmitSignalStudyFrameChanged()
2285 emit SignalStudyFrameChanged();
2288 //=============================================================================
2292 //=============================================================================
2293 void SMESHGUI::EmitSignalCloseAllDialogs()
2295 emit SignalCloseAllDialogs();
2298 //=============================================================================
2302 //=============================================================================
2303 void SMESHGUI::EmitSignalVisibilityChanged()
2305 emit SignalVisibilityChanged();
2308 //=============================================================================
2312 //=============================================================================
2313 void SMESHGUI::EmitSignalCloseView()
2315 emit SignalCloseView();
2318 //=============================================================================
2322 //=============================================================================
2323 void SMESHGUI::EmitSignalActivatedViewManager()
2325 emit SignalActivatedViewManager();
2328 //=============================================================================
2332 //=============================================================================
2333 QDialog *SMESHGUI::GetActiveDialogBox()
2335 return myActiveDialogBox;
2338 //=============================================================================
2342 //=============================================================================
2343 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2345 myActiveDialogBox = (QDialog *) aDlg;
2349 //=============================================================================
2353 //=============================================================================
2354 SUIT_Desktop* SMESHGUI::desktop()
2356 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2358 return app->desktop();
2363 //=============================================================================
2367 //=============================================================================
2368 SalomeApp_Study* SMESHGUI::activeStudy()
2370 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2372 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2377 //=============================================================================
2381 //=============================================================================
2382 void SMESHGUI::Modified( bool theIsUpdateActions )
2384 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2385 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2386 appStudy->Modified();
2387 if( theIsUpdateActions )
2388 app->updateActions();
2393 //=============================================================================
2397 //=============================================================================
2398 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2400 /* Here the position is on the bottom right corner - 10 */
2401 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2403 SUIT_Desktop *PP = desktop();
2404 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2405 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2409 //=============================================================================
2413 //=============================================================================
2414 static int isStudyLocked(_PTR(Study) theStudy){
2415 return theStudy->GetProperties()->IsLocked();
2418 static bool checkLock(_PTR(Study) theStudy) {
2419 if (isStudyLocked(theStudy)) {
2420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2421 QObject::tr("WRN_WARNING"),
2422 QObject::tr("WRN_STUDY_LOCKED") );
2428 //=======================================================================
2429 //function : CheckActiveStudyLocked
2431 //=======================================================================
2433 bool SMESHGUI::isActiveStudyLocked()
2435 _PTR(Study) aStudy = activeStudy()->studyDS();
2436 return checkLock( aStudy );
2439 //=============================================================================
2443 //=============================================================================
2444 bool SMESHGUI::OnGUIEvent( int theCommandID )
2446 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2450 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2451 SUIT_ResourceMgr* mgr = resourceMgr();
2455 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2456 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2459 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2460 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2462 //QAction* act = action( theCommandID );
2464 switch (theCommandID) {
2465 case SMESHOp::OpDelete:
2466 if(checkLock(aStudy)) break;
2469 case SMESHOp::OpImportDAT:
2470 case SMESHOp::OpImportUNV:
2471 case SMESHOp::OpImportMED:
2472 case SMESHOp::OpImportSTL:
2473 case SMESHOp::OpImportCGNS:
2474 case SMESHOp::OpImportSAUV:
2475 case SMESHOp::OpImportGMF:
2476 case SMESHOp::OpPopupImportDAT:
2477 case SMESHOp::OpPopupImportUNV:
2478 case SMESHOp::OpPopupImportMED:
2479 case SMESHOp::OpPopupImportSTL:
2480 case SMESHOp::OpPopupImportCGNS:
2481 case SMESHOp::OpPopupImportSAUV:
2482 case SMESHOp::OpPopupImportGMF:
2484 if(checkLock(aStudy)) break;
2485 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2489 case SMESHOp::OpFileInformation:
2491 SALOME_ListIO selected;
2492 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2494 aSel->selectedObjects( selected );
2495 if( selected.Extent() )
2497 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2498 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2499 if ( !aMesh->_is_nil() )
2501 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2507 case SMESHOp::OpExportDAT:
2508 case SMESHOp::OpExportMED:
2509 case SMESHOp::OpExportUNV:
2510 case SMESHOp::OpExportSTL:
2511 case SMESHOp::OpExportCGNS:
2512 case SMESHOp::OpExportSAUV:
2513 case SMESHOp::OpExportGMF:
2514 case SMESHOp::OpPopupExportDAT:
2515 case SMESHOp::OpPopupExportMED:
2516 case SMESHOp::OpPopupExportUNV:
2517 case SMESHOp::OpPopupExportSTL:
2518 case SMESHOp::OpPopupExportCGNS:
2519 case SMESHOp::OpPopupExportSAUV:
2520 case SMESHOp::OpPopupExportGMF:
2522 ::ExportMeshToFile(theCommandID);
2526 case SMESHOp::OpReset: // SCALAR BAR
2528 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2529 SALOME_ListIO selected;
2531 aSel->selectedObjects( selected );
2533 SALOME_ListIteratorOfListIO it(selected);
2534 for( ; it.More(); it.Next()) {
2535 Handle(SALOME_InteractiveObject) anIO = it.Value();
2536 if( anIO->hasEntry() ) {
2537 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2538 anActor->SetControlMode( SMESH_Actor::eNone );
2539 #ifndef DISABLE_PLOT2DVIEWER
2540 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2545 SMESH::UpdateView();
2548 case SMESHOp::OpScalarBarProperties:
2550 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2553 case SMESHOp::OpShowScalarBar:
2555 // show/hide scalar bar
2556 ::ShowElement(theCommandID);
2559 case SMESHOp::OpSaveDistribution:
2561 // dump control distribution data to the text file
2562 ::SaveDistribution();
2566 case SMESHOp::OpShowDistribution:
2568 // show/hide distribution
2569 ::ShowElement(theCommandID);
2573 #ifndef DISABLE_PLOT2DVIEWER
2574 case SMESHOp::OpPlotDistribution:
2576 // plot distribution
2577 ::PlotDistribution();
2583 case SMESHOp::OpAutoColor:
2587 case SMESHOp::OpDisableAutoColor:
2588 ::DisableAutoColor();
2591 case SMESHOp::OpClipping:
2592 case SMESHOp::OpTransparency:
2593 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2596 case SMESHOp::OpDMWireframe:
2597 case SMESHOp::OpDMShading:
2598 case SMESHOp::OpDMNodes:
2599 case SMESHOp::OpDMShrink:
2600 ::SetDisplayMode(theCommandID, myMarkerMap);
2603 //2D quadratic representation
2604 case SMESHOp::OpRepresentationLines:
2605 case SMESHOp::OpRepresentationArcs:
2606 ::SetDisplayMode(theCommandID, myMarkerMap);
2610 case SMESHOp::OpDE0DElements:
2611 case SMESHOp::OpDEEdges:
2612 case SMESHOp::OpDEFaces:
2613 case SMESHOp::OpDEVolumes:
2614 case SMESHOp::OpDEBalls:
2615 case SMESHOp::OpDEAllEntity:
2616 ::SetDisplayEntity(theCommandID);
2619 // Choose entities to be displayed
2620 case SMESHOp::OpDEChoose:
2622 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2626 case SMESHOp::OpOrientationOnFaces:
2628 SUIT_OverrideCursor wc;
2629 LightApp_SelectionMgr* mgr = selectionMgr();
2630 SALOME_ListIO selected; mgr->selectedObjects( selected );
2632 SALOME_ListIteratorOfListIO it(selected);
2633 for( ; it.More(); it.Next()) {
2634 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2635 if(anIObject->hasEntry()) {
2636 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2637 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2644 case SMESHOp::OpUpdate:
2646 if(checkLock(aStudy)) break;
2647 SUIT_OverrideCursor wc;
2650 SMESH::UpdateView();
2652 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2653 SMESH::OnVisuException();
2655 catch (...) { // PAL16774 (Crash after display of many groups)
2656 SMESH::OnVisuException();
2660 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2661 aSel->selectedObjects( l );
2662 aSel->setSelectedObjects( l );
2666 case SMESHOp::OpHide:
2667 case SMESHOp::OpShow:
2668 case SMESHOp::OpShowOnly:
2670 SUIT_OverrideCursor wc;
2671 SMESH::EDisplaing anAction;
2672 switch (theCommandID) {
2673 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2674 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2675 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2678 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2679 SALOME_ListIO sel_objects, to_process;
2681 aSel->selectedObjects( sel_objects );
2683 if ( theCommandID==SMESHOp::OpShowOnly )
2685 //MESSAGE("anAction = SMESH::eDisplayOnly");
2686 startOperation( myEraseAll );
2689 extractContainers( sel_objects, to_process );
2694 SALOME_ListIteratorOfListIO It( to_process );
2695 for ( ; It.More(); It.Next())
2697 Handle(SALOME_InteractiveObject) IOS = It.Value();
2698 if ( IOS->hasEntry() )
2700 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2701 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2702 break; // PAL16774 (Crash after display of many groups)
2704 if (anAction == SMESH::eDisplayOnly)
2705 anAction = SMESH::eDisplay;
2710 // PAL13338 + PAL15161 -->
2711 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2712 SMESH::UpdateView();
2713 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2715 // PAL13338 + PAL15161 <--
2717 catch (...) { // PAL16774 (Crash after display of many groups)
2718 SMESH::OnVisuException();
2721 if (anAction == SMESH::eErase) {
2723 aSel->setSelectedObjects( l1 );
2726 aSel->setSelectedObjects( to_process );
2731 case SMESHOp::OpNode:
2733 if(checkLock(aStudy)) break;
2736 EmitSignalDeactivateDialog();
2738 ( new SMESHGUI_NodesDlg( this ) )->show();
2741 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2746 case SMESHOp::OpCreateMesh:
2747 case SMESHOp::OpCreateSubMesh:
2748 case SMESHOp::OpEditMeshOrSubMesh:
2749 case SMESHOp::OpEditMesh:
2750 case SMESHOp::OpEditSubMesh:
2751 case SMESHOp::OpCompute:
2752 case SMESHOp::OpComputeSubMesh:
2753 case SMESHOp::OpPreCompute:
2754 case SMESHOp::OpEvaluate:
2755 case SMESHOp::OpMeshOrder:
2756 startOperation( theCommandID );
2758 case SMESHOp::OpCopyMesh:
2760 if (checkLock(aStudy)) break;
2761 EmitSignalDeactivateDialog();
2762 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2765 case SMESHOp::OpBuildCompoundMesh:
2767 if (checkLock(aStudy)) break;
2768 EmitSignalDeactivateDialog();
2769 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2773 case SMESHOp::OpDiagonalInversion:
2774 case SMESHOp::OpUnionOfTwoTriangle:
2778 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2782 if ( checkLock( aStudy ) )
2785 /*Standard_Boolean aRes;
2786 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2787 if ( aMesh->_is_nil() )
2789 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2790 tr( "SMESH_BAD_SELECTION" ) );
2794 EmitSignalDeactivateDialog();
2795 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2796 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2798 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2801 case SMESHOp::OpOrientation:
2802 case SMESHOp::OpUnionOfTriangles:
2803 case SMESHOp::OpCuttingOfQuadrangles:
2804 case SMESHOp::OpSplitVolumes:
2808 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2812 if ( checkLock( aStudy ) )
2815 EmitSignalDeactivateDialog();
2816 SMESHGUI_MultiEditDlg* aDlg = NULL;
2817 if ( theCommandID == SMESHOp::OpOrientation )
2818 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2819 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2820 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2821 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2822 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2824 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2829 case SMESHOp::OpSmoothing:
2831 if(checkLock(aStudy)) break;
2833 EmitSignalDeactivateDialog();
2834 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2837 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2841 case SMESHOp::OpExtrusion:
2843 if (checkLock(aStudy)) break;
2845 EmitSignalDeactivateDialog();
2846 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpExtrusionAlongAPath:
2854 if (checkLock(aStudy)) break;
2856 EmitSignalDeactivateDialog();
2857 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2859 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2863 case SMESHOp::OpRevolution:
2865 if(checkLock(aStudy)) break;
2867 EmitSignalDeactivateDialog();
2868 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2871 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2875 case SMESHOp::OpPatternMapping:
2877 if ( checkLock( aStudy ) )
2881 EmitSignalDeactivateDialog();
2882 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2885 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2889 case SMESHOp::OpSplitBiQuadratic:
2890 case SMESHOp::OpConvertMeshToQuadratic:
2891 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2892 case SMESHOp::OpReorientFaces:
2893 case SMESHOp::OpCreateGeometryGroup:
2895 startOperation( theCommandID );
2898 case SMESHOp::OpCreateGroup:
2902 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2906 if(checkLock(aStudy)) break;
2907 EmitSignalDeactivateDialog();
2908 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2910 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2911 SALOME_ListIO selected;
2913 aSel->selectedObjects( selected );
2915 int nbSel = selected.Extent();
2917 // check if mesh is selected
2918 aMesh = SMESH::GetMeshByIO( selected.First() );
2920 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2925 case SMESHOp::OpConstructGroup:
2929 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2933 if(checkLock(aStudy)) break;
2934 EmitSignalDeactivateDialog();
2936 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2937 SALOME_ListIO selected;
2939 aSel->selectedObjects( selected );
2941 int nbSel = selected.Extent();
2943 // check if submesh is selected
2944 Handle(SALOME_InteractiveObject) IObject = selected.First();
2945 if (IObject->hasEntry()) {
2946 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2948 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2949 if (!aSubMesh->_is_nil()) {
2951 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2952 // get submesh elements list by types
2953 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2954 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2955 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2956 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2957 // create group for each type o elements
2958 QString aName = IObject->getName();
2959 QStringList anEntryList;
2960 if (aNodes->length() > 0) {
2961 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2962 aGroup->Add(aNodes.inout());
2963 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2964 anEntryList.append( aSObject->GetID().c_str() );
2966 if (aEdges->length() > 0) {
2967 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2968 aGroup->Add(aEdges.inout());
2969 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2970 anEntryList.append( aSObject->GetID().c_str() );
2972 if (aFaces->length() > 0) {
2973 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2974 aGroup->Add(aFaces.inout());
2975 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2976 anEntryList.append( aSObject->GetID().c_str() );
2978 if (aVolumes->length() > 0) {
2979 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2980 aGroup->Add(aVolumes.inout());
2981 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2982 anEntryList.append( aSObject->GetID().c_str() );
2985 anApp->browseObjects( anEntryList );
2987 catch(const SALOME::SALOME_Exception & S_ex){
2988 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2995 SUIT_MessageBox::warning(desktop(),
2996 tr("SMESH_WRN_WARNING"),
2997 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3002 case SMESHOp::OpEditGroup:
3006 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3010 if(checkLock(aStudy)) break;
3011 EmitSignalDeactivateDialog();
3013 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3014 SALOME_ListIO selected;
3016 aSel->selectedObjects( selected );
3018 SALOME_ListIteratorOfListIO It (selected);
3019 int nbSelectedGroups = 0;
3020 for ( ; It.More(); It.Next() )
3022 SMESH::SMESH_GroupBase_var aGroup =
3023 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3024 if (!aGroup->_is_nil()) {
3026 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3030 if (nbSelectedGroups == 0)
3032 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3038 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3040 if(checkLock(aStudy)) break;
3041 if (myState == 800) {
3042 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3043 if (aDlg) aDlg->onAdd();
3048 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3050 if(checkLock(aStudy)) break;
3051 if (myState == 800) {
3052 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3053 if (aDlg) aDlg->onRemove();
3058 case SMESHOp::OpEditGeomGroupAsGroup:
3062 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3066 if(checkLock(aStudy)) break;
3067 EmitSignalDeactivateDialog();
3069 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3070 SALOME_ListIO selected;
3072 aSel->selectedObjects( selected );
3074 SALOME_ListIteratorOfListIO It (selected);
3075 for ( ; It.More(); It.Next() )
3077 SMESH::SMESH_GroupOnGeom_var aGroup =
3078 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3079 if (!aGroup->_is_nil()) {
3080 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3085 SMESH::SMESH_GroupOnFilter_var aGroup =
3086 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3087 if (!aGroup->_is_nil()) {
3088 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3096 case SMESHOp::OpUnionGroups:
3097 case SMESHOp::OpIntersectGroups:
3098 case SMESHOp::OpCutGroups:
3102 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3106 if ( checkLock( aStudy ) )
3109 EmitSignalDeactivateDialog();
3111 SMESHGUI_GroupOpDlg* aDlg = 0;
3112 if ( theCommandID == SMESHOp::OpUnionGroups )
3113 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3114 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3115 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3117 aDlg = new SMESHGUI_CutGroupsDlg( this );
3124 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3126 if ( checkLock( aStudy ) )
3129 EmitSignalDeactivateDialog();
3130 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3136 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3140 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3144 if ( checkLock( aStudy ) )
3147 EmitSignalDeactivateDialog();
3149 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3153 case SMESHOp::OpMeshInformation:
3154 case SMESHOp::OpWhatIs:
3156 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3157 EmitSignalDeactivateDialog();
3158 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3159 SALOME_ListIO selected;
3161 aSel->selectedObjects( selected );
3163 if ( selected.Extent() > 1 ) { // a dlg for each IO
3164 SALOME_ListIteratorOfListIO It( selected );
3165 for ( ; It.More(); It.Next() ) {
3166 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3167 dlg->showInfo( It.Value() );
3172 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3178 case SMESHOp::OpFindElementByPoint:
3180 startOperation( theCommandID );
3184 case SMESHOp::OpEditHypothesis:
3186 if(checkLock(aStudy)) break;
3188 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3189 SALOME_ListIO selected;
3191 aSel->selectedObjects( selected );
3193 int nbSel = selected.Extent();
3196 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3197 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3199 if ( !aHypothesis->_is_nil() )
3201 SMESHGUI_GenericHypothesisCreator* aCreator =
3202 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3205 // set geometry of mesh and sub-mesh to aCreator
3206 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3207 if ( selected.Extent() == 1 )
3209 QString subGeomID, meshGeomID;
3210 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3211 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3213 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3214 aCreator->setShapeEntry( subGeomID );
3215 aCreator->setMainShapeEntry( meshGeomID );
3219 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3229 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3231 if(checkLock(aStudy)) break;
3232 SUIT_OverrideCursor wc;
3234 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3235 SALOME_ListIO selected;
3237 aSel->selectedObjects( selected, QString::null, false );
3239 SALOME_ListIteratorOfListIO It(selected);
3240 for (int i = 0; It.More(); It.Next(), i++) {
3241 Handle(SALOME_InteractiveObject) IObject = It.Value();
3242 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3245 aSel->setSelectedObjects( l1 );
3250 case SMESHOp::OpElem0D:
3251 case SMESHOp::OpBall:
3252 case SMESHOp::OpEdge:
3253 case SMESHOp::OpTriangle:
3254 case SMESHOp::OpQuadrangle:
3255 case SMESHOp::OpPolygon:
3256 case SMESHOp::OpTetrahedron:
3257 case SMESHOp::OpHexahedron:
3258 case SMESHOp::OpPentahedron:
3259 case SMESHOp::OpPyramid:
3260 case SMESHOp::OpHexagonalPrism:
3262 if(checkLock(aStudy)) break;
3264 EmitSignalDeactivateDialog();
3265 SMDSAbs_EntityType type = SMDSEntity_Edge;
3266 switch (theCommandID) {
3267 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3268 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3269 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3270 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3271 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3272 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3273 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3274 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3275 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3276 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3279 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3282 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3286 case SMESHOp::OpPolyhedron:
3288 if(checkLock(aStudy)) break;
3290 EmitSignalDeactivateDialog();
3291 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3294 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3298 case SMESHOp::OpQuadraticEdge:
3299 case SMESHOp::OpQuadraticTriangle:
3300 case SMESHOp::OpBiQuadraticTriangle:
3301 case SMESHOp::OpQuadraticQuadrangle:
3302 case SMESHOp::OpBiQuadraticQuadrangle:
3303 case SMESHOp::OpQuadraticPolygon:
3304 case SMESHOp::OpQuadraticTetrahedron:
3305 case SMESHOp::OpQuadraticPyramid:
3306 case SMESHOp::OpQuadraticPentahedron:
3307 case SMESHOp::OpBiQuadraticPentahedron:
3308 case SMESHOp::OpQuadraticHexahedron:
3309 case SMESHOp::OpTriQuadraticHexahedron:
3311 if(checkLock(aStudy)) break;
3313 EmitSignalDeactivateDialog();
3314 SMDSAbs_EntityType type = SMDSEntity_Last;
3316 switch (theCommandID) {
3317 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3318 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3319 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3320 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3321 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3322 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3323 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3324 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3325 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3326 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3327 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3328 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3331 if ( type != SMDSEntity_Last )
3332 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3335 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3336 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3340 case SMESHOp::OpRemoveNodes:
3342 if(checkLock(aStudy)) break;
3344 EmitSignalDeactivateDialog();
3345 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3348 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3349 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3353 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3355 if(checkLock(aStudy)) break;
3357 EmitSignalDeactivateDialog();
3358 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3362 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3363 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3367 case SMESHOp::OpClearMesh: {
3369 if(checkLock(aStudy)) break;
3371 SALOME_ListIO selected;
3372 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3373 aSel->selectedObjects( selected );
3375 SUIT_OverrideCursor wc;
3376 SALOME_ListIteratorOfListIO It (selected);
3377 for ( ; It.More(); It.Next() )
3379 Handle(SALOME_InteractiveObject) IOS = It.Value();
3380 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3381 if ( aMesh->_is_nil()) continue;
3384 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3385 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3386 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3387 SMESH::ModifiedMesh( aMeshSObj, false, true);
3388 // hide groups and submeshes
3389 _PTR(ChildIterator) anIter =
3390 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3391 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3393 _PTR(SObject) so = anIter->Value();
3394 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3397 catch (const SALOME::SALOME_Exception& S_ex){
3399 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3403 SMESH::UpdateView();
3407 case SMESHOp::OpRemoveOrphanNodes:
3409 if(checkLock(aStudy)) break;
3410 SALOME_ListIO selected;
3411 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3412 aSel->selectedObjects( selected );
3413 if ( selected.Extent() == 1 ) {
3414 Handle(SALOME_InteractiveObject) anIO = selected.First();
3415 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3416 if ( !aMesh->_is_nil() ) {
3417 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3418 tr( "SMESH_WARNING" ),
3419 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3420 SUIT_MessageBox::Yes |
3421 SUIT_MessageBox::No,
3422 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3425 SUIT_OverrideCursor wc;
3426 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3427 int removed = aMeshEditor->RemoveOrphanNodes();
3428 SUIT_MessageBox::information(SMESHGUI::desktop(),
3429 tr("SMESH_INFORMATION"),
3430 tr("NB_NODES_REMOVED").arg(removed));
3431 if ( removed > 0 ) {
3432 SMESH::UpdateView();
3433 SMESHGUI::Modified();
3436 catch (const SALOME::SALOME_Exception& S_ex) {
3437 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3446 case SMESHOp::OpRenumberingNodes:
3448 if(checkLock(aStudy)) break;
3450 EmitSignalDeactivateDialog();
3451 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3455 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3456 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3460 case SMESHOp::OpRenumberingElements:
3462 if(checkLock(aStudy)) break;
3464 EmitSignalDeactivateDialog();
3465 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpTranslation:
3476 if(checkLock(aStudy)) break;
3478 EmitSignalDeactivateDialog();
3479 ( new SMESHGUI_TranslationDlg( this ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3487 case SMESHOp::OpRotation:
3489 if(checkLock(aStudy)) break;
3491 EmitSignalDeactivateDialog();
3492 ( new SMESHGUI_RotationDlg( this ) )->show();
3495 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3496 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpSymmetry:
3502 if(checkLock(aStudy)) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3513 case SMESHOp::OpScale:
3515 if(checkLock(aStudy)) break;
3517 EmitSignalDeactivateDialog();
3518 ( new SMESHGUI_ScaleDlg( this ) )->show();
3521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3527 case SMESHOp::OpSewing:
3529 if(checkLock(aStudy)) break;
3531 EmitSignalDeactivateDialog();
3532 ( new SMESHGUI_SewingDlg( this ) )->show();
3535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3536 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpMergeNodes:
3542 if(checkLock(aStudy)) break;
3544 EmitSignalDeactivateDialog();
3545 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3548 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3549 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3553 case SMESHOp::OpMergeElements:
3555 if (checkLock(aStudy)) break;
3557 EmitSignalDeactivateDialog();
3558 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3560 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3561 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3566 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3567 startOperation( SMESHOp::OpMoveNode );
3570 case SMESHOp::OpDuplicateNodes:
3572 if(checkLock(aStudy)) break;
3574 EmitSignalDeactivateDialog();
3575 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3578 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3579 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3584 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3585 startOperation( SMESHOp::OpElem0DOnElemNodes );
3588 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3590 static QList<int> aTypes;
3591 if ( aTypes.isEmpty() )
3593 aTypes.append( SMESH::NODE );
3594 aTypes.append( SMESH::EDGE );
3595 aTypes.append( SMESH::FACE );
3596 aTypes.append( SMESH::VOLUME );
3598 if (!myFilterLibraryDlg)
3599 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3600 else if (myFilterLibraryDlg->isHidden())
3601 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3602 myFilterLibraryDlg->raise();
3606 case SMESHOp::OpFreeNode:
3607 case SMESHOp::OpEqualNode:
3608 case SMESHOp::OpNodeConnectivityNb:
3609 case SMESHOp::OpFreeEdge:
3610 case SMESHOp::OpFreeBorder:
3611 case SMESHOp::OpLength:
3612 case SMESHOp::OpConnection:
3613 case SMESHOp::OpEqualEdge:
3614 case SMESHOp::OpFreeFace:
3615 case SMESHOp::OpBareBorderFace:
3616 case SMESHOp::OpOverConstrainedFace:
3617 case SMESHOp::OpLength2D:
3618 case SMESHOp::OpConnection2D:
3619 case SMESHOp::OpArea:
3620 case SMESHOp::OpTaper:
3621 case SMESHOp::OpAspectRatio:
3622 case SMESHOp::OpMinimumAngle:
3623 case SMESHOp::OpWarpingAngle:
3624 case SMESHOp::OpSkew:
3625 case SMESHOp::OpMaxElementLength2D:
3626 case SMESHOp::OpEqualFace:
3627 case SMESHOp::OpAspectRatio3D:
3628 case SMESHOp::OpVolume:
3629 case SMESHOp::OpMaxElementLength3D:
3630 case SMESHOp::OpBareBorderVolume:
3631 case SMESHOp::OpOverConstrainedVolume:
3632 case SMESHOp::OpEqualVolume:
3635 LightApp_SelectionMgr* mgr = selectionMgr();
3636 SALOME_ListIO selected; mgr->selectedObjects( selected );
3638 if( !selected.IsEmpty() ) {
3639 SUIT_OverrideCursor wc;
3640 ::Control( theCommandID );
3643 SUIT_MessageBox::warning(desktop(),
3644 tr( "SMESH_WRN_WARNING" ),
3645 tr( "SMESH_BAD_SELECTION" ) );
3649 SUIT_MessageBox::warning(desktop(),
3650 tr( "SMESH_WRN_WARNING" ),
3651 tr( "NOT_A_VTK_VIEWER" ) );
3654 case SMESHOp::OpOverallMeshQuality:
3655 OverallMeshQuality();
3657 case SMESHOp::OpNumberingNodes:
3659 SUIT_OverrideCursor wc;
3660 LightApp_SelectionMgr* mgr = selectionMgr();
3661 SALOME_ListIO selected; mgr->selectedObjects( selected );
3663 SALOME_ListIteratorOfListIO it(selected);
3664 for( ; it.More(); it.Next()) {
3665 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3666 if(anIObject->hasEntry()) {
3667 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3668 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3674 case SMESHOp::OpNumberingElements:
3676 SUIT_OverrideCursor wc;
3677 LightApp_SelectionMgr* mgr = selectionMgr();
3678 SALOME_ListIO selected; mgr->selectedObjects( selected );
3680 SALOME_ListIteratorOfListIO it(selected);
3681 for( ; it.More(); it.Next()) {
3682 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3683 if(anIObject->hasEntry())
3684 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3685 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3690 case SMESHOp::OpPropertiesLength:
3691 case SMESHOp::OpPropertiesArea:
3692 case SMESHOp::OpPropertiesVolume:
3693 case SMESHOp::OpMinimumDistance:
3694 case SMESHOp::OpBoundingBox:
3696 int page = SMESHGUI_MeasureDlg::MinDistance;
3697 if ( theCommandID == SMESHOp::OpBoundingBox )
3698 page = SMESHGUI_MeasureDlg::BoundingBox;
3699 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3700 page = SMESHGUI_MeasureDlg::Length;
3701 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3702 page = SMESHGUI_MeasureDlg::Area;
3703 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3704 page = SMESHGUI_MeasureDlg::Volume;
3706 EmitSignalDeactivateDialog();
3707 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3711 case SMESHOp::OpSortChild:
3717 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3718 //updateObjBrowser();
3722 //=============================================================================
3726 //=============================================================================
3727 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3732 //=============================================================================
3736 //=============================================================================
3737 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3742 //=============================================================================
3746 //=============================================================================
3747 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3752 //=============================================================================
3753 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3754 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3756 //=============================================================================
3757 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3758 SUIT_ViewWindow* wnd )
3760 if(theIO->hasEntry()){
3761 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3762 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3766 //=======================================================================
3767 // function : createSMESHAction
3769 //=======================================================================
3770 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3771 const int key, const bool toggle, const QString& shortcutAction )
3774 QWidget* parent = application()->desktop();
3775 SUIT_ResourceMgr* resMgr = resourceMgr();
3777 if ( !icon_id.isEmpty() )
3778 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3780 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3781 if ( !pix.isNull() )
3782 icon = QIcon( pix );
3784 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3785 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3786 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3788 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3789 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3792 //=======================================================================
3793 // function : createPopupItem
3795 //=======================================================================
3796 void SMESHGUI::createPopupItem( const int id,
3797 const QString& clients,
3798 const QString& types,
3799 const QString& theRule,
3802 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3803 popupMgr()->insert( action( id ), pId, 0 );
3805 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3806 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3807 QString rule = "(%1) and (%2) and (%3)";
3808 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3809 if( clients.isEmpty() )
3810 rule = rule.arg( QString( "true" ) );
3812 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3813 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3816 bool cont = myRules.contains( id );
3818 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3820 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3821 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3824 //=======================================================================
3825 // function : initialize
3827 //=======================================================================
3828 void SMESHGUI::initialize( CAM_Application* app )
3830 SalomeApp_Module::initialize( app );
3832 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3834 /* Automatic Update flag */
3835 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3837 // ----- create actions --------------
3839 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3840 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3841 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3842 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3844 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3846 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3847 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3848 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3849 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3850 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3852 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3854 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3855 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3857 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3858 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3859 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3860 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3862 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3864 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3865 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3866 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3867 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3868 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3869 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3871 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3873 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3874 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3875 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3876 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3877 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3878 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3879 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3880 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3881 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3882 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3883 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3884 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3885 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3886 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3887 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3888 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3889 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3890 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3891 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3892 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3893 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3894 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3895 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3896 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3897 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3898 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3899 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3900 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3901 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3902 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3903 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3904 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3905 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3907 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3908 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3909 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3910 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3911 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3912 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3913 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3914 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3915 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3916 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3917 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3918 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3919 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3920 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3921 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3922 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3923 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3924 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3925 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3926 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3927 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3928 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3929 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3930 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3931 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3932 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3933 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3934 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3936 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3937 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3938 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3939 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3940 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3941 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3942 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3943 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3944 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3945 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3946 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3947 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3948 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3949 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3950 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3951 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3952 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3953 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3954 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3955 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3956 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3957 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3958 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3960 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3961 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3963 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3964 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3965 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3966 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3968 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3969 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3971 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3972 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3973 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3974 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3975 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3976 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3977 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3978 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3979 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3980 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3981 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3982 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3983 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3984 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3985 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3986 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3987 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3988 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3989 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3990 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3991 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3992 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3993 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3994 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3996 createSMESHAction( SMESHOp::OpReset, "RESET" );
3997 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3998 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3999 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4000 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4001 #ifndef DISABLE_PLOT2DVIEWER
4002 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4004 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4005 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4006 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4007 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4008 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4009 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4010 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4011 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4012 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4013 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4014 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4015 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4016 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4018 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4019 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4021 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4022 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4023 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4024 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4025 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4026 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4027 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4028 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4029 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4031 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4032 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4033 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4034 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4035 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4037 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4038 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4039 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4041 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4043 QList<int> aCtrlActions;
4044 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4045 << SMESHOp::OpNodeConnectivityNb // node controls
4046 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4047 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4048 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4049 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4050 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4051 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4052 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4053 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4054 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4055 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4056 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4057 aCtrlGroup->setExclusive( true );
4058 for( int i = 0; i < aCtrlActions.size(); i++ )
4059 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4061 // ----- create menu --------------
4062 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4063 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4064 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4065 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4066 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4067 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4068 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4069 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4071 createMenu( separator(), fileId );
4073 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4074 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4075 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4076 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4077 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4078 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4079 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4080 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4081 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4082 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4083 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4084 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4085 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4087 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4088 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4089 createMenu( SMESHOp::OpImportMED, importId, -1 );
4090 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4092 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4094 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4095 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4096 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4097 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4098 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4099 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4101 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4103 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4104 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4105 createMenu( separator(), fileId, 10 );
4107 createMenu( SMESHOp::OpDelete, editId, -1 );
4109 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4111 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4112 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4113 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4114 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4115 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4116 createMenu( separator(), meshId, -1 );
4117 createMenu( SMESHOp::OpCompute, meshId, -1 );
4118 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4119 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4120 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4121 createMenu( separator(), meshId, -1 );
4122 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4123 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4124 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4125 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4126 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4127 createMenu( separator(), meshId, -1 );
4128 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4129 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4130 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4131 createMenu( separator(), meshId, -1 );
4132 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4133 createMenu( separator(), meshId, -1 );
4134 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4135 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4136 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4137 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4140 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4141 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4142 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4143 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4144 createMenu( SMESHOp::OpLength, edgeId, -1 );
4145 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4146 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4147 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4148 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4149 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4150 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4151 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4152 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4153 createMenu( SMESHOp::OpArea, faceId, -1 );
4154 createMenu( SMESHOp::OpTaper, faceId, -1 );
4155 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4156 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4157 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4158 createMenu( SMESHOp::OpSkew, faceId, -1 );
4159 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4160 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4161 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4162 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4163 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4164 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4165 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4166 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4167 createMenu( separator(), ctrlId, -1 );
4168 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4169 createMenu( separator(), ctrlId, -1 );
4170 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4172 createMenu( SMESHOp::OpNode, addId, -1 );
4173 createMenu( SMESHOp::OpElem0D, addId, -1 );
4174 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4175 createMenu( SMESHOp::OpBall, addId, -1 );
4176 createMenu( SMESHOp::OpEdge, addId, -1 );
4177 createMenu( SMESHOp::OpTriangle, addId, -1 );
4178 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4179 createMenu( SMESHOp::OpPolygon, addId, -1 );
4180 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4181 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4182 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4183 createMenu( SMESHOp::OpPyramid, addId, -1 );
4184 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4185 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4186 createMenu( separator(), addId, -1 );
4187 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4188 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4189 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4190 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4191 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4192 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4193 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4194 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4196 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4198 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4200 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4201 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4202 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4203 createMenu( separator(), removeId, -1 );
4204 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4205 createMenu( separator(), removeId, -1 );
4206 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4208 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4209 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4211 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4212 createMenu( SMESHOp::OpRotation, transfId, -1 );
4213 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4214 createMenu( SMESHOp::OpScale, transfId, -1 );
4215 createMenu( SMESHOp::OpSewing, transfId, -1 );
4216 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4217 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4218 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4220 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4221 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4222 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4223 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4224 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4225 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4226 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4227 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4228 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4229 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4230 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4231 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4232 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4233 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4234 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4235 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4237 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4238 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4239 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4240 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4241 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4242 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4244 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4245 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4246 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4247 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4249 // ----- create toolbars --------------
4250 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4251 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4252 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4253 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4254 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4255 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4256 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4257 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4258 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4259 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4260 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4261 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4262 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4263 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4264 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4266 createTool( SMESHOp::OpCreateMesh, meshTb );
4267 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4268 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4269 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4270 createTool( SMESHOp::OpCopyMesh, meshTb );
4271 createTool( separator(), meshTb );
4272 createTool( SMESHOp::OpCompute, meshTb );
4273 createTool( SMESHOp::OpPreCompute, meshTb );
4274 createTool( SMESHOp::OpEvaluate, meshTb );
4275 createTool( SMESHOp::OpMeshOrder, meshTb );
4277 createTool( SMESHOp::OpCreateGroup, groupTb );
4278 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4279 createTool( SMESHOp::OpConstructGroup, groupTb );
4280 createTool( SMESHOp::OpEditGroup, groupTb );
4282 createTool( SMESHOp::OpMeshInformation, info );
4283 //createTool( SMESHOp::OpStdInfo, meshTb );
4284 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4285 createTool( SMESHOp::OpFindElementByPoint, info );
4287 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4288 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4289 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4291 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4292 createTool( SMESHOp::OpLength, ctrl1dTb );
4293 createTool( SMESHOp::OpConnection, ctrl1dTb );
4294 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4296 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4297 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4298 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4299 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4300 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4301 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4302 createTool( SMESHOp::OpArea, ctrl2dTb );
4303 createTool( SMESHOp::OpTaper, ctrl2dTb );
4304 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4305 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4306 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4307 createTool( SMESHOp::OpSkew, ctrl2dTb );
4308 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4309 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4311 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4312 createTool( SMESHOp::OpVolume, ctrl3dTb );
4313 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4314 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4315 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4316 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4318 createTool( SMESHOp::OpNode, addElemTb );
4319 createTool( SMESHOp::OpElem0D, addElemTb );
4320 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4321 createTool( SMESHOp::OpBall, addElemTb );
4322 createTool( SMESHOp::OpEdge, addElemTb );
4323 createTool( SMESHOp::OpTriangle, addElemTb );
4324 createTool( SMESHOp::OpQuadrangle, addElemTb );
4325 createTool( SMESHOp::OpPolygon, addElemTb );
4326 createTool( SMESHOp::OpTetrahedron, addElemTb );
4327 createTool( SMESHOp::OpHexahedron, addElemTb );
4328 createTool( SMESHOp::OpPentahedron, addElemTb );
4329 createTool( SMESHOp::OpPyramid, addElemTb );
4330 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4331 createTool( SMESHOp::OpPolyhedron, addElemTb );
4333 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4334 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4335 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4336 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4337 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4338 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4339 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4340 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4341 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4342 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4343 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4344 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4346 createTool( SMESHOp::OpRemoveNodes, remTb );
4347 createTool( SMESHOp::OpRemoveElements, remTb );
4348 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4349 createTool( SMESHOp::OpClearMesh, remTb );
4351 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4352 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4354 createTool( SMESHOp::OpTranslation, transformTb );
4355 createTool( SMESHOp::OpRotation, transformTb );
4356 createTool( SMESHOp::OpSymmetry, transformTb );
4357 createTool( SMESHOp::OpScale, transformTb );
4358 createTool( SMESHOp::OpSewing, transformTb );
4359 createTool( SMESHOp::OpMergeNodes, transformTb );
4360 createTool( SMESHOp::OpMergeElements, transformTb );
4361 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4363 createTool( SMESHOp::OpMoveNode, modifyTb );
4364 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4365 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4366 createTool( SMESHOp::OpOrientation, modifyTb );
4367 createTool( SMESHOp::OpReorientFaces, modifyTb );
4368 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4369 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4370 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4371 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4372 createTool( SMESHOp::OpSmoothing, modifyTb );
4373 createTool( SMESHOp::OpExtrusion, modifyTb );
4374 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4375 createTool( SMESHOp::OpRevolution, modifyTb );
4376 createTool( SMESHOp::OpPatternMapping, modifyTb );
4377 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4378 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4380 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4382 createTool( SMESHOp::OpUpdate, dispModeTb );
4384 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4385 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4389 OB = "'ObjectBrowser'",
4390 View = "'" + SVTK_Viewer::Type() + "'",
4392 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4393 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4394 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4395 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4396 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4397 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4398 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4399 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4400 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4401 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4402 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4403 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4405 mesh_part = mesh + " " + subMesh + " " + group,
4406 mesh_group = mesh + " " + group,
4407 mesh_submesh = mesh + " " + subMesh,
4408 hyp_alg = hypo + " " + algo;
4410 // popup for object browser
4412 isInvisible("not( isVisible )"),
4413 isEmpty("numberOfNodes = 0"),
4414 isNotEmpty("numberOfNodes <> 0"),
4416 // has nodes, edges, etc in VISIBLE! actor
4417 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4418 hasElems("(count( elemTypes ) > 0)"),
4419 hasDifferentElems("(count( elemTypes ) > 1)"),
4420 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4421 hasBalls("({'BallElem'} in elemTypes)"),
4422 hasElems0d("({'Elem0d'} in elemTypes)"),
4423 hasEdges("({'Edge'} in elemTypes)"),
4424 hasFaces("({'Face'} in elemTypes)"),
4425 hasVolumes("({'Volume'} in elemTypes)"),
4426 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4428 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4429 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4430 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4431 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4432 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4433 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4435 popupMgr()->insert( separator(), -1, 0 );
4436 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4437 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4438 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4439 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4440 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4441 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4442 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4443 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4444 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4445 popupMgr()->insert( separator(), -1, 0 );
4446 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4447 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4448 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4449 popupMgr()->insert( separator(), -1, 0 );
4450 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4451 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4452 popupMgr()->insert( separator(), -1, 0 );
4453 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4454 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4455 popupMgr()->insert( separator(), -1, 0 );
4456 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4457 //popupMgr()->insert( separator(), -1, 0 );
4459 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4460 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4461 QString only_one_2D = only_one_non_empty + " && dim>1";
4463 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4464 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4465 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4466 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4468 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4470 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4471 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4472 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4473 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4474 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4476 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4477 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4478 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4479 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4481 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4483 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4484 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4485 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4486 popupMgr()->insert( separator(), -1, 0 );
4489 createPopupItem( SMESHOp::OpEditGroup, View, group );
4490 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4491 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4493 popupMgr()->insert( separator(), -1, 0 );
4494 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4495 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4496 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4497 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4498 popupMgr()->insert( separator(), -1, 0 );
4500 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4501 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4502 popupMgr()->insert( separator(), -1, 0 );
4504 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4505 QString aType = QString( "%1type in {%2}" ).arg( lc );
4506 aType = aType.arg( mesh_part );
4507 QString aMeshInVTK = aClient + "&&" + aType;
4509 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4510 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4511 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4513 //-------------------------------------------------
4515 //-------------------------------------------------
4516 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4518 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4519 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4520 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4522 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4523 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4524 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4526 popupMgr()->insert( separator(), -1, -1 );
4528 //-------------------------------------------------
4530 //-------------------------------------------------
4531 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4533 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4539 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4545 popupMgr()->insert( separator(), anId, -1 );
4547 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4549 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4551 //-------------------------------------------------
4553 //-------------------------------------------------
4554 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4556 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4558 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4560 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4562 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4570 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4574 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert( separator(), anId, -1 );
4580 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4583 popupMgr()->insert( separator(), anId, -1 );
4585 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4589 //-------------------------------------------------
4590 // Representation of the 2D Quadratic elements
4591 //-------------------------------------------------
4592 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4593 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4595 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4597 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4598 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4599 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4601 //-------------------------------------------------
4602 // Orientation of faces
4603 //-------------------------------------------------
4604 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4606 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4608 //-------------------------------------------------
4610 //-------------------------------------------------
4611 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4614 //-------------------------------------------------
4616 //-------------------------------------------------
4617 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4620 //-------------------------------------------------
4622 //-------------------------------------------------
4624 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4625 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4626 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4627 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4629 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4631 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4632 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4634 popupMgr()->insert( separator(), anId, -1 );
4636 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4638 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4644 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4646 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4647 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4648 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4650 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4652 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4656 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4657 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4658 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4660 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4662 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4663 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4664 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4667 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4669 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4671 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4673 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4675 QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4690 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4692 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4694 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4704 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4706 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4707 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4708 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4710 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4712 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4714 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4716 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4718 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4719 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4720 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4725 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4727 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4737 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4739 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4740 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4741 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4743 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4744 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4745 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4747 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4749 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4751 popupMgr()->insert( separator(), anId, -1 );
4753 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4754 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4755 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4756 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4757 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4759 popupMgr()->insert( separator(), anId, -1 );
4761 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4763 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4766 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4767 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4768 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4770 #ifndef DISABLE_PLOT2DVIEWER
4771 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4775 //-------------------------------------------------
4777 //-------------------------------------------------
4778 popupMgr()->insert( separator(), -1, -1 );
4779 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4780 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4781 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4784 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4785 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4787 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4788 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4790 popupMgr()->insert( separator(), -1, -1 );
4792 //-------------------------------------------------
4794 //-------------------------------------------------
4795 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4798 popupMgr()->insert( separator(), -1, -1 );
4800 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4802 popupMgr()->insert( separator(), -1, -1 );
4804 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4805 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4807 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4808 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4811 //================================================================================
4813 * \brief Return true if SMESH or GEOM objects are selected.
4814 * Is called form LightApp_Module::activateModule() which clear selection if
4815 * not isSelectionCompatible()
4817 //================================================================================
4819 bool SMESHGUI::isSelectionCompatible()
4821 bool isCompatible = true;
4822 SALOME_ListIO selected;
4823 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4824 Sel->selectedObjects( selected );
4826 SALOME_ListIteratorOfListIO It( selected );
4827 for ( ; isCompatible && It.More(); It.Next())
4829 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4830 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4832 return isCompatible;
4836 bool SMESHGUI::reusableOperation( const int id )
4838 // compute, evaluate and precompute are not reusable operations
4839 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4842 bool SMESHGUI::activateModule( SUIT_Study* study )
4844 bool res = SalomeApp_Module::activateModule( study );
4846 setMenuShown( true );
4847 setToolShown( true );
4849 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4850 PyGILState_STATE gstate = PyGILState_Ensure();
4851 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4852 if ( !pluginsmanager ) {
4856 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4861 PyGILState_Release(gstate);
4862 // end of SMESH plugins loading
4864 // Reset actions accelerator keys
4865 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4867 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4868 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4869 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4870 if ( _PTR(Study) aStudy = s->studyDS() )
4871 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4874 // get all view currently opened in the study and connect their signals to
4875 // the corresponding slots of the class.
4876 SUIT_Desktop* aDesk = study->application()->desktop();
4878 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4879 SUIT_ViewWindow* wnd;
4880 foreach ( wnd, wndList )
4884 Py_XDECREF(pluginsmanager);
4888 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4890 setMenuShown( false );
4891 setToolShown( false );
4893 EmitSignalCloseAllDialogs();
4895 // Unset actions accelerator keys
4896 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4898 return SalomeApp_Module::deactivateModule( study );
4901 void SMESHGUI::studyClosed( SUIT_Study* s )
4905 SMESH::RemoveVisuData( s->id() );
4906 SalomeApp_Module::studyClosed( s );
4909 void SMESHGUI::OnGUIEvent()
4911 const QObject* obj = sender();
4912 if ( !obj || !obj->inherits( "QAction" ) )
4914 int id = actionId((QAction*)obj);
4919 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4921 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4922 if ( CORBA::is_nil( myComponentSMESH ) )
4924 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4926 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4927 return aGUI.myComponentSMESH;
4930 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4931 return myComponentSMESH;
4934 QString SMESHGUI::engineIOR() const
4936 CORBA::ORB_var anORB = getApp()->orb();
4937 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4938 return QString( anIOR.in() );
4941 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4943 SalomeApp_Module::contextMenuPopup( client, menu, title );
4945 selectionMgr()->selectedObjects( lst );
4946 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4947 Handle(SALOME_InteractiveObject) io = lst.First();
4948 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4949 _PTR(Study) study = appStudy->studyDS();
4950 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4952 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4953 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4954 aName.remove( (aName.length() - 1), 1 );
4960 LightApp_Selection* SMESHGUI::createSelection() const
4962 return new SMESHGUI_Selection();
4965 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4967 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4968 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4969 #ifndef DISABLE_PYCONSOLE
4970 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4974 void SMESHGUI::viewManagers( QStringList& list ) const
4976 list.append( SVTK_Viewer::Type() );
4979 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4981 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4982 SMESH::UpdateSelectionProp( this );
4984 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4985 for(int i = 0; i < aViews.count() ; i++){
4986 SUIT_ViewWindow *sf = aViews[i];
4989 EmitSignalActivatedViewManager();
4993 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4995 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4996 myClippingPlaneInfoMap.erase( theViewManager );
4999 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5001 theActor->AddObserver( SMESH::DeleteActorEvent,
5002 myEventCallbackCommand.GetPointer(),
5006 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5007 unsigned long theEvent,
5008 void* theClientData,
5011 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5012 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5013 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5014 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5015 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5016 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5017 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5018 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5019 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5020 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5021 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5022 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5023 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5024 if( anActor == *anIter3 ) {
5025 anActorList.erase( anIter3 );
5036 void SMESHGUI::createPreferences()
5038 // General tab ------------------------------------------------------------------------
5039 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5041 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5042 setPreferenceProperty( autoUpdate, "columns", 2 );
5043 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5044 setPreferenceProperty( lim, "min", 0 );
5045 setPreferenceProperty( lim, "max", 100000000 );
5046 setPreferenceProperty( lim, "step", 1000 );
5047 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5048 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5050 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5051 setPreferenceProperty( dispgroup, "columns", 2 );
5052 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5054 modes.append( tr("MEN_WIRE") );
5055 modes.append( tr("MEN_SHADE") );
5056 modes.append( tr("MEN_NODES") );
5057 modes.append( tr("MEN_SHRINK") );
5058 QList<QVariant> indices;
5059 indices.append( 0 );
5060 indices.append( 1 );
5061 indices.append( 2 );
5062 indices.append( 3 );
5063 setPreferenceProperty( dispmode, "strings", modes );
5064 setPreferenceProperty( dispmode, "indexes", indices );
5066 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5067 setPreferenceProperty( arcgroup, "columns", 2 );
5068 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5069 QStringList quadraticModes;
5070 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5071 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5073 indices.append( 0 );
5074 indices.append( 1 );
5075 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5076 setPreferenceProperty( quadraticmode, "indexes", indices );
5078 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5079 "SMESH", "max_angle" );
5080 setPreferenceProperty( maxAngle, "min", 1 );
5081 setPreferenceProperty( maxAngle, "max", 90 );
5083 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5084 setPreferenceProperty( qaGroup, "columns", 2 );
5085 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5086 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5087 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5088 setPreferenceProperty( prec, "min", 0 );
5089 setPreferenceProperty( prec, "max", 100 );
5090 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5091 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5092 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5093 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5094 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5097 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5098 setPreferenceProperty( exportgroup, "columns", 2 );
5099 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5100 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5101 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5103 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5104 setPreferenceProperty( computeGroup, "columns", 2 );
5105 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5107 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5108 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5109 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5111 indices.append( 0 );
5112 indices.append( 1 );
5113 indices.append( 2 );
5114 setPreferenceProperty( notifyMode, "strings", modes );
5115 setPreferenceProperty( notifyMode, "indexes", indices );
5117 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5118 setPreferenceProperty( infoGroup, "columns", 2 );
5119 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5121 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5122 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5124 indices.append( 0 );
5125 indices.append( 1 );
5126 setPreferenceProperty( elemInfo, "strings", modes );
5127 setPreferenceProperty( elemInfo, "indexes", indices );
5128 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5129 setPreferenceProperty( nodesLim, "min", 0 );
5130 setPreferenceProperty( nodesLim, "max", 10000000 );
5131 setPreferenceProperty( nodesLim, "step", 10000 );
5132 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5133 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5134 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5135 setPreferenceProperty( ctrlLim, "min", 0 );
5136 setPreferenceProperty( ctrlLim, "max", 10000000 );
5137 setPreferenceProperty( ctrlLim, "step", 1000 );
5138 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5139 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5140 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5141 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5142 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5144 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5145 setPreferenceProperty( segGroup, "columns", 2 );
5146 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5147 "SMESH", "segmentation" );
5148 setPreferenceProperty( segLen, "min", 1 );
5149 setPreferenceProperty( segLen, "max", 10000000 );
5150 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5151 "SMESH", "nb_segments_per_edge" );
5152 setPreferenceProperty( nbSeg, "min", 1 );
5153 setPreferenceProperty( nbSeg, "max", 10000000 );
5155 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5156 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5157 "SMESH", "forget_mesh_on_hyp_modif" );
5160 // Quantities with individual precision settings
5161 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5162 setPreferenceProperty( precGroup, "columns", 2 );
5164 const int nbQuantities = 6;
5165 int precs[nbQuantities], ii = 0;
5166 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5167 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5168 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5169 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5170 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5171 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5172 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5173 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5174 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5175 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5176 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5177 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5179 // Set property for precision value for spinboxes
5180 for ( ii = 0; ii < nbQuantities; ii++ ){
5181 setPreferenceProperty( precs[ii], "min", -14 );
5182 setPreferenceProperty( precs[ii], "max", 14 );
5183 setPreferenceProperty( precs[ii], "precision", 2 );
5186 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5187 setPreferenceProperty( previewGroup, "columns", 2 );
5188 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5189 setPreferenceProperty( chunkSize, "min", 1 );
5190 setPreferenceProperty( chunkSize, "max", 1000 );
5191 setPreferenceProperty( chunkSize, "step", 50 );
5193 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5194 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5196 // Mesh tab ------------------------------------------------------------------------
5197 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5198 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5199 setPreferenceProperty( nodeGroup, "columns", 3 );
5201 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5203 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5205 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5206 QList<QVariant> aMarkerTypeIndicesList;
5207 QList<QVariant> aMarkerTypeIconsList;
5208 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5209 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5210 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5211 aMarkerTypeIndicesList << i;
5212 aMarkerTypeIconsList << pixmap;
5214 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5215 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5217 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5219 QList<QVariant> aMarkerScaleIndicesList;
5220 QStringList aMarkerScaleValuesList;
5221 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5222 aMarkerScaleIndicesList << i;
5223 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5224 aMarkerScaleValuesList << QString::number( i );
5226 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5227 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5229 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5230 //setPreferenceProperty( elemGroup, "columns", 2 );
5232 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5233 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5234 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5235 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5236 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5237 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5238 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5239 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5240 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5243 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5244 setPreferenceProperty( grpGroup, "columns", 2 );
5246 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5247 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5249 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5250 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5251 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5252 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5253 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5254 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5255 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5256 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5257 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5258 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5259 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5260 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5261 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5262 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5264 setPreferenceProperty( size0d, "min", 1 );
5265 setPreferenceProperty( size0d, "max", 10 );
5267 // setPreferenceProperty( ballSize, "min", 1 );
5268 // setPreferenceProperty( ballSize, "max", 10 );
5270 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5271 setPreferenceProperty( ballDiameter, "max", 1e9 );
5272 setPreferenceProperty( ballDiameter, "step", 0.1 );
5274 setPreferenceProperty( ballScale, "min", 1e-2 );
5275 setPreferenceProperty( ballScale, "max", 1e7 );
5276 setPreferenceProperty( ballScale, "step", 0.5 );
5278 setPreferenceProperty( elemW, "min", 1 );
5279 setPreferenceProperty( elemW, "max", 5 );
5281 setPreferenceProperty( outW, "min", 1 );
5282 setPreferenceProperty( outW, "max", 5 );
5284 setPreferenceProperty( shrink, "min", 0 );
5285 setPreferenceProperty( shrink, "max", 100 );
5287 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5288 setPreferenceProperty( numGroup, "columns", 2 );
5290 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5291 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5293 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5294 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5296 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5297 setPreferenceProperty( orientGroup, "columns", 1 );
5299 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5300 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5302 setPreferenceProperty( orientScale, "min", 0.05 );
5303 setPreferenceProperty( orientScale, "max", 0.5 );
5304 setPreferenceProperty( orientScale, "step", 0.05 );
5306 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5308 // Selection tab ------------------------------------------------------------------------
5309 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5311 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5312 setPreferenceProperty( selGroup, "columns", 2 );
5314 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5315 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5317 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5318 setPreferenceProperty( preGroup, "columns", 2 );
5320 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5322 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5323 setPreferenceProperty( precSelGroup, "columns", 2 );
5325 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5326 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5327 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5329 // Scalar Bar tab ------------------------------------------------------------------------
5330 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5331 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5332 setPreferenceProperty( fontGr, "columns", 2 );
5334 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5335 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5337 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5338 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5340 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5341 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5343 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5344 setPreferenceProperty( numcol, "min", 2 );
5345 setPreferenceProperty( numcol, "max", 256 );
5347 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5348 setPreferenceProperty( numlab, "min", 2 );
5349 setPreferenceProperty( numlab, "max", 65 );
5351 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5352 setPreferenceProperty( orientGr, "columns", 2 );
5353 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5354 QStringList orients;
5355 orients.append( tr( "SMESH_VERTICAL" ) );
5356 orients.append( tr( "SMESH_HORIZONTAL" ) );
5357 indices.clear(); indices.append( 0 ); indices.append( 1 );
5358 setPreferenceProperty( orient, "strings", orients );
5359 setPreferenceProperty( orient, "indexes", indices );
5361 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5362 setPreferenceProperty( posVSizeGr, "columns", 2 );
5363 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5364 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5365 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5366 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5367 setPreferenceProperty( xv, "step", 0.1 );
5368 setPreferenceProperty( xv, "min", 0.0 );
5369 setPreferenceProperty( xv, "max", 1.0 );
5370 setPreferenceProperty( yv, "step", 0.1 );
5371 setPreferenceProperty( yv, "min", 0.0 );
5372 setPreferenceProperty( yv, "max", 1.0 );
5373 setPreferenceProperty( wv, "step", 0.1 );
5374 setPreferenceProperty( wv, "min", 0.0 );
5375 setPreferenceProperty( wv, "max", 1.0 );
5376 setPreferenceProperty( hv, "min", 0.0 );
5377 setPreferenceProperty( hv, "max", 1.0 );
5378 setPreferenceProperty( hv, "step", 0.1 );
5380 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5381 setPreferenceProperty( posHSizeGr, "columns", 2 );
5382 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5383 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5384 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5385 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5386 setPreferenceProperty( xv, "min", 0.0 );
5387 setPreferenceProperty( xv, "max", 1.0 );
5388 setPreferenceProperty( xv, "step", 0.1 );
5389 setPreferenceProperty( xh, "min", 0.0 );
5390 setPreferenceProperty( xh, "max", 1.0 );
5391 setPreferenceProperty( xh, "step", 0.1 );
5392 setPreferenceProperty( yh, "min", 0.0 );
5393 setPreferenceProperty( yh, "max", 1.0 );
5394 setPreferenceProperty( yh, "step", 0.1 );
5395 setPreferenceProperty( wh, "min", 0.0 );
5396 setPreferenceProperty( wh, "max", 1.0 );
5397 setPreferenceProperty( wh, "step", 0.1 );
5398 setPreferenceProperty( hh, "min", 0.0 );
5399 setPreferenceProperty( hh, "max", 1.0 );
5400 setPreferenceProperty( hh, "step", 0.1 );
5402 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5403 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5404 setPreferenceProperty( distributionGr, "columns", 3 );
5406 types.append( tr( "SMESH_MONOCOLOR" ) );
5407 types.append( tr( "SMESH_MULTICOLOR" ) );
5408 indices.clear(); indices.append( 0 ); indices.append( 1 );
5409 setPreferenceProperty( coloringType, "strings", types );
5410 setPreferenceProperty( coloringType, "indexes", indices );
5411 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5415 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5417 if ( sect=="SMESH" ) {
5418 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5419 float aTol = 1.00000009999999;
5420 std::string aWarning;
5421 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5423 if ( name== "selection_object_color" ||
5424 name=="selection_element_color" ||
5425 name== "highlight_color" ||
5426 name=="selection_precision_node" ||
5427 name=="selection_precision_element" ||
5428 name=="selection_precision_object" )
5430 SMESH::UpdateSelectionProp( this );
5432 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5434 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5435 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5436 if ( sbX1+sbW > aTol ) {
5437 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5440 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5441 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5444 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5446 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5447 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5448 if ( sbY1 + sbH > aTol ) {
5449 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5450 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5451 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5454 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5456 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5457 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5458 if ( sbX1 + sbW > aTol ) {
5459 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5462 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5463 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5466 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5468 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5469 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5470 if ( sbY1 + sbH > aTol ) {
5471 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5474 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5475 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5478 else if ( name == "segmentation" )
5480 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5481 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5483 else if ( name == "nb_segments_per_edge" )
5485 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5486 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5488 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5490 QString val = aResourceMgr->stringValue( "SMESH", name );
5491 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5493 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5495 SMESH::UpdateFontProp( this );
5497 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5499 SMESH::UpdateFontProp( this );
5502 if ( aWarning.size() != 0 ) {
5503 aWarning += "The default values are applied instead.";
5504 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5505 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5506 QObject::tr(aWarning.c_str()));
5511 //================================================================================
5513 * \brief Update something in accordance with update flags
5514 * \param theFlags - update flags
5516 * Update viewer or/and object browser etc. in accordance with update flags ( see
5517 * LightApp_UpdateFlags enumeration ).
5519 //================================================================================
5520 void SMESHGUI::update( const int flags )
5522 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5523 SMESH::UpdateView();
5525 SalomeApp_Module::update( flags );
5528 //================================================================================
5530 * \brief Set default selection mode
5532 * SLOT called when operation committed. Sets default selection mode
5534 //================================================================================
5535 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5537 SVTK_ViewWindow* vtkWnd =
5538 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5540 vtkWnd->SetSelectionMode( ActorSelection );
5543 //================================================================================
5545 * \brief Set default selection mode
5547 * SLOT called when operation aborted. Sets default selection mode
5549 //================================================================================
5550 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5552 SVTK_ViewWindow* vtkWnd =
5553 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5555 vtkWnd->SetSelectionMode( ActorSelection );
5558 //================================================================================
5560 * \brief Creates operation with given identifier
5561 * \param id - identifier of operation to be started
5562 * \return Pointer on created operation or NULL if operation is not created
5564 * Virtual method redefined from the base class creates operation with given id.
5565 * It is called called automatically from startOperation method of base class.
5567 //================================================================================
5568 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5570 LightApp_Operation* op = 0;
5571 // to do : create operation here
5574 case SMESHOp::OpSplitBiQuadratic:
5575 op = new SMESHGUI_SplitBiQuadOp();
5577 case SMESHOp::OpConvertMeshToQuadratic:
5578 op = new SMESHGUI_ConvToQuadOp();
5580 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5581 op = new SMESHGUI_Make2DFrom3DOp();
5583 case SMESHOp::OpReorientFaces:
5584 op = new SMESHGUI_ReorientFacesOp();
5586 case SMESHOp::OpCreateMesh:
5587 op = new SMESHGUI_MeshOp( true, true );
5589 case SMESHOp::OpCreateSubMesh:
5590 op = new SMESHGUI_MeshOp( true, false );
5592 case SMESHOp::OpEditMeshOrSubMesh:
5593 case SMESHOp::OpEditMesh:
5594 case SMESHOp::OpEditSubMesh:
5595 op = new SMESHGUI_MeshOp( false );
5597 case SMESHOp::OpCompute:
5598 case SMESHOp::OpComputeSubMesh:
5599 op = new SMESHGUI_ComputeOp();
5601 case SMESHOp::OpPreCompute:
5602 op = new SMESHGUI_PrecomputeOp();
5604 case SMESHOp::OpEvaluate:
5605 op = new SMESHGUI_EvaluateOp();
5607 case SMESHOp::OpMeshOrder:
5608 op = new SMESHGUI_MeshOrderOp();
5610 case SMESHOp::OpCreateGeometryGroup:
5611 op = new SMESHGUI_GroupOnShapeOp();
5613 case SMESHOp::OpFindElementByPoint:
5614 op = new SMESHGUI_FindElemByPointOp();
5616 case SMESHOp::OpMoveNode: // Make mesh pass through point
5617 op = new SMESHGUI_MakeNodeAtPointOp();
5619 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5620 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5627 op = SalomeApp_Module::createOperation( id );
5631 //================================================================================
5633 * \brief Stops current operations and starts a given one
5634 * \param id - The id of the operation to start
5636 //================================================================================
5638 void SMESHGUI::switchToOperation(int id)
5640 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5641 activeStudy()->abortAllOperations();
5642 startOperation( id );
5645 LightApp_Displayer* SMESHGUI::displayer()
5648 myDisplayer = new SMESHGUI_Displayer( getApp() );
5652 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5655 int aTolerance = 64;
5656 int anIterations = 0;
5662 if( anIterations % aPeriod == 0 )
5665 if( aTolerance < 1 )
5669 aHue = (int)( 360.0 * rand() / RAND_MAX );
5672 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5673 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5674 for( ; it != itEnd; ++it )
5676 SALOMEDS::Color anAutoColor = *it;
5677 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5680 aQColor.getHsv( &h, &s, &v );
5681 if( abs( h - aHue ) < aTolerance )
5693 aColor.setHsv( aHue, 255, 255 );
5695 SALOMEDS::Color aSColor;
5696 aSColor.R = aColor.redF();
5697 aSColor.G = aColor.greenF();
5698 aSColor.B = aColor.blueF();
5703 const char* gSeparator = "_"; // character used to separate parameter names
5704 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5705 const char* gPathSep = "|"; // character used to separate paths
5708 * \brief Store visual parameters
5710 * This method is called just before the study document is saved.
5711 * Store visual parameters in AttributeParameter attribue(s)
5713 void SMESHGUI::storeVisualParameters (int savePoint)
5716 Kernel_Utils::Localizer loc;
5718 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5719 if (!appStudy || !appStudy->studyDS())
5721 _PTR(Study) studyDS = appStudy->studyDS();
5723 // componentName is used for encoding of entries when storing them in IParameters
5724 std::string componentName = myComponentSMESH->ComponentDataType();
5725 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5726 //if (!aSComponent) return;
5729 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5730 componentName.c_str(),
5732 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5734 // store map of custom markers
5735 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5736 if( !aMarkerMap.empty() )
5738 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5739 for( ; anIter != aMarkerMap.end(); anIter++ )
5741 int anId = anIter->first;
5742 VTK::MarkerData aMarkerData = anIter->second;
5743 std::string aMarkerFileName = aMarkerData.first;
5744 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5745 if( aMarkerTexture.size() < 3 )
5746 continue; // should contain at least width, height and the first value
5748 QString aPropertyName( "texture" );
5749 aPropertyName += gSeparator;
5750 aPropertyName += QString::number( anId );
5752 QString aPropertyValue = aMarkerFileName.c_str();
5753 aPropertyValue += gPathSep;
5755 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5756 ushort aWidth = *aTextureIter++;
5757 ushort aHeight = *aTextureIter++;
5758 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5759 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5760 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5761 aPropertyValue += QString::number( *aTextureIter );
5763 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5767 // viewers counters are used for storing view_numbers in IParameters
5770 // main cycle to store parameters of displayed objects
5771 QList<SUIT_ViewManager*> lst;
5772 QList<SUIT_ViewManager*>::Iterator it;
5773 getApp()->viewManagers(lst);
5774 for (it = lst.begin(); it != lst.end(); it++)
5776 SUIT_ViewManager* vman = *it;
5777 QString vType = vman->getType();
5779 // saving VTK actors properties
5780 if (vType == SVTK_Viewer::Type())
5782 // store the clipping planes attached to the view manager
5783 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5784 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5785 if( anIter != myClippingPlaneInfoMap.end() )
5786 aClippingPlaneInfoList = anIter->second;
5788 if( !aClippingPlaneInfoList.empty() ) {
5789 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5790 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5792 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5793 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5795 QString aPropertyName( "ClippingPlane" );
5796 aPropertyName += gSeparator;
5797 aPropertyName += QString::number( vtkViewers );
5798 aPropertyName += gSeparator;
5799 aPropertyName += QString::number( anId );
5801 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5802 aPropertyValue += gDigitsSep;
5803 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5804 aPropertyValue += gDigitsSep;
5805 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5806 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5807 aPropertyValue += gDigitsSep;
5808 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5809 aPropertyValue += gDigitsSep;
5810 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5811 aPropertyValue += gDigitsSep;
5812 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5813 aPropertyValue += gDigitsSep;
5814 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5815 aPropertyValue += gDigitsSep;
5816 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5817 aPropertyValue += gDigitsSep;
5818 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5820 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5821 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5830 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5834 QVector<SUIT_ViewWindow*> views = vman->getViews();
5835 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5837 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5839 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5840 vtkActorCollection* allActors = aCopy.GetActors();
5841 allActors->InitTraversal();
5842 while (vtkActor* actor = allActors->GetNextActor())
5844 if (actor->GetVisibility()) // store only visible actors
5846 SMESH_Actor* aSmeshActor = 0;
5847 if (actor->IsA("SMESH_Actor"))
5848 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5849 if (aSmeshActor && aSmeshActor->hasIO())
5851 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5854 // entry is "encoded" = it does NOT contain component address,
5855 // since it is a subject to change on next component loading
5856 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5858 std::string param, vtkParam = vType.toLatin1().data();
5859 vtkParam += gSeparator;
5860 vtkParam += QString::number(vtkViewers).toLatin1().data();
5861 vtkParam += gSeparator;
5864 param = vtkParam + "Visibility";
5865 ip->setParameter(entry, param, "On");
5868 param = vtkParam + "Representation";
5869 ip->setParameter(entry, param, QString::number
5870 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5873 param = vtkParam + "IsShrunk";
5874 ip->setParameter(entry, param, QString::number
5875 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5877 // Displayed entities
5878 unsigned int aMode = aSmeshActor->GetEntityMode();
5879 bool isE = aMode & SMESH_Actor::eEdges;
5880 bool isF = aMode & SMESH_Actor::eFaces;
5881 bool isV = aMode & SMESH_Actor::eVolumes;
5882 bool is0d = aMode & SMESH_Actor::e0DElements;
5883 bool isB = aMode & SMESH_Actor::eBallElem;
5885 QString modeStr ("e");
5886 modeStr += gDigitsSep; modeStr += QString::number(isE);
5887 modeStr += gDigitsSep; modeStr += "f";
5888 modeStr += gDigitsSep; modeStr += QString::number(isF);
5889 modeStr += gDigitsSep; modeStr += "v";
5890 modeStr += gDigitsSep; modeStr += QString::number(isV);
5891 modeStr += gDigitsSep; modeStr += "0d";
5892 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5893 modeStr += gDigitsSep; modeStr += "b";
5894 modeStr += gDigitsSep; modeStr += QString::number(isB);
5896 param = vtkParam + "Entities";
5897 ip->setParameter(entry, param, modeStr.toLatin1().data());
5903 aSmeshActor->GetSufaceColor(r, g, b, delta);
5904 QStringList colorStr;
5905 colorStr << "surface";
5906 colorStr << QString::number(r);
5907 colorStr << QString::number(g);
5908 colorStr << QString::number(b);
5910 colorStr << "backsurface";
5911 colorStr << QString::number(delta);
5913 aSmeshActor->GetVolumeColor(r, g, b, delta);
5914 colorStr << "volume";
5915 colorStr << QString::number(r);
5916 colorStr << QString::number(g);
5917 colorStr << QString::number(b);
5918 colorStr << QString::number(delta);
5920 aSmeshActor->GetEdgeColor(r, g, b);
5922 colorStr << QString::number(r);
5923 colorStr << QString::number(g);
5924 colorStr << QString::number(b);
5926 aSmeshActor->GetNodeColor(r, g, b);
5928 colorStr << QString::number(r);
5929 colorStr << QString::number(g);
5930 colorStr << QString::number(b);
5932 aSmeshActor->GetOutlineColor(r, g, b);
5933 colorStr << "outline";
5934 colorStr << QString::number(r);
5935 colorStr << QString::number(g);
5936 colorStr << QString::number(b);
5938 aSmeshActor->Get0DColor(r, g, b);
5939 colorStr << "elem0d";
5940 colorStr << QString::number(r);
5941 colorStr << QString::number(g);
5942 colorStr << QString::number(b);
5944 aSmeshActor->GetBallColor(r, g, b);
5946 colorStr << QString::number(r);
5947 colorStr << QString::number(g);
5948 colorStr << QString::number(b);
5950 aSmeshActor->GetFacesOrientationColor(r, g, b);
5951 colorStr << "orientation";
5952 colorStr << QString::number(r);
5953 colorStr << QString::number(g);
5954 colorStr << QString::number(b);
5956 param = vtkParam + "Colors";
5957 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5960 QStringList sizeStr;
5962 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5963 sizeStr << "outline";
5964 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5965 sizeStr << "elem0d";
5966 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5968 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5969 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5970 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5971 sizeStr << "shrink";
5972 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5973 sizeStr << "orientation";
5974 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5975 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5977 param = vtkParam + "Sizes";
5978 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5983 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5984 if( aMarkerType == VTK::MT_USER ) {
5985 markerStr += "custom";
5986 markerStr += gDigitsSep;
5987 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5991 markerStr += gDigitsSep;
5992 markerStr += QString::number( (int)aMarkerType );
5993 markerStr += gDigitsSep;
5994 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5997 param = vtkParam + "PointMarker";
5998 ip->setParameter(entry, param, markerStr.toLatin1().data());
6001 param = vtkParam + "Opacity";
6002 ip->setParameter(entry, param,
6003 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6006 param = vtkParam + "ClippingPlane";
6008 if( !aClippingPlaneInfoList.empty() ) {
6009 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6010 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6012 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6013 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6014 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6015 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6016 if( aSmeshActor == *anIter2 ) {
6017 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6018 QString::number( anId ).toLatin1().constData() );
6025 ip->setParameter( entry, param, "Off" );
6026 } // if (io->hasEntry())
6027 } // SMESH_Actor && hasIO
6029 } // while.. actors traversal
6033 } // if (SVTK view model)
6034 } // for (viewManagers)
6037 // data structures for clipping planes processing
6041 bool isOpenGLClipping;
6042 vtkIdType RelativeOrientation;
6045 int AbsoluteOrientation;
6046 double X, Y, Z, Dx, Dy, Dz;
6048 typedef std::list<TPlaneData> TPlaneDataList;
6049 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6051 typedef std::list<vtkActor*> TActorList;
6054 TActorList ActorList;
6055 SUIT_ViewManager* ViewManager;
6057 typedef std::list<TPlaneInfo> TPlaneInfoList;
6058 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6061 * \brief Restore visual parameters
6063 * This method is called after the study document is opened.
6064 * Restore visual parameters from AttributeParameter attribue(s)
6066 void SMESHGUI::restoreVisualParameters (int savePoint)
6069 Kernel_Utils::Localizer loc;
6071 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6072 if (!appStudy || !appStudy->studyDS())
6074 _PTR(Study) studyDS = appStudy->studyDS();
6076 // componentName is used for encoding of entries when storing them in IParameters
6077 std::string componentName = myComponentSMESH->ComponentDataType();
6078 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6079 //if (!aSComponent) return;
6082 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6083 componentName.c_str(),
6085 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6087 // restore map of custom markers and map of clipping planes
6088 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6089 TPlaneDataMap aPlaneDataMap;
6091 std::vector<std::string> properties = ip->getProperties();
6092 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6094 std::string property = *propIt;
6095 QString aPropertyName( property.c_str() );
6096 QString aPropertyValue( ip->getProperty( property ).c_str() );
6098 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6099 if( aPropertyNameList.isEmpty() )
6102 QString aPropertyType = aPropertyNameList[0];
6103 if( aPropertyType == "texture" )
6105 if( aPropertyNameList.size() != 2 )
6109 int anId = aPropertyNameList[1].toInt( &ok );
6110 if( !ok || anId < 1 )
6113 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6114 if( aPropertyValueList.size() != 2 )
6117 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6118 QString aMarkerTextureString = aPropertyValueList[1];
6119 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6120 if( aMarkerTextureStringList.size() != 3 )
6124 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6129 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6133 VTK::MarkerTexture aMarkerTexture;
6134 aMarkerTexture.push_back( aWidth );
6135 aMarkerTexture.push_back( aHeight );
6137 QString aMarkerTextureData = aMarkerTextureStringList[2];
6138 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6140 QChar aChar = aMarkerTextureData.at( i );
6141 if( aChar.isDigit() )
6142 aMarkerTexture.push_back( aChar.digitValue() );
6145 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6147 else if( aPropertyType == "ClippingPlane" )
6149 if( aPropertyNameList.size() != 3 )
6153 int aViewId = aPropertyNameList[1].toInt( &ok );
6154 if( !ok || aViewId < 0 )
6158 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6159 if( !ok || aClippingPlaneId < 0 )
6162 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6163 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6166 TPlaneData aPlaneData;
6167 aPlaneData.AbsoluteOrientation = false;
6168 aPlaneData.RelativeOrientation = 0;
6169 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6170 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6171 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6173 aPlaneData.Id = aClippingPlaneId;
6176 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6181 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6185 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6188 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6193 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6198 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6203 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6208 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6213 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6218 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6222 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6224 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6229 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6234 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6239 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6244 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6245 aPlaneDataList.push_back( aPlaneData );
6249 TPlaneInfoMap aPlaneInfoMap;
6251 std::vector<std::string> entries = ip->getEntries();
6253 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6255 // entry is a normal entry - it should be "decoded" (setting base address of component)
6256 QString entry (ip->decodeEntry(*entIt).c_str());
6258 // Check that the entry corresponds to a real object in the Study
6259 // as the object may be deleted or modified after the visual state is saved.
6260 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6261 if (!so) continue; //Skip the not existent entry
6263 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6264 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6266 std::vector<std::string>::iterator namesIt = paramNames.begin();
6267 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6269 // actors are stored in a map after displaying of them for
6270 // quicker access in the future: map < viewID to actor >
6271 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6273 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6275 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6276 // '_' is used as separator and should not be used in viewer type or parameter names.
6277 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6278 if (lst.size() != 3)
6281 QString viewerTypStr = lst[0];
6282 QString viewIndexStr = lst[1];
6283 QString paramNameStr = lst[2];
6286 int viewIndex = viewIndexStr.toUInt(&ok);
6287 if (!ok) // bad conversion of view index to integer
6291 if (viewerTypStr == SVTK_Viewer::Type())
6293 SMESH_Actor* aSmeshActor = 0;
6294 if (vtkActors.IsBound(viewIndex))
6295 aSmeshActor = vtkActors.Find(viewIndex);
6297 QList<SUIT_ViewManager*> lst;
6298 getApp()->viewManagers(viewerTypStr, lst);
6300 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6301 SUIT_ViewManager* vman = NULL;
6302 if (viewIndex >= 0 && viewIndex < lst.count())
6303 vman = lst.at(viewIndex);
6305 if (paramNameStr == "Visibility")
6307 if (!aSmeshActor && displayer() && vman)
6309 SUIT_ViewModel* vmodel = vman->getViewModel();
6310 // SVTK view model can be casted to SALOME_View
6311 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6313 // store displayed actor in a temporary map for quicker
6314 // access later when restoring other parameters
6315 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6316 vtkRenderer* Renderer = vtkView->getRenderer();
6317 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6318 vtkActorCollection* theActors = aCopy.GetActors();
6319 theActors->InitTraversal();
6320 bool isFound = false;
6321 vtkActor *ac = theActors->GetNextActor();
6322 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6323 if (ac->IsA("SMESH_Actor")) {
6324 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6325 if (aGeomAc->hasIO()) {
6326 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6327 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6329 vtkActors.Bind(viewIndex, aGeomAc);
6335 } // if (paramNameStr == "Visibility")
6338 // the rest properties "work" with SMESH_Actor
6341 QString val ((*valuesIt).c_str());
6344 if (paramNameStr == "Representation") {
6345 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6348 else if (paramNameStr == "IsShrunk") {
6350 if (!aSmeshActor->IsShrunk())
6351 aSmeshActor->SetShrink();
6354 if (aSmeshActor->IsShrunk())
6355 aSmeshActor->UnShrink();
6358 // Displayed entities
6359 else if (paramNameStr == "Entities") {
6360 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6361 int aEntityMode = SMESH_Actor::eAllEntity;
6362 for ( int i = 0; i < mode.count(); i+=2 ) {
6363 if ( i < mode.count()-1 ) {
6364 QString type = mode[i];
6365 bool val = mode[i+1].toInt();
6366 if ( type == "e" && !val )
6367 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6368 else if ( type == "f" && !val )
6369 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6370 else if ( type == "v" && !val )
6371 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6372 else if ( type == "0d" && !val )
6373 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6374 else if ( type == "b" && !val )
6375 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6378 aSmeshActor->SetEntityMode( aEntityMode );
6381 else if (paramNameStr == "Colors") {
6382 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6389 QColor outlineColor;
6390 QColor orientationColor;
6396 // below lines are required to get default values for delta coefficients
6397 // of backface color for faces and color of reversed volumes
6398 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6399 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6400 for ( int i = 0; i < colors.count(); i++ ) {
6401 QString type = colors[i];
6402 if ( type == "surface" ) {
6403 // face color is set by 3 values r:g:b, where
6404 // - r,g,b - is rgb color components
6405 if ( i+1 >= colors.count() ) break; // format error
6406 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6407 if ( i+2 >= colors.count() ) break; // format error
6408 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 if ( i+3 >= colors.count() ) break; // format error
6410 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 faceColor.setRgbF( r, g, b );
6414 else if ( type == "backsurface" ) {
6415 // backface color can be defined in several ways
6416 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6417 // - in latest versions, it is set as delta coefficient
6418 bool rgbOk = false, deltaOk;
6419 if ( i+1 >= colors.count() ) break; // format error
6420 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6421 int delta = colors[i+1].toInt( &deltaOk );
6423 if ( i+1 < colors.count() ) // index is shifted to 1
6424 g = colors[i+1].toDouble( &rgbOk );
6425 if ( rgbOk ) i++; // shift index
6426 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6427 b = colors[i+1].toDouble( &rgbOk );
6429 // - as currently there's no way to set directly backsurface color as it was before,
6430 // we ignore old dump where r,g,b triple was set
6431 // - also we check that delta parameter is set properly
6432 if ( !rgbOk && deltaOk )
6435 else if ( type == "volume" ) {
6436 // volume color is set by 4 values r:g:b:delta, where
6437 // - r,g,b - is a normal volume rgb color components
6438 // - delta - is a reversed volume color delta coefficient
6439 if ( i+1 >= colors.count() ) break; // format error
6440 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6441 if ( i+2 >= colors.count() ) break; // format error
6442 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+3 >= colors.count() ) break; // format error
6444 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+4 >= colors.count() ) break; // format error
6446 int delta = colors[i+4].toInt( &bOk );
6447 if ( !bOk ) break; // format error
6448 volumeColor.setRgbF( r, g, b );
6452 else if ( type == "edge" ) {
6453 // edge color is set by 3 values r:g:b, where
6454 // - r,g,b - is rgb color components
6455 if ( i+1 >= colors.count() ) break; // format error
6456 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+2 >= colors.count() ) break; // format error
6458 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+3 >= colors.count() ) break; // format error
6460 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 edgeColor.setRgbF( r, g, b );
6464 else if ( type == "node" ) {
6465 // node color is set by 3 values r:g:b, where
6466 // - r,g,b - is rgb color components
6467 if ( i+1 >= colors.count() ) break; // format error
6468 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 if ( i+2 >= colors.count() ) break; // format error
6470 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+3 >= colors.count() ) break; // format error
6472 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 nodeColor.setRgbF( r, g, b );
6476 else if ( type == "elem0d" ) {
6477 // 0d element color is set by 3 values r:g:b, where
6478 // - r,g,b - is rgb color components
6479 if ( i+1 >= colors.count() ) break; // format error
6480 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 if ( i+2 >= colors.count() ) break; // format error
6482 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 if ( i+3 >= colors.count() ) break; // format error
6484 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 elem0dColor.setRgbF( r, g, b );
6488 else if ( type == "ball" ) {
6489 // ball color is set by 3 values r:g:b, where
6490 // - r,g,b - is rgb color components
6491 if ( i+1 >= colors.count() ) break; // format error
6492 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 if ( i+2 >= colors.count() ) break; // format error
6494 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+3 >= colors.count() ) break; // format error
6496 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 ballColor.setRgbF( r, g, b );
6500 else if ( type == "outline" ) {
6501 // outline color is set by 3 values r:g:b, where
6502 // - r,g,b - is rgb color components
6503 if ( i+1 >= colors.count() ) break; // format error
6504 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6505 if ( i+2 >= colors.count() ) break; // format error
6506 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+3 >= colors.count() ) break; // format error
6508 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 outlineColor.setRgbF( r, g, b );
6512 else if ( type == "orientation" ) {
6513 // orientation color is set by 3 values r:g:b, where
6514 // - r,g,b - is rgb color components
6515 if ( i+1 >= colors.count() ) break; // format error
6516 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6517 if ( i+2 >= colors.count() ) break; // format error
6518 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6519 if ( i+3 >= colors.count() ) break; // format error
6520 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 orientationColor.setRgbF( r, g, b );
6526 if ( nodeColor.isValid() )
6527 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6529 if ( edgeColor.isValid() )
6530 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6532 if ( faceColor.isValid() )
6533 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6535 if ( volumeColor.isValid() )
6536 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6537 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6538 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6540 if ( elem0dColor.isValid() )
6541 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6543 if ( ballColor.isValid() )
6544 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6546 if ( outlineColor.isValid() )
6547 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6548 // orientation color
6549 if ( orientationColor.isValid() )
6550 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6553 else if (paramNameStr == "Sizes") {
6554 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6557 int outlineWidth = -1;
6558 int elem0dSize = -1;
6559 //int ballSize = -1;
6560 double ballDiameter = -1.0;
6561 double ballScale = -1.0;
6562 double shrinkSize = -1;
6563 double orientationSize = -1;
6564 bool orientation3d = false;
6565 for ( int i = 0; i < sizes.count(); i++ ) {
6566 QString type = sizes[i];
6567 if ( type == "line" ) {
6568 // line (wireframe) width is given as single integer value
6569 if ( i+1 >= sizes.count() ) break; // format error
6570 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6574 if ( type == "outline" ) {
6575 // outline width is given as single integer value
6576 if ( i+1 >= sizes.count() ) break; // format error
6577 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6581 else if ( type == "elem0d" ) {
6582 // 0d element size is given as single integer value
6583 if ( i+1 >= sizes.count() ) break; // format error
6584 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6588 else if ( type == "ball" ) {
6589 // balls are specified by two values: size:scale, where
6590 // - size - is a integer value specifying size
6591 // - scale - is a double value specifying scale factor
6592 if ( i+1 >= sizes.count() ) break; // format error
6593 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6594 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6595 if ( i+2 >= sizes.count() ) break; // format error
6596 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6602 else if ( type == "shrink" ) {
6603 // shrink factor is given as single floating point value
6604 if ( i+1 >= sizes.count() ) break; // format error
6605 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6609 else if ( type == "orientation" ) {
6610 // orientation vectors are specified by two values size:3d, where
6611 // - size - is a floating point value specifying scale factor
6612 // - 3d - is a boolean
6613 if ( i+1 >= sizes.count() ) break; // format error
6614 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6615 if ( i+2 >= sizes.count() ) break; // format error
6616 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6617 orientationSize = v1;
6618 orientation3d = (bool)v2;
6622 // line (wireframe) width
6623 if ( lineWidth > 0 )
6624 aSmeshActor->SetLineWidth( lineWidth );
6626 if ( outlineWidth > 0 )
6627 aSmeshActor->SetOutlineWidth( outlineWidth );
6628 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6629 aSmeshActor->SetOutlineWidth( lineWidth );
6631 if ( elem0dSize > 0 )
6632 aSmeshActor->Set0DSize( elem0dSize );
6634 /*if ( ballSize > 0 )
6635 aSmeshActor->SetBallSize( ballSize );*/
6637 if ( ballDiameter > 0 )
6638 aSmeshActor->SetBallSize( ballDiameter );
6640 if ( ballScale > 0.0 )
6641 aSmeshActor->SetBallScale( ballScale );
6643 if ( shrinkSize > 0 )
6644 aSmeshActor->SetShrinkFactor( shrinkSize );
6645 // orientation vectors
6646 if ( orientationSize > 0 ) {
6647 aSmeshActor->SetFacesOrientationScale( orientationSize );
6648 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6652 else if (paramNameStr == "PointMarker") {
6653 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6654 if( data.count() >= 2 ) {
6656 int aParam1 = data[1].toInt( &ok );
6658 if( data[0] == "std" && data.count() == 3 ) {
6659 int aParam2 = data[2].toInt( &ok );
6660 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6662 else if( data[0] == "custom" ) {
6663 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6664 if( markerIt != aMarkerMap.end() ) {
6665 VTK::MarkerData aMarkerData = markerIt->second;
6666 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6673 else if (paramNameStr == "Opacity") {
6674 aSmeshActor->SetOpacity(val.toFloat());
6677 else if (paramNameStr.startsWith("ClippingPlane")) {
6678 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6679 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6680 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6681 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6682 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6683 // new format - val looks like "Off" or "0" (plane id)
6684 // (note: in new format "Off" value is used only for consistency,
6685 // so it is processed together with values in old format)
6686 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6687 if( anIsOldFormat ) {
6688 if (paramNameStr == "ClippingPlane1" || val == "Off")
6689 aSmeshActor->RemoveAllClippingPlanes();
6691 QList<SUIT_ViewManager*> lst;
6692 getApp()->viewManagers(viewerTypStr, lst);
6693 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6694 if (viewIndex >= 0 && viewIndex < lst.count()) {
6695 SUIT_ViewManager* vman = lst.at(viewIndex);
6696 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6698 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6700 SMESH::TActorList anActorList;
6701 anActorList.push_back( aSmeshActor );
6702 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6703 aPlane->myViewWindow = vtkView;
6704 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6705 aPlane->PlaneMode = aMode;
6706 bool isOpenGLClipping = ( bool )vals[1].toInt();
6707 aPlane->IsOpenGLClipping = isOpenGLClipping;
6708 if ( aMode == SMESH::Absolute ) {
6709 aPlane->myAbsoluteOrientation = vals[2].toInt();
6710 aPlane->X = vals[3].toFloat();
6711 aPlane->Y = vals[4].toFloat();
6712 aPlane->Z = vals[5].toFloat();
6713 aPlane->Dx = vals[6].toFloat();
6714 aPlane->Dy = vals[7].toFloat();
6715 aPlane->Dz = vals[8].toFloat();
6717 else if ( aMode == SMESH::Relative ) {
6718 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6719 aPlane->myDistance = vals[3].toFloat();
6720 aPlane->myAngle[0] = vals[4].toFloat();
6721 aPlane->myAngle[1] = vals[5].toFloat();
6725 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6726 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6727 aClippingPlaneInfo.Plane = aPlane;
6728 aClippingPlaneInfo.ActorList = anActorList;
6729 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6737 int aPlaneId = val.toInt( &ok );
6738 if( ok && aPlaneId >= 0 ) {
6739 bool anIsDefinedPlane = false;
6740 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6741 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6742 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6743 TPlaneInfo& aPlaneInfo = *anIter;
6744 if( aPlaneInfo.PlaneId == aPlaneId ) {
6745 aPlaneInfo.ActorList.push_back( aSmeshActor );
6746 anIsDefinedPlane = true;
6750 if( !anIsDefinedPlane ) {
6751 TPlaneInfo aPlaneInfo;
6752 aPlaneInfo.PlaneId = aPlaneId;
6753 aPlaneInfo.ActorList.push_back( aSmeshActor );
6754 aPlaneInfo.ViewManager = vman;
6756 // to make the list sorted by plane id
6757 anIter = aPlaneInfoList.begin();
6758 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6759 const TPlaneInfo& aPlaneInfoRef = *anIter;
6760 if( aPlaneInfoRef.PlaneId > aPlaneId )
6763 aPlaneInfoList.insert( anIter, aPlaneInfo );
6768 } // if (aSmeshActor)
6769 } // other parameters than Visibility
6771 } // for names/parameters iterator
6772 } // for entries iterator
6774 // take into account planes with empty list of actors referred to them
6775 QList<SUIT_ViewManager*> aVMList;
6776 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6778 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6779 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6780 int aViewId = aPlaneDataIter->first;
6781 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6782 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6784 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6786 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6787 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6788 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6789 const TPlaneData& aPlaneData = *anIter2;
6790 int aPlaneId = aPlaneData.Id;
6792 bool anIsFound = false;
6793 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6794 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6795 const TPlaneInfo& aPlaneInfo = *anIter3;
6796 if( aPlaneInfo.PlaneId == aPlaneId ) {
6803 TPlaneInfo aPlaneInfo; // ActorList field is empty
6804 aPlaneInfo.PlaneId = aPlaneId;
6805 aPlaneInfo.ViewManager = aViewManager;
6807 // to make the list sorted by plane id
6808 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6809 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6810 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6811 if( aPlaneInfoRef.PlaneId > aPlaneId )
6814 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6820 // add clipping planes to actors according to the restored parameters
6821 // and update the clipping plane map
6822 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6823 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6824 int aViewId = anIter1->first;
6825 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6827 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6828 if( anIter2 == aPlaneDataMap.end() )
6830 const TPlaneDataList& aPlaneDataList = anIter2->second;
6832 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6833 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6834 const TPlaneInfo& aPlaneInfo = *anIter3;
6835 int aPlaneId = aPlaneInfo.PlaneId;
6836 const TActorList& anActorList = aPlaneInfo.ActorList;
6837 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6841 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6845 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6847 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6848 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6849 const TPlaneData& aPlaneData = *anIter4;
6850 if( aPlaneData.Id == aPlaneId ) {
6851 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6852 aPlane->myViewWindow = aViewWindow;
6853 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6854 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6855 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6856 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6857 aPlane->X = aPlaneData.X;
6858 aPlane->Y = aPlaneData.Y;
6859 aPlane->Z = aPlaneData.Z;
6860 aPlane->Dx = aPlaneData.Dx;
6861 aPlane->Dy = aPlaneData.Dy;
6862 aPlane->Dz = aPlaneData.Dz;
6864 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6865 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6866 aPlane->myDistance = aPlaneData.Distance;
6867 aPlane->myAngle[0] = aPlaneData.Angle[0];
6868 aPlane->myAngle[1] = aPlaneData.Angle[1];
6871 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6872 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6873 aClippingPlaneInfo.Plane = aPlane;
6874 aClippingPlaneInfo.ActorList = anActorList;
6875 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6886 // update all VTK views
6887 QList<SUIT_ViewManager*> lst;
6888 getApp()->viewManagers(lst);
6889 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6890 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6891 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6892 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6893 // set OpenGL clipping planes
6894 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6895 vtkActorCollection* anAllActors = aCopy.GetActors();
6896 anAllActors->InitTraversal();
6897 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6898 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6899 anActor->SetOpenGLClippingPlane();
6901 vtkView->getRenderer()->ResetCameraClippingRange();
6908 \brief Adds preferences for dfont of VTK viewer
6910 \param pIf group identifier
6911 \param param parameter
6912 \return identifier of preferences
6914 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6916 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6918 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6921 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6922 fam.append( tr( "SMESH_FONT_COURIER" ) );
6923 fam.append( tr( "SMESH_FONT_TIMES" ) );
6925 setPreferenceProperty( tfont, "fonts", fam );
6927 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6928 if ( needSize ) f = f | QtxFontEdit::Size;
6929 setPreferenceProperty( tfont, "features", f );
6935 \brief Actions after hypothesis edition
6936 Updates object browser after hypothesis edition
6938 void SMESHGUI::onHypothesisEdit( int result )
6941 SMESHGUI::Modified();
6942 updateObjBrowser( true );
6946 \brief Actions after choosing menu of control modes
6947 Updates control mode actions according to current selection
6949 void SMESHGUI::onUpdateControlActions()
6951 SALOME_ListIO selected;
6952 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6953 aSel->selectedObjects( selected );
6955 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6956 if ( selected.Extent() ) {
6957 if ( selected.First()->hasEntry() ) {
6958 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6959 aControl = anActor->GetControlMode();
6960 SALOME_ListIteratorOfListIO it(selected);
6961 for ( it.Next(); it.More(); it.Next() ) {
6962 Handle(SALOME_InteractiveObject) anIO = it.Value();
6963 if ( anIO->hasEntry() ) {
6964 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6965 if ( aControl != anActor->GetControlMode() ) {
6966 aControl = SMESH_Actor::eNone;
6976 int anAction = ActionToControl( aControl, true );
6978 action( anAction )->setChecked( true );
6980 QMenu* send = (QMenu*)sender();
6981 QList<QAction*> actions = send->actions();
6982 for ( int i = 0; i < actions.size(); i++ )
6983 actions[i]->setChecked( false );
6989 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6990 \param pview view being closed
6992 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6993 #ifndef DISABLE_PLOT2DVIEWER
6994 //Crear all Plot2d Viewers if need.
6995 SMESH::ClearPlot2Viewers(pview);
6997 EmitSignalCloseView();
7000 void SMESHGUI::message( const QString& msg )
7003 QStringList data = msg.split("/");
7004 if ( data.count() > 0 ) {
7005 if ( data.first() == "mesh_loading" ) {
7007 QString entry = data.count() > 1 ? data[1] : QString();
7008 if ( entry.isEmpty() )
7011 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7013 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7016 name = SMESH::fromUtf8(obj->GetName());
7017 if ( name.isEmpty() )
7020 if ( data.last() == "stop" )
7021 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7023 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7024 QApplication::processEvents();
7030 \brief Connects or disconnects signals about activating and cloning view on the module slots
7031 \param pview view which is connected/disconnected
7033 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7037 SUIT_ViewManager* viewMgr = pview->getViewManager();
7039 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7040 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7042 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7043 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7048 \brief Return \c true if object can be renamed
7050 bool SMESHGUI::renameAllowed( const QString& entry) const {
7051 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7055 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7059 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7064 if(appStudy->isComponent(entry) || obj->isReference())
7067 // check type to prevent renaming of inappropriate objects
7068 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7069 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7070 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7071 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7072 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7073 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7080 Rename object by entry.
7081 \param entry entry of the object
7082 \param name new name of the object
7083 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7085 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7087 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7091 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7096 _PTR(Study) aStudy = appStudy->studyDS();
7101 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7103 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7108 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7109 _PTR(GenericAttribute) anAttr;
7110 _PTR(AttributeName) aName;
7112 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7114 // check type to prevent renaming of inappropriate objects
7115 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7116 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7117 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7118 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7119 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7120 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7121 if ( !name.isEmpty() ) {
7122 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7124 // update name of group object and its actor
7125 Handle(SALOME_InteractiveObject) IObject =
7126 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7128 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7129 if( !aGroupObject->_is_nil() ) {
7130 aGroupObject->SetName( qPrintable(name) );
7131 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7132 anActor->setName( qPrintable(name) );
7142 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7144 static QList<QColor> colors;
7146 if ( colors.isEmpty() ) {
7148 for (int s = 0; s < 2 ; s++)
7150 for (int v = 100; v >= 40; v = v - 20)
7152 for (int h = 0; h < 359 ; h = h + 60)
7154 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7159 static int currentColor = randomize( colors.size() );
7161 SALOMEDS::Color color;
7162 color.R = (double)colors[currentColor].red() / 255.0;
7163 color.G = (double)colors[currentColor].green() / 255.0;
7164 color.B = (double)colors[currentColor].blue() / 255.0;
7166 currentColor = (currentColor+1) % colors.count();