Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_plot_curve.cpp

Timestamp:

May 10, 2017, 3:20:54 PM (7 years ago)

Author:

stoecker

Message:

update qwt and qwtpolar, many QT5 fixes (unfinished)

File:

• trunk/BNC/qwt/qwt_plot_curve.cpp (modified) (42 diffs)

trunk/BNC/qwt/qwt_plot_curve.cpp

@@ -9 +9 @@
 
 #include "qwt_plot_curve.h"
+#include "qwt_point_data.h"
 #include "qwt_math.h"
 #include "qwt_clipper.h"
 #include "qwt_painter.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include "qwt_scale_map.h"
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_curve_fitter.h"
 #include "qwt_symbol.h"
+#include "qwt_point_mapper.h"
 #include <qpainter.h>
 #include <qpixmap.h>
@@ -24 +23 @@
 #include <qmath.h>
 
-static int verifyRange( int size, int &i1, int &i2 )
+static void qwtUpdateLegendIconSize( QwtPlotCurve *curve )
+{
+    if ( curve->symbol() && 
+        curve->testLegendAttribute( QwtPlotCurve::LegendShowSymbol ) )
+    {
+        QSize sz = curve->symbol()->boundingRect().size();
+        sz += QSize( 2, 2 ); // margin
+
+        if ( curve->testLegendAttribute( QwtPlotCurve::LegendShowLine ) )
+        {
+            // Avoid, that the line is completely covered by the symbol
+
+            int w = qCeil( 1.5 * sz.width() );
+            if ( w % 2 )
+                w++;
+
+            sz.setWidth( qMax( 8, w ) );
+        }
+
+        curve->setLegendIconSize( sz );
+    }
+}
+
+static int qwtVerifyRange( int size, int &i1, int &i2 )
 {
     if ( size < 1 )
@@ -46 +68 @@
         symbol( NULL ),
         attributes( 0 ),
-        paintAttributes( QwtPlotCurve::ClipPolygons ),
+        paintAttributes( 
+            QwtPlotCurve::ClipPolygons | QwtPlotCurve::FilterPoints ),
         legendAttributes( 0 )
     {
@@ -79 +102 @@
 */
 QwtPlotCurve::QwtPlotCurve( const QwtText &title ):
-    QwtPlotSeriesItem<QPointF>( title )
+    QwtPlotSeriesItem( title )
 {
     init();
@@ -89 +112 @@
 */
 QwtPlotCurve::QwtPlotCurve( const QString &title ):
-    QwtPlotSeriesItem<QPointF>( QwtText( title ) )
+    QwtPlotSeriesItem( QwtText( title ) )
 {
     init();
@@ -107 +130 @@
 
     d_data = new PrivateData;
-    d_series = new QwtPointSeriesData();
+    setData( new QwtPointSeriesData() );
 
     setZ( 20.0 );
@@ -134 +157 @@
 
 /*!
-    \brief Return the current paint attributes
+    \return True, when attribute is enabled
     \sa setPaintAttribute()
 */
@@ -143 +166 @@
 
 /*!
-  Specify an attribute how to draw the legend identifier
+  Specify an attribute how to draw the legend icon
 
   \param attribute Attribute
   \param on On/Off
-  /sa testLegendAttribute()
+  /sa testLegendAttribute(). legendIcon()
 */
 void QwtPlotCurve::setLegendAttribute( LegendAttribute attribute, bool on )
 {
-    if ( on )
-        d_data->legendAttributes |= attribute;
-    else
-        d_data->legendAttributes &= ~attribute;
-}
-
-/*!
-    \brief Return the current paint attributes
-    \sa setLegendAttribute()
+    if ( on != testLegendAttribute( attribute ) )
+    {
+        if ( on )
+            d_data->legendAttributes |= attribute;
+        else
+            d_data->legendAttributes &= ~attribute;
+
+        qwtUpdateLegendIconSize( this );
+        legendChanged();
+    }
+}
+
+/*!
+  \return True, when attribute is enabled
+  \sa setLegendAttribute()
 */
 bool QwtPlotCurve::testLegendAttribute( LegendAttribute attribute ) const
@@ -177 +206 @@
     {
         d_data->style = style;
+
+        legendChanged();
         itemChanged();
     }
@@ -182 +213 @@
 
 /*!
-    Return the current style
-    \sa setStyle()
+  \return Style of the curve
+  \sa setStyle()
 */
 QwtPlotCurve::CurveStyle QwtPlotCurve::style() const
@@ -191 +222 @@
 
 /*!
-  Assign a symbol
+  \brief Assign a symbol
+
+  The curve will take the ownership of the symbol, hence the previously
+  set symbol will be delete by setting a new one. If \p symbol is 
+  \c NULL no symbol will be drawn.
 
   \param symbol Symbol
   \sa symbol()
 */
-void QwtPlotCurve::setSymbol( const QwtSymbol *symbol )
+void QwtPlotCurve::setSymbol( QwtSymbol *symbol )
 {
     if ( symbol != d_data->symbol )
@@ -202 +237 @@
         delete d_data->symbol;
         d_data->symbol = symbol;
+
+        qwtUpdateLegendIconSize( this );
+
+        legendChanged();
         itemChanged();
     }
@@ -216 +255 @@
 
 /*!
+  Build and assign a pen
+
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+
+  \sa pen(), brush()
+ */
+void QwtPlotCurve::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
+
+/*!
   Assign a pen
 
@@ -226 +283 @@
     {
         d_data->pen = pen;
+
+        legendChanged();
         itemChanged();
     }
@@ -259 +318 @@
     {
         d_data->brush = brush;
+
+        legendChanged();
         itemChanged();
     }
@@ -278 +339 @@
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first point to be painted
   \param to Index of the last point to be painted. If to < 0 the
@@ -289 +350 @@
     const QRectF &canvasRect, int from, int to ) const
 {
-    if ( !painter || dataSize() <= 0 )
+    const size_t numSamples = dataSize();
+
+    if ( !painter || numSamples <= 0 )
         return;
 
     if ( to < 0 )
-        to = dataSize() - 1;
-
-    if ( verifyRange( dataSize(), from, to ) > 0 )
+        to = numSamples - 1;
+
+    if ( qwtVerifyRange( numSamples, from, to ) > 0 )
     {
         painter->save();
@@ -326 +389 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
@@ -371 +434 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
@@ -382 +445 @@
     const QRectF &canvasRect, int from, int to ) const
 {
-    int size = to - from + 1;
-    if ( size <= 0 )
+    if ( from > to )
         return;
 
     const bool doAlign = QwtPainter::roundingAlignment( painter );
-
-    QPolygonF polyline( size );
-
-    QPointF *points = polyline.data();
-    for ( int i = from; i <= to; i++ )
-    {
-        const QPointF sample = d_series->sample( i );
-
-        double x = xMap.transform( sample.x() );
-        double y = yMap.transform( sample.y() );
-        if ( doAlign )
-        {
-            x = qRound( x );
-            y = qRound( y );
-        }
-
-        points[i - from].rx() = x;
-        points[i - from].ry() = y;
-    }
-
-    if ( ( d_data->attributes & Fitted ) && d_data->curveFitter )
-        polyline = d_data->curveFitter->fitCurve( polyline );
-
+    const bool doFit = ( d_data->attributes & Fitted ) && d_data->curveFitter;
+    const bool doFill = ( d_data->brush.style() != Qt::NoBrush )
+            && ( d_data->brush.color().alpha() > 0 );
+
+    QRectF clipRect;
     if ( d_data->paintAttributes & ClipPolygons )
     {
         qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
-        const QPolygonF clipped = QwtClipper::clipPolygonF( 
-            canvasRect.adjusted(-pw, -pw, pw, pw), polyline, false );
-
-        QwtPainter::drawPolyline( painter, clipped );
+        clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
+    }
+
+    bool doIntegers = false;
+
+#if QT_VERSION < 0x040800
+
+    // For Qt <= 4.7 the raster paint engine is significantly faster
+    // for rendering QPolygon than for QPolygonF. So let's
+    // see if we can use it.
+
+    if ( painter->paintEngine()->type() == QPaintEngine::Raster )
+    {
+        // In case of filling or fitting performance doesn't count
+        // because both operations are much more expensive
+        // then drawing the polyline itself
+
+        if ( !doFit && !doFill )
+            doIntegers = true; 
+    }
+#endif
+
+    const bool noDuplicates = d_data->paintAttributes & FilterPoints;
+
+    QwtPointMapper mapper;
+    mapper.setFlag( QwtPointMapper::RoundPoints, doAlign );
+    mapper.setFlag( QwtPointMapper::WeedOutPoints, noDuplicates );
+    mapper.setBoundingRect( canvasRect );
+
+    if ( doIntegers )
+    {
+        QPolygon polyline = mapper.toPolygon( 
+            xMap, yMap, data(), from, to );
+
+        if ( d_data->paintAttributes & ClipPolygons )
+        {
+            polyline = QwtClipper::clipPolygon( 
+                clipRect.toAlignedRect(), polyline, false );
+        }
+
+        QwtPainter::drawPolyline( painter, polyline );
     }
     else
     {
-        QwtPainter::drawPolyline( painter, polyline );
-    }
-
-    if ( d_data->brush.style() != Qt::NoBrush )
-        fillCurve( painter, xMap, yMap, canvasRect, polyline );
+        QPolygonF polyline = mapper.toPolygonF( xMap, yMap, data(), from, to );
+
+        if ( doFit )
+            polyline = d_data->curveFitter->fitCurve( polyline );
+
+        if ( doFill )
+        {
+            if ( painter->pen().style() != Qt::NoPen )
+            {
+                // here we are wasting memory for the filled copy,
+                // do polygon clipping twice etc .. TODO
+
+                QPolygonF filled = polyline;
+                fillCurve( painter, xMap, yMap, canvasRect, filled );
+                filled.clear();
+
+                if ( d_data->paintAttributes & ClipPolygons )
+                {
+                    polyline = QwtClipper::clipPolygonF( 
+                        clipRect, polyline, false );
+                }
+
+                QwtPainter::drawPolyline( painter, polyline );
+            }
+            else
+            {
+                fillCurve( painter, xMap, yMap, canvasRect, polyline );
+            }
+        }
+        else
+        {
+            if ( d_data->paintAttributes & ClipPolygons )
+            {
+                polyline = QwtClipper::clipPolygonF(
+                    clipRect, polyline, false );
+            }
+
+            QwtPainter::drawPolyline( painter, polyline );
+        }
+    }
 }
 
@@ -433 +549 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
@@ -458 +574 @@
     const Qt::Orientation o = orientation();
 
+    const QwtSeriesData<QPointF> *series = data();
+
     for ( int i = from; i <= to; i++ )
     {
-        const QPointF sample = d_series->sample( i );
+        const QPointF sample = series->sample( i );
         double xi = xMap.transform( sample.x() );
         double yi = yMap.transform( sample.y() );
@@ -484 +602 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
@@ -494 +612 @@
     const QRectF &canvasRect, int from, int to ) const
 {
-    const bool doFill = d_data->brush.style() != Qt::NoBrush;
+    const QColor color = painter->pen().color();
+
+    if ( painter->pen().style() == Qt::NoPen || color.alpha() == 0 )
+    {
+        return;
+    }
+
+    const bool doFill = ( d_data->brush.style() != Qt::NoBrush )
+            && ( d_data->brush.color().alpha() > 0 );
     const bool doAlign = QwtPainter::roundingAlignment( painter );
 
-    QPolygonF polyline;
+    QwtPointMapper mapper;
+    mapper.setBoundingRect( canvasRect );
+    mapper.setFlag( QwtPointMapper::RoundPoints, doAlign );
+
+    if ( d_data->paintAttributes & FilterPoints )
+    {
+        if ( ( color.alpha() == 255 )
+            && !( painter->renderHints() & QPainter::Antialiasing ) )
+        {
+            mapper.setFlag( QwtPointMapper::WeedOutPoints, true );
+        }
+    }
+
     if ( doFill )
-        polyline.resize( to - from + 1 );
-
-    QPointF *points = polyline.data();
-
-    for ( int i = from; i <= to; i++ )
-    {
-        const QPointF sample = d_series->sample( i );
-        double xi = xMap.transform( sample.x() );
-        double yi = yMap.transform( sample.y() );
+    {
+        mapper.setFlag( QwtPointMapper::WeedOutPoints, false );
+
+        QPolygonF points = mapper.toPointsF( 
+            xMap, yMap, data(), from, to );
+
+        QwtPainter::drawPoints( painter, points );
+        fillCurve( painter, xMap, yMap, canvasRect, points );
+    }
+    else if ( d_data->paintAttributes & ImageBuffer )
+    {
+        const QImage image = mapper.toImage( xMap, yMap,
+            data(), from, to, d_data->pen, 
+            painter->testRenderHint( QPainter::Antialiasing ),
+            renderThreadCount() );
+
+        painter->drawImage( canvasRect.toAlignedRect(), image );
+    }
+    else if ( d_data->paintAttributes & MinimizeMemory )
+    {
+        const QwtSeriesData<QPointF> *series = data();
+
+        for ( int i = from; i <= to; i++ )
+        {
+            const QPointF sample = series->sample( i );
+
+            double xi = xMap.transform( sample.x() );
+            double yi = yMap.transform( sample.y() );
+
+            if ( doAlign )
+            {
+                xi = qRound( xi );
+                yi = qRound( yi );
+            }
+
+            QwtPainter::drawPoint( painter, QPointF( xi, yi ) );
+        }
+    }
+    else
+    {
         if ( doAlign )
         {
-            xi = qRound( xi );
-            yi = qRound( yi );
-        }
-
-        QwtPainter::drawPoint( painter, QPointF( xi, yi ) );
-
-        if ( doFill )
-        {
-            points[i - from].rx() = xi;
-            points[i - from].ry() = yi;
-        }
-    }
-
-    if ( doFill )
-        fillCurve( painter, xMap, yMap, canvasRect, polyline );
+            const QPolygon points = mapper.toPoints(
+                xMap, yMap, data(), from, to ); 
+
+            QwtPainter::drawPoints( painter, points );
+        }
+        else
+        {
+            const QPolygonF points = mapper.toPointsF( 
+                xMap, yMap, data(), from, to );
+
+            QwtPainter::drawPoints( painter, points );
+        }
+    }
 }
 
@@ -535 +702 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
@@ -555 +722 @@
         inverted = !inverted;
 
+    const QwtSeriesData<QPointF> *series = data();
+
     int i, ip;
     for ( i = from, ip = 0; i <= to; i++, ip += 2 )
     {
-        const QPointF sample = d_series->sample( i );
+        const QPointF sample = series->sample( i );
         double xi = xMap.transform( sample.x() );
         double yi = yMap.transform( sample.y() );
@@ -590 +759 @@
     if ( d_data->paintAttributes & ClipPolygons )
     {
+        qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
+        const QRectF clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
+        
         const QPolygonF clipped = QwtClipper::clipPolygonF( 
-            canvasRect, polygon, false );
+            clipRect, polygon, false );
 
         QwtPainter::drawPolyline( painter, clipped );
@@ -678 +850 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param polygon Polygon - will be modified !
 
@@ -733 +905 @@
     if ( orientation() == Qt::Vertical )
     {
-        if ( yMap.transformation()->type() == QwtScaleTransformation::Log10 )
-        {
-            if ( baseline < QwtScaleMap::LogMin )
-                baseline = QwtScaleMap::LogMin;
-        }
+        if ( yMap.transformation() )
+            baseline = yMap.transformation()->bounded( baseline );
 
         double refY = yMap.transform( baseline );
@@ -748 +917 @@
     else
     {
-        if ( xMap.transformation()->type() == QwtScaleTransformation::Log10 )
-        {
-            if ( baseline < QwtScaleMap::LogMin )
-                baseline = QwtScaleMap::LogMin;
-        }
+        if ( xMap.transformation() )
+            baseline = xMap.transformation()->bounded( baseline );
 
         double refX = xMap.transform( baseline );
@@ -770 +936 @@
   \param xMap x map
   \param yMap y map
-  \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first point to be painted
   \param to Index of the last point to be painted
@@ -780 +946 @@
     const QRectF &canvasRect, int from, int to ) const
 {
-    const bool doAlign = QwtPainter::roundingAlignment( painter );
-
-    bool usePixmap = testPaintAttribute( CacheSymbols );
-    if ( usePixmap && !doAlign )
-    {
-        // Don't use the pixmap, when the paint device
-        // could generate scalable vectors
-
-        usePixmap = false;
-    }
-
-    if ( usePixmap )
-    {
-        QPixmap pm( symbol.boundingSize() );
-        pm.fill( Qt::transparent );
-
-        const double pw2 = 0.5 * pm.width();
-        const double ph2 = 0.5 * pm.height();
-
-        QPainter p( &pm );
-        p.setRenderHints( painter->renderHints() );
-        symbol.drawSymbol( &p, QPointF( pw2, ph2 ) );
-        p.end();
-
-        for ( int i = from; i <= to; i++ )
-        {
-            const QPointF sample = d_series->sample( i );
-
-            double xi = xMap.transform( sample.x() );
-            double yi = yMap.transform( sample.y() );
-            if ( doAlign )
-            {
-                xi = qRound( xi );
-                yi = qRound( yi );
-            }
-
-            if ( canvasRect.contains( xi, yi ) )
-            {
-                const int left = qCeil( xi ) - pw2;
-                const int top = qCeil( yi ) - ph2;
-
-                painter->drawPixmap( left, top, pm );
-            }
-        }
-    }
-    else
-    {
-        const int chunkSize = 500;
-
-        for ( int i = from; i <= to; i += chunkSize )
-        {
-            const int n = qMin( chunkSize, to - i + 1 );
-
-            QPolygonF points;
-            for ( int j = 0; j < n; j++ )
-            {
-                const QPointF sample = d_series->sample( i + j );
-
-                const double xi = xMap.transform( sample.x() );
-                const double yi = yMap.transform( sample.y() );
-
-                if ( canvasRect.contains( xi, yi ) )
-                    points += QPointF( xi, yi );
-            }
-
-            if ( points.size() > 0 )
-                symbol.drawSymbols( painter, points );
-        }
+    QwtPointMapper mapper;
+    mapper.setFlag( QwtPointMapper::RoundPoints, 
+        QwtPainter::roundingAlignment( painter ) );
+    mapper.setFlag( QwtPointMapper::WeedOutPoints, 
+        testPaintAttribute( QwtPlotCurve::FilterPoints ) );
+    mapper.setBoundingRect( canvasRect );
+
+    const int chunkSize = 500;
+
+    for ( int i = from; i <= to; i += chunkSize )
+    {
+        const int n = qMin( chunkSize, to - i + 1 );
+
+        const QPolygonF points = mapper.toPointsF( xMap, yMap,
+            data(), i, i + n - 1 );
+
+        if ( points.size() > 0 )
+            symbol.drawSymbols( painter, points );
     }
 }
@@ -856 +972 @@
   The baseline is needed for filling the curve with a brush or
   the Sticks drawing style.
-  The interpretation of the baseline depends on the CurveType.
-  With QwtPlotCurve::Yfx, the baseline is interpreted as a horizontal line
-  at y = baseline(), with QwtPlotCurve::Yfy, it is interpreted as a vertical
+
+  The interpretation of the baseline depends on the orientation().
+  With Qt::Horizontal, the baseline is interpreted as a horizontal line
+  at y = baseline(), with Qt::Vertical, it is interpreted as a vertical
   line at x = baseline().
 
@@ -864 +981 @@
 
   \param value Value of the baseline
-  \sa baseline(), setBrush(), setStyle(), setStyle()
+  \sa baseline(), setBrush(), setStyle(), QwtPlotAbstractSeriesItem::orientation()
 */
 void QwtPlotCurve::setBaseline( double value )
@@ -889 +1006 @@
   \param pos Position, where to look for the closest curve point
   \param dist If dist != NULL, closestPoint() returns the distance between
-              the position and the clostest curve point
+              the position and the closest curve point
   \return Index of the closest curve point, or -1 if none can be found
           ( f.e when the curve has no points )
@@ -897 +1014 @@
 int QwtPlotCurve::closestPoint( const QPoint &pos, double *dist ) const
 {
-    if ( plot() == NULL || dataSize() <= 0 )
+    const size_t numSamples = dataSize();
+
+    if ( plot() == NULL || numSamples <= 0 )
         return -1;
+
+    const QwtSeriesData<QPointF> *series = data();
 
     const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
@@ -906 +1027 @@
     double dmin = 1.0e10;
 
-    for ( uint i = 0; i < dataSize(); i++ )
-    {
-        const QPointF sample = d_series->sample( i );
+    for ( uint i = 0; i < numSamples; i++ )
+    {
+        const QPointF sample = series->sample( i );
 
         const double cx = xMap.transform( sample.x() ) - pos.x();
@@ -927 +1048 @@
 
 /*!
-   \brief Update the widget that represents the item on the legend
-
-   \param legend Legend
-   \sa drawLegendIdentifier(), legendItem(), QwtPlotItem::Legend
-*/
-void QwtPlotCurve::updateLegend( QwtLegend *legend ) const
-{
-    if ( legend && testItemAttribute( QwtPlotItem::Legend )
-        && ( d_data->legendAttributes & QwtPlotCurve::LegendShowSymbol )
-        && d_data->symbol
-        && d_data->symbol->style() != QwtSymbol::NoSymbol )
-    {
-        QWidget *lgdItem = legend->find( this );
-        if ( lgdItem == NULL )
-        {
-            lgdItem = legendItem();
-            if ( lgdItem )
-                legend->insert( this, lgdItem );
-        }
-
-        QwtLegendItem *l = qobject_cast<QwtLegendItem *>( lgdItem );
-        if ( l )
-        {
-            QSize sz = d_data->symbol->boundingSize();
-            sz += QSize( 2, 2 ); // margin
-
-            if ( d_data->legendAttributes & QwtPlotCurve::LegendShowLine )
+   \return Icon representing the curve on the legend
+
+   \param index Index of the legend entry 
+                ( ignored as there is only one )
+   \param size Icon size
+
+   \sa QwtPlotItem::setLegendIconSize(), QwtPlotItem::legendData()
+ */
+QwtGraphic QwtPlotCurve::legendIcon( int index, 
+    const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+
+    if ( size.isEmpty() )
+        return QwtGraphic();
+
+    QwtGraphic graphic;
+    graphic.setDefaultSize( size );
+    graphic.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
+
+    QPainter painter( &graphic );
+    painter.setRenderHint( QPainter::Antialiasing,
+        testRenderHint( QwtPlotItem::RenderAntialiased ) );
+
+    if ( d_data->legendAttributes == 0 ||
+        d_data->legendAttributes & QwtPlotCurve::LegendShowBrush )
+    {
+        QBrush brush = d_data->brush;
+
+        if ( brush.style() == Qt::NoBrush &&
+            d_data->legendAttributes == 0 )
+        {
+            if ( style() != QwtPlotCurve::NoCurve )
             {
-                // Avoid, that the line is completely covered by the symbol
-
-                int w = qCeil( 1.5 * sz.width() );
-                if ( w % 2 )
-                    w++;
-
-                sz.setWidth( qMax( 8, w ) );
+                brush = QBrush( pen().color() );
             }
-
-            l->setIdentifierSize( sz );
-        }
-    }
-
-    QwtPlotItem::updateLegend( legend );
-}
-
-/*!
-  \brief Draw the identifier representing the curve on the legend
-
-  \param painter Painter
-  \param rect Bounding rectangle for the identifier
-
-  \sa setLegendAttribute(), QwtPlotItem::Legend
-*/
-void QwtPlotCurve::drawLegendIdentifier(
-    QPainter *painter, const QRectF &rect ) const
-{
-    if ( rect.isEmpty() )
-        return;
-
-    const int dim = qMin( rect.width(), rect.height() );
-
-    QSize size( dim, dim );
-
-    QRectF r( 0, 0, size.width(), size.height() );
-    r.moveCenter( rect.center() );
-
-    if ( d_data->legendAttributes == 0 )
-    {
-        QBrush brush = d_data->brush;
-        if ( brush.style() == Qt::NoBrush )
-        {
-            if ( style() != QwtPlotCurve::NoCurve )
-                brush = QBrush( pen().color() );
             else if ( d_data->symbol &&
                 ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
@@ -1005 +1090 @@
             }
         }
+
         if ( brush.style() != Qt::NoBrush )
-            painter->fillRect( r, brush );
-    }
-    if ( d_data->legendAttributes & QwtPlotCurve::LegendShowBrush )
-    {
-        if ( d_data->brush.style() != Qt::NoBrush )
-            painter->fillRect( r, d_data->brush );
-    }
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            painter.fillRect( r, brush );
+        }
+    }
+
     if ( d_data->legendAttributes & QwtPlotCurve::LegendShowLine )
     {
         if ( pen() != Qt::NoPen )
         {
-            painter->setPen( pen() );
-            QwtPainter::drawLine( painter, rect.left(), rect.center().y(),
-                                  rect.right() - 1.0, rect.center().y() );
-        }
-    }
+            QPen pn = pen();
+            pn.setCapStyle( Qt::FlatCap );
+
+            painter.setPen( pn );
+
+            const double y = 0.5 * size.height();
+            QwtPainter::drawLine( &painter, 0.0, y, size.width(), y );
+        }
+    }
+
     if ( d_data->legendAttributes & QwtPlotCurve::LegendShowSymbol )
     {
-        if ( d_data->symbol &&
-            ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
-        {
-            QSize symbolSize = d_data->symbol->boundingSize();
-            symbolSize -= QSize( 2, 2 );
-
-            // scale the symbol size down if it doesn't fit into rect.
-
-            double xRatio = 1.0;
-            if ( rect.width() < symbolSize.width() )
-                xRatio = rect.width() / symbolSize.width();
-            double yRatio = 1.0;
-            if ( rect.height() < symbolSize.height() )
-                yRatio = rect.height() / symbolSize.height();
-
-            const double ratio = qMin( xRatio, yRatio );
-
-            painter->save();
-            painter->scale( ratio, ratio );
-
-            d_data->symbol->drawSymbol( painter, rect.center() / ratio );
-
-            painter->restore();
-        }
-    }
-}
-
-/*!
-  Initialize data with an array of points (explicitly shared).
+        if ( d_data->symbol )
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            d_data->symbol->drawSymbol( &painter, r );
+        }
+    }
+
+    return graphic;
+}
+
+/*!
+  Initialize data with an array of points.
 
   \param samples Vector of points
+  \note QVector is implicitly shared
+  \note QPolygonF is derived from QVector<QPointF>
 */
 void QwtPlotCurve::setSamples( const QVector<QPointF> &samples )
 {
-    delete d_series;
-    d_series = new QwtPointSeriesData( samples );
-    itemChanged();
+    setData( new QwtPointSeriesData( samples ) );
+}
+
+/*!
+  Assign a series of points
+
+  setSamples() is just a wrapper for setData() without any additional
+  value - beside that it is easier to find for the developer.
+
+  \param data Data
+  \warning The item takes ownership of the data object, deleting
+           it when its not used anymore.
+*/
+void QwtPlotCurve::setSamples( QwtSeriesData<QPointF> *data )
+{
+    setData( data );
 }
 
@@ -1082 +1170 @@
     const double *xData, const double *yData, int size )
 {
-    delete d_series;
-    d_series = new QwtCPointerData( xData, yData, size );
-    itemChanged();
+    setData( new QwtCPointerData( xData, yData, size ) );
 }
 
@@ -1101 +1187 @@
     const double *xData, const double *yData, int size )
 {
-    delete d_series;
-    d_series = new QwtPointArrayData( xData, yData, size );
-    itemChanged();
+    setData( new QwtPointArrayData( xData, yData, size ) );
 }
 
@@ -1117 +1201 @@
     const QVector<double> &yData )
 {
-    delete d_series;
-    d_series = new QwtPointArrayData( xData, yData );
-    itemChanged();
-}
+    setData( new QwtPointArrayData( xData, yData ) );
+}
+
 #endif // !QWT_NO_COMPAT