qwt_plot_marker.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_marker.h"
#include "qwt_painter.h"
#include "qwt_scale_map.h"
#include "qwt_symbol.h"
#include "qwt_text.h"
#include "qwt_graphic.h"
#include "qwt_math.h"
 
#include <qpainter.h>
 
class QwtPlotMarker::PrivateData
{
  public:
    PrivateData()
        : labelAlignment( Qt::AlignCenter )
        , labelOrientation( Qt::Horizontal )
        , spacing( 2 )
        , symbol( NULL )
        , style( QwtPlotMarker::NoLine )
        , xValue( 0.0 )
        , yValue( 0.0 )
    {
    }
 
    ~PrivateData()
    {
        delete symbol;
    }
 
    QwtText label;
    Qt::Alignment labelAlignment;
    Qt::Orientation labelOrientation;
    int spacing;
 
    QPen pen;
    const QwtSymbol* symbol;
    LineStyle style;
 
    double xValue;
    double yValue;
};
 
QwtPlotMarker::QwtPlotMarker()
{
    m_data = new PrivateData;
    setZ( 30.0 );
}
 
QwtPlotMarker::QwtPlotMarker( const QString& title )
    : QwtPlotItem( QwtText( title ) )
{
    m_data = new PrivateData;
    setZ( 30.0 );
}
 
QwtPlotMarker::QwtPlotMarker( const QwtText& title )
    : QwtPlotItem( title )
{
    m_data = new PrivateData;
    setZ( 30.0 );
}
 
QwtPlotMarker::~QwtPlotMarker()
{
    delete m_data;
}
 
int QwtPlotMarker::rtti() const
{
    return QwtPlotItem::Rtti_PlotMarker;
}
 
QPointF QwtPlotMarker::value() const
{
    return QPointF( m_data->xValue, m_data->yValue );
}
 
double QwtPlotMarker::xValue() const
{
    return m_data->xValue;
}
 
double QwtPlotMarker::yValue() const
{
    return m_data->yValue;
}
 
void QwtPlotMarker::setValue( const QPointF& pos )
{
    setValue( pos.x(), pos.y() );
}
 
void QwtPlotMarker::setValue( double x, double y )
{
    if ( x != m_data->xValue || y != m_data->yValue )
    {
        m_data->xValue = x;
        m_data->yValue = y;
        itemChanged();
    }
}
 
void QwtPlotMarker::setXValue( double x )
{
    setValue( x, m_data->yValue );
}
 
void QwtPlotMarker::setYValue( double y )
{
    setValue( m_data->xValue, y );
}
 
void QwtPlotMarker::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    const QPointF pos( xMap.transform( m_data->xValue ),
        yMap.transform( m_data->yValue ) );
 
    drawLines( painter, canvasRect, pos );
    drawSymbol( painter, canvasRect, pos );
    drawLabel( painter, canvasRect, pos );
}
 
void QwtPlotMarker::drawLines( QPainter* painter,
    const QRectF& canvasRect, const QPointF& pos ) const
{
    if ( m_data->style == NoLine )
        return;
 
    const bool doAlign = QwtPainter::roundingAlignment( painter );
 
    painter->setPen( m_data->pen );
    if ( m_data->style == QwtPlotMarker::HLine ||
        m_data->style == QwtPlotMarker::Cross )
    {
        double y = pos.y();
        if ( doAlign )
            y = qRound( y );
 
        QwtPainter::drawLine( painter, canvasRect.left(),
            y, canvasRect.right() - 1.0, y );
    }
    if ( m_data->style == QwtPlotMarker::VLine ||
        m_data->style == QwtPlotMarker::Cross )
    {
        double x = pos.x();
        if ( doAlign )
            x = qRound( x );
 
        QwtPainter::drawLine( painter, x,
            canvasRect.top(), x, canvasRect.bottom() - 1.0 );
    }
}
 
void QwtPlotMarker::drawSymbol( QPainter* painter,
    const QRectF& canvasRect, const QPointF& pos ) const
{
    if ( m_data->symbol == NULL )
        return;
 
    const QwtSymbol& symbol = *m_data->symbol;
 
    if ( symbol.style() != QwtSymbol::NoSymbol )
    {
        const QSizeF sz = symbol.size();
 
        const QRectF clipRect = canvasRect.adjusted(
            -sz.width(), -sz.height(), sz.width(), sz.height() );
 
        if ( clipRect.contains( pos ) )
            symbol.drawSymbol( painter, pos );
    }
}
 
