qwt_abstract_scale.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_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 )
{
    d_data = new PrivateData;
    rescale( 0.0, 100.0, d_data->stepSize );
}

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

void QwtAbstractScale::setLowerBound( double value )
{
    setScale( value, upperBound() );
}

double QwtAbstractScale::lowerBound() const
{
    return d_data->scaleDraw->scaleDiv().lowerBound();
}

void QwtAbstractScale::setUpperBound( double value )
{
    setScale( lowerBound(), value );
}

double QwtAbstractScale::upperBound() const
{
    return d_data->scaleDraw->scaleDiv().upperBound();
}

void QwtAbstractScale::setScale( double lowerBound, double upperBound )
{
    rescale( lowerBound, upperBound, d_data->stepSize );
}

void QwtAbstractScale::setScale( const QwtInterval &interval )
{
    setScale( interval.minValue(), interval.maxValue() );
}

void QwtAbstractScale::setScale( const QwtScaleDiv &scaleDiv )
{
    if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
    {
#if 1
        if ( d_data->scaleEngine )
        {
            d_data->scaleDraw->setTransformation(
                d_data->scaleEngine->transformation() );
        }
#endif

        d_data->scaleDraw->setScaleDiv( scaleDiv );

        scaleChange();
    }
}

void QwtAbstractScale::setScaleMaxMajor( int ticks )
{
    if ( ticks != d_data->maxMajor )
    {
        d_data->maxMajor = ticks;
        updateScaleDraw();
    }
}

int QwtAbstractScale::scaleMaxMajor() const
{
    return d_data->maxMajor;
}

void QwtAbstractScale::setScaleMaxMinor( int ticks )
{
    if ( ticks != d_data->maxMinor )
    {
        d_data->maxMinor = ticks;
        updateScaleDraw();
    }
}

int QwtAbstractScale::scaleMaxMinor() const
{
    return d_data->maxMinor;
}

void QwtAbstractScale::setScaleStepSize( double stepSize )
{
    if ( stepSize != d_data->stepSize )
    {
        d_data->stepSize = stepSize;
        updateScaleDraw();
    }
}

double QwtAbstractScale::scaleStepSize() const
{
    return d_data->stepSize;
}

void QwtAbstractScale::setAbstractScaleDraw( QwtAbstractScaleDraw *scaleDraw )
{
    if ( scaleDraw == NULL || scaleDraw == d_data->scaleDraw )
        return;

    if ( d_data->scaleDraw != NULL )
        scaleDraw->setScaleDiv( d_data->scaleDraw->scaleDiv() );

    delete d_data->scaleDraw;
    d_data->scaleDraw = scaleDraw;
}

QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw()
{
    return d_data->scaleDraw;
}

const QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw() const
{
    return d_data->scaleDraw;
}

void QwtAbstractScale::setScaleEngine( QwtScaleEngine *scaleEngine )
{
    if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine )
    {
        delete d_data->scaleEngine;
        d_data->scaleEngine = scaleEngine;
    }
}

const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
{
    return d_data->scaleEngine;
}

QwtScaleEngine *QwtAbstractScale::scaleEngine()
{
    return d_data->scaleEngine;
}

const QwtScaleDiv &QwtAbstractScale::scaleDiv() const
{
    return d_data->scaleDraw->scaleDiv();
}

const QwtScaleMap &QwtAbstractScale::scaleMap() const
{
    return d_data->scaleDraw->scaleMap();
}

int QwtAbstractScale::transform( double value ) const
{
    return qRound( d_data->scaleDraw->scaleMap().transform( value ) );
}

double QwtAbstractScale::invTransform( int value ) const
{
    return d_data->scaleDraw->scaleMap().invTransform( value );
}

bool QwtAbstractScale::isInverted() const
{
    return d_data->scaleDraw->scaleMap().isInverting();
}

double QwtAbstractScale::minimum() const
{
    return qMin( d_data->scaleDraw->scaleDiv().lowerBound(),
        d_data->scaleDraw->scaleDiv().upperBound() );
}

double QwtAbstractScale::maximum() const
{
    return qMax( d_data->scaleDraw->scaleDiv().lowerBound(),
        d_data->scaleDraw->scaleDiv().upperBound() );
}

void QwtAbstractScale::scaleChange()
{
}

void QwtAbstractScale::rescale(
    double lowerBound, double upperBound, double stepSize )
{
    const QwtScaleDiv scaleDiv = d_data->scaleEngine->divideScale(
        lowerBound, upperBound, d_data->maxMajor, d_data->maxMinor, stepSize );

    if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
    {
#if 1
        d_data->scaleDraw->setTransformation(
            d_data->scaleEngine->transformation() );
#endif

        d_data->scaleDraw->setScaleDiv( scaleDiv );
        scaleChange();
    }
}

void QwtAbstractScale::changeEvent( QEvent *event )
{
    if ( event->type() == QEvent::LocaleChange )
    {
        d_data->scaleDraw->invalidateCache();
    }

    QWidget::changeEvent( event );
}

void QwtAbstractScale::updateScaleDraw()
{
    rescale( d_data->scaleDraw->scaleDiv().lowerBound(),
        d_data->scaleDraw->scaleDiv().upperBound(), d_data->stepSize );
}

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