qwt_plot_marker.cpp

Go to the documentation of this file.

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * 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
 *****************************************************************************/

// vim: expandtab

#include <qpainter.h>
#include "qwt_painter.h"
#include "qwt_scale_map.h"
#include "qwt_plot_marker.h"
#include "qwt_symbol.h"
#include "qwt_text.h"
#include "qwt_math.h"

class QwtPlotMarker::PrivateData
{
public:
    PrivateData():
        labelAlignment(Qt::AlignCenter),
        labelOrientation(Qt::Horizontal),
        spacing(2),
        style(NoLine),
        xValue(0.0),
        yValue(0.0)
    {
        symbol = new QwtSymbol();
    }

    ~PrivateData()
    {
        delete symbol;
    }

    QwtText label;
#if QT_VERSION < 0x040000
    int labelAlignment;
#else
    Qt::Alignment labelAlignment;
#endif
    Qt::Orientation labelOrientation;
    int spacing;

    QPen pen;
    QwtSymbol *symbol;
    LineStyle style;

    double xValue;
    double yValue;
};

QwtPlotMarker::QwtPlotMarker():
    QwtPlotItem(QwtText("Marker"))
{
    d_data = new PrivateData;
    setZ(30.0);
}

QwtPlotMarker::~QwtPlotMarker()
{
    delete d_data;
}

int QwtPlotMarker::rtti() const
{
    return QwtPlotItem::Rtti_PlotMarker;
}

QwtDoublePoint QwtPlotMarker::value() const
{
    return QwtDoublePoint(d_data->xValue, d_data->yValue);
}

double QwtPlotMarker::xValue() const 
{ 
    return d_data->xValue; 
}

double QwtPlotMarker::yValue() const 
{ 
    return d_data->yValue; 
}

void QwtPlotMarker::setValue(const QwtDoublePoint& pos)
{
    setValue(pos.x(), pos.y());
}

void QwtPlotMarker::setValue(double x, double y) 
{
    if ( x != d_data->xValue || y != d_data->yValue )
    {
        d_data->xValue = x; 
        d_data->yValue = y; 
        itemChanged(); 
    }
}

void QwtPlotMarker::setXValue(double x) 
{ 
    setValue(x, d_data->yValue);
}

void QwtPlotMarker::setYValue(double y) 
{ 
    setValue(d_data->xValue, y);
}

void QwtPlotMarker::draw(QPainter *painter,
    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
    const QRect &canvasRect) const
{
    const int x = xMap.transform(d_data->xValue);
    const int y = yMap.transform(d_data->yValue);

    drawAt(painter, canvasRect, QPoint(x, y));
}

void QwtPlotMarker::drawAt(QPainter *painter, 
    const QRect &canvasRect, const QPoint &pos) const
{
    // draw lines
    if (d_data->style != NoLine)
    {
        painter->setPen(QwtPainter::scaledPen(d_data->pen));
        if ( d_data->style == QwtPlotMarker::HLine || 
            d_data->style == QwtPlotMarker::Cross )
        {
            QwtPainter::drawLine(painter, canvasRect.left(), 
                pos.y(), canvasRect.right(), pos.y() );
        }
        if (d_data->style == QwtPlotMarker::VLine || 
            d_data->style == QwtPlotMarker::Cross )
        {
            QwtPainter::drawLine(painter, pos.x(), 
                canvasRect.top(), pos.x(), canvasRect.bottom());
        }
    }

    // draw symbol
    if (d_data->symbol->style() != QwtSymbol::NoSymbol)
        d_data->symbol->draw(painter, pos.x(), pos.y());

    drawLabel(painter, canvasRect, pos);
}