void QwtPlotMarker::drawLabel( QPainter* painter,
    const QRectF& canvasRect, const QPointF& pos ) const
{
    if ( m_data->label.isEmpty() )
        return;
 
    Qt::Alignment align = m_data->labelAlignment;
    QPointF alignPos = pos;
 
    QSizeF symbolOff( 0, 0 );
 
    switch ( m_data->style )
    {
        case QwtPlotMarker::VLine:
        {
            // In VLine-style the y-position is pointless and
            // the alignment flags are relative to the canvas
 
            if ( m_data->labelAlignment & Qt::AlignTop )
            {
                alignPos.setY( canvasRect.top() );
                align &= ~Qt::AlignTop;
                align |= Qt::AlignBottom;
            }
            else if ( m_data->labelAlignment & Qt::AlignBottom )
            {
                // In HLine-style the x-position is pointless and
                // the alignment flags are relative to the canvas
 
                alignPos.setY( canvasRect.bottom() - 1 );
                align &= ~Qt::AlignBottom;
                align |= Qt::AlignTop;
            }
            else
            {
                alignPos.setY( canvasRect.center().y() );
            }
            break;
        }
        case QwtPlotMarker::HLine:
        {
            if ( m_data->labelAlignment & Qt::AlignLeft )
            {
                alignPos.setX( canvasRect.left() );
                align &= ~Qt::AlignLeft;
                align |= Qt::AlignRight;
            }
            else if ( m_data->labelAlignment & Qt::AlignRight )
            {
                alignPos.setX( canvasRect.right() - 1 );
                align &= ~Qt::AlignRight;
                align |= Qt::AlignLeft;
            }
            else
            {
                alignPos.setX( canvasRect.center().x() );
            }
            break;
        }
        default:
        {
            if ( m_data->symbol &&
                ( m_data->symbol->style() != QwtSymbol::NoSymbol ) )
            {
                symbolOff = m_data->symbol->size() + QSizeF( 1, 1 );
                symbolOff /= 2;
            }
        }
    }
 
    qreal pw2 = m_data->pen.widthF() / 2.0;
    if ( pw2 == 0.0 )
        pw2 = 0.5;
 
    const int spacing = m_data->spacing;
 
    const qreal xOff = qwtMaxF( pw2, symbolOff.width() );
    const qreal yOff = qwtMaxF( pw2, symbolOff.height() );
 
    const QSizeF textSize = m_data->label.textSize( painter->font() );
 
    if ( align & Qt::AlignLeft )
    {
        alignPos.rx() -= xOff + spacing;
        if ( m_data->labelOrientation == Qt::Vertical )
            alignPos.rx() -= textSize.height();
        else
            alignPos.rx() -= textSize.width();
    }
    else if ( align & Qt::AlignRight )
    {
        alignPos.rx() += xOff + spacing;
    }
    else
    {
        if ( m_data->labelOrientation == Qt::Vertical )
            alignPos.rx() -= textSize.height() / 2;
        else
            alignPos.rx() -= textSize.width() / 2;
    }
 
    if ( align & Qt::AlignTop )
    {
        alignPos.ry() -= yOff + spacing;
        if ( m_data->labelOrientation != Qt::Vertical )
            alignPos.ry() -= textSize.height();
    }
    else if ( align & Qt::AlignBottom )
    {
        alignPos.ry() += yOff + spacing;
        if ( m_data->labelOrientation == Qt::Vertical )
            alignPos.ry() += textSize.width();
    }
    else
    {
        if ( m_data->labelOrientation == Qt::Vertical )
            alignPos.ry() += textSize.width() / 2;
        else
            alignPos.ry() -= textSize.height() / 2;
    }
 
    painter->translate( alignPos.x(), alignPos.y() );
    if ( m_data->labelOrientation == Qt::Vertical )
        painter->rotate( -90.0 );
 
    const QRectF textRect( 0, 0, textSize.width(), textSize.height() );
    m_data->label.draw( painter, textRect );
}
 
