Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_symbol.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_symbol.cpp (modified) (21 diffs)

trunk/BNC/qwt/qwt_symbol.cpp

@@ -10 +10 @@
 #include "qwt_symbol.h"
 #include "qwt_painter.h"
+#include "qwt_graphic.h"
 #include <qapplication.h>
 #include <qpainter.h>
+#include <qpainterpath.h>
+#include <qpixmap.h>
+#include <qpaintengine.h>
 #include <qmath.h>
+#ifndef QWT_NO_SVG
+#include <qsvgrenderer.h>
+#endif
 
 namespace QwtTriangle
@@ -23 +30 @@
         Down
     };
+}
+
+static QwtGraphic qwtPathGraphic( const QPainterPath &path, 
+    const QPen &pen, const QBrush& brush )
+{
+    QwtGraphic graphic;
+    graphic.setRenderHint( QwtGraphic::RenderPensUnscaled );
+
+    QPainter painter( &graphic );
+    painter.setPen( pen );
+    painter.setBrush( brush );
+    painter.drawPath( path );
+    painter.end();
+
+    return graphic;
+}
+
+static inline QRectF qwtScaledBoundingRect( 
+    const QwtGraphic &graphic, const QSizeF size )
+{
+    QSizeF scaledSize = size;
+    if ( scaledSize.isEmpty() )
+        scaledSize = graphic.defaultSize();
+        
+    const QSizeF sz = graphic.controlPointRect().size();
+
+    double sx = 1.0;
+    if ( sz.width() > 0.0 )
+        sx = scaledSize.width() / sz.width();
+    
+    double sy = 1.0;
+    if ( sz.height() > 0.0 )
+        sy = scaledSize.height() / sz.height();
+
+    return graphic.scaledBoundingRect( sx, sy );
+}
+
+static inline void qwtDrawPixmapSymbols( QPainter *painter,
+    const QPointF *points, int numPoints, const QwtSymbol &symbol )
+{
+    QSize size = symbol.size();
+    if ( size.isEmpty() )
+        size = symbol.pixmap().size();
+
+    const QTransform transform = painter->transform();
+    if ( transform.isScaling() )
+    {
+        const QRect r( 0, 0, size.width(), size.height() );
+        size = transform.mapRect( r ).size();
+    }
+
+    QPixmap pm = symbol.pixmap();
+    if ( pm.size() != size )
+        pm = pm.scaled( size );
+    
+    QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+
+    painter->resetTransform();
+
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        const QPointF pos = transform.map( points[i] ) - pinPoint;
+
+        QwtPainter::drawPixmap( painter, 
+            QRect( pos.toPoint(), pm.size() ), pm );
+    }
+}
+
+#ifndef QWT_NO_SVG
+
+static inline void qwtDrawSvgSymbols( QPainter *painter, 
+    const QPointF *points, int numPoints, 
+    QSvgRenderer *renderer, const QwtSymbol &symbol )
+{
+    if ( renderer == NULL || !renderer->isValid() )
+        return;
+
+    const QRectF viewBox = renderer->viewBoxF();
+    if ( viewBox.isEmpty() )
+        return;
+
+    QSizeF sz = symbol.size();
+    if ( !sz.isValid() )
+        sz = viewBox.size();
+
+    const double sx = sz.width() / viewBox.width();
+    const double sy = sz.height() / viewBox.height();
+
+    QPointF pinPoint = viewBox.center();
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+
+    const double dx = sx * ( pinPoint.x() - viewBox.left() );
+    const double dy = sy * ( pinPoint.y() - viewBox.top() );
+
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        const double x = points[i].x() - dx;
+        const double y = points[i].y() - dy;
+
+        renderer->render( painter, 
+            QRectF( x, y, sz.width(), sz.height() ) );
+    }
+}
+
+#endif
+
+static inline void qwtDrawGraphicSymbols( QPainter *painter, 
+    const QPointF *points, int numPoints, const QwtGraphic &graphic,
+    const QwtSymbol &symbol )
+{
+    const QRectF pointRect = graphic.controlPointRect();
+    if ( pointRect.isEmpty() )
+        return;
+
+    double sx = 1.0;
+    double sy = 1.0;
+
+    const QSize sz = symbol.size();
+    if ( sz.isValid() )
+    {
+        sx = sz.width() / pointRect.width();
+        sy = sz.height() / pointRect.height();
+    }
+
+    QPointF pinPoint = pointRect.center();
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+
+    const QTransform transform = painter->transform();
+
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        QTransform tr = transform;
+        tr.translate( points[i].x(), points[i].y() );
+        tr.scale( sx, sy );
+        tr.translate( -pinPoint.x(), -pinPoint.y() );
+
+        painter->setTransform( tr );
+
+        graphic.render( painter );
+    }
+
+    painter->setTransform( transform );
 }
 
