qwt_plot_axis.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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_plot.h"
#include "qwt_scale_widget.h"
#include "qwt_scale_map.h"
#include "qwt_scale_div.h"
#include "qwt_scale_engine.h"
#include "qwt_interval.h"

namespace
{
    class AxisData
    {
      public:
        AxisData()
            : isVisible( true )
            , doAutoScale( true )
            , minValue( 0.0 )
            , maxValue( 1000.0 )
            , stepSize( 0.0 )
            , maxMajor( 8 )
            , maxMinor( 5 )
            , isValid( false )
            , scaleEngine( new QwtLinearScaleEngine() )
            , scaleWidget( NULL )
        {
        }

        ~AxisData()
        {
            if( scaleWidget ) {
                delete scaleWidget;
            }
            delete scaleEngine;
        }

        void initWidget( QwtScaleDraw::Alignment align, const QString& name, QwtPlot* plot )
        {
            scaleWidget = new QwtScaleWidget( align, plot );
            scaleWidget->setObjectName( name );

    #if 1
            // better find the font sizes from the application font
            const QFont fscl( plot->fontInfo().family(), 10 );
            const QFont fttl( plot->fontInfo().family(), 12, QFont::Bold );
    #endif

            scaleWidget->setTransformation( scaleEngine->transformation() );

            scaleWidget->setFont( fscl );
            scaleWidget->setMargin( 2 );

            QwtText text = scaleWidget->title();
            text.setFont( fttl );
            scaleWidget->setTitle( text );
        }

        bool isVisible;
        bool doAutoScale;

        double minValue;
        double maxValue;
        double stepSize;

        int maxMajor;
        int maxMinor;

        bool isValid;

        QwtScaleDiv scaleDiv;
        QwtScaleEngine* scaleEngine;
        QwtScaleWidget* scaleWidget;
    };
}

class QwtPlot::ScaleData
{
  public:
    ScaleData( QwtPlot* plot )
    {
        using namespace QwtAxis;

        m_axisData[YLeft].initWidget( QwtScaleDraw::LeftScale, "QwtPlotAxisYLeft", plot );
        m_axisData[YRight].initWidget( QwtScaleDraw::RightScale, "QwtPlotAxisYRight", plot );
        m_axisData[XTop].initWidget( QwtScaleDraw::TopScale, "QwtPlotAxisXTop", plot );
        m_axisData[XBottom].initWidget( QwtScaleDraw::BottomScale, "QwtPlotAxisXBottom", plot );
    }

    inline AxisData& axisData( QwtAxisId axisId )
    {
        return m_axisData[ axisId ];
    }

    inline const AxisData& axisData( QwtAxisId axisId ) const
    {
        return m_axisData[ axisId ];
    }

  private:
    AxisData m_axisData[ QwtAxis::AxisPositions ];
};

void QwtPlot::initAxesData()
{
    m_scaleData = new ScaleData( this );

    m_scaleData->axisData( QwtAxis::YRight ).isVisible = false;
    m_scaleData->axisData( QwtAxis::XTop ).isVisible = false;
}

void QwtPlot::deleteAxesData()
{
    delete m_scaleData;
    m_scaleData = NULL;
}

bool QwtPlot::isAxisValid( QwtAxisId axisId ) const
{
    return QwtAxis::isValid( axisId );
}

const QwtScaleWidget* QwtPlot::axisWidget( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).scaleWidget;

    return NULL;
}

QwtScaleWidget* QwtPlot::axisWidget( QwtAxisId axisId )
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).scaleWidget;

    return NULL;
}

void QwtPlot::setAxisScaleEngine( QwtAxisId axisId, QwtScaleEngine* scaleEngine )
{
    if ( isAxisValid( axisId ) && scaleEngine != NULL )
    {
        AxisData& d = m_scaleData->axisData( axisId );

        delete d.scaleEngine;
        d.scaleEngine = scaleEngine;

        d.scaleWidget->setTransformation( scaleEngine->transformation() );

        d.isValid = false;

        autoRefresh();
    }
}

QwtScaleEngine* QwtPlot::axisScaleEngine( QwtAxisId axisId )
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).scaleEngine;
    else
        return NULL;
}

