kplotaxis.cpp

Go to the documentation of this file.

/*  -*- C++ -*-
    This file is part of the KDE libraries
    Copyright (C) 2005 Andreas Nicolai <Andreas.Nicolai@gmx.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "kplotaxis.h"

#include <math.h> //for log10(), pow(), modf()
#include <kdebug.h>

class KPlotAxis::Private
{
    public:
        Private( KPlotAxis *qq )
            : q( qq )
            , m_visible( true )
            , m_showTickLabels( false )
            , m_labelFmt( 'g' )
            , m_labelFieldWidth( 0 )
            , m_labelPrec( -1 )
        {
        }

        KPlotAxis *q;

        bool m_visible : 1; // Property "visible" defines if Axis is drawn or not.
        bool m_showTickLabels : 1;
        char m_labelFmt; // Number format for number labels, see QString::arg()
        QString m_label; // The label of the axis.
        int m_labelFieldWidth; // Field width for number labels, see QString::arg()
        int m_labelPrec; // Number precision for number labels, see QString::arg()
        QList<double> m_MajorTickMarks, m_MinorTickMarks;
};

KPlotAxis::KPlotAxis( const QString &label )
    : d( new Private( this ) )
{
    d->m_label = label;
}

KPlotAxis::~KPlotAxis()
{
    delete d;
}

bool KPlotAxis::isVisible() const
{
    return d->m_visible;
}

void KPlotAxis::setVisible( bool visible )
{
    d->m_visible = visible;
}

bool KPlotAxis::areTickLabelsShown() const
{
    return d->m_showTickLabels;
}

void KPlotAxis::setTickLabelsShown( bool b )
{
    d->m_showTickLabels = b;
}

void KPlotAxis::setLabel( const QString& label )
{
    d->m_label = label;
}

QString KPlotAxis::label() const
{
    return d->m_label;
}

void KPlotAxis::setTickLabelFormat( char format, int fieldWidth, int precision )
{
    d->m_labelFieldWidth = fieldWidth;
    d->m_labelFmt = format;
    d->m_labelPrec = precision;
}

int KPlotAxis::tickLabelWidth() const
{
    return d->m_labelFieldWidth;
}

char KPlotAxis::tickLabelFormat() const
{
    return d->m_labelFmt;
}

int KPlotAxis::tickLabelPrecision() const
{
    return d->m_labelPrec;
}

void KPlotAxis::setTickMarks( double x0, double length ) {
    d->m_MajorTickMarks.clear();
    d->m_MinorTickMarks.clear();

    //s is the power-of-ten factor of length:
    //length = t * s; s = 10^(pwr).  e.g., length=350.0 then t=3.5, s = 100.0; pwr = 2.0
    double pwr = 0.0;
    modf( log10( length ), &pwr );
    double s = pow( 10.0, pwr );
    double t = length / s;

    double TickDistance = 0.0; //The distance between major tickmarks
    int NumMajorTicks = 0; //will be between 3 and 5
    int NumMinorTicks = 0; //The number of minor ticks between major ticks (will be 4 or 5)

    //adjust s and t such that t is between 3 and 5:
    if ( t < 3.0 ) {
        t *= 10.0;
        s /= 10.0;
        // t is now between 3 and 30
    }

    if ( t < 6.0 ) { //accept current values
        TickDistance = s;
        NumMajorTicks = int( t );
        NumMinorTicks = 5;
    } else if ( t < 10.0 ) { // adjust by a factor of 2
        TickDistance = s * 2.0;
        NumMajorTicks = int( t / 2.0 );
        NumMinorTicks = 4;
    } else if ( t < 20.0 ) { //adjust by a factor of 4
        TickDistance = s * 4.0;
        NumMajorTicks = int( t / 4.0 );
        NumMinorTicks = 4;
    } else { //adjust by a factor of 5
        TickDistance = s * 5.0;
        NumMajorTicks = int( t / 5.0 );
        NumMinorTicks = 5;
    }

    //We have determined the number of tickmarks and their separation
    //Now we determine their positions in the Data space.

    //Tick0 is the position of a "virtual" tickmark; the first major tickmark 
    //position beyond the "minimum" edge of the data range.
    double Tick0 = x0 - fmod( x0, TickDistance );
    if ( x0 < 0.0 ) {
        Tick0 -= TickDistance;
        NumMajorTicks++;
    }

    for ( int i=0; i<NumMajorTicks+1; i++ ) {
        double xmaj = Tick0 + i*TickDistance;
        if ( xmaj >= x0 && xmaj <= x0 + length ) {
            d->m_MajorTickMarks.append( xmaj );
        }

        for ( int j=1; j<NumMinorTicks; j++ ) {
            double xmin = xmaj + TickDistance*j/NumMinorTicks;
            if ( xmin >= x0 && xmin <= x0 + length ) 
                d->m_MinorTickMarks.append( xmin );
        }
    }
}

QString KPlotAxis::tickLabel( double val ) const {
    if ( d->m_labelFmt == 't' ) {
        while ( val <   0.0 ) val += 24.0;
        while ( val >= 24.0 ) val -= 24.0;

        int h = int(val);
        int m = int( 60.*(val - h) );
        return QString( "%1:%2" ).arg( h, 2, 10, QLatin1Char('0') ).arg( m, 2, 10, QLatin1Char('0') );
    }

    return QString( "%1" ).arg( val, d->m_labelFieldWidth, d->m_labelFmt, d->m_labelPrec );
}

QList< double > KPlotAxis::majorTickMarks() const
{
    return d->m_MajorTickMarks;
}

QList< double > KPlotAxis::minorTickMarks() const
{
    return d->m_MinorTickMarks;
}