qwt_scale_draw.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
 *****************************************************************************/

#include "qwt_scale_draw.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_math.h"
#include "qwt_painter.h"
#include "qwt_text.h"

#include <qpainter.h>
#include <qpaintengine.h>
#include <qmath.h>

static inline double qwtEffectivePenWidth( const QwtAbstractScaleDraw* scaleDraw )
{
    return qwtMaxF( scaleDraw->penWidthF(), 1.0 );
}

namespace QwtScaleRendererReal
{
    inline qreal penWidth( const QPainter *painter, const QwtScaleDraw* scaleDraw )
    {
        qreal width = scaleDraw->penWidthF();
#if 1
        if ( width <= 0.0 )
            width = 1.0;
#endif

        if ( painter->pen().isCosmetic() )
        {
            const QTransform &transform = painter->transform();

            switch ( scaleDraw->alignment() )
            {
                case QwtScaleDraw::LeftScale:
                case QwtScaleDraw::RightScale:
                {
                    width /= transform.m11();
                    break;
                }
                case QwtScaleDraw::TopScale:
                case QwtScaleDraw::BottomScale:
                {
                    width /= transform.m22();
                    break;
                }
            }
        }

        return width;
    }

    inline void drawBackbone( QPainter *painter, const QwtScaleDraw* scaleDraw ) 
    {
        const qreal pw2 = 0.5 * penWidth( painter, scaleDraw );

        const QPointF pos = scaleDraw->pos();
        const qreal length = scaleDraw->length();

        switch ( scaleDraw->alignment() )
        {
            case QwtScaleDraw::LeftScale:
            {
                const qreal x = pos.x() + 1.0 - pw2;
                QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + length );

                break;
            }
            case QwtScaleDraw::RightScale:
            {
                const qreal x = pos.x() - 1.0 + pw2;
                QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + length );

                break;
            }
            case QwtScaleDraw::TopScale:
            {
                const qreal y = pos.y() + 1.0 - pw2;
                QwtPainter::drawLine( painter, pos.x(), y, pos.x() + length, y );

                break;
            }
            case QwtScaleDraw::BottomScale:
            {
                const qreal y = pos.y() - 1.0 + pw2;
                QwtPainter::drawLine( painter, pos.x(), y, pos.x() + length, y );

                break;
            }
        }
    }

    inline void drawTick( QPainter *painter,
        const QwtScaleDraw* scaleDraw, qreal tickPos, qreal tickLength )
    {
        const QPointF pos = scaleDraw->pos();

        qreal pw = 0.0;

        if ( scaleDraw->hasComponent( QwtScaleDraw::Backbone ) )
            pw = penWidth( painter, scaleDraw );

        const qreal length = tickLength + pw;

        /*
            Those correction offsets have been found by try and error.
            They need to be understood and replaced by a calculation,
            that makes sense. TODO ...
         */
        const qreal off1 = 1.0;
        const qreal off2 = ( scaleDraw->penWidthF() <= 0.0 ) ? 0.5 : 0.0;

        switch ( scaleDraw->alignment() )
        {
            case QwtScaleDraw::LeftScale:
            {
                const qreal x = pos.x() + off1 - off2;
                QwtPainter::drawLine( painter, x, tickPos, x - length, tickPos );

                break;
            }
            case QwtScaleDraw::RightScale:
            {
                const qreal x = pos.x() - off1 + off2;
                QwtPainter::drawLine( painter, x, tickPos, x + length, tickPos );
                break;
            }
            case QwtScaleDraw::TopScale:
            {
                const qreal y = pos.y() + off1 - 2 * off2;
                QwtPainter::drawLine( painter, tickPos, y, tickPos, y - length );

                break;
            }
            case QwtScaleDraw::BottomScale:
            {
                const qreal y = pos.y() - off1 + off2;
                QwtPainter::drawLine( painter, tickPos, y, tickPos, y + length );

                break;
            }
        }
    }
}

