qwt_abstract_scale.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.h"
#include "qwt_scale_engine.h"
#include "qwt_scale_draw.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_interval.h"
 
#include <qcoreevent.h>
 
class QwtAbstractScale::PrivateData
{
  public:
    PrivateData():
        maxMajor( 5 ),
        maxMinor( 3 ),
        stepSize( 0.0 )
    {
        scaleEngine = new QwtLinearScaleEngine();
        scaleDraw = new QwtScaleDraw();
    }
 
    ~PrivateData()
    {
        delete scaleEngine;
        delete scaleDraw;
    }
 
    QwtScaleEngine* scaleEngine;
    QwtAbstractScaleDraw* scaleDraw;
 
    int maxMajor;
    int maxMinor;
    double stepSize;
};
 
QwtAbstractScale::QwtAbstractScale( QWidget* parent )
    : QWidget( parent )
{
    m_data = new PrivateData;
    rescale( 0.0, 100.0, m_data->stepSize );
}
 
QwtAbstractScale::~QwtAbstractScale()
{
    delete m_data;
}
 
void QwtAbstractScale::setLowerBound( double value )
{
    setScale( value, upperBound() );
}
 
double QwtAbstractScale::lowerBound() const
{
    return m_data->scaleDraw->scaleDiv().lowerBound();
}
 
void QwtAbstractScale::setUpperBound( double value )
{
    setScale( lowerBound(), value );
}
 
double QwtAbstractScale::upperBound() const
{
    return m_data->scaleDraw->scaleDiv().upperBound();
}
 
void QwtAbstractScale::setScale( double lowerBound, double upperBound )
{
    rescale( lowerBound, upperBound, m_data->stepSize );
}
 
void QwtAbstractScale::setScale( const QwtInterval& interval )
{
    setScale( interval.minValue(), interval.maxValue() );
}
 
void QwtAbstractScale::setScale( const QwtScaleDiv& scaleDiv )
{
    if ( scaleDiv != m_data->scaleDraw->scaleDiv() )
    {
#if 1
        if ( m_data->scaleEngine )
        {
            m_data->scaleDraw->setTransformation(
                m_data->scaleEngine->transformation() );
        }
#endif
 
        m_data->scaleDraw->setScaleDiv( scaleDiv );
 
        scaleChange();
    }
}
 
void QwtAbstractScale::setScaleMaxMajor( int ticks )
{
    if ( ticks != m_data->maxMajor )
    {
        m_data->maxMajor = ticks;
        updateScaleDraw();
    }
}
 
int QwtAbstractScale::scaleMaxMajor() const
{
    return m_data->maxMajor;
}
 
void QwtAbstractScale::setScaleMaxMinor( int ticks )
{
    if ( ticks != m_data->maxMinor )
    {
        m_data->maxMinor = ticks;
        updateScaleDraw();
    }
}
 
int QwtAbstractScale::scaleMaxMinor() const
{
    return m_data->maxMinor;
}
 
void QwtAbstractScale::setScaleStepSize( double stepSize )
{
    if ( stepSize != m_data->stepSize )
    {
        m_data->stepSize = stepSize;
        updateScaleDraw();
    }
}
 
double QwtAbstractScale::scaleStepSize() const
{
    return m_data->stepSize;
}
 
void QwtAbstractScale::setAbstractScaleDraw( QwtAbstractScaleDraw* scaleDraw )
{
    if ( scaleDraw == NULL || scaleDraw == m_data->scaleDraw )
        return;
 
    if ( m_data->scaleDraw != NULL )
        scaleDraw->setScaleDiv( m_data->scaleDraw->scaleDiv() );
 
    delete m_data->scaleDraw;
    m_data->scaleDraw = scaleDraw;
}
 
QwtAbstractScaleDraw* QwtAbstractScale::abstractScaleDraw()
{
    return m_data->scaleDraw;
}
 
const QwtAbstractScaleDraw* QwtAbstractScale::abstractScaleDraw() const
{
    return m_data->scaleDraw;
}
 
void QwtAbstractScale::setScaleEngine( QwtScaleEngine* scaleEngine )
{
    if ( scaleEngine != NULL && scaleEngine != m_data->scaleEngine )
    {
        delete m_data->scaleEngine;
        m_data->scaleEngine = scaleEngine;
    }
}
 
const QwtScaleEngine* QwtAbstractScale::scaleEngine() const
{
    return m_data->scaleEngine;
}
 
QwtScaleEngine* QwtAbstractScale::scaleEngine()
{
    return m_data->scaleEngine;
}
 
const QwtScaleDiv& QwtAbstractScale::scaleDiv() const
{
    return m_data->scaleDraw->scaleDiv();
}
 
const QwtScaleMap& QwtAbstractScale::scaleMap() const
{
    return m_data->scaleDraw->scaleMap();
}
 
int QwtAbstractScale::transform( double value ) const
{
    return qRound( m_data->scaleDraw->scaleMap().transform( value ) );
}
 
double QwtAbstractScale::invTransform( int value ) const
{
    return m_data->scaleDraw->scaleMap().invTransform( value );
}
 
bool QwtAbstractScale::isInverted() const
{
    return m_data->scaleDraw->scaleMap().isInverting();
}
 
double QwtAbstractScale::minimum() const
{
    return qMin( m_data->scaleDraw->scaleDiv().lowerBound(),
        m_data->scaleDraw->scaleDiv().upperBound() );
}
 
double QwtAbstractScale::maximum() const
{
    return qMax( m_data->scaleDraw->scaleDiv().lowerBound(),
        m_data->scaleDraw->scaleDiv().upperBound() );
}
 
void QwtAbstractScale::scaleChange()
{
}
 
void QwtAbstractScale::rescale(
    double lowerBound, double upperBound, double stepSize )
{
    const QwtScaleDiv scaleDiv = m_data->scaleEngine->divideScale(
        lowerBound, upperBound, m_data->maxMajor, m_data->maxMinor, stepSize );
 
    if ( scaleDiv != m_data->scaleDraw->scaleDiv() )
    {
#if 1
        m_data->scaleDraw->setTransformation(
            m_data->scaleEngine->transformation() );
#endif
 
        m_data->scaleDraw->setScaleDiv( scaleDiv );
        scaleChange();
    }
}
 
void QwtAbstractScale::changeEvent( QEvent* event )
{
    if ( event->type() == QEvent::LocaleChange )
    {
        m_data->scaleDraw->invalidateCache();
    }
 
    QWidget::changeEvent( event );
}
 
void QwtAbstractScale::updateScaleDraw()
{
    rescale( m_data->scaleDraw->scaleDiv().lowerBound(),
        m_data->scaleDraw->scaleDiv().upperBound(), m_data->stepSize );
}
 
#include "moc_qwt_abstract_scale.cpp"