qwt_plot_scaleitem.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_scaleitem.h"
#include "qwt_plot.h"
#include "qwt_scale_map.h"
#include "qwt_interval.h"
#include "qwt_text.h"
 
#include <qpalette.h>
#include <qpainter.h>
 
class QwtPlotScaleItem::PrivateData
{
  public:
    PrivateData()
        : position( 0.0 )
        , borderDistance( -1 )
        , scaleDivFromAxis( true )
        , scaleDraw( new QwtScaleDraw() )
    {
    }
 
    ~PrivateData()
    {
        delete scaleDraw;
    }
 
    QwtInterval scaleInterval( const QRectF&,
        const QwtScaleMap&, const QwtScaleMap& ) const;
 
    QPalette palette;
    QFont font;
    double position;
    int borderDistance;
    bool scaleDivFromAxis;
    QwtScaleDraw* scaleDraw;
};
 
QwtInterval QwtPlotScaleItem::PrivateData::scaleInterval( const QRectF& canvasRect,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap ) const
{
    QwtInterval interval;
    if ( scaleDraw->orientation() == Qt::Horizontal )
    {
        interval.setMinValue( xMap.invTransform( canvasRect.left() ) );
        interval.setMaxValue( xMap.invTransform( canvasRect.right() - 1 ) );
    }
    else
    {
        interval.setMinValue( yMap.invTransform( canvasRect.bottom() - 1 ) );
        interval.setMaxValue( yMap.invTransform( canvasRect.top() ) );
    }
 
    return interval;
}
 
QwtPlotScaleItem::QwtPlotScaleItem(
        QwtScaleDraw::Alignment alignment, const double pos )
    : QwtPlotItem( QwtText( "Scale" ) )
{
    m_data = new PrivateData;
    m_data->position = pos;
    m_data->scaleDraw->setAlignment( alignment );
 
    setItemInterest( QwtPlotItem::ScaleInterest, true );
    setZ( 11.0 );
}
 
QwtPlotScaleItem::~QwtPlotScaleItem()
{
    delete m_data;
}
 
int QwtPlotScaleItem::rtti() const
{
    return QwtPlotItem::Rtti_PlotScale;
}
 
void QwtPlotScaleItem::setScaleDiv( const QwtScaleDiv& scaleDiv )
{
    m_data->scaleDivFromAxis = false;
    m_data->scaleDraw->setScaleDiv( scaleDiv );
}
 
const QwtScaleDiv& QwtPlotScaleItem::scaleDiv() const
{
    return m_data->scaleDraw->scaleDiv();
}
 
void QwtPlotScaleItem::setScaleDivFromAxis( bool on )
{
    if ( on != m_data->scaleDivFromAxis )
    {
        m_data->scaleDivFromAxis = on;
        if ( on )
        {
            const QwtPlot* plt = plot();
            if ( plt )
            {
                updateScaleDiv( plt->axisScaleDiv( xAxis() ),
                    plt->axisScaleDiv( yAxis() ) );
                itemChanged();
            }
        }
    }
}
 
bool QwtPlotScaleItem::isScaleDivFromAxis() const
{
    return m_data->scaleDivFromAxis;
}
 
void QwtPlotScaleItem::setPalette( const QPalette& palette )
{
    if ( palette != m_data->palette )
    {
        m_data->palette = palette;
 
        legendChanged();
        itemChanged();
    }
}
 
QPalette QwtPlotScaleItem::palette() const
{
    return m_data->palette;
}
 
void QwtPlotScaleItem::setFont( const QFont& font )
{
    if ( font != m_data->font )
    {
        m_data->font = font;
        itemChanged();
    }
}
 
QFont QwtPlotScaleItem::font() const
{
    return m_data->font;
}
 
void QwtPlotScaleItem::setScaleDraw( QwtScaleDraw* scaleDraw )
{
    if ( scaleDraw == NULL )
        return;
 
    if ( scaleDraw != m_data->scaleDraw )
        delete m_data->scaleDraw;
 
    m_data->scaleDraw = scaleDraw;
 
    const QwtPlot* plt = plot();
    if ( plt )
    {
        updateScaleDiv( plt->axisScaleDiv( xAxis() ),
            plt->axisScaleDiv( yAxis() ) );
    }
 
    itemChanged();
}
 
const QwtScaleDraw* QwtPlotScaleItem::scaleDraw() const
{
    return m_data->scaleDraw;
}
 
QwtScaleDraw* QwtPlotScaleItem::scaleDraw()
{
    return m_data->scaleDraw;
}
 
