qwt_double_range.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_double_range.h"
#include "qwt_math.h"

static double MinRelStep = 1.0e-10;
static double DefaultRelStep = 1.0e-2;
static double MinEps = 1.0e-10;

QwtDoubleRange::QwtDoubleRange():
    d_minValue(0.0),
    d_maxValue(0.0),
    d_step(1.0),
    d_pageSize(1),
    d_isValid(false),
    d_value(0.0),
    d_exactValue(0.0),
    d_exactPrevValue(0.0),
    d_prevValue(0.0),
    d_periodic(false)
{
}

QwtDoubleRange::~QwtDoubleRange()
{
}

void QwtDoubleRange::setValid(bool isValid)
{
    if ( isValid != d_isValid )
    {
        d_isValid = isValid;
        valueChange();
    }
}

bool QwtDoubleRange::isValid() const
{
    return d_isValid;
}

void QwtDoubleRange::setNewValue(double x, bool align)
{
    double vmin,vmax;
    
    d_prevValue = d_value;

    vmin = qwtMin(d_minValue, d_maxValue);
    vmax = qwtMax(d_minValue, d_maxValue);

    // 
    // Range check
    //
    if (x < vmin)
    {
        if ((d_periodic) && (vmin != vmax))
           d_value = x + ceil( (vmin - x) / (vmax - vmin ) ) 
              * (vmax - vmin);
        else
           d_value = vmin;
    }
    else if (x > vmax)
    {
        if ((d_periodic) && (vmin != vmax))
           d_value = x - ceil( ( x - vmax) / (vmax - vmin )) 
              * (vmax - vmin);
        else
           d_value = vmax;
    }
    else
       d_value = x;

    d_exactPrevValue = d_exactValue;
    d_exactValue = d_value;
    
    // align to grid
    if (align)
    {
        if (d_step != 0.0)
           d_value = d_minValue +
             qRound((d_value - d_minValue) / d_step) * d_step;
        else
           d_value = d_minValue;
        
        // correct rounding error at the border
        if (fabs(d_value - d_maxValue) < MinEps * qwtAbs(d_step))
           d_value = d_maxValue;

        // correct rounding error if value = 0
        if (fabs(d_value) < MinEps * qwtAbs(d_step))
           d_value = 0.0;
    }

    if (!d_isValid || d_prevValue != d_value)
    {
        d_isValid = true;
        valueChange();
    }
}

void QwtDoubleRange::fitValue(double x)
{
    setNewValue(x, true);
}


void QwtDoubleRange::setValue(double x)
{
    setNewValue(x, false);
}

void QwtDoubleRange::setRange(double vmin, double vmax, double vstep, int pageSize)
{
    bool rchg = ((d_maxValue != vmax) || (d_minValue != vmin));
    
    if (rchg) 
    {
        d_minValue = vmin;
        d_maxValue = vmax;
    }
    
    //
    // look if the step width has an acceptable 
    // value or otherwise change it.
    //
    setStep(vstep);

    //
    // limit page size
    //
    d_pageSize = qwtLim(pageSize,0, 
        int(qwtAbs((d_maxValue - d_minValue) / d_step))); 
    
    // 
    // If the value lies out of the range, it 
    // will be changed. Note that it will not be adjusted to 
    // the new step width.
    setNewValue(d_value, false);
    
    // call notifier after the step width has been 
    // adjusted.
    if (rchg)
       rangeChange();
}

void QwtDoubleRange::setStep(double vstep)
{
    double intv = d_maxValue - d_minValue;
    
    double newStep;
    if (vstep == 0.0)
       newStep = intv * DefaultRelStep;
    else
    {
        if ((intv > 0) && (vstep < 0) || (intv < 0) && (vstep > 0))
           newStep = -vstep;
        else
           newStep = vstep;
        
        if ( fabs(newStep) < fabs(MinRelStep * intv) )
           newStep = MinRelStep * intv;
    }
    
    if (newStep != d_step)
    {
        d_step = newStep;
        stepChange();
    }
}


void QwtDoubleRange::setPeriodic(bool tf)
{
    d_periodic = tf;
}

void QwtDoubleRange::incValue(int nSteps)
{
    if ( isValid() )
        setNewValue(d_value + double(nSteps) * d_step, true);
}

void QwtDoubleRange::incPages(int nPages)
{
    if ( isValid() )
        setNewValue(d_value + double(nPages) * double(d_pageSize) * d_step, true);
}

void QwtDoubleRange::valueChange()
{
}


void QwtDoubleRange::rangeChange()
{
}


void QwtDoubleRange::stepChange()
{
}

double QwtDoubleRange::step() const
{
    return qwtAbs(d_step);
}

double QwtDoubleRange::maxValue() const
{   
    return d_maxValue;
} 
    
double QwtDoubleRange::minValue() const 
{
    return d_minValue; 
}   

bool QwtDoubleRange::periodic() const 
{ 
    return d_periodic; 
}

int QwtDoubleRange::pageSize() const 
{ 
    return d_pageSize; 
}

double QwtDoubleRange::value() const 
{ 
    return d_value; 
}

double QwtDoubleRange::exactValue() const 
{ 
    return d_exactValue; 
}

double QwtDoubleRange::exactPrevValue() const 
{ 
    return d_exactPrevValue; 
}

double QwtDoubleRange::prevValue() const 
{ 
    return d_prevValue; 
}

---