qwt_scale_div.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_div.h"
#include "qwt_interval.h"

QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound ):
    d_lowerBound( lowerBound ),
    d_upperBound( upperBound )
{
}

QwtScaleDiv::QwtScaleDiv( const QwtInterval &interval,
        QList<double> ticks[NTickTypes] ):
    d_lowerBound( interval.minValue() ),
    d_upperBound( interval.maxValue() )
{
    for ( int i = 0; i < NTickTypes; i++ )
        d_ticks[i] = ticks[i];
}

QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
        QList<double> ticks[NTickTypes] ):
    d_lowerBound( lowerBound ),
    d_upperBound( upperBound )
{
    for ( int i = 0; i < NTickTypes; i++ )
        d_ticks[i] = ticks[i];
}

QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
        const QList<double> &minorTicks,
        const QList<double> &mediumTicks,
        const QList<double> &majorTicks ):
    d_lowerBound( lowerBound ),
    d_upperBound( upperBound )
{
    d_ticks[ MinorTick ] = minorTicks;
    d_ticks[ MediumTick ] = mediumTicks;
    d_ticks[ MajorTick ] = majorTicks;
}

void QwtScaleDiv::setInterval( double lowerBound, double upperBound )
{
    d_lowerBound = lowerBound;
    d_upperBound = upperBound;
}

void QwtScaleDiv::setInterval( const QwtInterval &interval )
{
    d_lowerBound = interval.minValue();
    d_upperBound = interval.maxValue();
}

QwtInterval QwtScaleDiv::interval() const
{
    return QwtInterval( d_lowerBound, d_upperBound );
}

void QwtScaleDiv::setLowerBound( double lowerBound  )
{
    d_lowerBound = lowerBound;
}

double QwtScaleDiv::lowerBound() const
{
    return d_lowerBound;
}

void QwtScaleDiv::setUpperBound( double upperBound  )
{
    d_upperBound = upperBound;
}

double QwtScaleDiv::upperBound() const
{
    return d_upperBound;
}

double QwtScaleDiv::range() const
{
    return d_upperBound - d_lowerBound;
}

bool QwtScaleDiv::operator==( const QwtScaleDiv &other ) const
{
    if ( d_lowerBound != other.d_lowerBound ||
        d_upperBound != other.d_upperBound )
    {
        return false;
    }

    for ( int i = 0; i < NTickTypes; i++ )
    {
        if ( d_ticks[i] != other.d_ticks[i] )
            return false;
    }

    return true;
}

bool QwtScaleDiv::operator!=( const QwtScaleDiv &other ) const
{
    return ( !( *this == other ) );
}

bool QwtScaleDiv::isEmpty() const
{
    return ( d_lowerBound == d_upperBound );
}

bool QwtScaleDiv::isIncreasing() const
{
    return d_lowerBound <= d_upperBound;
}

bool QwtScaleDiv::contains( double value ) const
{
    const double min = qMin( d_lowerBound, d_upperBound );
    const double max = qMax( d_lowerBound, d_upperBound );

    return value >= min && value <= max;
}

void QwtScaleDiv::invert()
{
    qSwap( d_lowerBound, d_upperBound );

    for ( int i = 0; i < NTickTypes; i++ )
    {
        QList<double>& ticks = d_ticks[i];

        const int size = ticks.count();
        const int size2 = size / 2;

        for ( int j = 0; j < size2; j++ )
            qSwap( ticks[j], ticks[size - 1 - j] );
    }
}

QwtScaleDiv QwtScaleDiv::inverted() const
{
    QwtScaleDiv other = *this;
    other.invert();

    return other;
}

QwtScaleDiv QwtScaleDiv::bounded(
    double lowerBound, double upperBound ) const
{
    const double min = qMin( lowerBound, upperBound );
    const double max = qMax( lowerBound, upperBound );

    QwtScaleDiv sd;
    sd.setInterval( lowerBound, upperBound );

    for ( int tickType = 0; tickType < QwtScaleDiv::NTickTypes; tickType++ )
    {
        const QList<double> &ticks = d_ticks[ tickType ];

        QList<double> boundedTicks;
        for ( int i = 0; i < ticks.size(); i++ )
        {
            const double tick = ticks[i];
            if ( tick >= min && tick <= max )
                boundedTicks += tick;
        }

        sd.setTicks( tickType, boundedTicks );
    }

    return sd;

}

void QwtScaleDiv::setTicks( int tickType, const QList<double> &ticks )
{
    if ( tickType >= 0 && tickType < NTickTypes )
        d_ticks[tickType] = ticks;
}

QList<double> QwtScaleDiv::ticks( int tickType ) const
{
    if ( tickType >= 0 && tickType < NTickTypes )
        return d_ticks[tickType];

    return QList<double>();
}

#ifndef QT_NO_DEBUG_STREAM

#include <qdebug.h>

QDebug operator<<( QDebug debug, const QwtScaleDiv &scaleDiv )
{
    debug << scaleDiv.lowerBound() << "<->" << scaleDiv.upperBound();
    debug << "Major: " << scaleDiv.ticks( QwtScaleDiv::MajorTick );
    debug << "Medium: " << scaleDiv.ticks( QwtScaleDiv::MediumTick );
    debug << "Minor: " << scaleDiv.ticks( QwtScaleDiv::MinorTick );

    return debug;
}

#endif