namespace QwtScaleRendererInt
{
    inline void drawBackbone( QPainter *painter, const QwtScaleDraw* scaleDraw ) 
    {
        const int pw = qMax( qRound( scaleDraw->penWidthF() ), 1 );

        const qreal length = scaleDraw->length();
        const QPointF pos = scaleDraw->pos();

        switch ( scaleDraw->alignment() )
        {
            case QwtScaleDraw::LeftScale:
            {
                const qreal x = qRound( pos.x() - ( pw - 1 ) / 2 );
                QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + length );

                break;
            }
            case QwtScaleDraw::RightScale:
            {
                const qreal x = qRound( pos.x() + pw / 2 );
                QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + length );

                break;
            }
            case QwtScaleDraw::TopScale:
            {
                const qreal y = qRound( pos.y() - ( pw - 1 ) / 2 );
                QwtPainter::drawLine( painter, pos.x(), y, pos.x() + length, y );
                
                break;
            }
            case QwtScaleDraw::BottomScale:
            { 
                const qreal y = qRound( pos.y() + pw / 2 );
                QwtPainter::drawLine( painter, pos.x(), y, pos.x() + length, y );
                    
                break;
            }   
        }   
    }

    inline void drawTick( QPainter *painter,
        const QwtScaleDraw* scaleDraw, qreal tickPos, qreal tickLength )
    {
        const QPointF pos = scaleDraw->pos();
        tickPos = qRound( tickPos );

        int pw = 0;
        if ( scaleDraw->hasComponent( QwtScaleDraw::Backbone ) )
            pw = qMax( qRound( scaleDraw->penWidthF() ), 1 );

        int len = qMax( qRound( tickLength ), 1 );

        // the width of ticks at the borders might extent the backbone 
        len += pw;

        if ( painter->pen().capStyle() == Qt::FlatCap )
            len++; // the end point is not rendered

        qreal off = 0.0;

        if ( painter->paintEngine()->type() == QPaintEngine::X11 )
        {
            if ( pw == 1 )
            {
                // In opposite to raster, X11 paints the end point
                off = 1.0;
            }
        }

        switch ( scaleDraw->alignment() )
        {
            case QwtScaleDraw::LeftScale:
            {
                const qreal x1 = qRound( pos.x() ) + 1;
                const qreal x2 = x1 - len + 1;

                QwtPainter::drawLine( painter, x2, tickPos, x1 - off, tickPos );

                break;
            }
            case QwtScaleDraw::RightScale:
            {
                const qreal x1 = qRound( pos.x() );
                const qreal x2 = x1 + len - 1;

                QwtPainter::drawLine( painter, x1, tickPos, x2 - off, tickPos );

                break;
            }
            case QwtScaleDraw::BottomScale:
            {
                const qreal y1 = qRound( pos.y() );
                const qreal y2 = y1 + len - 1;

                QwtPainter::drawLine( painter, tickPos, y1, tickPos, y2 - off );

                break;
            }
            case QwtScaleDraw::TopScale:
            {
                const qreal y1 = qRound( pos.y() );
                const qreal y2 = y1 - len + 1;

                QwtPainter::drawLine( painter, tickPos, y2 + 1, tickPos, y1 + 1 - off );

                break;
            }
        }
    }
}

class QwtScaleDraw::PrivateData
{
public:
    PrivateData():
        len( 0 ),
        alignment( QwtScaleDraw::BottomScale ),
        labelRotation( 0.0 )
    {
    }

    QPointF pos;
    double len;

    Alignment alignment;

    Qt::Alignment labelAlignment;
    double labelRotation;
};

QwtScaleDraw::QwtScaleDraw()
{
    d_data = new QwtScaleDraw::PrivateData;
    setLength( 100 );
}

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

QwtScaleDraw::Alignment QwtScaleDraw::alignment() const
{
    return d_data->alignment;
}

void QwtScaleDraw::setAlignment( Alignment align )
{
    d_data->alignment = align;
}

Qt::Orientation QwtScaleDraw::orientation() const
{
    switch ( d_data->alignment )
    {
        case TopScale:
        case BottomScale:
            return Qt::Horizontal;
        case LeftScale:
        case RightScale:
        default:
            return Qt::Vertical;
    }
}

