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_scale_engine.h"
#include "qwt_scale_draw.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_double_interval.h"
#include "qwt_abstract_scale.h"

class QwtAbstractScale::PrivateData
{
public:
    PrivateData():
        maxMajor(5),
        maxMinor(3),
        stepSize(0.0),
        autoScale(true)
    {
        scaleEngine = new QwtLinearScaleEngine;
        scaleDraw = new QwtScaleDraw();
    }

    ~PrivateData()
    {
        delete scaleEngine;
        delete scaleDraw;
    }

    QwtScaleEngine *scaleEngine;
    QwtAbstractScaleDraw *scaleDraw;

    int maxMajor;
    int maxMinor;
    double stepSize;

    bool autoScale;
};

QwtAbstractScale::QwtAbstractScale()
{
    d_data = new PrivateData;
    rescale(0.0, 100.0);
}

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

void QwtAbstractScale::setScale(double vmin, double vmax, double stepSize)
{
    d_data->autoScale = false;
    d_data->stepSize = stepSize;

    rescale(vmin, vmax, stepSize);
}

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


void QwtAbstractScale::setScale(const QwtScaleDiv &scaleDiv)
{
    d_data->autoScale = false;

    if (scaleDiv != d_data->scaleDraw->scaleDiv())
    {
        d_data->scaleDraw->setScaleDiv(scaleDiv);
        scaleChange();
    }
}

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

    if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
    {
        d_data->scaleDraw->setTransformation(
            d_data->scaleEngine->transformation());
        d_data->scaleDraw->setScaleDiv(scaleDiv);
        scaleChange();
    }
}

void QwtAbstractScale::setAutoScale()
{
    if (!d_data->autoScale) 
    {
        d_data->autoScale = true;
        scaleChange();
    }
}

bool QwtAbstractScale::autoScale() const
{
    return d_data->autoScale;
}

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

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

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

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

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::updateScaleDraw()
{
    rescale( d_data->scaleDraw->scaleDiv().lowerBound(), 
        d_data->scaleDraw->scaleDiv().upperBound(), d_data->stepSize);
}

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;
}

void QwtAbstractScale::scaleChange()
{
}

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