qwt_plot_axis.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_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()
        {
            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() ) );
        }
    }
}