qwt_abstract_scale_draw.cpp

/* -*- 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 <qpalette.h>
#include <qmap.h>
#include "qwt_math.h"
#include "qwt_text.h"
#include "qwt_painter.h"
#include "qwt_scale_map.h"
#include "qwt_scale_draw.h"

class QwtAbstractScaleDraw::PrivateData
{
public:
    PrivateData():
        components(Backbone | Ticks | Labels),
        spacing(4),
        minExtent(0)
    {
        tickLength[QwtScaleDiv::MinorTick] = 4;
        tickLength[QwtScaleDiv::MediumTick] = 6;
        tickLength[QwtScaleDiv::MajorTick] = 8;
    }

    int components;
    
    QwtScaleMap map;
    QwtScaleDiv scldiv;
        
    int spacing;
    int tickLength[QwtScaleDiv::NTickTypes];

    int minExtent;

    QMap<double, QwtText> labelCache;
};

QwtAbstractScaleDraw::QwtAbstractScaleDraw()
{
    d_data = new QwtAbstractScaleDraw::PrivateData;
}

QwtAbstractScaleDraw::QwtAbstractScaleDraw(const QwtAbstractScaleDraw &other)
{
    d_data = new QwtAbstractScaleDraw::PrivateData(*other.d_data);
}

QwtAbstractScaleDraw::~QwtAbstractScaleDraw()
{
    delete d_data;
}
QwtAbstractScaleDraw &QwtAbstractScaleDraw::operator=(const QwtAbstractScaleDraw &other)
{
    *d_data = *other.d_data;
    return *this;
}

void QwtAbstractScaleDraw::enableComponent(
    ScaleComponent component, bool enable)
{
    if ( enable )
        d_data->components |= component;
    else
        d_data->components &= ~component;
}

bool QwtAbstractScaleDraw::hasComponent(ScaleComponent component) const
{
    return (d_data->components & component);
}

void QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &sd)
{
    d_data->scldiv = sd;
    d_data->map.setScaleInterval(sd.lBound(), sd.hBound());
    d_data->labelCache.clear();
}

void QwtAbstractScaleDraw::setTransformation(
    QwtScaleTransformation *transformation)
{
    d_data->map.setTransformation(transformation);
}

const QwtScaleMap &QwtAbstractScaleDraw::map() const
{
    return d_data->map;
}

QwtScaleMap &QwtAbstractScaleDraw::scaleMap() 
{
    return d_data->map;
}

const QwtScaleDiv& QwtAbstractScaleDraw::scaleDiv() const 
{ 
    return d_data->scldiv; 
}

#if QT_VERSION < 0x040000

void QwtAbstractScaleDraw::draw(QPainter *painter, 
    const QColorGroup& colorGroup) const

#else

void QwtAbstractScaleDraw::draw(QPainter *painter, 
    const QPalette& palette) const
#endif
{
    if ( hasComponent(QwtAbstractScaleDraw::Labels) )
    {
        painter->save();

#if QT_VERSION < 0x040000
        painter->setPen(colorGroup.text()); // ignore pen style
#else
        painter->setPen(palette.color(QPalette::Text)); // ignore pen style
#endif

        const QwtValueList &majorTicks = 
            d_data->scldiv.ticks(QwtScaleDiv::MajorTick);

        for (int i = 0; i < (int)majorTicks.count(); i++)
        {
            const double v = majorTicks[i];
            if ( d_data->scldiv.contains(v) )
                drawLabel(painter, majorTicks[i]);
        }

        painter->restore();
    }

    if ( hasComponent(QwtAbstractScaleDraw::Ticks) )
    {
        painter->save();

        QPen pen = painter->pen();
#if QT_VERSION < 0x040000
        pen.setColor(colorGroup.foreground());
#else
        pen.setColor(palette.color(QPalette::Foreground));
#endif
        painter->setPen(pen);

        for ( int tickType = QwtScaleDiv::MinorTick; 
            tickType < QwtScaleDiv::NTickTypes; tickType++ )
        {
            const QwtValueList &ticks = d_data->scldiv.ticks(tickType);
            for (int i = 0; i < (int)ticks.count(); i++)
            {
                const double v = ticks[i];
                if ( d_data->scldiv.contains(v) )
                    drawTick(painter, v, d_data->tickLength[tickType]);
            }
        }

        painter->restore();
    }

    if ( hasComponent(QwtAbstractScaleDraw::Backbone) )
    {
        painter->save();

        QPen pen = painter->pen();
#if QT_VERSION < 0x040000
        pen.setColor(colorGroup.foreground());
#else
        pen.setColor(palette.color(QPalette::Foreground));
#endif
        painter->setPen(pen);

        drawBackbone(painter);

        painter->restore();
    }
}

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

    d_data->spacing = spacing;
}

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

void QwtAbstractScaleDraw::setMinimumExtent(int minExtent)
{
    if ( minExtent < 0 )
        minExtent = 0;

    d_data->minExtent = minExtent;
}

int QwtAbstractScaleDraw::minimumExtent() const
{
    return d_data->minExtent;
}

void QwtAbstractScaleDraw::setTickLength(
    QwtScaleDiv::TickType tickType, int length)
{
    if ( tickType < QwtScaleDiv::MinorTick || 
        tickType > QwtScaleDiv::MajorTick )
    {
        return;
    }

    if ( length < 0 )
        length = 0;

    const int maxTickLen = 1000;
    if ( length > maxTickLen )
        length = 1000;

    d_data->tickLength[tickType] = length;
}

int QwtAbstractScaleDraw::tickLength(QwtScaleDiv::TickType tickType) const
{
    if ( tickType < QwtScaleDiv::MinorTick || 
        tickType > QwtScaleDiv::MajorTick )
    {
        return 0;
    }

    return d_data->tickLength[tickType];
}

int QwtAbstractScaleDraw::majTickLength() const
{
    return d_data->tickLength[QwtScaleDiv::MajorTick];
}

QwtText QwtAbstractScaleDraw::label(double value) const
{
    return QString::number(value);
}

const QwtText &QwtAbstractScaleDraw::tickLabel(
    const QFont &font, double value) const
{
    QMap<double, QwtText>::const_iterator it = d_data->labelCache.find(value);
    if ( it == d_data->labelCache.end() )
    {
        QwtText lbl = label(value);
        lbl.setRenderFlags(0);
        lbl.setLayoutAttribute(QwtText::MinimumLayout);

        (void)lbl.textSize(font); // initialize the internal cache

        it = d_data->labelCache.insert(value, lbl);
    }

    return (*it);
}

void QwtAbstractScaleDraw::invalidateCache()
{
    d_data->labelCache.clear();
}

---