void QwtPlotMarker::drawLabel(QPainter *painter, 
    const QRect &canvasRect, const QPoint &pos) const
{
    if (d_data->label.isEmpty())
        return;

    int align = d_data->labelAlignment;
    QPoint alignPos = pos;

    QSize symbolOff(0, 0);

    switch(d_data->style)
    {
        case QwtPlotMarker::VLine:
        {
            // In VLine-style the y-position is pointless and
            // the alignment flags are relative to the canvas

            if (d_data->labelAlignment & (int) Qt::AlignTop)
            {
                alignPos.setY(canvasRect.top());
                align &= ~Qt::AlignTop;
                align |= Qt::AlignBottom;
            }
            else if (d_data->labelAlignment & (int) 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 (d_data->labelAlignment & (int) Qt::AlignLeft)
            {
                alignPos.setX(canvasRect.left());
                align &= ~Qt::AlignLeft;
                align |= Qt::AlignRight;
            }
            else if (d_data->labelAlignment & (int) Qt::AlignRight)
            {
                alignPos.setX(canvasRect.right() - 1);
                align &= ~Qt::AlignRight;
                align |= Qt::AlignLeft;
            }
            else
            {
                alignPos.setX(canvasRect.center().x());
            }
            break;
        }
        default:
        {
            if ( d_data->symbol->style() != QwtSymbol::NoSymbol )
            {
                symbolOff = d_data->symbol->size() + QSize(1, 1);
                symbolOff /= 2;
            }
        }
    }
    
    int pw = d_data->pen.width();
    if ( pw == 0 )
        pw = 1;

    const int xSpacing = 
        QwtPainter::metricsMap().screenToLayoutX(d_data->spacing);
    const int ySpacing = 
        QwtPainter::metricsMap().screenToLayoutY(d_data->spacing);


    int xOff = qwtMax( (pw + 1) / 2, symbolOff.width() );
    int yOff = qwtMax( (pw + 1) / 2, symbolOff.height() );

    const QSize textSize = d_data->label.textSize(painter->font());

    if ( align & Qt::AlignLeft )
    {
        alignPos.rx() -= xOff + xSpacing;
        if ( d_data->labelOrientation == Qt::Vertical )
            alignPos.rx() -= textSize.height();
        else
            alignPos.rx() -= textSize.width();
    }
    else if ( align & Qt::AlignRight )
    {
        alignPos.rx() += xOff + xSpacing;
    }
    else
    {
        if ( d_data->labelOrientation == Qt::Vertical )
            alignPos.rx() -= textSize.height() / 2;
        else
            alignPos.rx() -= textSize.width() / 2;
    }

    if (align & (int) Qt::AlignTop)
    {
        alignPos.ry() -= yOff + ySpacing;
        if ( d_data->labelOrientation != Qt::Vertical )
            alignPos.ry() -= textSize.height();
    }
    else if (align & (int) Qt::AlignBottom)
    {
        alignPos.ry() += yOff + ySpacing;
        if ( d_data->labelOrientation == Qt::Vertical )
            alignPos.ry() += textSize.width();
    }
    else
    {
        if ( d_data->labelOrientation == Qt::Vertical )
            alignPos.ry() += textSize.width() / 2;
        else
            alignPos.ry() -= textSize.height() / 2;
    }

    painter->translate(alignPos.x(), alignPos.y());
    if ( d_data->labelOrientation == Qt::Vertical )
        painter->rotate(-90.0);

    const QRect textRect(0, 0, textSize.width(), textSize.height());
    d_data->label.draw(painter, textRect);
}

void QwtPlotMarker::setLineStyle(QwtPlotMarker::LineStyle st)
{
    if ( st != d_data->style )
    {
        d_data->style = st;
        itemChanged();
    }
}

QwtPlotMarker::LineStyle QwtPlotMarker::lineStyle() const 
{ 
    return d_data->style; 
}

void QwtPlotMarker::setSymbol(const QwtSymbol &s)
{
    delete d_data->symbol;
    d_data->symbol = s.clone();
    itemChanged();
}

const QwtSymbol &QwtPlotMarker::symbol() const 
{ 
    return *d_data->symbol; 
}

void QwtPlotMarker::setLabel(const QwtText& label)
{
    if ( label != d_data->label )
    {
        d_data->label = label;
        itemChanged();
    }
}

QwtText QwtPlotMarker::label() const 
{ 
    return d_data->label; 
}

#if QT_VERSION < 0x040000
void QwtPlotMarker::setLabelAlignment(int align)
#else
void QwtPlotMarker::setLabelAlignment(Qt::Alignment align)
#endif
{
    if ( align != d_data->labelAlignment )
    {
        d_data->labelAlignment = align;
        itemChanged();
    }
}

#if QT_VERSION < 0x040000
int QwtPlotMarker::labelAlignment() const 
#else
Qt::Alignment QwtPlotMarker::labelAlignment() const 
#endif
{ 
    return d_data->labelAlignment; 
}

void QwtPlotMarker::setLabelOrientation(Qt::Orientation orientation)
{
    if ( orientation != d_data->labelOrientation )
    {
        d_data->labelOrientation = orientation;
        itemChanged();
    }
}

Qt::Orientation QwtPlotMarker::labelOrientation() const
{
    return d_data->labelOrientation;
}

void QwtPlotMarker::setSpacing(int spacing)
{
    if ( spacing < 0 )
        spacing = 0;

    if ( spacing == d_data->spacing )
        return;

    d_data->spacing = spacing;
    itemChanged();
}

int QwtPlotMarker::spacing() const
{
    return d_data->spacing;
}

void QwtPlotMarker::setLinePen(const QPen &pen)
{
    if ( pen != d_data->pen )
    {
        d_data->pen = pen;
        itemChanged();
    }
}

const QPen &QwtPlotMarker::linePen() const 
{ 
    return d_data->pen; 
}

QwtDoubleRect QwtPlotMarker::boundingRect() const
{
    return QwtDoubleRect(d_data->xValue, d_data->yValue, 0.0, 0.0);
}