const QwtScaleEngine* QwtPlot::axisScaleEngine( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).scaleEngine;
    else
        return NULL;
}
bool QwtPlot::axisAutoScale( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).doAutoScale;
    else
        return false;
}

bool QwtPlot::isAxisVisible( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).isVisible;
    else
        return false;
}

QFont QwtPlot::axisFont( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return axisWidget( axisId )->font();
    else
        return QFont();

}

int QwtPlot::axisMaxMajor( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).maxMajor;
    else
        return 0;
}

int QwtPlot::axisMaxMinor( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return m_scaleData->axisData( axisId ).maxMinor;
    else
        return 0;
}

const QwtScaleDiv& QwtPlot::axisScaleDiv( QwtAxisId axisId ) const
{
    return m_scaleData->axisData( axisId ).scaleDiv;
}

const QwtScaleDraw* QwtPlot::axisScaleDraw( QwtAxisId axisId ) const
{
    if ( !isAxisValid( axisId ) )
        return NULL;

    return axisWidget( axisId )->scaleDraw();
}

QwtScaleDraw* QwtPlot::axisScaleDraw( QwtAxisId axisId )
{
    if ( !isAxisValid( axisId ) )
        return NULL;

    return axisWidget( axisId )->scaleDraw();
}

double QwtPlot::axisStepSize( QwtAxisId axisId ) const
{
    if ( !isAxisValid( axisId ) )
        return 0;

    return m_scaleData->axisData( axisId ).stepSize;
}

QwtInterval QwtPlot::axisInterval( QwtAxisId axisId ) const
{
    if ( !isAxisValid( axisId ) )
        return QwtInterval();

    return m_scaleData->axisData( axisId ).scaleDiv.interval();
}

QwtText QwtPlot::axisTitle( QwtAxisId axisId ) const
{
    if ( isAxisValid( axisId ) )
        return axisWidget( axisId )->title();
    else
        return QwtText();
}

void QwtPlot::setAxisVisible( QwtAxisId axisId, bool on )
{
    if ( isAxisValid( axisId ) && on != m_scaleData->axisData( axisId ).isVisible )
    {
        m_scaleData->axisData( axisId ).isVisible = on;
        updateLayout();
    }
}

double QwtPlot::invTransform( QwtAxisId axisId, double pos ) const
{
    if ( isAxisValid( axisId ) )
        return( canvasMap( axisId ).invTransform( pos ) );
    else
        return 0.0;
}


double QwtPlot::transform( QwtAxisId axisId, double value ) const
{
    if ( isAxisValid( axisId ) )
        return( canvasMap( axisId ).transform( value ) );
    else
        return 0.0;
}

void QwtPlot::setAxisFont( QwtAxisId axisId, const QFont& font )
{
    if ( isAxisValid( axisId ) )
        axisWidget( axisId )->setFont( font );
}

void QwtPlot::setAxisAutoScale( QwtAxisId axisId, bool on )
{
    if ( isAxisValid( axisId ) && ( m_scaleData->axisData( axisId ).doAutoScale != on ) )
    {
        m_scaleData->axisData( axisId ).doAutoScale = on;
        autoRefresh();
    }
}

void QwtPlot::setAxisScale( QwtAxisId axisId, double min, double max, double stepSize )
{
    if ( isAxisValid( axisId ) )
    {
        AxisData& d = m_scaleData->axisData( axisId );

        d.doAutoScale = false;
        d.isValid = false;

        d.minValue = min;
        d.maxValue = max;
        d.stepSize = stepSize;

        autoRefresh();
    }
}

void QwtPlot::setAxisScaleDiv( QwtAxisId axisId, const QwtScaleDiv& scaleDiv )
{
    if ( isAxisValid( axisId ) )
    {
        AxisData& d = m_scaleData->axisData( axisId );

        d.doAutoScale = false;
        d.scaleDiv = scaleDiv;
        d.isValid = true;

        autoRefresh();
    }
}

void QwtPlot::setAxisScaleDraw( QwtAxisId axisId, QwtScaleDraw* scaleDraw )
{
    if ( isAxisValid( axisId ) )
    {
        axisWidget( axisId )->setScaleDraw( scaleDraw );
        autoRefresh();
    }
}