void QwtPlotMarker::setLineStyle( LineStyle style )
{
    if ( style != m_data->style )
    {
        m_data->style = style;
 
        legendChanged();
        itemChanged();
    }
}
 
QwtPlotMarker::LineStyle QwtPlotMarker::lineStyle() const
{
    return m_data->style;
}
 
void QwtPlotMarker::setSymbol( const QwtSymbol* symbol )
{
    if ( symbol != m_data->symbol )
    {
        delete m_data->symbol;
        m_data->symbol = symbol;
 
        if ( symbol )
            setLegendIconSize( symbol->boundingRect().size() );
 
        legendChanged();
        itemChanged();
    }
}
 
const QwtSymbol* QwtPlotMarker::symbol() const
{
    return m_data->symbol;
}
 
void QwtPlotMarker::setLabel( const QwtText& label )
{
    if ( label != m_data->label )
    {
        m_data->label = label;
        itemChanged();
    }
}
 
QwtText QwtPlotMarker::label() const
{
    return m_data->label;
}
 
void QwtPlotMarker::setLabelAlignment( Qt::Alignment align )
{
    if ( align != m_data->labelAlignment )
    {
        m_data->labelAlignment = align;
        itemChanged();
    }
}
 
Qt::Alignment QwtPlotMarker::labelAlignment() const
{
    return m_data->labelAlignment;
}
 
void QwtPlotMarker::setLabelOrientation( Qt::Orientation orientation )
{
    if ( orientation != m_data->labelOrientation )
    {
        m_data->labelOrientation = orientation;
        itemChanged();
    }
}
 
Qt::Orientation QwtPlotMarker::labelOrientation() const
{
    return m_data->labelOrientation;
}
 
void QwtPlotMarker::setSpacing( int spacing )
{
    if ( spacing < 0 )
        spacing = 0;
 
    if ( spacing == m_data->spacing )
        return;
 
    m_data->spacing = spacing;
    itemChanged();
}
 
int QwtPlotMarker::spacing() const
{
    return m_data->spacing;
}
 
void QwtPlotMarker::setLinePen( const QColor& color, qreal width, Qt::PenStyle style )
{
    setLinePen( QPen( color, width, style ) );
}
 
void QwtPlotMarker::setLinePen( const QPen& pen )
{
    if ( pen != m_data->pen )
    {
        m_data->pen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
const QPen& QwtPlotMarker::linePen() const
{
    return m_data->pen;
}
 
QRectF QwtPlotMarker::boundingRect() const
{
    // width/height of -1 does not affect the autoscale calculation
 
    switch (m_data->style)
    {
        case QwtPlotMarker::HLine:
            return QRectF( m_data->xValue, m_data->yValue, -1.0, 0.0 );
 
        case QwtPlotMarker::VLine:
            return QRectF( m_data->xValue, m_data->yValue, 0.0, -1.0 );
 
        default:
            return QRectF( m_data->xValue, m_data->yValue, 0.0, 0.0 );
    }
}
 
QwtGraphic QwtPlotMarker::legendIcon( int index, const QSizeF& size ) const
{
    Q_UNUSED( index );
 
    if ( size.isEmpty() )
        return QwtGraphic();
 
    QwtGraphic icon;
    icon.setDefaultSize( size );
    icon.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
 
    QPainter painter( &icon );
    painter.setRenderHint( QPainter::Antialiasing,
        testRenderHint( QwtPlotItem::RenderAntialiased ) );
 
    if ( m_data->style != QwtPlotMarker::NoLine )
    {
        painter.setPen( m_data->pen );
 
        if ( m_data->style == QwtPlotMarker::HLine ||
            m_data->style == QwtPlotMarker::Cross )
        {
            const double y = 0.5 * size.height();
 
            QwtPainter::drawLine( &painter,
                0.0, y, size.width(), y );
        }
 
        if ( m_data->style == QwtPlotMarker::VLine ||
            m_data->style == QwtPlotMarker::Cross )
        {
            const double x = 0.5 * size.width();
 
            QwtPainter::drawLine( &painter,
                x, 0.0, x, size.height() );
        }
    }
 
    if ( m_data->symbol )
    {
        const QRect r( 0.0, 0.0, size.width(), size.height() );
        m_data->symbol->drawSymbol( &painter, r );
    }
 
    return icon;
}