qwt_plot_abstract_barchart.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_abstract_barchart.h"
#include "qwt_scale_map.h"
#include "qwt_math.h"

static inline double qwtTransformWidth(
    const QwtScaleMap& map, double value, double width )
{
    const double w2 = 0.5 * width;

    const double v1 = map.transform( value - w2 );
    const double v2 = map.transform( value + w2 );

    return qAbs( v2 - v1 );
}

class QwtPlotAbstractBarChart::PrivateData
{
  public:
    PrivateData()
        : layoutPolicy( QwtPlotAbstractBarChart::AutoAdjustSamples )
        , layoutHint( 0.5 )
        , spacing( 10 )
        , margin( 5 )
        , baseline( 0.0 )
    {
    }

    QwtPlotAbstractBarChart::LayoutPolicy layoutPolicy;
    double layoutHint;
    int spacing;
    int margin;
    double baseline;
};

QwtPlotAbstractBarChart::QwtPlotAbstractBarChart( const QwtText& title )
    : QwtPlotSeriesItem( title )
{
    m_data = new PrivateData;

    setItemAttribute( QwtPlotItem::Legend, true );
    setItemAttribute( QwtPlotItem::AutoScale, true );
    setItemAttribute( QwtPlotItem::Margins, true );
    setZ( 19.0 );
}

QwtPlotAbstractBarChart::~QwtPlotAbstractBarChart()
{
    delete m_data;
}

void QwtPlotAbstractBarChart::setLayoutPolicy( LayoutPolicy policy )
{
    if ( policy != m_data->layoutPolicy )
    {
        m_data->layoutPolicy = policy;
        itemChanged();
    }
}

QwtPlotAbstractBarChart::LayoutPolicy QwtPlotAbstractBarChart::layoutPolicy() const
{
    return m_data->layoutPolicy;
}

void QwtPlotAbstractBarChart::setLayoutHint( double hint )
{
    hint = qwtMaxF( 0.0, hint );
    if ( hint != m_data->layoutHint )
    {
        m_data->layoutHint = hint;
        itemChanged();
    }
}

double QwtPlotAbstractBarChart::layoutHint() const
{
    return m_data->layoutHint;
}

void QwtPlotAbstractBarChart::setSpacing( int spacing )
{
    spacing = qMax( spacing, 0 );
    if ( spacing != m_data->spacing )
    {
        m_data->spacing = spacing;
        itemChanged();
    }
}

int QwtPlotAbstractBarChart::spacing() const
{
    return m_data->spacing;
}
void QwtPlotAbstractBarChart::setMargin( int margin )
{
    margin = qMax( margin, 0 );
    if ( margin != m_data->margin )
    {
        m_data->margin = margin;
        itemChanged();
    }
}

int QwtPlotAbstractBarChart::margin() const
{
    return m_data->margin;
}

void QwtPlotAbstractBarChart::setBaseline( double value )
{
    if ( value != m_data->baseline )
    {
        m_data->baseline = value;
        itemChanged();
    }
}

double QwtPlotAbstractBarChart::baseline() const
{
    return m_data->baseline;
}

double QwtPlotAbstractBarChart::sampleWidth( const QwtScaleMap& map,
    double canvasSize, double boundingSize, double value ) const
{
    double width;

    switch( m_data->layoutPolicy )
    {
        case ScaleSamplesToAxes:
        {
            width = qwtTransformWidth( map, value, m_data->layoutHint );
            break;
        }
        case ScaleSampleToCanvas:
        {
            width = canvasSize * m_data->layoutHint;
            break;
        }
        case FixedSampleSize:
        {
            width = m_data->layoutHint;
            break;
        }
        case AutoAdjustSamples:
        default:
        {
            const size_t numSamples = dataSize();

            double w = 1.0;
            if ( numSamples > 1 )
            {
                w = qAbs( boundingSize / ( numSamples - 1 ) );
            }

            width = qwtTransformWidth( map, value, w );
            width -= m_data->spacing;
            width = qwtMaxF( width, m_data->layoutHint );
        }
    }

    return width;
}

void QwtPlotAbstractBarChart::getCanvasMarginHint( const QwtScaleMap& xMap,
    const QwtScaleMap& yMap, const QRectF& canvasRect,
    double& left, double& top, double& right, double& bottom ) const
{
    double hint = -1.0;

    switch( layoutPolicy() )
    {
        case ScaleSampleToCanvas:
        {
            if ( orientation() == Qt::Vertical )
                hint = 0.5 * canvasRect.width() * m_data->layoutHint;
            else
                hint = 0.5 * canvasRect.height() * m_data->layoutHint;

            break;
        }
        case FixedSampleSize:
        {
            hint = 0.5 * m_data->layoutHint;
            break;
        }
        case AutoAdjustSamples:
        case ScaleSamplesToAxes:
        default:
        {
            const size_t numSamples = dataSize();
            if ( numSamples <= 0 )
                break;

            // doesn't work for nonlinear scales

            const QRectF br = dataRect();
            double spacing = 0.0;
            double sampleWidthS = 1.0;

            if ( layoutPolicy() == ScaleSamplesToAxes )
            {
                sampleWidthS = qwtMaxF( m_data->layoutHint, 0.0 );
            }
            else
            {
                spacing = m_data->spacing;

                if ( numSamples > 1 )
                {
                    sampleWidthS = qAbs( br.width() / ( numSamples - 1 ) );
                }
            }

            double ds, w;
            if ( orientation() == Qt::Vertical )
            {
                ds = qAbs( xMap.sDist() );
                w = canvasRect.width();
            }
            else
            {
                ds = qAbs( yMap.sDist() );
                w = canvasRect.height();
            }

            const double sampleWidthP = ( w - spacing * ( numSamples - 1 ) )
                * sampleWidthS / ( ds + sampleWidthS );

            hint = 0.5 * sampleWidthP;
            hint += qMax( m_data->margin, 0 );
        }
    }

    if ( orientation() == Qt::Vertical )
    {
        left = right = hint;
        top = bottom = -1.0; // no hint
    }
    else
    {
        left = right = -1.0; // no hint
        top = bottom = hint;
    }
}