void QwtPlot::setAxisLabelAlignment( QwtAxisId axisId, Qt::Alignment alignment )
{
    if ( isAxisValid( axisId ) )
        axisWidget( axisId )->setLabelAlignment( alignment );
}

void QwtPlot::setAxisLabelRotation( QwtAxisId axisId, double rotation )
{
    if ( isAxisValid( axisId ) )
        axisWidget( axisId )->setLabelRotation( rotation );
}

void QwtPlot::setAxisMaxMinor( QwtAxisId axisId, int maxMinor )
{
    if ( isAxisValid( axisId ) )
    {
        maxMinor = qBound( 0, maxMinor, 100 );

        AxisData& d = m_scaleData->axisData( axisId );
        if ( maxMinor != d.maxMinor )
        {
            d.maxMinor = maxMinor;
            d.isValid = false;
            autoRefresh();
        }
    }
}

void QwtPlot::setAxisMaxMajor( QwtAxisId axisId, int maxMajor )
{
    if ( isAxisValid( axisId ) )
    {
        maxMajor = qBound( 1, maxMajor, 10000 );

        AxisData& d = m_scaleData->axisData( axisId );
        if ( maxMajor != d.maxMajor )
        {
            d.maxMajor = maxMajor;
            d.isValid = false;
            autoRefresh();
        }
    }
}

void QwtPlot::setAxisTitle( QwtAxisId axisId, const QString& title )
{
    if ( isAxisValid( axisId ) )
        axisWidget( axisId )->setTitle( title );
}

void QwtPlot::setAxisTitle( QwtAxisId axisId, const QwtText& title )
{
    if ( isAxisValid( axisId ) )
        axisWidget( axisId )->setTitle( title );
}

void QwtPlot::updateAxes()
{
    // Find bounding interval of the item data
    // for all axes, where autoscaling is enabled

    QwtInterval boundingIntervals[QwtAxis::AxisPositions];

    const QwtPlotItemList& itmList = itemList();

    QwtPlotItemIterator it;
    for ( it = itmList.begin(); it != itmList.end(); ++it )
    {
        const QwtPlotItem* item = *it;

        if ( !item->testItemAttribute( QwtPlotItem::AutoScale ) )
            continue;

        if ( !item->isVisible() )
            continue;

        if ( axisAutoScale( item->xAxis() ) || axisAutoScale( item->yAxis() ) )
        {
            const QRectF rect = item->boundingRect();

            if ( rect.width() >= 0.0 )
                boundingIntervals[item->xAxis()] |= QwtInterval( rect.left(), rect.right() );

            if ( rect.height() >= 0.0 )
                boundingIntervals[item->yAxis()] |= QwtInterval( rect.top(), rect.bottom() );
        }
    }

    // Adjust scales

    for ( int axisPos = 0; axisPos < QwtAxis::AxisPositions; axisPos++ )
    {
        {
            const QwtAxisId axisId( axisPos );

            AxisData& d = m_scaleData->axisData( axisId );

            double minValue = d.minValue;
            double maxValue = d.maxValue;
            double stepSize = d.stepSize;

            const QwtInterval& interval = boundingIntervals[axisId];

            if ( d.doAutoScale && interval.isValid() )
            {
                d.isValid = false;

                minValue = interval.minValue();
                maxValue = interval.maxValue();

                d.scaleEngine->autoScale( d.maxMajor,
                    minValue, maxValue, stepSize );
            }
            if ( !d.isValid )
            {
                d.scaleDiv = d.scaleEngine->divideScale(
                    minValue, maxValue, d.maxMajor, d.maxMinor, stepSize );
                d.isValid = true;
            }

            QwtScaleWidget* scaleWidget = axisWidget( axisId );
            scaleWidget->setScaleDiv( d.scaleDiv );

            int startDist, endDist;
            scaleWidget->getBorderDistHint( startDist, endDist );
            scaleWidget->setBorderDist( startDist, endDist );
        }
    }

    for ( it = itmList.begin(); it != itmList.end(); ++it )
    {
        QwtPlotItem* item = *it;
        if ( item->testItemInterest( QwtPlotItem::ScaleInterest ) )
        {
            item->updateScaleDiv( axisScaleDiv( item->xAxis() ),
                axisScaleDiv( item->yAxis() ) );
        }
    }
}