qwt_plot_shapeitem.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_shapeitem.h"
#include "qwt_scale_map.h"
#include "qwt_text.h"
#include "qwt_graphic.h"
#include "qwt_painter.h"
#include "qwt_weeding_curve_fitter.h"
#include "qwt_clipper.h"
#include "qwt_math.h"
 
#include <qpainter.h>
#include <qpainterpath.h>
 
static QPainterPath qwtTransformPath( const QwtScaleMap& xMap,
    const QwtScaleMap& yMap, const QPainterPath& path, bool doAlign )
{
    QPainterPath shape;
    shape.setFillRule( path.fillRule() );
 
    for ( int i = 0; i < path.elementCount(); i++ )
    {
        const QPainterPath::Element element = path.elementAt( i );
 
        double x = xMap.transform( element.x );
        double y = yMap.transform( element.y );
 
        switch( element.type )
        {
            case QPainterPath::MoveToElement:
            {
                if ( doAlign )
                {
                    x = qRound( x );
                    y = qRound( y );
                }
 
                shape.moveTo( x, y );
                break;
            }
            case QPainterPath::LineToElement:
            {
                if ( doAlign )
                {
                    x = qRound( x );
                    y = qRound( y );
                }
 
                shape.lineTo( x, y );
                break;
            }
            case QPainterPath::CurveToElement:
            {
                const QPainterPath::Element element1 = path.elementAt( ++i );
                const double x1 = xMap.transform( element1.x );
                const double y1 = yMap.transform( element1.y );
 
                const QPainterPath::Element element2 = path.elementAt( ++i );
                const double x2 = xMap.transform( element2.x );
                const double y2 = yMap.transform( element2.y );
 
                shape.cubicTo( x, y, x1, y1, x2, y2 );
                break;
            }
            case QPainterPath::CurveToDataElement:
            {
                break;
            }
        }
    }
 
    return shape;
}
 
 
class QwtPlotShapeItem::PrivateData
{
  public:
    PrivateData()
        : legendMode( QwtPlotShapeItem::LegendColor )
        , renderTolerance( 0.0 )
    {
    }
 
    QwtPlotShapeItem::PaintAttributes paintAttributes;
    QwtPlotShapeItem::LegendMode legendMode;
 
    double renderTolerance;
    QRectF boundingRect;
 
    QPen pen;
    QBrush brush;
    QPainterPath shape;
};
 
QwtPlotShapeItem::QwtPlotShapeItem( const QString& title )
    : QwtPlotItem( QwtText( title ) )
{
    init();
}
 
QwtPlotShapeItem::QwtPlotShapeItem( const QwtText& title )
    : QwtPlotItem( title )
{
    init();
}
 
QwtPlotShapeItem::~QwtPlotShapeItem()
{
    delete m_data;
}
 
void QwtPlotShapeItem::init()
{
    m_data = new PrivateData();
    m_data->boundingRect = QwtPlotItem::boundingRect();
 
    setItemAttribute( QwtPlotItem::AutoScale, true );
    setItemAttribute( QwtPlotItem::Legend, false );
 
    setZ( 8.0 );
}
 
int QwtPlotShapeItem::rtti() const
{
    return QwtPlotItem::Rtti_PlotShape;
}
 
void QwtPlotShapeItem::setPaintAttribute( PaintAttribute attribute, bool on )
{
    if ( on )
        m_data->paintAttributes |= attribute;
    else
        m_data->paintAttributes &= ~attribute;
}
 
bool QwtPlotShapeItem::testPaintAttribute( PaintAttribute attribute ) const
{
    return ( m_data->paintAttributes & attribute );
}
 
void QwtPlotShapeItem::setLegendMode( LegendMode mode )
{
    if ( mode != m_data->legendMode )
    {
        m_data->legendMode = mode;
        legendChanged();
    }
}
 
QwtPlotShapeItem::LegendMode QwtPlotShapeItem::legendMode() const
{
    return m_data->legendMode;
}
 
QRectF QwtPlotShapeItem::boundingRect() const
{
    return m_data->boundingRect;
}
 
void QwtPlotShapeItem::setRect( const QRectF& rect )
{
    QPainterPath path;
    path.addRect( rect );
 
    setShape( path );
}
 
void QwtPlotShapeItem::setPolygon( const QPolygonF& polygon )
{
    QPainterPath shape;
    shape.addPolygon( polygon );
 
    setShape( shape );
}
 
void QwtPlotShapeItem::setShape( const QPainterPath& shape )
{
    if ( shape != m_data->shape )
    {
        m_data->shape = shape;
        if ( shape.isEmpty() )
        {
            m_data->boundingRect = QwtPlotItem::boundingRect();
        }
        else
        {
            m_data->boundingRect = shape.boundingRect();
        }
 
        itemChanged();
    }
}
 