void QwtScaleDraw::getBorderDistHint(
    const QFont &font, int &start, int &end ) const
{
    start = 0;
    end = 1.0;

    if ( !hasComponent( QwtAbstractScaleDraw::Labels ) )
        return;

    const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
    if ( ticks.count() == 0 )
        return;

    // Find the ticks, that are mapped to the borders.
    // minTick is the tick, that is mapped to the top/left-most position
    // in widget coordinates.

    double minTick = ticks[0];
    double minPos = scaleMap().transform( minTick );
    double maxTick = minTick;
    double maxPos = minPos;

    for ( int i = 1; i < ticks.count(); i++ )
    {
        const double tickPos = scaleMap().transform( ticks[i] );
        if ( tickPos < minPos )
        {
            minTick = ticks[i];
            minPos = tickPos;
        }
        if ( tickPos > scaleMap().transform( maxTick ) )
        {
            maxTick = ticks[i];
            maxPos = tickPos;
        }
    }

    double e = 0.0;
    double s = 0.0;
    if ( orientation() == Qt::Vertical )
    {
        s = -labelRect( font, minTick ).top();
        s -= qAbs( minPos - qRound( scaleMap().p2() ) );

        e = labelRect( font, maxTick ).bottom();
        e -= qAbs( maxPos - scaleMap().p1() );
    }
    else
    {
        s = -labelRect( font, minTick ).left();
        s -= qAbs( minPos - scaleMap().p1() );

        e = labelRect( font, maxTick ).right();
        e -= qAbs( maxPos - scaleMap().p2() );
    }

    if ( s < 0.0 )
        s = 0.0;
    if ( e < 0.0 )
        e = 0.0;

    start = qwtCeil( s );
    end = qwtCeil( e );
}

int QwtScaleDraw::minLabelDist( const QFont &font ) const
{
    if ( !hasComponent( QwtAbstractScaleDraw::Labels ) )
        return 0;

    const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
    if ( ticks.isEmpty() )
        return 0;

    const QFontMetrics fm( font );

    const bool vertical = ( orientation() == Qt::Vertical );

    QRectF bRect1;
    QRectF bRect2 = labelRect( font, ticks[0] );
    if ( vertical )
    {
        bRect2.setRect( -bRect2.bottom(), 0.0, bRect2.height(), bRect2.width() );
    }

    double maxDist = 0.0;

    for ( int i = 1; i < ticks.count(); i++ )
    {
        bRect1 = bRect2;
        bRect2 = labelRect( font, ticks[i] );
        if ( vertical )
        {
            bRect2.setRect( -bRect2.bottom(), 0.0,
                bRect2.height(), bRect2.width() );
        }

        double dist = fm.leading(); // space between the labels
        if ( bRect1.right() > 0 )
            dist += bRect1.right();
        if ( bRect2.left() < 0 )
            dist += -bRect2.left();

        if ( dist > maxDist )
            maxDist = dist;
    }

    double angle = qwtRadians( labelRotation() );
    if ( vertical )
        angle += M_PI / 2;

    const double sinA = qFastSin( angle ); // qreal -> double
    if ( qFuzzyCompare( sinA + 1.0, 1.0 ) )
        return qCeil( maxDist );

    const int fmHeight = fm.ascent() - 2;

    // The distance we need until there is
    // the height of the label font. This height is needed
    // for the neighbored label.

    double labelDist = fmHeight / qFastSin( angle ) * qFastCos( angle );
    if ( labelDist < 0 )
        labelDist = -labelDist;

    // For text orientations close to the scale orientation

    if ( labelDist > maxDist )
        labelDist = maxDist;

    // For text orientations close to the opposite of the
    // scale orientation

    if ( labelDist < fmHeight )
        labelDist = fmHeight;

    return qCeil( labelDist );
}

double QwtScaleDraw::extent( const QFont &font ) const
{
    double d = 0;

    if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
    {
        if ( orientation() == Qt::Vertical )
            d = maxLabelWidth( font );
        else
            d = maxLabelHeight( font );

        if ( d > 0 )
            d += spacing();
    }

    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
    {
        d += maxTickLength();
    }

    if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
    {
        d += qwtEffectivePenWidth( this );
    }

    d = qwtMaxF( d, minimumExtent() );
    return d;
}

