qwt_abstract_scale.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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 );
}

#if QWT_MOC_INCLUDE
#include "moc_qwt_abstract_scale.cpp"
#endif