qwt_plot_textlabel.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_textlabel.h"
#include "qwt_painter.h"
#include "qwt_text.h"
#include "qwt_math.h"
 
#include <qpainter.h>
#include <qpaintengine.h>
#include <qpixmap.h>
 
static QRect qwtItemRect( int renderFlags,
    const QRectF& rect, const QSizeF& itemSize )
{
    int x;
    if ( renderFlags & Qt::AlignLeft )
    {
        x = rect.left();
    }
    else if ( renderFlags & Qt::AlignRight )
    {
        x = rect.right() - itemSize.width();
    }
    else
    {
        x = rect.center().x() - 0.5 * itemSize.width();
    }
 
    int y;
    if ( renderFlags & Qt::AlignTop )
    {
        y = rect.top();
    }
    else if ( renderFlags & Qt::AlignBottom )
    {
        y = rect.bottom() - itemSize.height();
    }
    else
    {
        y = rect.center().y() - 0.5 * itemSize.height();
    }
 
    return QRect( x, y, itemSize.width(), itemSize.height() );
}
 
class QwtPlotTextLabel::PrivateData
{
  public:
    PrivateData()
        : margin( 5 )
    {
    }
 
    QwtText text;
    int margin;
 
    QPixmap pixmap;
};
 
QwtPlotTextLabel::QwtPlotTextLabel()
    : QwtPlotItem( QwtText( "Label" ) )
{
    m_data = new PrivateData;
 
    setItemAttribute( QwtPlotItem::AutoScale, false );
    setItemAttribute( QwtPlotItem::Legend, false );
 
    setZ( 150 );
}
 
QwtPlotTextLabel::~QwtPlotTextLabel()
{
    delete m_data;
}
 
int QwtPlotTextLabel::rtti() const
{
    return QwtPlotItem::Rtti_PlotTextLabel;
}
 
void QwtPlotTextLabel::setText( const QwtText& text )
{
    if ( m_data->text != text )
    {
        m_data->text = text;
 
        invalidateCache();
        itemChanged();
    }
}
 
QwtText QwtPlotTextLabel::text() const
{
    return m_data->text;
}
 
void QwtPlotTextLabel::setMargin( int margin )
{
    margin = qMax( margin, 0 );
    if ( m_data->margin != margin )
    {
        m_data->margin = margin;
        itemChanged();
    }
}
 
int QwtPlotTextLabel::margin() const
{
    return m_data->margin;
}
 
void QwtPlotTextLabel::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    Q_UNUSED( xMap );
    Q_UNUSED( yMap );
 
    const int m = m_data->margin;
 
    const QRectF rect = textRect( canvasRect.adjusted( m, m, -m, -m ),
        m_data->text.textSize( painter->font() ) );
 
    bool doCache = QwtPainter::roundingAlignment( painter );
    if ( doCache )
    {
        switch( painter->paintEngine()->type() )
        {
            case QPaintEngine::Picture:
            case QPaintEngine::User: // usually QwtGraphic
            {
                // don't use a cache for record/replay devices
                doCache = false;
                break;
            }
            default:;
        }
    }
 
    if ( doCache )
    {
        // when the paint device is aligning it is not one
        // where scalability matters ( PDF, SVG ).
        // As rendering a text label is an expensive operation
        // we use a cache.
 
        int pw = 0;
        if ( m_data->text.borderPen().style() != Qt::NoPen )
            pw = qMax( m_data->text.borderPen().width(), 1 );
 
        QRect pixmapRect;
        pixmapRect.setLeft( qwtFloor( rect.left() ) - pw );
        pixmapRect.setTop( qwtFloor( rect.top() ) - pw );
        pixmapRect.setRight( qwtCeil( rect.right() ) + pw );
        pixmapRect.setBottom( qwtCeil( rect.bottom() ) + pw );
 
#if QT_VERSION >= 0x050000
        const qreal pixelRatio = QwtPainter::devicePixelRatio( painter->device() );
        const QSize scaledSize = pixmapRect.size() * pixelRatio;
#else
        const QSize scaledSize = pixmapRect.size();
#endif
 
        if ( m_data->pixmap.isNull() ||
            ( scaledSize != m_data->pixmap.size() ) )
        {
            m_data->pixmap = QPixmap( scaledSize );
#if QT_VERSION >= 0x050000
            m_data->pixmap.setDevicePixelRatio( pixelRatio );
#endif
            m_data->pixmap.fill( Qt::transparent );
 
            const QRect r( pw, pw,
                pixmapRect.width() - 2 * pw, pixmapRect.height() - 2 * pw );
 
            QPainter pmPainter( &m_data->pixmap );
            m_data->text.draw( &pmPainter, r );
        }
 
        painter->drawPixmap( pixmapRect, m_data->pixmap );
    }
    else
    {
        m_data->text.draw( painter, rect );
    }
}
 
QRectF QwtPlotTextLabel::textRect(
    const QRectF& rect, const QSizeF& textSize ) const
{
    return qwtItemRect( m_data->text.renderFlags(), rect, textSize );
}
 
void QwtPlotTextLabel::invalidateCache()
{
    m_data->pixmap = QPixmap();
}