qwt_abstract_scale_draw.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_abstract_scale_draw.h"
#include "qwt_text.h"
#include "qwt_painter.h"
#include "qwt_scale_map.h"
#include "qwt_math.h"
 
#include <qpainter.h>
#include <qpalette.h>
#include <qmap.h>
#include <qlist.h>
#include <qlocale.h>
 
class QwtAbstractScaleDraw::PrivateData
{
  public:
    PrivateData():
        spacing( 4.0 ),
        penWidthF( 0.0 ),
        minExtent( 0.0 )
    {
        components = QwtAbstractScaleDraw::Backbone
            | QwtAbstractScaleDraw::Ticks
            | QwtAbstractScaleDraw::Labels;
 
        tickLength[QwtScaleDiv::MinorTick] = 4.0;
        tickLength[QwtScaleDiv::MediumTick] = 6.0;
        tickLength[QwtScaleDiv::MajorTick] = 8.0;
    }
 
    ScaleComponents components;
 
    QwtScaleMap map;
    QwtScaleDiv scaleDiv;
 
    double spacing;
    double tickLength[QwtScaleDiv::NTickTypes];
    qreal penWidthF;
 
    double minExtent;
 
    QMap< double, QwtText > labelCache;
};
 
QwtAbstractScaleDraw::QwtAbstractScaleDraw()
{
    m_data = new QwtAbstractScaleDraw::PrivateData;
}
 
QwtAbstractScaleDraw::~QwtAbstractScaleDraw()
{
    delete m_data;
}
 
void QwtAbstractScaleDraw::enableComponent(
    ScaleComponent component, bool enable )
{
    if ( enable )
        m_data->components |= component;
    else
        m_data->components &= ~component;
}
 
bool QwtAbstractScaleDraw::hasComponent( ScaleComponent component ) const
{
    return ( m_data->components & component );
}
 
void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv& scaleDiv )
{
    m_data->scaleDiv = scaleDiv;
    m_data->map.setScaleInterval( scaleDiv.lowerBound(), scaleDiv.upperBound() );
    m_data->labelCache.clear();
}
 
void QwtAbstractScaleDraw::setTransformation( QwtTransform* transformation )
{
    m_data->map.setTransformation( transformation );
}
 
const QwtScaleMap& QwtAbstractScaleDraw::scaleMap() const
{
    return m_data->map;
}
 
QwtScaleMap& QwtAbstractScaleDraw::scaleMap()
{
    return m_data->map;
}
 
const QwtScaleDiv& QwtAbstractScaleDraw::scaleDiv() const
{
    return m_data->scaleDiv;
}
 
void QwtAbstractScaleDraw::setPenWidthF( qreal width )
{
    if ( width < 0.0 )
        width = 0.0;
 
    m_data->penWidthF = width;
}
 
qreal QwtAbstractScaleDraw::penWidthF() const
{
    return m_data->penWidthF;
}
 
void QwtAbstractScaleDraw::draw( QPainter* painter,
    const QPalette& palette ) const
{
    painter->save();
 
    QPen pen = painter->pen();
    pen.setWidthF( m_data->penWidthF );
 
    painter->setPen( pen );
 
    if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
    {
        painter->save();
        painter->setPen( palette.color( QPalette::Text ) ); // ignore pen style
 
        const QList< double >& majorTicks =
            m_data->scaleDiv.ticks( QwtScaleDiv::MajorTick );
 
        for ( int i = 0; i < majorTicks.count(); i++ )
        {
            const double v = majorTicks[i];
            if ( m_data->scaleDiv.contains( v ) )
                drawLabel( painter, v );
        }
 
        painter->restore();
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
    {
        painter->save();
 
        pen = painter->pen();
        pen.setColor( palette.color( QPalette::WindowText ) );
        pen.setCapStyle( Qt::FlatCap );
 
        painter->setPen( pen );
 
        for ( int tickType = QwtScaleDiv::MinorTick;
            tickType < QwtScaleDiv::NTickTypes; tickType++ )
        {
            const double tickLen = m_data->tickLength[tickType];
            if ( tickLen <= 0.0 )
                continue;
 
            const QList< double >& ticks = m_data->scaleDiv.ticks( tickType );
            for ( int i = 0; i < ticks.count(); i++ )
            {
                const double v = ticks[i];
                if ( m_data->scaleDiv.contains( v ) )
                    drawTick( painter, v, tickLen );
            }
        }
 
        painter->restore();
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
    {
        painter->save();
 
        pen = painter->pen();
        pen.setColor( palette.color( QPalette::WindowText ) );
        pen.setCapStyle( Qt::FlatCap );
 
        painter->setPen( pen );
 
        drawBackbone( painter );
 
        painter->restore();
    }
 
    painter->restore();
}
 
void QwtAbstractScaleDraw::setSpacing( double spacing )
{
    if ( spacing < 0 )
        spacing = 0;
 
    m_data->spacing = spacing;
}
 
double QwtAbstractScaleDraw::spacing() const
{
    return m_data->spacing;
}
 
void QwtAbstractScaleDraw::setMinimumExtent( double minExtent )
{
    if ( minExtent < 0.0 )
        minExtent = 0.0;
 
    m_data->minExtent = minExtent;
}
 
double QwtAbstractScaleDraw::minimumExtent() const
{
    return m_data->minExtent;
}
 
void QwtAbstractScaleDraw::setTickLength(
    QwtScaleDiv::TickType tickType, double length )
{
    if ( tickType < QwtScaleDiv::MinorTick ||
        tickType > QwtScaleDiv::MajorTick )
    {
        return;
    }
 
    if ( length < 0.0 )
        length = 0.0;
 
    const double maxTickLen = 1000.0;
    if ( length > maxTickLen )
        length = maxTickLen;
 
    m_data->tickLength[tickType] = length;
}
 
double QwtAbstractScaleDraw::tickLength( QwtScaleDiv::TickType tickType ) const
{
    if ( tickType < QwtScaleDiv::MinorTick ||
        tickType > QwtScaleDiv::MajorTick )
    {
        return 0;
    }
 
    return m_data->tickLength[tickType];
}
 
double QwtAbstractScaleDraw::maxTickLength() const
{
    double length = 0.0;
    for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
        length = qwtMaxF( length, m_data->tickLength[i] );
 
    return length;
}
 
QwtText QwtAbstractScaleDraw::label( double value ) const
{
    return QLocale().toString( value );
}
 
const QwtText& QwtAbstractScaleDraw::tickLabel(
    const QFont& font, double value ) const
{
    QMap< double, QwtText >::const_iterator it1 = m_data->labelCache.constFind( value );
    if ( it1 != m_data->labelCache.constEnd() )
        return *it1;
 
    QwtText lbl = label( value );
    lbl.setRenderFlags( 0 );
    lbl.setLayoutAttribute( QwtText::MinimumLayout );
 
    ( void )lbl.textSize( font ); // initialize the internal cache
 
    QMap< double, QwtText >::iterator it2 = m_data->labelCache.insert( value, lbl );
    return *it2;
}
 
void QwtAbstractScaleDraw::invalidateCache()
{
    m_data->labelCache.clear();
}