QPainterPath QwtPlotShapeItem::shape() const
{
    return m_data->shape;
}
 
void QwtPlotShapeItem::setPen( const QColor& color, qreal width, Qt::PenStyle style )
{
    setPen( QPen( color, width, style ) );
}
 
void QwtPlotShapeItem::setPen( const QPen& pen )
{
    if ( pen != m_data->pen )
    {
        m_data->pen = pen;
        itemChanged();
    }
}
 
QPen QwtPlotShapeItem::pen() const
{
    return m_data->pen;
}
 
void QwtPlotShapeItem::setBrush( const QBrush& brush )
{
    if ( brush != m_data->brush )
    {
        m_data->brush = brush;
        itemChanged();
    }
}
 
QBrush QwtPlotShapeItem::brush() const
{
    return m_data->brush;
}
 
void QwtPlotShapeItem::setRenderTolerance( double tolerance )
{
    tolerance = qwtMaxF( tolerance, 0.0 );
 
    if ( tolerance != m_data->renderTolerance )
    {
        m_data->renderTolerance = tolerance;
        itemChanged();
    }
}
 
double QwtPlotShapeItem::renderTolerance() const
{
    return m_data->renderTolerance;
}
 
void QwtPlotShapeItem::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    if ( m_data->shape.isEmpty() )
        return;
 
    if ( m_data->pen.style() == Qt::NoPen
        && m_data->brush.style() == Qt::NoBrush )
    {
        return;
    }
 
    const QRectF cr = QwtScaleMap::invTransform(
        xMap, yMap, canvasRect.toRect() );
 
    const QRectF& br = m_data->boundingRect;
 
    if ( ( br.left() > cr.right() ) || ( br.right() < cr.left() )
        || ( br.top() > cr.bottom() ) || ( br.bottom() < cr.top() ) )
    {
        // outside the visible area
        return;
    }
 
    const bool doAlign = QwtPainter::roundingAlignment( painter );
 
    QPainterPath path = qwtTransformPath( xMap, yMap,
        m_data->shape, doAlign );
 
    if ( testPaintAttribute( QwtPlotShapeItem::ClipPolygons ) )
    {
        const qreal pw = QwtPainter::effectivePenWidth( painter->pen() );
        const QRectF clipRect = canvasRect.adjusted( -pw, -pw, pw, pw );
 
        QPainterPath clippedPath;
        clippedPath.setFillRule( path.fillRule() );
 
        QList< QPolygonF > polygons = path.toSubpathPolygons();
        for ( int i = 0; i < polygons.size(); i++ )
        {
            QwtClipper::clipPolygonF( clipRect, polygons[i], true );
            clippedPath.addPolygon( polygons[i] );
 
        }
 
        path = clippedPath;
    }
 
    if ( m_data->renderTolerance > 0.0 )
    {
        QwtWeedingCurveFitter fitter( m_data->renderTolerance );
 
        QPainterPath fittedPath;
        fittedPath.setFillRule( path.fillRule() );
 
        const QList< QPolygonF > polygons = path.toSubpathPolygons();
        for ( int i = 0; i < polygons.size(); i++ )
            fittedPath.addPolygon( fitter.fitCurve( polygons[ i ] ) );
 
        path = fittedPath;
    }
 
    painter->setPen( m_data->pen );
    painter->setBrush( m_data->brush );
 
    painter->drawPath( path );
}
 
QwtGraphic QwtPlotShapeItem::legendIcon( int index,
    const QSizeF& size ) const
{
    Q_UNUSED( index );
 
    QwtGraphic icon;
    icon.setDefaultSize( size );
 
    if ( size.isEmpty() )
        return icon;
 
    if ( m_data->legendMode == QwtPlotShapeItem::LegendShape )
    {
        const QRectF& br = m_data->boundingRect;
 
        QPainter painter( &icon );
        painter.setRenderHint( QPainter::Antialiasing,
            testRenderHint( QwtPlotItem::RenderAntialiased ) );
 
        painter.translate( -br.topLeft() );
 
        painter.setPen( m_data->pen );
        painter.setBrush( m_data->brush );
        painter.drawPath( m_data->shape );
    }
    else
    {
        QColor iconColor;
        if ( m_data->brush.style() != Qt::NoBrush )
            iconColor = m_data->brush.color();
        else
            iconColor = m_data->pen.color();
 
        icon = defaultIcon( iconColor, size );
    }
 
    return icon;
}