Logo Search packages:      
Sourcecode: pcp-gui version File versions

qwt_abstract_scale.cpp

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

/*!
  Constructor

  Creates a default QwtScaleDraw and a QwtLinearScaleEngine. 
  Autoscaling is enabled, and the stepSize is initialized by 0.0.
*/
   
00053 QwtAbstractScale::QwtAbstractScale()
{
    d_data = new PrivateData;
    rescale(0.0, 100.0);
}

//! Destructor
00060 QwtAbstractScale::~QwtAbstractScale()
{
    delete d_data;
}

/*!
  \brief Specify a scale.

  Disable autoscaling and define a scale by an interval and a step size

  \param vmin lower limit of the scale interval
  \param vmax upper limit of the scale interval
  \param stepSize major step size
  \sa setAutoScale()
*/
00075 void QwtAbstractScale::setScale(double vmin, double vmax, double stepSize)
{
    d_data->autoScale = false;
    d_data->stepSize = stepSize;

    rescale(vmin, vmax, stepSize);
}

/*!
  \brief Specify a scale.

  Disable autoscaling and define a scale by an interval and a step size

  \param interval Interval
  \param stepSize major step size
  \sa setAutoScale()
*/
00092 void QwtAbstractScale::setScale(const QwtDoubleInterval &interval, 
    double stepSize)
{
    setScale(interval.minValue(), interval.maxValue(), stepSize);
}


/*!
  \brief Specify a scale.

  Disable autoscaling and define a scale by a scale division

  \param scaleDiv Scale division
  \sa setAutoScale()
*/
00107 void QwtAbstractScale::setScale(const QwtScaleDiv &scaleDiv)
{
    d_data->autoScale = false;

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

/*!
  Recalculate the scale division and update the scale draw.

  \param vmin Lower limit of the scale interval
  \param vmax Upper limit of the scale interval
  \param stepSize Major step size

  \sa scaleChange()
*/
00127 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();
    }
}

/*!
  \brief Advise the widget to control the scale range internally.

  Autoscaling is on by default. 
  \sa setScale(), autoScale()
*/
00147 void QwtAbstractScale::setAutoScale()
{
    if (!d_data->autoScale) 
    {
        d_data->autoScale = true;
        scaleChange();
    }
}

/*!
  \return \c true if autoscaling is enabled
*/  
00159 bool QwtAbstractScale::autoScale() const
{
    return d_data->autoScale;
}

/*!
  \brief Set the maximum number of major tick intervals.

  The scale's major ticks are calculated automatically such that
  the number of major intervals does not exceed ticks.
  The default value is 5.
  \param ticks maximal number of major ticks.
  \sa QwtAbstractScaleDraw
*/
00173 void QwtAbstractScale::setScaleMaxMajor(int ticks)
{
    if (ticks != d_data->maxMajor)
    {
        d_data->maxMajor = ticks;
        updateScaleDraw();
    }
}

/*!
  \brief Set the maximum number of minor tick intervals

  The scale's minor ticks are calculated automatically such that
  the number of minor intervals does not exceed ticks.
  The default value is 3.
  \param ticks
  \sa QwtAbstractScaleDraw
*/
00191 void QwtAbstractScale::setScaleMaxMinor(int ticks)
{
    if ( ticks != d_data->maxMinor)
    {
        d_data->maxMinor = ticks;
        updateScaleDraw();
    }
}

/*! 
  \return Max. number of minor tick intervals 
  The default value is 3.
*/
00204 int QwtAbstractScale::scaleMaxMinor() const 
{
    return d_data->maxMinor;
}

/*! 
  \return Max. number of major tick intervals 
  The default value is 5.
*/
00213 int QwtAbstractScale::scaleMaxMajor() const 
{
    return d_data->maxMajor;
}

/*!
  \brief Set a scale draw

  scaleDraw has to be created with new and will be deleted in
  ~QwtAbstractScale or the next call of setAbstractScaleDraw.
*/
00224 void QwtAbstractScale::setAbstractScaleDraw(QwtAbstractScaleDraw *scaleDraw)
{
    if ( scaleDraw == NULL || scaleDraw == d_data->scaleDraw )
        return;

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

/*!
    \return Scale draw
    \sa setAbstractScaleDraw()
*/
00237 QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw() 
{
    return d_data->scaleDraw;
}

/*!
    \return Scale draw
    \sa setAbstractScaleDraw()
*/
00246 const QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw() const
{
    return d_data->scaleDraw;
}

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

/*!
  \brief Set a scale engine

  The scale engine is responsible for calculating the scale division,
  and in case of auto scaling how to align the scale.

  scaleEngine has to be created with new and will be deleted in
  ~QwtAbstractScale or the next call of setScaleEngine.
*/
00266 void QwtAbstractScale::setScaleEngine(QwtScaleEngine *scaleEngine)
{
    if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine )
    {
        delete d_data->scaleEngine;
        d_data->scaleEngine = scaleEngine;
    }
}

/*!
    \return Scale engine
    \sa setScaleEngine()
*/
00279 const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
{
    return d_data->scaleEngine;
}

/*!
    \return Scale engine
    \sa setScaleEngine()
*/
00288 QwtScaleEngine *QwtAbstractScale::scaleEngine()
{
    return d_data->scaleEngine;
}

/*!
  \brief Notify changed scale

  Dummy empty implementation, intended to be overloaded by derived classes
*/
00298 void QwtAbstractScale::scaleChange()
{
}

/*!
   \return abstractScaleDraw()->scaleMap()
*/
00305 const QwtScaleMap &QwtAbstractScale::scaleMap() const
{
    return d_data->scaleDraw->scaleMap();
}

Generated by  Doxygen 1.6.0   Back to index