void QwtPlotScaleItem::setPosition( double pos )
{
    if ( m_data->position != pos )
    {
        m_data->position = pos;
        m_data->borderDistance = -1;
        itemChanged();
    }
}
 
double QwtPlotScaleItem::position() const
{
    return m_data->position;
}
 
void QwtPlotScaleItem::setBorderDistance( int distance )
{
    if ( distance < 0 )
        distance = -1;
 
    if ( distance != m_data->borderDistance )
    {
        m_data->borderDistance = distance;
        itemChanged();
    }
}
 
int QwtPlotScaleItem::borderDistance() const
{
    return m_data->borderDistance;
}
 
void QwtPlotScaleItem::setAlignment( QwtScaleDraw::Alignment alignment )
{
    QwtScaleDraw* sd = m_data->scaleDraw;
    if ( sd->alignment() != alignment )
    {
        sd->setAlignment( alignment );
        itemChanged();
    }
}
 
void QwtPlotScaleItem::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    QwtScaleDraw* sd = m_data->scaleDraw;
 
    if ( m_data->scaleDivFromAxis )
    {
        const QwtInterval interval =
            m_data->scaleInterval( canvasRect, xMap, yMap );
 
        if ( interval != sd->scaleDiv().interval() )
        {
            QwtScaleDiv scaleDiv = sd->scaleDiv();
            scaleDiv.setInterval( interval );
            sd->setScaleDiv( scaleDiv );
        }
    }
 
    QPen pen = painter->pen();
    pen.setStyle( Qt::SolidLine );
    painter->setPen( pen );
 
    if ( sd->orientation() == Qt::Horizontal )
    {
        double y;
        if ( m_data->borderDistance >= 0 )
        {
            if ( sd->alignment() == QwtScaleDraw::BottomScale )
                y = canvasRect.top() + m_data->borderDistance;
            else
            {
                y = canvasRect.bottom() - m_data->borderDistance;
            }
 
        }
        else
        {
            y = yMap.transform( m_data->position );
        }
 
        if ( y < canvasRect.top() || y > canvasRect.bottom() )
            return;
 
        sd->move( canvasRect.left(), y );
        sd->setLength( canvasRect.width() - 1 );
 
        QwtTransform* transform = NULL;
        if ( xMap.transformation() )
            transform = xMap.transformation()->copy();
 
        sd->setTransformation( transform );
    }
    else // == Qt::Vertical
    {
        double x;
        if ( m_data->borderDistance >= 0 )
        {
            if ( sd->alignment() == QwtScaleDraw::RightScale )
                x = canvasRect.left() + m_data->borderDistance;
            else
            {
                x = canvasRect.right() - m_data->borderDistance;
            }
        }
        else
        {
            x = xMap.transform( m_data->position );
        }
        if ( x < canvasRect.left() || x > canvasRect.right() )
            return;
 
        sd->move( x, canvasRect.top() );
        sd->setLength( canvasRect.height() - 1 );
 
        QwtTransform* transform = NULL;
        if ( yMap.transformation() )
            transform = yMap.transformation()->copy();
 
        sd->setTransformation( transform );
    }
 
    painter->setFont( m_data->font );
 
    sd->draw( painter, m_data->palette );
}
 
void QwtPlotScaleItem::updateScaleDiv( const QwtScaleDiv& xScaleDiv,
    const QwtScaleDiv& yScaleDiv )
{
    QwtScaleDraw* scaleDraw = m_data->scaleDraw;
 
    if ( m_data->scaleDivFromAxis && scaleDraw )
    {
        const QwtScaleDiv& scaleDiv =
            scaleDraw->orientation() == Qt::Horizontal ? xScaleDiv : yScaleDiv;
 
        const QwtPlot* plt = plot();
        if ( plt != NULL )
        {
            const QRectF canvasRect = plt->canvas()->contentsRect();
 
            const QwtInterval interval = m_data->scaleInterval(
                canvasRect, plt->canvasMap( xAxis() ), plt->canvasMap( yAxis() ) );
 
            QwtScaleDiv sd = scaleDiv;
            sd.setInterval( interval );
 
            if ( sd != scaleDraw->scaleDiv() )
            {
                // the internal label cache of QwtScaleDraw
                // is cleared here, so better avoid pointless
                // assignments.
 
                scaleDraw->setScaleDiv( sd );
            }
        }
        else
        {
            scaleDraw->setScaleDiv( scaleDiv );
        }
    }
}