@@ -623 +776 @@
         size( sz ),
         brush( br ),
-        pen( pn )
-    {
-    }
-
-    bool operator==( const PrivateData &other ) const
-    {
-        return ( style == other.style )
-            && ( size == other.size )
-            && ( brush == other.brush )
-            && ( pen == other.pen );
-    }
-
+        pen( pn ),
+        isPinPointEnabled( false )
+    {
+        cache.policy = QwtSymbol::AutoCache;
+#ifndef QWT_NO_SVG
+        svg.renderer = NULL;
+#endif
+    }
+
+    ~PrivateData()
+    {
+#ifndef QWT_NO_SVG
+        delete svg.renderer;
+#endif
+    }
 
     Style style;
@@ -640 +796 @@
     QBrush brush;
     QPen pen;
+
+    bool isPinPointEnabled;
+    QPointF pinPoint;
+
+    struct Path
+    {
+        QPainterPath path;
+        QwtGraphic graphic;
+
+    } path;
+
+    struct Pixmap
+    {
+        QPixmap pixmap;
+
+    } pixmap;
+
+    struct Graphic
+    {
+        QwtGraphic graphic;
+
+    } graphic;
+
+#ifndef QWT_NO_SVG
+    struct SVG
+    {
+        QSvgRenderer *renderer;
+    } svg;
+#endif
+
+    struct PaintCache
+    {
+        QwtSymbol::CachePolicy policy;
+        QPixmap pixmap;
+
+    } cache;
 };
 
@@ -652 +844 @@
 {
     d_data = new PrivateData( style, QBrush( Qt::gray ),
-        QPen( Qt::black ), QSize( 0.0, 0.0 ) );
+        QPen( Qt::black, 0 ), QSize() );
 }
 
@@ -671 +863 @@
 
 /*!
-  \brief Copy constructor
-
-  \param other Symbol
+  \brief Constructor
+
+  The symbol gets initialized by a painter path. The style is
+  set to QwtSymbol::Path, the size is set to empty ( the path
+  is displayed unscaled ).
+
+  \param path painter path
+  \param brush brush to fill the interior
+  \param pen outline pen
+
+  \sa setPath(), setBrush(), setPen(), setSize()
 */
-QwtSymbol::QwtSymbol( const QwtSymbol &other )
-{
-    d_data = new PrivateData( other.style(), other.brush(),
-        other.pen(), other.size() );
-};
+
+QwtSymbol::QwtSymbol( const QPainterPath &path, 
+    const QBrush &brush, const QPen &pen )
+{
+    d_data = new PrivateData( QwtSymbol::Path, brush, pen, QSize() );
+    setPath( path );
+}
 
 //! Destructor
@@ -687 +889 @@
 }
 