int QwtScaleDraw::minLength( const QFont &font ) const
{
    int startDist, endDist;
    getBorderDistHint( font, startDist, endDist );

    const QwtScaleDiv &sd = scaleDiv();

    const uint minorCount =
        sd.ticks( QwtScaleDiv::MinorTick ).count() +
        sd.ticks( QwtScaleDiv::MediumTick ).count();
    const uint majorCount =
        sd.ticks( QwtScaleDiv::MajorTick ).count();

    int lengthForLabels = 0;
    if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
        lengthForLabels = minLabelDist( font ) * majorCount;

    int lengthForTicks = 0;
    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
    {
        const double pw = qwtEffectivePenWidth( this );
        lengthForTicks = qCeil( ( majorCount + minorCount ) * ( pw + 1.0 ) );
    }

    return startDist + endDist + qMax( lengthForLabels, lengthForTicks );
}

QPointF QwtScaleDraw::labelPosition( double value ) const
{
    const double tval = scaleMap().transform( value );
    double dist = spacing();
    if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
        dist += qwtEffectivePenWidth( this );

    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
        dist += tickLength( QwtScaleDiv::MajorTick );

    double px = 0;
    double py = 0;

    switch ( alignment() )
    {
        case RightScale:
        {
            px = d_data->pos.x() + dist;
            py = tval;
            break;
        }
        case LeftScale:
        {
            px = d_data->pos.x() - dist;
            py = tval;
            break;
        }
        case BottomScale:
        {
            px = tval;
            py = d_data->pos.y() + dist;
            break;
        }
        case TopScale:
        {
            px = tval;
            py = d_data->pos.y() - dist;
            break;
        }
    }

    return QPointF( px, py );
}

void QwtScaleDraw::drawTick( QPainter *painter, double value, double len ) const
{
    if ( len <= 0 )
        return;

    const double tval = scaleMap().transform( value );

    if ( QwtPainter::roundingAlignment( painter ) )
        QwtScaleRendererInt::drawTick( painter, this, tval, len );
    else
        QwtScaleRendererReal::drawTick( painter, this, tval, len );
}

void QwtScaleDraw::drawBackbone( QPainter *painter ) const
{
    if ( QwtPainter::roundingAlignment( painter ) )
        QwtScaleRendererInt::drawBackbone( painter, this );
    else
        QwtScaleRendererReal::drawBackbone( painter, this );
}

void QwtScaleDraw::move( const QPointF &pos )
{
    d_data->pos = pos;
    updateMap();
}

QPointF QwtScaleDraw::pos() const
{
    return d_data->pos;
}

void QwtScaleDraw::setLength( double length )
{
#if 0
    if ( length >= 0 && length < 10 )
        length = 10;

    // why should we accept negative lengths ???
    if ( length < 0 && length > -10 )
        length = -10;
#else
    length = qwtMaxF( length, 10.0 );
#endif

    d_data->len = length;
    updateMap();
}

double QwtScaleDraw::length() const
{
    return d_data->len;
}

void QwtScaleDraw::drawLabel( QPainter *painter, double value ) const
{
    QwtText lbl = tickLabel( painter->font(), value );
    if ( lbl.isEmpty() )
        return;

    QPointF pos = labelPosition( value );

    QSizeF labelSize = lbl.textSize( painter->font() );

    const QTransform transform = labelTransformation( pos, labelSize );

    painter->save();
    painter->setWorldTransform( transform, true );

    lbl.draw ( painter, QRect( QPoint( 0, 0 ), labelSize.toSize() ) );

    painter->restore();
}

QRect QwtScaleDraw::boundingLabelRect( const QFont &font, double value ) const
{
    QwtText lbl = tickLabel( font, value );
    if ( lbl.isEmpty() )
        return QRect();

    const QPointF pos = labelPosition( value );
    QSizeF labelSize = lbl.textSize( font );

    const QTransform transform = labelTransformation( pos, labelSize );
    return transform.mapRect( QRect( QPoint( 0, 0 ), labelSize.toSize() ) );
}

