#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
#endif
#include "Python.h"
+
// SMESH includes
#include "SMESHGUI.h"
+#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
#include "SMESHGUI_BuildCompoundDlg.h"
#include "SMESHGUI_ClippingDlg.h"
#include "SMESHGUI_ComputeDlg.h"
#include "SMESHGUI_ConvToQuadOp.h"
+#include "SMESHGUI_CopyMeshDlg.h"
#include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
#include "SMESHGUI_DeleteGroupDlg.h"
#include "SMESHGUI_Displayer.h"
-#include "SMESHGUI_MergeDlg.h"
+#include "SMESHGUI_DuplicateNodesDlg.h"
#include "SMESHGUI_ExtrusionAlongPathDlg.h"
#include "SMESHGUI_ExtrusionDlg.h"
#include "SMESHGUI_FileInfoDlg.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
+#include "SMESHGUI_MergeDlg.h"
#include "SMESHGUI_MeshInfo.h"
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI_MeshOrderOp.h"
#include "SMESHGUI_RemoveElementsDlg.h"
#include "SMESHGUI_RemoveNodesDlg.h"
#include "SMESHGUI_RenumberingDlg.h"
+#include "SMESHGUI_ReorientFacesDlg.h"
#include "SMESHGUI_RevolutionDlg.h"
#include "SMESHGUI_RotationDlg.h"
+#include "SMESHGUI_ScaleDlg.h"
#include "SMESHGUI_Selection.h"
#include "SMESHGUI_SewingDlg.h"
#include "SMESHGUI_SingleEditDlg.h"
#include "SMESHGUI_SmoothingDlg.h"
#include "SMESHGUI_SymmetryDlg.h"
#include "SMESHGUI_TranslationDlg.h"
-#include "SMESHGUI_ScaleDlg.h"
#include "SMESHGUI_TransparencyDlg.h"
-#include "SMESHGUI_DuplicateNodesDlg.h"
-#include "SMESHGUI_CopyMeshDlg.h"
-#include "SMESHGUI_ReorientFacesDlg.h"
-#include "SMESHGUI_Utils.h"
-#include "SMESHGUI_MeshUtils.h"
-#include "SMESHGUI_GroupUtils.h"
#include "SMESHGUI_FilterUtils.h"
+#include "SMESHGUI_GroupUtils.h"
+#include "SMESHGUI_HypothesesUtils.h"
+#include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_PatternUtils.h"
+#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
-#include "SMESHGUI_HypothesesUtils.h"
#include <SMESH_version.h>
-#include <SMESH_Client.hxx>
+#include "SMESH_ControlsDef.hxx"
#include <SMESH_Actor.h>
-#include <SMESH_ScalarBarActor.h>
#include <SMESH_ActorUtils.h>
+#include <SMESH_Client.hxx>
+#include <SMESH_ScalarBarActor.h>
#include <SMESH_TypeFilter.hxx>
-#include "SMESH_ControlsDef.hxx"
// SALOME GUI includes
-#include <SalomeApp_Tools.h>
-#include <SalomeApp_Study.h>
#include <SalomeApp_Application.h>
#include <SalomeApp_CheckFileDlg.h>
#include <SalomeApp_DataObject.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_Tools.h>
#include <LightApp_DataOwner.h>
+#include <LightApp_NameDlg.h>
#include <LightApp_Preferences.h>
#include <LightApp_SelectionMgr.h>
#include <LightApp_UpdateFlags.h>
-#include <LightApp_NameDlg.h>
-#include <SVTK_ViewWindow.h>
-#include <SVTK_ViewModel.h>
#include <SVTK_ViewManager.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
#include <VTKViewer_Algorithm.h>
-#include <SUIT_MessageBox.h>
-#include <SUIT_ResourceMgr.h>
-#include <SUIT_FileDlg.h>
#include <SUIT_Desktop.h>
+#include <SUIT_FileDlg.h>
+#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
+#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <QtxPopupMgr.h>
#include <boost/shared_ptr.hpp>
// VTK includes
-#include <vtkCamera.h>
-#include <vtkRenderer.h>
-#include <vtkPlane.h>
#include <vtkCallbackCommand.h>
+#include <vtkCamera.h>
#include <vtkLookupTable.h>
+#include <vtkPlane.h>
+#include <vtkRenderer.h>
// SALOME KERNEL includes
-#include <SALOMEDS_Study.hxx>
-#include <SALOMEDSClient_StudyBuilder.hxx>
-#include <SALOMEDSClient_SComponent.hxx>
#include <SALOMEDSClient_ClientFactory.hxx>
#include <SALOMEDSClient_IParameters.hxx>
+#include <SALOMEDSClient_SComponent.hxx>
+#include <SALOMEDSClient_StudyBuilder.hxx>
+#include <SALOMEDS_Study.hxx>
// OCCT includes
#include <Standard_ErrorHandler.hxx>
#include <Basics_Utils.hxx>
//To disable automatic genericobj management, the following line should be commented.
-//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
+//Otherwise, it should be uncommented.
+//Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
#define WITHGENERICOBJ
//namespace{
std::string myExtension;
if ( theCommandID == 113 ) {
- filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
+ filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
}
else if ( theCommandID == 112 ) {
filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
}
else if ( theCommandID == 115 ) {
- filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
+ filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
}
else if ( theCommandID == 116 ) {
filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
anInitialPath = QDir::currentPath();
- QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
- anInitialPath,
- filter,
- QObject::tr( "SMESH_IMPORT_MESH" ) );
+ QStringList filenames;
+ bool toCreateGroups = true;
+
+ // if ( theCommandID == 118 ) { // GMF
+ // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
+ // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
+ // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
+ // fd->setNameFilters( filter );
+ // fd->SetChecked( true );
+ // if ( fd->exec() )
+ // filenames << fd->selectedFile();
+ // toCreateGroups = fd->IsChecked();
+
+ // delete fd;
+ // }
+ // else
+ {
+ filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
+ anInitialPath,
+ filter,
+ QObject::tr( "SMESH_IMPORT_MESH" ) );
+ }
if ( filenames.count() > 0 ) {
SUIT_OverrideCursor wc;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
// GMF format
SMESH::ComputeError_var res;
aMeshes->length( 1 );
- aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(), res.out() );
+ aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
+ toCreateGroups,
+ res.out() );
if ( res->code != SMESH::DRS_OK ) {
errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
anEntryList.append( aMeshSO->GetID().c_str() );
-#ifdef WITHGENERICOBJ
// obj has been published in study. Its refcount has been incremented.
// It is safe to decrement its refcount
// so that it will be destroyed when the entry in study will be removed
aMeshes[i]->UnRegister();
-#endif
}
else {
isEmpty = true;
{
format = "GMF";
notSupportedElemTypes.push_back( SMESH::Entity_0D );
- notSupportedElemTypes.push_back( SMESH::Entity_Quad_Quadrangle );
notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
- notSupportedElemTypes.push_back( SMESH::Entity_Quad_Hexa );
notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
else if ( isGMF )
aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
- if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
+ if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
anInitialPath + QString("/") + aMeshName,
aFilter, aTitle, false);
}
+ // else if ( isGMF )// Export to GMF
+ // {
+ // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
+ // ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
+ // QStringList filters;
+ // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
+ // << QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
+ // fd->setWindowTitle( aTitle );
+ // fd->setNameFilters( filters );
+
+ // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
+ // toCreateGroups = false;
+ // else
+ // toCreateGroups = ( aMesh->NbGroups() > 0 );
+
+ // fd->SetChecked( true );
+ // if ( !anInitialPath.isEmpty() )
+ // fd->setDirectory( anInitialPath );
+ // fd->selectFile(aMeshName);
+
+ // if ( fd->exec() )
+ // aFilename = fd->selectedFile();
+ // toCreateGroups = fd->IsChecked();
+
+ // delete fd;
+ // }
else if ( isCGNS )// Export to CGNS
{
SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
}
else if ( isGMF )
{
- aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data() );
+ toCreateGroups = true;
+ aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
}
}
catch (const SALOME::SALOME_Exception& S_ex){
vtkLookupTable* lookupTable =
static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
double * minmax = lookupTable->GetRange();
+ bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
std::vector<int> nbEvents;
std::vector<double> funValues;
- aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
+ aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
QString anInitialPath = "";
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
anInitialPath = QDir::currentPath();
return;
}
case 1132: {
- vtkFloatingPointType color[3];
+ double color[3];
QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
QColor orientationColor, outlineColor, volumeColor;
int deltaF = 0, deltaV = 0;
int ballSize = 1;
int edgeWidth = 1;
int outlineWidth = 1;
- vtkFloatingPointType shrinkCoef = 0.0;
- vtkFloatingPointType orientationScale = 0.0;
+ double shrinkCoef = 0.0;
+ double orientationScale = 0.0;
bool orientation3d = false;
VTK::MarkerType markerType = VTK::MT_NONE;
VTK::MarkerScale markerScale = VTK::MS_NONE;
aControl = SMESH_Actor::eCoincidentElems3D;
break;
}
-
+
anActor->SetControlMode(aControl);
anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
SMESH::RepaintCurrentView();
std::string anEntry = SO->GetID();
/** Erase graphical object **/
- if(SO->FindAttribute(anAttr, "AttributeIOR")){
- ViewManagerList aViewMenegers = anApp->viewManagers();
- ViewManagerList::const_iterator it = aViewMenegers.begin();
- for( ; it != aViewMenegers.end(); it++) {
- SUIT_ViewManager* vm = *it;
- int nbSf = vm ? vm->getViewsCount() : 0;
- if(vm) {
- QVector<SUIT_ViewWindow*> aViews = vm->getViews();
- for(int i = 0; i < nbSf; i++){
- SUIT_ViewWindow *sf = aViews[i];
- if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
- SMESH::RemoveActor(sf,anActor);
- }
- }
- }
- }
+ if(SO->FindAttribute(anAttr, "AttributeIOR")) {
+ SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
+ // ViewManagerList aViewMenegers = anApp->viewManagers();
+ // ViewManagerList::const_iterator it = aViewMenegers.begin();
+ // for( ; it != aViewMenegers.end(); it++) {
+ // SUIT_ViewManager* vm = *it;
+ // int nbSf = vm ? vm->getViewsCount() : 0;
+ // if(vm) {
+ // QVector<SUIT_ViewWindow*> aViews = vm->getViews();
+ // for(int i = 0; i < nbSf; i++){
+ // SUIT_ViewWindow *sf = aViews[i];
+ // if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
+ // SMESH::RemoveActor(sf,anActor);
+ // }
+ // }
+ // }
+ // }
}
/** Remove an object from data structures **/
SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
*/
//=============================================================================
SMESHGUI::SMESHGUI() :
-SalomeApp_Module( "SMESH" ),
-LightApp_Module( "SMESH" )
+SalomeApp_Module( "SMESH" )
{
if ( CORBA::is_nil( myComponentSMESH ) )
{
myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
myPriority = 0.0;
- SMESH::GetFilterManager();
- SMESH::GetPattern();
- SMESH::GetMeasurements();
-
/* load resources for all available meshers */
SMESH::InitAvailableHypotheses();
}
//=============================================================================
SMESHGUI::~SMESHGUI()
{
-#ifdef WITHGENERICOBJ
- SMESH::GetFilterManager()->UnRegister();
- SMESH::GetMeasurements()->UnRegister();
-#endif
- SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
- SMESH::GetMeasurements() = SMESH::Measurements::_nil();
}
//=============================================================================
if(checkLock(aStudy)) break;
if ( vtkwnd ) {
EmitSignalDeactivateDialog();
- SMDSAbs_EntityType type;
+ SMDSAbs_EntityType type = SMDSEntity_Last;
switch (theCommandID) {
case 4034:
case 4039:
type = SMDSEntity_Quad_Penta; break;
case 4040:
- type = SMDSEntity_Quad_Hexa;
+ type = SMDSEntity_Quad_Hexa; break;
case 4140:
- type = SMDSEntity_TriQuad_Hexa;
- break;
- default:;
+ type = SMDSEntity_TriQuad_Hexa; break;
+ default: break;
}
- ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
+ if ( type != SMDSEntity_Last )
+ ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
}
else {
SUIT_MessageBox::warning(SMESHGUI::desktop(),
break;
}
+ case 4070: // 0D_ON_ALL_NODES
+ startOperation( 4070 );
+ break;
+
case 5105: // Library of selection filters
{
static QList<int> aTypes;
createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
+ createSMESHAction( 4070, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
createMenu( 4000, addId, -1 );
createMenu( 4009, addId, -1 );
+ createMenu( 4070, addId, -1 );
createMenu( 4008, addId, -1 );
createMenu( 4010, addId, -1 );
createMenu( 4021, addId, -1 );
createTool( 4000, addRemTb );
createTool( 4009, addRemTb );
+ createTool( 4070, addRemTb );
createTool( 4008, addRemTb );
createTool( 4010, addRemTb );
createTool( 4021, addRemTb );
setPreferenceProperty( notifyMode, "indexes", indices );
int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
- setPreferenceProperty( infoGroup, "columns", 4 );
+ setPreferenceProperty( infoGroup, "columns", 2 );
int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
modes.clear();
modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
setPreferenceProperty( nodesLim, "max", 10000000 );
setPreferenceProperty( nodesLim, "step", 10000 );
setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
+ addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
+ addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
+ addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
+ addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
setPreferenceProperty( segGroup, "columns", 2 );
setPreferenceProperty( shrink, "min", 0 );
setPreferenceProperty( shrink, "max", 100 );
+ int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
+ setPreferenceProperty( numGroup, "columns", 2 );
+
+ addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
+ addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
+
+ addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
+ addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
+
int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
setPreferenceProperty( orientGroup, "columns", 1 );
QString val = aResourceMgr->stringValue( "SMESH", name );
myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
}
+ else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
+ SMESH::UpdateFontProp( this );
+ }
+ else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
+ SMESH::UpdateFontProp( this );
+ }
if(aWarning.size() != 0){
aWarning += "The default values are applied instead.";
case 904: // Find element
op = new SMESHGUI_FindElemByPointOp();
break;
- case 4067: // make mesh pass through point
+ case 4067: // Make mesh pass through point
op = new SMESHGUI_MakeNodeAtPointOp();
break;
+ case 4070: // Create 0D elements on all nodes
+ op = new SMESHGUI_Add0DElemsOnAllNodesOp();
+ break;
default:
break;
}
bool isE = aMode & SMESH_Actor::eEdges;
bool isF = aMode & SMESH_Actor::eFaces;
bool isV = aMode & SMESH_Actor::eVolumes;
- bool is0d = aMode & SMESH_Actor::e0DElements;
- bool isB = aMode & SMESH_Actor::eBallElem;
+ bool is0d = aMode & SMESH_Actor::e0DElements;
+ bool isB = aMode & SMESH_Actor::eBallElem;
QString modeStr ("e");
modeStr += gDigitsSep; modeStr += QString::number(isE);
ip->setParameter(entry, param, modeStr.toLatin1().data());
// Colors
- vtkFloatingPointType r, g, b;
+ double r, g, b;
int delta;
aSmeshActor->GetSufaceColor(r, g, b, delta);
QStringList colorStr;
- colorStr << "surface";
+ colorStr << "surface";
colorStr << QString::number(r);
colorStr << QString::number(g);
colorStr << QString::number(b);
ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
// Sizes
- QStringList sizeStr;
- sizeStr << "line";
+ QStringList sizeStr;
+ sizeStr << "line";
sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
sizeStr << "outline";
sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
typedef struct {
int Id;
vtkIdType Orientation;
- vtkFloatingPointType Distance;
- vtkFloatingPointType Angle[2];
+ double Distance;
+ double Angle[2];
} TPlaneData;
typedef std::list<TPlaneData> TPlaneDataList;
typedef std::map<int, TPlaneDataList> TPlaneDataMap;
// Displayed entities
else if (paramNameStr == "Entities") {
QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
- int aEntityMode = SMESH_Actor::eAllEntity;
- for ( int i = 0; i < mode.count(); i+=2 ) {
- if ( i < mode.count()-1 ) {
- QString type = mode[i];
- bool val = mode[i+1].toInt();
- if ( type == "e" && !val )
- aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
- else if ( type == "f" && !val )
- aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
- else if ( type == "v" && !val )
- aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
- else if ( type == "0d" && !val )
- aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
- else if ( type == "b" && !val )
- aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
- }
- }
- aSmeshActor->SetEntityMode( aEntityMode );
+ int aEntityMode = SMESH_Actor::eAllEntity;
+ for ( int i = 0; i < mode.count(); i+=2 ) {
+ if ( i < mode.count()-1 ) {
+ QString type = mode[i];
+ bool val = mode[i+1].toInt();
+ if ( type == "e" && !val )
+ aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
+ else if ( type == "f" && !val )
+ aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
+ else if ( type == "v" && !val )
+ aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
+ else if ( type == "0d" && !val )
+ aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
+ else if ( type == "b" && !val )
+ aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
+ }
+ }
+ aSmeshActor->SetEntityMode( aEntityMode );
}
// Colors
else if (paramNameStr == "Colors") {
QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
- QColor nodeColor;
- QColor edgeColor;
- QColor faceColor;
- QColor volumeColor;
- QColor elem0dColor;
- QColor ballColor;
- QColor outlineColor;
- QColor orientationColor;
- int deltaF;
- int deltaV;
- QColor c;
- double r, g, b;
- bool bOk;
- // below lines are required to get default values for delta coefficients
- // of backface color for faces and color of reversed volumes
- SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
- SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
- for ( int i = 0; i < colors.count(); i++ ) {
- QString type = colors[i];
- if ( type == "surface" ) {
- // face color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- faceColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "backsurface" ) {
- // backface color can be defined in several ways
- // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
- // - in latest versions, it is set as delta coefficient
- bool rgbOk = false, deltaOk;
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- int delta = colors[i+1].toInt( &deltaOk );
- i++; // shift index
- if ( i+1 < colors.count() ) // index is shifted to 1
- g = colors[i+1].toDouble( &rgbOk );
- if ( rgbOk ) i++; // shift index
- if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
- b = colors[i+1].toDouble( &rgbOk );
- if ( rgbOk ) i++;
- // - as currently there's no way to set directly backsurface color as it was before,
- // we ignore old dump where r,g,b triple was set
- // - also we check that delta parameter is set properly
- if ( !rgbOk && deltaOk )
- deltaF = delta;
- }
- else if ( type == "volume" ) {
- // volume color is set by 4 values r:g:b:delta, where
- // - r,g,b - is a normal volume rgb color components
- // - delta - is a reversed volume color delta coefficient
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+4 >= colors.count() ) break; // format error
- int delta = colors[i+4].toInt( &bOk );
+ QColor nodeColor;
+ QColor edgeColor;
+ QColor faceColor;
+ QColor volumeColor;
+ QColor elem0dColor;
+ QColor ballColor;
+ QColor outlineColor;
+ QColor orientationColor;
+ int deltaF;
+ int deltaV;
+ QColor c;
+ double r, g, b;
+ bool bOk;
+ // below lines are required to get default values for delta coefficients
+ // of backface color for faces and color of reversed volumes
+ SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
+ SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
+ for ( int i = 0; i < colors.count(); i++ ) {
+ QString type = colors[i];
+ if ( type == "surface" ) {
+ // face color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ faceColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "backsurface" ) {
+ // backface color can be defined in several ways
+ // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
+ // - in latest versions, it is set as delta coefficient
+ bool rgbOk = false, deltaOk;
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ int delta = colors[i+1].toInt( &deltaOk );
+ i++; // shift index
+ if ( i+1 < colors.count() ) // index is shifted to 1
+ g = colors[i+1].toDouble( &rgbOk );
+ if ( rgbOk ) i++; // shift index
+ if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
+ b = colors[i+1].toDouble( &rgbOk );
+ if ( rgbOk ) i++;
+ // - as currently there's no way to set directly backsurface color as it was before,
+ // we ignore old dump where r,g,b triple was set
+ // - also we check that delta parameter is set properly
+ if ( !rgbOk && deltaOk )
+ deltaF = delta;
+ }
+ else if ( type == "volume" ) {
+ // volume color is set by 4 values r:g:b:delta, where
+ // - r,g,b - is a normal volume rgb color components
+ // - delta - is a reversed volume color delta coefficient
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+4 >= colors.count() ) break; // format error
+ int delta = colors[i+4].toInt( &bOk );
if ( !bOk ) break; // format error
- volumeColor.setRgbF( r, g, b );
- deltaV = delta;
- i += 4;
- }
- else if ( type == "edge" ) {
- // edge color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- edgeColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "node" ) {
- // node color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- nodeColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "elem0d" ) {
- // 0d element color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- elem0dColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "ball" ) {
- // ball color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- ballColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "outline" ) {
- // outline color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- outlineColor.setRgbF( r, g, b );
- i += 3;
- }
- else if ( type == "orientation" ) {
- // orientation color is set by 3 values r:g:b, where
- // - r,g,b - is rgb color components
- if ( i+1 >= colors.count() ) break; // format error
- r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= colors.count() ) break; // format error
- g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+3 >= colors.count() ) break; // format error
- b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
- orientationColor.setRgbF( r, g, b );
- i += 3;
- }
- }
- // node color
- if ( nodeColor.isValid() )
- aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
- // edge color
- if ( edgeColor.isValid() )
- aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
- // face color
- if ( faceColor.isValid() )
- aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
- // volume color
- if ( volumeColor.isValid() )
- aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
- else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
- aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
- // 0d element color
- if ( elem0dColor.isValid() )
- aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
- // ball color
- if ( ballColor.isValid() )
- aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
- // outline color
- if ( outlineColor.isValid() )
- aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
- // orientation color
- if ( orientationColor.isValid() )
- aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
+ volumeColor.setRgbF( r, g, b );
+ deltaV = delta;
+ i += 4;
+ }
+ else if ( type == "edge" ) {
+ // edge color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ edgeColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "node" ) {
+ // node color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ nodeColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "elem0d" ) {
+ // 0d element color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ elem0dColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "ball" ) {
+ // ball color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ ballColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "outline" ) {
+ // outline color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ outlineColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ else if ( type == "orientation" ) {
+ // orientation color is set by 3 values r:g:b, where
+ // - r,g,b - is rgb color components
+ if ( i+1 >= colors.count() ) break; // format error
+ r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= colors.count() ) break; // format error
+ g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+3 >= colors.count() ) break; // format error
+ b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
+ orientationColor.setRgbF( r, g, b );
+ i += 3;
+ }
+ }
+ // node color
+ if ( nodeColor.isValid() )
+ aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
+ // edge color
+ if ( edgeColor.isValid() )
+ aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
+ // face color
+ if ( faceColor.isValid() )
+ aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
+ // volume color
+ if ( volumeColor.isValid() )
+ aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
+ else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
+ aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
+ // 0d element color
+ if ( elem0dColor.isValid() )
+ aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
+ // ball color
+ if ( ballColor.isValid() )
+ aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
+ // outline color
+ if ( outlineColor.isValid() )
+ aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
+ // orientation color
+ if ( orientationColor.isValid() )
+ aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
}
// Sizes
else if (paramNameStr == "Sizes") {
QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
- bool bOk;
- int lineWidth = -1;
- int outlineWidth = -1;
- int elem0dSize = -1;
- int ballSize = -1;
- double shrinkSize = -1;
- double orientationSize = -1;
- bool orientation3d = false;
- for ( int i = 0; i < sizes.count(); i++ ) {
- QString type = sizes[i];
- if ( type == "line" ) {
- // line (wireframe) width is given as single integer value
- if ( i+1 >= sizes.count() ) break; // format error
- int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
- lineWidth = v;
- i++;
- }
- if ( type == "outline" ) {
- // outline width is given as single integer value
- if ( i+1 >= sizes.count() ) break; // format error
- int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
- outlineWidth = v;
- i++;
- }
- else if ( type == "elem0d" ) {
- // 0d element size is given as single integer value
- if ( i+1 >= sizes.count() ) break; // format error
- int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
- elem0dSize = v;
- i++;
- }
- else if ( type == "ball" ) {
- // ball size is given as single integer value
- if ( i+1 >= sizes.count() ) break; // format error
- int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
- ballSize = v;
- i++;
- }
- else if ( type == "shrink" ) {
- // shrink factor is given as single floating point value
- if ( i+1 >= sizes.count() ) break; // format error
- double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- shrinkSize = v;
- i++;
- }
- else if ( type == "orientation" ) {
- // orientation vectors are specified by two values size:3d, where
- // - size - is a floating point value specifying scale factor
- // - 3d - is a boolean
- if ( i+1 >= sizes.count() ) break; // format error
- double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
- if ( i+2 >= sizes.count() ) break; // format error
- int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
- orientationSize = v1;
- orientation3d = (bool)v2;
- i += 2;
- }
- }
- // line (wireframe) width
- if ( lineWidth > 0 )
- aSmeshActor->SetLineWidth( lineWidth );
- // outline width
- if ( outlineWidth > 0 )
- aSmeshActor->SetOutlineWidth( outlineWidth );
- else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
- aSmeshActor->SetOutlineWidth( lineWidth );
- // 0d element size
- if ( elem0dSize > 0 )
- aSmeshActor->Set0DSize( elem0dSize );
- // ball size
- if ( ballSize > 0 )
- aSmeshActor->SetBallSize( ballSize );
- // shrink factor
- if ( shrinkSize > 0 )
- aSmeshActor->SetShrinkFactor( shrinkSize );
- // orientation vectors
- if ( orientationSize > 0 ) {
- aSmeshActor->SetFacesOrientationScale( orientationSize );
- aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
- }
+ bool bOk;
+ int lineWidth = -1;
+ int outlineWidth = -1;
+ int elem0dSize = -1;
+ int ballSize = -1;
+ double shrinkSize = -1;
+ double orientationSize = -1;
+ bool orientation3d = false;
+ for ( int i = 0; i < sizes.count(); i++ ) {
+ QString type = sizes[i];
+ if ( type == "line" ) {
+ // line (wireframe) width is given as single integer value
+ if ( i+1 >= sizes.count() ) break; // format error
+ int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
+ lineWidth = v;
+ i++;
+ }
+ if ( type == "outline" ) {
+ // outline width is given as single integer value
+ if ( i+1 >= sizes.count() ) break; // format error
+ int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
+ outlineWidth = v;
+ i++;
+ }
+ else if ( type == "elem0d" ) {
+ // 0d element size is given as single integer value
+ if ( i+1 >= sizes.count() ) break; // format error
+ int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
+ elem0dSize = v;
+ i++;
+ }
+ else if ( type == "ball" ) {
+ // ball size is given as single integer value
+ if ( i+1 >= sizes.count() ) break; // format error
+ int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
+ ballSize = v;
+ i++;
+ }
+ else if ( type == "shrink" ) {
+ // shrink factor is given as single floating point value
+ if ( i+1 >= sizes.count() ) break; // format error
+ double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ shrinkSize = v;
+ i++;
+ }
+ else if ( type == "orientation" ) {
+ // orientation vectors are specified by two values size:3d, where
+ // - size - is a floating point value specifying scale factor
+ // - 3d - is a boolean
+ if ( i+1 >= sizes.count() ) break; // format error
+ double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
+ if ( i+2 >= sizes.count() ) break; // format error
+ int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
+ orientationSize = v1;
+ orientation3d = (bool)v2;
+ i += 2;
+ }
+ }
+ // line (wireframe) width
+ if ( lineWidth > 0 )
+ aSmeshActor->SetLineWidth( lineWidth );
+ // outline width
+ if ( outlineWidth > 0 )
+ aSmeshActor->SetOutlineWidth( outlineWidth );
+ else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
+ aSmeshActor->SetOutlineWidth( lineWidth );
+ // 0d element size
+ if ( elem0dSize > 0 )
+ aSmeshActor->Set0DSize( elem0dSize );
+ // ball size
+ if ( ballSize > 0 )
+ aSmeshActor->SetBallSize( ballSize );
+ // shrink factor
+ if ( shrinkSize > 0 )
+ aSmeshActor->SetShrinkFactor( shrinkSize );
+ // orientation vectors
+ if ( orientationSize > 0 ) {
+ aSmeshActor->SetFacesOrientationScale( orientationSize );
+ aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
+ }
}
// Point marker
else if (paramNameStr == "PointMarker") {
if (val != "Off") {
SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
double aDistance = vals[1].toFloat();
- vtkFloatingPointType anAngle[2];
+ double anAngle[2];
anAngle[0] = vals[2].toFloat();
anAngle[1] = vals[3].toFloat();
\param param parameter
\return identifier of preferences
*/
-int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
+int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
{
int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
setPreferenceProperty( tfont, "fonts", fam );
int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
+ if ( needSize ) f = f | QtxFontEdit::Size;
setPreferenceProperty( tfont, "features", f );
return tfont;
