qwt_plot_multi_barchart.cpp
/******************************************************************************
* Qwt Widget Library
* Copyright (C) 1997 Josef Wilgen
* Copyright (C) 2002 Uwe Rathmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#include "qwt_plot_multi_barchart.h"
#include "qwt_scale_map.h"
#include "qwt_column_symbol.h"
#include "qwt_text.h"
#include "qwt_graphic.h"
#include "qwt_legend_data.h"
#include "qwt_math.h"
#include <qmap.h>
inline static bool qwtIsIncreasing(
const QwtScaleMap& map, const QVector< double >& values )
{
bool isInverting = map.isInverting();
for ( int i = 0; i < values.size(); i++ )
{
const double y = values[ i ];
if ( y != 0.0 )
return ( map.isInverting() != ( y > 0.0 ) );
}
return !isInverting;
}
class QwtPlotMultiBarChart::PrivateData
{
public:
PrivateData()
: style( QwtPlotMultiBarChart::Grouped )
{
}
QwtPlotMultiBarChart::ChartStyle style;
QList< QwtText > barTitles;
QMap< int, QwtColumnSymbol* > symbolMap;
};
QwtPlotMultiBarChart::QwtPlotMultiBarChart( const QwtText& title )
: QwtPlotAbstractBarChart( title )
{
init();
}
QwtPlotMultiBarChart::QwtPlotMultiBarChart( const QString& title )
: QwtPlotAbstractBarChart( QwtText( title ) )
{
init();
}
QwtPlotMultiBarChart::~QwtPlotMultiBarChart()
{
resetSymbolMap();
delete m_data;
}
void QwtPlotMultiBarChart::init()
{
m_data = new PrivateData;
setData( new QwtSetSeriesData() );
}
int QwtPlotMultiBarChart::rtti() const
{
return QwtPlotItem::Rtti_PlotMultiBarChart;
}
void QwtPlotMultiBarChart::setSamples(
const QVector< QwtSetSample >& samples )
{
setData( new QwtSetSeriesData( samples ) );
}
void QwtPlotMultiBarChart::setSamples(
const QVector< QVector< double > >& samples )
{
QVector< QwtSetSample > s;
s.reserve( samples.size() );
for ( int i = 0; i < samples.size(); i++ )
s += QwtSetSample( i, samples[ i ] );
setData( new QwtSetSeriesData( s ) );
}
void QwtPlotMultiBarChart::setSamples(
QwtSeriesData< QwtSetSample >* data )
{
setData( data );
}
void QwtPlotMultiBarChart::setBarTitles( const QList< QwtText >& titles )
{
m_data->barTitles = titles;
itemChanged();
}
QList< QwtText > QwtPlotMultiBarChart::barTitles() const
{
return m_data->barTitles;
}
void QwtPlotMultiBarChart::setSymbol( int valueIndex, QwtColumnSymbol* symbol )
{
if ( valueIndex < 0 )
return;
QMap< int, QwtColumnSymbol* >::iterator it =
m_data->symbolMap.find(valueIndex);
if ( it == m_data->symbolMap.end() )
{
if ( symbol != NULL )
{
m_data->symbolMap.insert( valueIndex, symbol );
legendChanged();
itemChanged();
}
}
else
{
if ( symbol != it.value() )
{
delete it.value();
if ( symbol == NULL )
{
m_data->symbolMap.remove( valueIndex );
}
else
{
it.value() = symbol;
}
legendChanged();
itemChanged();
}
}
}
const QwtColumnSymbol* QwtPlotMultiBarChart::symbol( int valueIndex ) const
{
QMap< int, QwtColumnSymbol* >::const_iterator it =
m_data->symbolMap.constFind( valueIndex );
return ( it == m_data->symbolMap.constEnd() ) ? NULL : it.value();
}
QwtColumnSymbol* QwtPlotMultiBarChart::symbol( int valueIndex )
{
QMap< int, QwtColumnSymbol* >::const_iterator it =
m_data->symbolMap.constFind( valueIndex );
return ( it == m_data->symbolMap.constEnd() ) ? NULL : it.value();
}
void QwtPlotMultiBarChart::resetSymbolMap()
{
qDeleteAll( m_data->symbolMap );
m_data->symbolMap.clear();
}
QwtColumnSymbol* QwtPlotMultiBarChart::specialSymbol(
int sampleIndex, int valueIndex ) const
{
Q_UNUSED( sampleIndex );
Q_UNUSED( valueIndex );
return NULL;
}
void QwtPlotMultiBarChart::setStyle( ChartStyle style )
{
if ( style != m_data->style )
{
m_data->style = style;
legendChanged();
itemChanged();
}
}
QwtPlotMultiBarChart::ChartStyle QwtPlotMultiBarChart::style() const
{
return m_data->style;
}
QRectF QwtPlotMultiBarChart::boundingRect() const
{
const size_t numSamples = dataSize();
if ( numSamples == 0 )
return QwtPlotSeriesItem::boundingRect();
const double baseLine = baseline();
QRectF rect;
if ( m_data->style != QwtPlotMultiBarChart::Stacked )
{
rect = QwtPlotSeriesItem::boundingRect();
if ( rect.height() >= 0 )
{
if ( rect.bottom() < baseLine )
rect.setBottom( baseLine );
if ( rect.top() > baseLine )
rect.setTop( baseLine );
}
}
else
{
double xMin, xMax, yMin, yMax;
xMin = xMax = 0.0;
yMin = yMax = baseLine;
const QwtSeriesData< QwtSetSample >* series = data();
for ( size_t i = 0; i < numSamples; i++ )
{
const QwtSetSample sample = series->sample( i );
if ( i == 0 )
{
xMin = xMax = sample.value;
}
else
{
xMin = qwtMinF( xMin, sample.value );
xMax = qwtMaxF( xMax, sample.value );
}
const double y = baseLine + sample.added();
yMin = qwtMinF( yMin, y );
yMax = qwtMaxF( yMax, y );
}
rect.setRect( xMin, yMin, xMax - xMin, yMax - yMin );
}
if ( orientation() == Qt::Horizontal )
rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
return rect;
}
void QwtPlotMultiBarChart::drawSeries( QPainter* painter,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
const QRectF& canvasRect, int from, int to ) const
{
if ( to < 0 )
to = dataSize() - 1;
if ( from < 0 )
from = 0;
if ( from > to )
return;
const QRectF br = data()->boundingRect();
const QwtInterval interval( br.left(), br.right() );
painter->save();
for ( int i = from; i <= to; i++ )
{
drawSample( painter, xMap, yMap,
canvasRect, interval, i, sample( i ) );
}
painter->restore();
}
void QwtPlotMultiBarChart::drawSample( QPainter* painter,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
const QRectF& canvasRect, const QwtInterval& boundingInterval,
int index, const QwtSetSample& sample ) const
{
if ( sample.set.size() <= 0 )
return;
double sampleW;
if ( orientation() == Qt::Horizontal )
{
sampleW = sampleWidth( yMap, canvasRect.height(),
boundingInterval.width(), sample.value );
}
else
{
sampleW = sampleWidth( xMap, canvasRect.width(),
boundingInterval.width(), sample.value );
}
if ( m_data->style == Stacked )
{
drawStackedBars( painter, xMap, yMap,
canvasRect, index, sampleW, sample );
}
else
{
drawGroupedBars( painter, xMap, yMap,
canvasRect, index, sampleW, sample );
}
}
void QwtPlotMultiBarChart::drawGroupedBars( QPainter* painter,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
const QRectF& canvasRect, int index, double sampleWidth,
const QwtSetSample& sample ) const
{
Q_UNUSED( canvasRect );
const int numBars = sample.set.size();
if ( numBars == 0 )
return;
if ( orientation() == Qt::Vertical )
{
const double barWidth = sampleWidth / numBars;
const double y1 = yMap.transform( baseline() );
const double x0 = xMap.transform( sample.value ) - 0.5 * sampleWidth;
for ( int i = 0; i < numBars; i++ )
{
const double x1 = x0 + i * barWidth;
const double x2 = x1 + barWidth;
const double y2 = yMap.transform( sample.set[i] );
QwtColumnRect barRect;
barRect.direction = ( y1 < y2 ) ?
QwtColumnRect::TopToBottom : QwtColumnRect::BottomToTop;
barRect.hInterval = QwtInterval( x1, x2 ).normalized();
if ( i != 0 )
barRect.hInterval.setBorderFlags( QwtInterval::ExcludeMinimum );
barRect.vInterval = QwtInterval( y1, y2 ).normalized();
drawBar( painter, index, i, barRect );
}
}
else
{
const double barHeight = sampleWidth / numBars;
const double x1 = xMap.transform( baseline() );
const double y0 = yMap.transform( sample.value ) - 0.5 * sampleWidth;
for ( int i = 0; i < numBars; i++ )
{
double y1 = y0 + i * barHeight;
double y2 = y1 + barHeight;
double x2 = xMap.transform( sample.set[i] );
QwtColumnRect barRect;
barRect.direction = x1 < x2 ?
QwtColumnRect::LeftToRight : QwtColumnRect::RightToLeft;
barRect.hInterval = QwtInterval( x1, x2 ).normalized();
barRect.vInterval = QwtInterval( y1, y2 );
if ( i != 0 )
barRect.vInterval.setBorderFlags( QwtInterval::ExcludeMinimum );
drawBar( painter, index, i, barRect );
}
}
}
void QwtPlotMultiBarChart::drawStackedBars( QPainter* painter,
const QwtScaleMap& xMap, const QwtScaleMap& yMap,
const QRectF& canvasRect, int index,
double sampleWidth, const QwtSetSample& sample ) const
{
Q_UNUSED( canvasRect ); // clipping the bars ?
const int numBars = sample.set.size();
if ( numBars == 0 )
return;
QwtInterval::BorderFlag borderFlags = QwtInterval::IncludeBorders;
if ( orientation() == Qt::Vertical )
{
const double x1 = xMap.transform( sample.value ) - 0.5 * sampleWidth;
const double x2 = x1 + sampleWidth;
const bool increasing = qwtIsIncreasing( yMap, sample.set );
QwtColumnRect bar;
bar.direction = increasing ?
QwtColumnRect::TopToBottom : QwtColumnRect::BottomToTop;
bar.hInterval = QwtInterval( x1, x2 ).normalized();
double sum = baseline();
for ( int i = 0; i < numBars; i++ )
{
const double si = sample.set[ i ];
if ( si == 0.0 )
continue;
const double y1 = yMap.transform( sum );
const double y2 = yMap.transform( sum + si );
if ( ( y2 > y1 ) != increasing )
{
// stacked bars need to be in the same direction
continue;
}
bar.vInterval = QwtInterval( y1, y2 ).normalized();
bar.vInterval.setBorderFlags( borderFlags );
drawBar( painter, index, i, bar );
sum += si;
if ( increasing )
borderFlags = QwtInterval::ExcludeMinimum;
else
borderFlags = QwtInterval::ExcludeMaximum;
}
}
else
{
const double y1 = yMap.transform( sample.value ) - 0.5 * sampleWidth;
const double y2 = y1 + sampleWidth;
const bool increasing = qwtIsIncreasing( xMap, sample.set );
QwtColumnRect bar;
bar.direction = increasing ?
QwtColumnRect::LeftToRight : QwtColumnRect::RightToLeft;
bar.vInterval = QwtInterval( y1, y2 ).normalized();
double sum = baseline();
for ( int i = 0; i < sample.set.size(); i++ )
{
const double si = sample.set[ i ];
if ( si == 0.0 )
continue;
const double x1 = xMap.transform( sum );
const double x2 = xMap.transform( sum + si );
if ( ( x2 > x1 ) != increasing )
{
// stacked bars need to be in the same direction
continue;
}
bar.hInterval = QwtInterval( x1, x2 ).normalized();
bar.hInterval.setBorderFlags( borderFlags );
drawBar( painter, index, i, bar );
sum += si;
if ( increasing )
borderFlags = QwtInterval::ExcludeMinimum;
else
borderFlags = QwtInterval::ExcludeMaximum;
}
}
}
void QwtPlotMultiBarChart::drawBar( QPainter* painter,
int sampleIndex, int valueIndex, const QwtColumnRect& rect ) const
{
const QwtColumnSymbol* specialSym = NULL;
if ( sampleIndex >= 0 )
specialSym = specialSymbol( sampleIndex, valueIndex );
const QwtColumnSymbol* sym = specialSym;
if ( sym == NULL )
sym = symbol( valueIndex );
if ( sym )
{
sym->draw( painter, rect );
}
else
{
// we build a temporary default symbol
QwtColumnSymbol columnSymbol( QwtColumnSymbol::Box );
columnSymbol.setLineWidth( 1 );
columnSymbol.setFrameStyle( QwtColumnSymbol::Plain );
columnSymbol.draw( painter, rect );
}
delete specialSym;
}
QList< QwtLegendData > QwtPlotMultiBarChart::legendData() const
{
QList< QwtLegendData > list;
list.reserve( m_data->barTitles.size() );
for ( int i = 0; i < m_data->barTitles.size(); i++ )
{
QwtLegendData data;
data.setValue( QwtLegendData::TitleRole,
QVariant::fromValue( m_data->barTitles[i] ) );
if ( !legendIconSize().isEmpty() )
{
data.setValue( QwtLegendData::IconRole,
QVariant::fromValue( legendIcon( i, legendIconSize() ) ) );
}
list += data;
}
return list;
}
QwtGraphic QwtPlotMultiBarChart::legendIcon( int index,
const QSizeF& size ) const
{
QwtColumnRect column;
column.hInterval = QwtInterval( 0.0, size.width() - 1.0 );
column.vInterval = QwtInterval( 0.0, size.height() - 1.0 );
QwtGraphic icon;
icon.setDefaultSize( size );
icon.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
QPainter painter( &icon );
painter.setRenderHint( QPainter::Antialiasing,
testRenderHint( QwtPlotItem::RenderAntialiased ) );
drawBar( &painter, -1, index, column );
return icon;
}
QList< QwtText >
QMap< int, QwtColumnSymbol * >
QVector< double >
QwtColumnRect
Directed rectangle representing bounding rectangle and orientation of a column.
Definition: qwt_column_symbol.h:27
QwtColumnRect::vInterval
QwtInterval vInterval
Interval for the vertical coordinates.
Definition: qwt_column_symbol.h:67
QwtColumnRect::hInterval
QwtInterval hInterval
Interval for the horizontal coordinates.
Definition: qwt_column_symbol.h:64
QwtColumnRect::LeftToRight
@ LeftToRight
From left to right.
Definition: qwt_column_symbol.h:33
QwtColumnRect::TopToBottom
@ TopToBottom
From top to bottom.
Definition: qwt_column_symbol.h:42
QwtColumnRect::BottomToTop
@ BottomToTop
From bottom to top.
Definition: qwt_column_symbol.h:39
QwtColumnRect::RightToLeft
@ RightToLeft
From right to left.
Definition: qwt_column_symbol.h:36
QwtColumnRect::direction
Direction direction
Direction.
Definition: qwt_column_symbol.h:70
QwtColumnSymbol
A drawing primitive for columns.
Definition: qwt_column_symbol.h:75
QwtColumnSymbol::Plain
@ Plain
A plain frame style.
Definition: qwt_column_symbol.h:110
QwtColumnSymbol::draw
virtual void draw(QPainter *, const QwtColumnRect &) const
Definition: qwt_column_symbol.cpp:238
QwtColumnSymbol::Box
@ Box
Definition: qwt_column_symbol.h:90
QwtColumnSymbol::setFrameStyle
void setFrameStyle(FrameStyle)
Definition: qwt_column_symbol.cpp:193
QwtColumnSymbol::setLineWidth
void setLineWidth(int width)
Definition: qwt_column_symbol.cpp:213
QwtGraphic
A paint device for scalable graphics.
Definition: qwt_graphic.h:76
QwtGraphic::RenderPensUnscaled
@ RenderPensUnscaled
Definition: qwt_graphic.h:96
QwtGraphic::setRenderHint
void setRenderHint(RenderHint, bool on=true)
Definition: qwt_graphic.cpp:443
QwtGraphic::setDefaultSize
void setDefaultSize(const QSizeF &)
Set a default size.
Definition: qwt_graphic.cpp:553
QwtInterval
A class representing an interval.
Definition: qwt_interval.h:23
QwtInterval::normalized
QwtInterval normalized() const
Normalize the limits of the interval.
Definition: qwt_interval.cpp:29
QwtInterval::width
double width() const
Return the width of an interval.
Definition: qwt_interval.h:227
QwtInterval::BorderFlag
BorderFlag
Definition: qwt_interval.h:30
QwtInterval::ExcludeMaximum
@ ExcludeMaximum
Max value is not included in the interval.
Definition: qwt_interval.h:38
QwtInterval::ExcludeMinimum
@ ExcludeMinimum
Min value is not included in the interval.
Definition: qwt_interval.h:35
QwtInterval::IncludeBorders
@ IncludeBorders
Min/Max values are inside the interval.
Definition: qwt_interval.h:32
QwtInterval::setBorderFlags
void setBorderFlags(BorderFlags)
Definition: qwt_interval.h:157
QwtLegendData
Attributes of an entry on a legend.
Definition: qwt_legend_data.h:37
QwtPlotAbstractBarChart
Abstract base class for bar chart items.
Definition: qwt_plot_abstract_barchart.h:25
QwtPlotAbstractBarChart::sampleWidth
double sampleWidth(const QwtScaleMap &map, double canvasSize, double boundingSize, double value) const
Definition: qwt_plot_abstract_barchart.cpp:225
QwtPlotAbstractBarChart::baseline
double baseline() const
Definition: qwt_plot_abstract_barchart.cpp:208
QwtPlotItem::legendChanged
virtual void legendChanged()
Definition: qwt_plot_item.cpp:491
QwtPlotItem::Rtti_PlotMultiBarChart
@ Rtti_PlotMultiBarChart
For QwtPlotMultiBarChart.
Definition: qwt_plot_item.h:117
QwtPlotItem::RenderAntialiased
@ RenderAntialiased
Enable antialiasing.
Definition: qwt_plot_item.h:206
QwtPlotItem::testRenderHint
bool testRenderHint(RenderHint) const
Definition: qwt_plot_item.cpp:332
QwtPlotItem::itemChanged
virtual void itemChanged()
Definition: qwt_plot_item.cpp:481
QwtPlotItem::legendIconSize
QSize legendIconSize() const
Definition: qwt_plot_item.cpp:386
QwtPlotMultiBarChart
QwtPlotMultiBarChart displays a series of a samples that consist each of a set of values.
Definition: qwt_plot_multi_barchart.h:44
QwtPlotMultiBarChart::barTitles
QList< QwtText > barTitles() const
Definition: qwt_plot_multi_barchart.cpp:148
QwtPlotMultiBarChart::legendIcon
virtual QwtGraphic legendIcon(int index, const QSizeF &) const override
Definition: qwt_plot_multi_barchart.cpp:720
QwtPlotMultiBarChart::~QwtPlotMultiBarChart
virtual ~QwtPlotMultiBarChart()
Destructor.
Definition: qwt_plot_multi_barchart.cpp:69
QwtPlotMultiBarChart::specialSymbol
virtual QwtColumnSymbol * specialSymbol(int sampleIndex, int valueIndex) const
Create a symbol for special values.
Definition: qwt_plot_multi_barchart.cpp:263
QwtPlotMultiBarChart::resetSymbolMap
void resetSymbolMap()
Definition: qwt_plot_multi_barchart.cpp:237
QwtPlotMultiBarChart::QwtPlotMultiBarChart
QwtPlotMultiBarChart(const QString &title=QString())
Definition: qwt_plot_multi_barchart.cpp:62
QwtPlotMultiBarChart::setStyle
void setStyle(ChartStyle style)
Definition: qwt_plot_multi_barchart.cpp:278
QwtPlotMultiBarChart::drawSeries
virtual void drawSeries(QPainter *, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, int from, int to) const override
Definition: qwt_plot_multi_barchart.cpp:374
QwtPlotMultiBarChart::drawSample
virtual void drawSample(QPainter *, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, const QwtInterval &boundingInterval, int index, const QwtSetSample &) const
Definition: qwt_plot_multi_barchart.cpp:415
QwtPlotMultiBarChart::drawStackedBars
void drawStackedBars(QPainter *, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, int index, double sampleWidth, const QwtSetSample &) const
Definition: qwt_plot_multi_barchart.cpp:541
QwtPlotMultiBarChart::setSymbol
void setSymbol(int valueIndex, QwtColumnSymbol *)
Add a symbol to the symbol map.
Definition: qwt_plot_multi_barchart.cpp:164
QwtPlotMultiBarChart::legendData
virtual QList< QwtLegendData > legendData() const override
Definition: qwt_plot_multi_barchart.cpp:687
QwtPlotMultiBarChart::drawGroupedBars
void drawGroupedBars(QPainter *, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &canvasRect, int index, double sampleWidth, const QwtSetSample &) const
Definition: qwt_plot_multi_barchart.cpp:461
QwtPlotMultiBarChart::rtti
virtual int rtti() const override
Definition: qwt_plot_multi_barchart.cpp:82
QwtPlotMultiBarChart::setBarTitles
void setBarTitles(const QList< QwtText > &)
Set the titles for the bars.
Definition: qwt_plot_multi_barchart.cpp:138
QwtPlotMultiBarChart::boundingRect
virtual QRectF boundingRect() const override
Definition: qwt_plot_multi_barchart.cpp:302
QwtPlotMultiBarChart::ChartStyle
ChartStyle
Chart styles.
Definition: qwt_plot_multi_barchart.h:53
QwtPlotMultiBarChart::Stacked
@ Stacked
Definition: qwt_plot_multi_barchart.h:62
QwtPlotMultiBarChart::Grouped
@ Grouped
The bars of a set are displayed side by side.
Definition: qwt_plot_multi_barchart.h:55
QwtPlotMultiBarChart::symbol
const QwtColumnSymbol * symbol(int valueIndex) const
Definition: qwt_plot_multi_barchart.cpp:210
QwtPlotMultiBarChart::drawBar
virtual void drawBar(QPainter *, int sampleIndex, int valueIndex, const QwtColumnRect &) const
Definition: qwt_plot_multi_barchart.cpp:652
QwtPlotMultiBarChart::setSamples
void setSamples(const QVector< QwtSetSample > &)
Definition: qwt_plot_multi_barchart.cpp:91
QwtPlotMultiBarChart::style
ChartStyle style() const
Definition: qwt_plot_multi_barchart.cpp:293
QwtPlotSeriesItem::orientation
Qt::Orientation orientation() const
Definition: qwt_plot_seriesitem.cpp:77
QwtPlotSeriesItem::boundingRect
virtual QRectF boundingRect() const override
Definition: qwt_plot_seriesitem.cpp:97
QwtScaleMap
A scale map.
Definition: qwt_scale_map.h:27
QwtScaleMap::isInverting
bool isInverting() const
Definition: qwt_scale_map.h:164
QwtScaleMap::transform
double transform(double s) const
Definition: qwt_scale_map.h:137
QwtSeriesData
Abstract interface for iterating over samples.
Definition: qwt_series_data.h:50
QwtSeriesData::sample
virtual T sample(size_t i) const =0
QwtSeriesStore< QwtSetSample >::sample
QwtSetSample sample(int index) const
Definition: qwt_series_store.h:158
QwtSeriesStore< QwtSetSample >::dataSize
virtual size_t dataSize() const override
Definition: qwt_series_store.h:175
QwtSeriesStore< QwtSetSample >::data
QwtSeriesData< QwtSetSample > * data()
Definition: qwt_series_store.h:146
QwtSeriesStore< QwtSetSample >::setData
void setData(QwtSeriesData< QwtSetSample > *series)
Definition: qwt_series_store.h:164
QwtSetSample
A sample of the types (x1...xn, y) or (x, y1..yn)
Definition: qwt_samples.h:74
QwtSetSample::added
double added() const
Definition: qwt_samples.h:125
QwtSetSample::value
double value
value
Definition: qwt_samples.h:85
QwtSetSample::set
QVector< double > set
Vector of values associated to value.
Definition: qwt_samples.h:88
QwtSetSeriesData
Interface for iterating over an array of samples.
Definition: qwt_series_data.h:240
QwtText
A class representing a text.
Definition: qwt_text.h:52