QTransform QwtScaleDraw::labelTransformation(
    const QPointF &pos, const QSizeF &size ) const
{
    QTransform transform;
    transform.translate( pos.x(), pos.y() );
    transform.rotate( labelRotation() );

    int flags = labelAlignment();
    if ( flags == 0 )
    {
        switch ( alignment() )
        {
            case RightScale:
            {
                if ( flags == 0 )
                    flags = Qt::AlignRight | Qt::AlignVCenter;
                break;
            }
            case LeftScale:
            {
                if ( flags == 0 )
                    flags = Qt::AlignLeft | Qt::AlignVCenter;
                break;
            }
            case BottomScale:
            {
                if ( flags == 0 )
                    flags = Qt::AlignHCenter | Qt::AlignBottom;
                break;
            }
            case TopScale:
            {
                if ( flags == 0 )
                    flags = Qt::AlignHCenter | Qt::AlignTop;
                break;
            }
        }
    }

    double x, y;

    if ( flags & Qt::AlignLeft )
        x = -size.width();
    else if ( flags & Qt::AlignRight )
        x = 0.0;
    else // Qt::AlignHCenter
        x = -( 0.5 * size.width() );

    if ( flags & Qt::AlignTop )
        y = -size.height();
    else if ( flags & Qt::AlignBottom )
        y = 0;
    else // Qt::AlignVCenter
        y = -( 0.5 * size.height() );

    transform.translate( x, y );

    return transform;
}

QRectF QwtScaleDraw::labelRect( const QFont &font, double value ) const
{
    QwtText lbl = tickLabel( font, value );
    if ( lbl.isEmpty() )
        return QRectF( 0.0, 0.0, 0.0, 0.0 );

    const QPointF pos = labelPosition( value );

    const QSizeF labelSize = lbl.textSize( font );
    const QTransform transform = labelTransformation( pos, labelSize );

    QRectF br = transform.mapRect( QRectF( QPointF( 0, 0 ), labelSize ) );
    br.translate( -pos.x(), -pos.y() );

    return br;
}

QSizeF QwtScaleDraw::labelSize( const QFont &font, double value ) const
{
    return labelRect( font, value ).size();
}

void QwtScaleDraw::setLabelRotation( double rotation )
{
    d_data->labelRotation = rotation;
}

double QwtScaleDraw::labelRotation() const
{
    return d_data->labelRotation;
}

void QwtScaleDraw::setLabelAlignment( Qt::Alignment alignment )
{
    d_data->labelAlignment = alignment;
}

Qt::Alignment QwtScaleDraw::labelAlignment() const
{
    return d_data->labelAlignment;
}

int QwtScaleDraw::maxLabelWidth( const QFont &font ) const
{
    double maxWidth = 0.0;

    const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
    for ( int i = 0; i < ticks.count(); i++ )
    {
        const double v = ticks[i];
        if ( scaleDiv().contains( v ) )
        {
            const double w = labelSize( font, ticks[i] ).width();
            if ( w > maxWidth )
                maxWidth = w;
        }
    }

    return qCeil( maxWidth );
}

int QwtScaleDraw::maxLabelHeight( const QFont &font ) const
{
    double maxHeight = 0.0;

    const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
    for ( int i = 0; i < ticks.count(); i++ )
    {
        const double v = ticks[i];
        if ( scaleDiv().contains( v ) )
        {
            const double h = labelSize( font, ticks[i] ).height();
            if ( h > maxHeight )
                maxHeight = h;
        }
    }

    return qCeil( maxHeight );
}

void QwtScaleDraw::updateMap()
{
    const QPointF pos = d_data->pos;
    double len = d_data->len;

    QwtScaleMap &sm = scaleMap();
    if ( orientation() == Qt::Vertical )
        sm.setPaintInterval( pos.y() + len, pos.y() );
    else
        sm.setPaintInterval( pos.x(), pos.x() + len );
}