-//! \brief Assignment operator
-QwtSymbol &QwtSymbol::operator=( const QwtSymbol &other )
-{
-    *d_data = *other.d_data;
-    return *this;
-}
-
-//! \brief Compare two symbols
-bool QwtSymbol::operator==( const QwtSymbol &other ) const
-{
-    return *d_data == *other.d_data;
-}
-
-//! \brief Compare two symbols
-bool QwtSymbol::operator!=( const QwtSymbol &other ) const
-{
-    return !( *d_data == *other.d_data );
-}
+/*!
+  Change the cache policy
+
+  The default policy is AutoCache
+
+  \param policy Cache policy
+  \sa CachePolicy, cachePolicy()
+*/
+void QwtSymbol::setCachePolicy(
+    QwtSymbol::CachePolicy policy )
+{
+    if ( d_data->cache.policy != policy )
+    {
+        d_data->cache.policy = policy;
+        invalidateCache();
+    }
+}
+
+/*!
+  \return Cache policy
+  \sa CachePolicy, setCachePolicy()
+*/
+QwtSymbol::CachePolicy QwtSymbol::cachePolicy() const
+{
+    return d_data->cache.policy;
+}
+
+/*!
+  \brief Set a painter path as symbol
+
+  The symbol is represented by a painter path, where the 
+  origin ( 0, 0 ) of the path coordinate system is mapped to
+  the position of the symbol.
+
+  When the symbol has valid size the painter path gets scaled
+  to fit into the size. Otherwise the symbol size depends on
+  the bounding rectangle of the path.
+
+  The following code defines a symbol drawing an arrow:
+
+  \verbatim
+#include <qwt_symbol.h>
+
+QwtSymbol *symbol = new QwtSymbol();
+
+QPen pen( Qt::black, 2 );
+pen.setJoinStyle( Qt::MiterJoin );
+
+symbol->setPen( pen );
+symbol->setBrush( Qt::red );
+
+QPainterPath path;
+path.moveTo( 0, 8 );
+path.lineTo( 0, 5 );
+path.lineTo( -3, 5 );
+path.lineTo( 0, 0 );
+path.lineTo( 3, 5 );
+path.lineTo( 0, 5 );
+
+QTransform transform;
+transform.rotate( -30.0 );
+path = transform.map( path );
+
+symbol->setPath( path );
+symbol->setPinPoint( QPointF( 0.0, 0.0 ) );
+
+setSize( 10, 14 );
+\endverbatim
+
+  \param path Painter path
+
+  \note The style is implicitely set to QwtSymbol::Path.
+  \sa path(), setSize()
+ */
+void QwtSymbol::setPath( const QPainterPath &path )
+{
+    d_data->style = QwtSymbol::Path;
+    d_data->path.path = path;
+    d_data->path.graphic.reset();
+}
+
+/*!
+   \return Painter path for displaying the symbol
+   \sa setPath()
+*/
+const QPainterPath &QwtSymbol::path() const
+{
+    return d_data->path.path;
+}
+
+/*!
+  Set a pixmap as symbol
+
+  \param pixmap Pixmap
+
+  \sa pixmap(), setGraphic()
+
+  \note the style() is set to QwtSymbol::Pixmap
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setPixmap( const QPixmap &pixmap )
+{
+    d_data->style = QwtSymbol::Pixmap;
+    d_data->pixmap.pixmap = pixmap;
+}
+
+/*!
+  \return Assigned pixmap
+  \sa setPixmap()
+ */
+const QPixmap &QwtSymbol::pixmap() const
+{
+    return d_data->pixmap.pixmap;
+}
+
+/*!
+  Set a graphic as symbol
+
+  \param graphic Graphic
+
+  \sa graphic(), setPixmap()
+
+  \note the style() is set to QwtSymbol::Graphic
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setGraphic( const QwtGraphic &graphic )
+{
+    d_data->style = QwtSymbol::Graphic;
+    d_data->graphic.graphic = graphic;
+}
+
+/*!
+  \return Assigned graphic
+  \sa setGraphic()
+ */
+const QwtGraphic &QwtSymbol::graphic() const
+{
+    return d_data->graphic.graphic;
+}
+
+#ifndef QWT_NO_SVG
+
+/*!
+  Set a SVG icon as symbol
+
+  \param svgDocument SVG icon
+
+  \sa setGraphic(), setPixmap()
+
+  \note the style() is set to QwtSymbol::SvgDocument
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setSvgDocument( const QByteArray &svgDocument )
+{
+    d_data->style = QwtSymbol::SvgDocument;
+    if ( d_data->svg.renderer == NULL )
+        d_data->svg.renderer = new QSvgRenderer();
+
+    d_data->svg.renderer->load( svgDocument );
+}
+
+#endif
 
 /*!
@@ -712 +1058 @@
   and the 'w' parameter is greater than or equal to 0,
   the symbol size will be set to (w,w).
+
   \param width Width
   \param height Height (defaults to -1)
@@ -722 +1069 @@
         height = width;
 
-    d_data->size = QSize( width, height );
+    setSize( QSize( width, height ) );
 }
 
@@ -733 +1080 @@
 void QwtSymbol::setSize( const QSize &size )
 {
-    if ( size.isValid() )
+    if ( size.isValid() && size != d_data->size )
+    {
         d_data->size = size;
+        invalidateCache();
+    }
 }
 
@@ -756 +1106 @@
 void QwtSymbol::setBrush( const QBrush &brush )
 {
-    d_data->brush = brush;
+    if ( brush != d_data->brush )
+    {
+        d_data->brush = brush;
+        invalidateCache();
+
+        if ( d_data->style == QwtSymbol::Path )
+            d_data->path.graphic.reset();
+    }
 }
 
@@ -769 +1126 @@
 
 /*!
+  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 QwtSymbol::setPen( const QColor &color,
+    qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
+
+/*!
   Assign a pen
 
@@ -778 +1154 @@
 void QwtSymbol::setPen( const QPen &pen )
 {
-    d_data->pen = pen;
+    if ( pen != d_data->pen )
+    {
+        d_data->pen = pen;
+        invalidateCache();
+
+        if ( d_data->style == QwtSymbol::Path )
+            d_data->path.graphic.reset();
+    }
 }
 
@@ -815 +1198 @@
         case QwtSymbol::Hexagon:
         {
-            d_data->brush.setColor( color );
+            if ( d_data->brush.color() != color )
+            {
+                d_data->brush.setColor( color );
+                invalidateCache();
+            }
             break;
         }
@@ -824 +1211 @@
         case QwtSymbol::Star1:
         {
-            d_data->pen.setColor( color );
+            if ( d_data->pen.color() != color )
+            {
+                d_data->pen.setColor( color );
+                invalidateCache();
+            }
             break;
         }
         default:
         {
+            if ( d_data->brush.color() != color ||
+                d_data->pen.color() != color )
+            {
+                invalidateCache();
+            }
+
             d_data->brush.setColor( color );
             d_data->pen.setColor( color );
@@ -836 +1233 @@
 
 /*!
-  Draw an array of symbols
+  \brief Set and enable a pin point
+
+  The position of a complex symbol is not always aligned to its center
+  ( f.e an arrow, where the peak points to a position ). The pin point
+  defines the position inside of a Pixmap, Graphic, SvgDocument 
+  or PainterPath symbol where the represented point has to
+  be aligned to.
+  
+  \param pos Position
+  \param enable En/Disable the pin point alignment
+
+  \sa pinPoint(), setPinPointEnabled()
+ */
+void QwtSymbol::setPinPoint( const QPointF &pos, bool enable )
+{
+    if ( d_data->pinPoint != pos )
+    {
+        d_data->pinPoint = pos;
+        if ( d_data->isPinPointEnabled )
+        {
+            invalidateCache();
+        }
+    }
+
+    setPinPointEnabled( enable );
+}
+
+/*!
+  \return Pin point
+  \sa setPinPoint(), setPinPointEnabled()
+ */
+QPointF QwtSymbol::pinPoint() const
+{
+    return d_data->pinPoint;
+}
+
+/*!
+  En/Disable the pin point alignment
+
+  \param on Enabled, when on is true
+  \sa setPinPoint(), isPinPointEnabled()
+ */
+void QwtSymbol::setPinPointEnabled( bool on )
+{
+    if ( d_data->isPinPointEnabled != on )
+    {
+        d_data->isPinPointEnabled = on;
+        invalidateCache();
+    }
+}
+
+/*!
+  \return True, when the pin point translation is enabled
+  \sa setPinPoint(), setPinPointEnabled()
+ */
+bool QwtSymbol::isPinPointEnabled() const
+{
+    return d_data->isPinPointEnabled;
+}
+
+/*!
+  Render an array of symbols
 
   Painting several symbols is more effective than drawing symbols
@@ -852 +1310 @@
         return;
 
-    painter->save();
-
+    bool useCache = false;
+
+    // Don't use the pixmap, when the paint device
+    // could generate scalable vectors
+
+    if ( QwtPainter::roundingAlignment( painter ) &&
+        !painter->transform().isScaling() )
+    {
+        if ( d_data->cache.policy == QwtSymbol::Cache )
+        {
+            useCache = true;
+        }
+        else if ( d_data->cache.policy == QwtSymbol::AutoCache )
+        {
+            if ( painter->paintEngine()->type() == QPaintEngine::Raster )
+            {
+                useCache = true;
+            }
+            else
+            {
+                switch( d_data->style )
+                {
+                    case QwtSymbol::XCross:
+                    case QwtSymbol::HLine:
+                    case QwtSymbol::VLine:
+                    case QwtSymbol::Cross:
+                        break;
+
+                    case QwtSymbol::Pixmap:
+                    {
+                        if ( !d_data->size.isEmpty() &&
+                            d_data->size != d_data->pixmap.pixmap.size() ) 
+                        {
+                            useCache = true;
+                        }
+                        break;
+                    }                       
+                    default:
+                        useCache = true;
+                }
+            }
+        }
+    }
+
+    if ( useCache )
+    {
+        const QRect br = boundingRect();
+
+        const QRect rect( 0, 0, br.width(), br.height() );
+        
+        if ( d_data->cache.pixmap.isNull() )
+        {
+            d_data->cache.pixmap = QwtPainter::backingStore( NULL, br.size() );
+            d_data->cache.pixmap.fill( Qt::transparent );
+
+            QPainter p( &d_data->cache.pixmap );
+            p.setRenderHints( painter->renderHints() );
+            p.translate( -br.topLeft() );
+
+            const QPointF pos;
+            renderSymbols( &p, &pos, 1 );
+        }
+
+        const int dx = br.left();
+        const int dy = br.top();
+
+        for ( int i = 0; i < numPoints; i++ )
+        {
+            const int left = qRound( points[i].x() ) + dx;
+            const int top = qRound( points[i].y() ) + dy;
+
+            painter->drawPixmap( left, top, d_data->cache.pixmap );
+        }
+    }
+    else
+    {
+        painter->save();
+        renderSymbols( painter, points, numPoints );
+        painter->restore();
+    }
+}
+
+/*!
+  \brief Draw the symbol into a rectangle
+
+  The symbol is painted centered and scaled into the target rectangle.
+  It is always painted uncached and the pin point is ignored.
+
+  This method is primarily intended for drawing a symbol to
+  the legend.
+
+  \param painter Painter
+  \param rect Target rectangle for the symbol 
+*/
+void QwtSymbol::drawSymbol( QPainter *painter, const QRectF &rect ) const
+{
+    if ( d_data->style == QwtSymbol::NoSymbol )
+        return;
+
+    if ( d_data->style == QwtSymbol::Graphic )
+    {
+        d_data->graphic.graphic.render( 
+            painter, rect, Qt::KeepAspectRatio );
+    }
+    else if ( d_data->style == QwtSymbol::Path )
+    {
+        if ( d_data->path.graphic.isNull() )
+        {
+            d_data->path.graphic = qwtPathGraphic( 
+                d_data->path.path, d_data->pen, d_data->brush );
+        }
+
+        d_data->path.graphic.render( 
+            painter, rect, Qt::KeepAspectRatio );
+        return;
+    }
+    else if ( d_data->style == QwtSymbol::SvgDocument )
+    {
+#ifndef QWT_NO_SVG
+        if ( d_data->svg.renderer )
+        {
+            QRectF scaledRect;
+
+            QSizeF sz = d_data->svg.renderer->viewBoxF().size();
+            if ( !sz.isEmpty() )
+            {
+                sz.scale( rect.size(), Qt::KeepAspectRatio );
+                scaledRect.setSize( sz );
+                scaledRect.moveCenter( rect.center() );
+            }
+            else
+            {
+                scaledRect = rect;
+            }
+
+            d_data->svg.renderer->render( 
+                painter, scaledRect );
+        }
+#endif
+    }
+    else
+    {
+        const QRect br = boundingRect();
+
+        // scale the symbol size to fit into rect.
+
+        const double ratio = qMin( rect.width() / br.width(), 
+            rect.height() / br.height() );
+
+        painter->save();
+
+        painter->translate( rect.center() );
+        painter->scale( ratio, ratio );
+
+        const bool isPinPointEnabled = d_data->isPinPointEnabled;
+        d_data->isPinPointEnabled = false;
+
+        const QPointF pos;
+        renderSymbols( painter, &pos, 1 );
+    
+        d_data->isPinPointEnabled = isPinPointEnabled;
+
+        painter->restore();
+    }
+}
+
+/*!
+  Render the symbol to series of points
+
+  \param painter Qt painter
+  \param points Positions of the symbols
+  \param numPoints Number of points
+ */
+void QwtSymbol::renderSymbols( QPainter *painter,
+    const QPointF *points, int numPoints ) const
+{
     switch ( d_data->style )
     {
@@ -934 +1566 @@
             break;
         }
+        case QwtSymbol::Path:
+        {
+            if ( d_data->path.graphic.isNull() )
+            {
+                d_data->path.graphic = qwtPathGraphic( d_data->path.path, 
+                    d_data->pen, d_data->brush );
+            }
+
+            qwtDrawGraphicSymbols( painter, points, numPoints, 
+                d_data->path.graphic, *this );
+            break;
+        }
+        case QwtSymbol::Pixmap:
+        {
+            qwtDrawPixmapSymbols( painter, points, numPoints, *this );
+            break;
+        }
+        case QwtSymbol::Graphic:
+        {
+            qwtDrawGraphicSymbols( painter, points, numPoints, 
+                d_data->graphic.graphic, *this );
+            break;
+        }
+        case QwtSymbol::SvgDocument:
+        {
+#ifndef QWT_NO_SVG
+            qwtDrawSvgSymbols( painter, points, numPoints, 
+                d_data->svg.renderer, *this );
+#endif
+            break;
+        }
         default:;
     }
