qwt_scale_div.cpp

/******************************************************************************
 * 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 )
    : m_lowerBound( lowerBound )
    , m_upperBound( upperBound )
{
}
 
QwtScaleDiv::QwtScaleDiv( const QwtInterval& interval,
        QList< double > ticks[NTickTypes] )
    : m_lowerBound( interval.minValue() )
    , m_upperBound( interval.maxValue() )
{
    for ( int i = 0; i < NTickTypes; i++ )
        m_ticks[i] = ticks[i];
}
 
QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
        QList< double > ticks[NTickTypes] )
    : m_lowerBound( lowerBound )
    , m_upperBound( upperBound )
{
    for ( int i = 0; i < NTickTypes; i++ )
        m_ticks[i] = ticks[i];
}
 
QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
        const QList< double >& minorTicks,
        const QList< double >& mediumTicks,
        const QList< double >& majorTicks )
    : m_lowerBound( lowerBound )
    , m_upperBound( upperBound )
{
    m_ticks[ MinorTick ] = minorTicks;
    m_ticks[ MediumTick ] = mediumTicks;
    m_ticks[ MajorTick ] = majorTicks;
}
 
void QwtScaleDiv::setInterval( double lowerBound, double upperBound )
{
    m_lowerBound = lowerBound;
    m_upperBound = upperBound;
}
 
void QwtScaleDiv::setInterval( const QwtInterval& interval )
{
    m_lowerBound = interval.minValue();
    m_upperBound = interval.maxValue();
}
 
QwtInterval QwtScaleDiv::interval() const
{
    return QwtInterval( m_lowerBound, m_upperBound );
}
 
void QwtScaleDiv::setLowerBound( double lowerBound  )
{
    m_lowerBound = lowerBound;
}
 
double QwtScaleDiv::lowerBound() const
{
    return m_lowerBound;
}
 
void QwtScaleDiv::setUpperBound( double upperBound  )
{
    m_upperBound = upperBound;
}
 
double QwtScaleDiv::upperBound() const
{
    return m_upperBound;
}
 
double QwtScaleDiv::range() const
{
    return m_upperBound - m_lowerBound;
}
 
bool QwtScaleDiv::operator==( const QwtScaleDiv& other ) const
{
    if ( m_lowerBound != other.m_lowerBound ||
        m_upperBound != other.m_upperBound )
    {
        return false;
    }
 
    for ( int i = 0; i < NTickTypes; i++ )
    {
        if ( m_ticks[i] != other.m_ticks[i] )
            return false;
    }
 
    return true;
}
 
bool QwtScaleDiv::operator!=( const QwtScaleDiv& other ) const
{
    return ( !( *this == other ) );
}
 
bool QwtScaleDiv::isEmpty() const
{
    return ( m_lowerBound == m_upperBound );
}
 
bool QwtScaleDiv::isIncreasing() const
{
    return m_lowerBound <= m_upperBound;
}
 
bool QwtScaleDiv::contains( double value ) const
{
    const double min = qMin( m_lowerBound, m_upperBound );
    const double max = qMax( m_lowerBound, m_upperBound );
 
    return value >= min && value <= max;
}
 
void QwtScaleDiv::invert()
{
    qSwap( m_lowerBound, m_upperBound );
 
    for ( int i = 0; i < NTickTypes; i++ )
    {
        QList< double >& ticks = m_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 = m_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 )
        m_ticks[tickType] = ticks;
}
 
QList< double > QwtScaleDiv::ticks( int tickType ) const
{
    if ( tickType >= 0 && tickType < NTickTypes )
        return m_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