-    painter->restore();
-}
-
-//!  \return Size of the bounding rectangle of a symbol
-QSize QwtSymbol::boundingSize() const
-{
-    QSize size;
+}
+
+/*!
+  Calculate the bounding rectangle for a symbol
+  at position (0,0).
+
+  \return Bounding rectangle
+ */
+QRect QwtSymbol::boundingRect() const
+{
+    QRectF rect;
+
+    bool pinPointTranslation = false;
 
     switch ( d_data->style )
@@ -954 +1623 @@
                 pw = qMax( d_data->pen.widthF(), qreal( 1.0 ) );
 
-            size = d_data->size + QSize( pw, pw );
+            rect.setSize( d_data->size + QSizeF( pw, pw ) );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
 
             break;
@@ -972 +1642 @@
                 pw = qMax( d_data->pen.widthF(), qreal( 1.0 ) );
 
-            size = d_data->size + QSize( 2 * pw, 2 * pw );
-            break;
-        }
+            rect.setSize( d_data->size + QSizeF( 2 * pw, 2 * pw ) );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
+            break;
+        }
+        case QwtSymbol::Path:
+        {
+            if ( d_data->path.graphic.isNull() )
+            {
+                d_data->path.graphic = qwtPathGraphic(
+                    d_data->path.path, d_data->pen, d_data->brush );
+            }
+
+            rect = qwtScaledBoundingRect( 
+                d_data->path.graphic, d_data->size );
+            pinPointTranslation = true;
+
+            break;
+        }
+        case QwtSymbol::Pixmap:
+        {
+            if ( d_data->size.isEmpty() )
+                rect.setSize( d_data->pixmap.pixmap.size() );
+            else
+                rect.setSize( d_data->size );
+            
+            pinPointTranslation = true;
+
+            break;
+        }
+        case QwtSymbol::Graphic:
+        {
+            rect = qwtScaledBoundingRect( 
+                d_data->graphic.graphic, d_data->size );
+            pinPointTranslation = true;
+
+            break;
+        }
+#ifndef QWT_NO_SVG
+        case QwtSymbol::SvgDocument:
+        {
+            if ( d_data->svg.renderer )
+                rect = d_data->svg.renderer->viewBoxF();
+
+            if ( d_data->size.isValid() && !rect.isEmpty() )
+            {
+                QSizeF sz = rect.size();
+
+                const double sx = d_data->size.width() / sz.width();
+                const double sy = d_data->size.height() / sz.height();
+
+                QTransform transform;
+                transform.scale( sx, sy );
+
+                rect = transform.mapRect( rect );
+            }
+            pinPointTranslation = true;
+            break;
+        }
+#endif
         default:
         {
-            size = d_data->size;
-        }
-    }
-
-    return size + QSize( 1, 1 ); // for antialiasing
+            rect.setSize( d_data->size );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
+        }
+    }
+
+    if ( pinPointTranslation )
+    {
+        QPointF pinPoint( 0.0, 0.0 );
+        if ( d_data->isPinPointEnabled )
+            pinPoint = rect.center() - d_data->pinPoint;
+
+        rect.moveCenter( pinPoint );
+    }
+
+    QRect r;
+    r.setLeft( qFloor( rect.left() ) );
+    r.setTop( qFloor( rect.top() ) );
+    r.setRight( qCeil( rect.right() ) );
+    r.setBottom( qCeil( rect.bottom() ) );
+
+    if ( d_data->style != QwtSymbol::Pixmap )
+        r.adjust( -1, -1, 1, 1 ); // for antialiasing
+
+    return r;
+}
+
+/*!
+  Invalidate the cached symbol pixmap
+
+  The symbol invalidates its cache, whenever an attribute is changed
+  that has an effect ob how to display a symbol. In case of derived
+  classes with individual styles ( >= QwtSymbol::UserStyle ) it
+  might be necessary to call invalidateCache() for attributes
+  that are relevant for this style.
+
+  \sa CachePolicy, setCachePolicy(), drawSymbols()
+ */
+void QwtSymbol::invalidateCache()
+{
+    if ( !d_data->cache.pixmap.isNull() )
+        d_data->cache.pixmap = QPixmap();
 }
 
@@ -992 +1754 @@
 void QwtSymbol::setStyle( QwtSymbol::Style style )
 {
-    d_data->style = style;
+    if ( d_data->style != style )
+    {
+        d_data->style = style;
+        invalidateCache();
+    }
 }