qwt_plot_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_barchart.h"
#include "qwt_scale_map.h"
#include "qwt_column_symbol.h"
#include "qwt_text.h"
#include "qwt_graphic.h"
#include "qwt_legend_data.h"

#include <qpainter.h>

class QwtPlotBarChart::PrivateData
{
  public:
    PrivateData()
        : symbol( NULL )
        , legendMode( QwtPlotBarChart::LegendChartTitle )
    {
    }

    ~PrivateData()
    {
        delete symbol;
    }

    QwtColumnSymbol* symbol;
    QwtPlotBarChart::LegendMode legendMode;
};

QwtPlotBarChart::QwtPlotBarChart( const QwtText& title )
    : QwtPlotAbstractBarChart( title )
{
    init();
}

QwtPlotBarChart::QwtPlotBarChart( const QString& title )
    : QwtPlotAbstractBarChart( QwtText( title ) )
{
    init();
}

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

void QwtPlotBarChart::init()
{
    m_data = new PrivateData;
    setData( new QwtPointSeriesData() );
}

int QwtPlotBarChart::rtti() const
{
    return QwtPlotItem::Rtti_PlotBarChart;
}

void QwtPlotBarChart::setSamples(
    const QVector< QPointF >& samples )
{
    setData( new QwtPointSeriesData( samples ) );
}

void QwtPlotBarChart::setSamples(
    const QVector< double >& samples )
{
    QVector< QPointF > points;
    points.reserve( samples.size() );

    for ( int i = 0; i < samples.size(); i++ )
        points += QPointF( i, samples[ i ] );

    setData( new QwtPointSeriesData( points ) );
}

void QwtPlotBarChart::setSamples( QwtSeriesData< QPointF >* data )
{
    setData( data );
}

void QwtPlotBarChart::setSymbol( QwtColumnSymbol* symbol )
{
    if ( symbol != m_data->symbol )
    {
        delete m_data->symbol;
        m_data->symbol = symbol;

        legendChanged();
        itemChanged();
    }
}

const QwtColumnSymbol* QwtPlotBarChart::symbol() const
{
    return m_data->symbol;
}

void QwtPlotBarChart::setLegendMode( LegendMode mode )
{
    if ( mode != m_data->legendMode )
    {
        m_data->legendMode = mode;
        legendChanged();
    }
}

QwtPlotBarChart::LegendMode QwtPlotBarChart::legendMode() const
{
    return m_data->legendMode;
}

QRectF QwtPlotBarChart::boundingRect() const
{
    const size_t numSamples = dataSize();
    if ( numSamples == 0 )
        return QwtPlotSeriesItem::boundingRect();

    QRectF rect = QwtPlotSeriesItem::boundingRect();
    if ( rect.height() >= 0 )
    {
        const double baseLine = baseline();

        if ( rect.bottom() < baseLine )
            rect.setBottom( baseLine );

        if ( rect.top() > baseLine )
            rect.setTop( baseLine );
    }

    if ( orientation() == Qt::Horizontal )
        rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );

    return rect;
}

void QwtPlotBarChart::drawSeries( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, int from, int to ) const
{
    if ( to < 0 )
        to = dataSize() - 1;

    if ( from < 0 )
        from = 0;

    if ( from > to )
        return;


    const QRectF br = data()->boundingRect();
    const QwtInterval interval( br.left(), br.right() );

    painter->save();

    for ( int i = from; i <= to; i++ )
    {
        drawSample( painter, xMap, yMap,
            canvasRect, interval, i, sample( i ) );
    }

    painter->restore();
}

QwtColumnRect QwtPlotBarChart::columnRect(
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, const QwtInterval& boundingInterval,
    const QPointF& sample ) const
{
    QwtColumnRect barRect;

    if ( orientation() == Qt::Horizontal )
    {
        const double barHeight = sampleWidth( yMap, canvasRect.height(),
            boundingInterval.width(), sample.y() );

        const double x1 = xMap.transform( baseline() );
        const double x2 = xMap.transform( sample.y() );

        const double y = yMap.transform( sample.x() );
        const double y1 = y - 0.5 * barHeight;
        const double y2 = y + 0.5 * barHeight;

        barRect.direction = ( x1 < x2 ) ?
            QwtColumnRect::LeftToRight : QwtColumnRect::RightToLeft;

        barRect.hInterval = QwtInterval( x1, x2 ).normalized();
        barRect.vInterval = QwtInterval( y1, y2 );
    }
    else
    {
        const double barWidth = sampleWidth( xMap, canvasRect.width(),
            boundingInterval.width(), sample.y() );

        const double x = xMap.transform( sample.x() );
        const double x1 = x - 0.5 * barWidth;
        const double x2 = x + 0.5 * barWidth;

        const double y1 = yMap.transform( baseline() );
        const double y2 = yMap.transform( sample.y() );

        barRect.direction = ( y1 < y2 ) ?
            QwtColumnRect::TopToBottom : QwtColumnRect::BottomToTop;

        barRect.hInterval = QwtInterval( x1, x2 );
        barRect.vInterval = QwtInterval( y1, y2 ).normalized();
    }

    return barRect;
}

void QwtPlotBarChart::drawSample( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, const QwtInterval& boundingInterval,
    int index, const QPointF& sample ) const
{
    const QwtColumnRect barRect = columnRect( xMap, yMap,
        canvasRect, boundingInterval, sample );

    drawBar( painter, index, sample, barRect );
}

void QwtPlotBarChart::drawBar( QPainter* painter,
    int sampleIndex, const QPointF& sample,
    const QwtColumnRect& rect ) const
{
    const QwtColumnSymbol* specialSym =
        specialSymbol( sampleIndex, sample );

    const QwtColumnSymbol* sym = specialSym;
    if ( sym == NULL )
        sym = m_data->symbol;

    if ( sym )
    {
        sym->draw( painter, rect );
    }
    else
    {
        // we build a temporary default symbol
        QwtColumnSymbol columnSymbol( QwtColumnSymbol::Box );
        columnSymbol.setLineWidth( 1 );
        columnSymbol.setFrameStyle( QwtColumnSymbol::Plain );
        columnSymbol.draw( painter, rect );
    }

    delete specialSym;
}

QwtColumnSymbol* QwtPlotBarChart::specialSymbol(
    int sampleIndex, const QPointF& sample ) const
{
    Q_UNUSED( sampleIndex );
    Q_UNUSED( sample );

    return NULL;
}

QwtText QwtPlotBarChart::barTitle( int sampleIndex ) const
{
    Q_UNUSED( sampleIndex );
    return QwtText();
}

QList< QwtLegendData > QwtPlotBarChart::legendData() const
{
    QList< QwtLegendData > list;

    if ( m_data->legendMode == LegendBarTitles )
    {
        const size_t numSamples = dataSize();
        list.reserve( numSamples );

        for ( size_t i = 0; i < numSamples; i++ )
        {
            QwtLegendData data;

            data.setValue( QwtLegendData::TitleRole,
                QVariant::fromValue( barTitle( i ) ) );

            if ( !legendIconSize().isEmpty() )
            {
                data.setValue( QwtLegendData::IconRole,
                    QVariant::fromValue( legendIcon( i, legendIconSize() ) ) );
            }

            list += data;
        }
    }
    else
    {
        return QwtPlotAbstractBarChart::legendData();
    }

    return list;
}

QwtGraphic QwtPlotBarChart::legendIcon(
    int index, const QSizeF& size ) const
{
    QwtColumnRect column;
    column.hInterval = QwtInterval( 0.0, size.width() - 1.0 );
    column.vInterval = QwtInterval( 0.0, size.height() - 1.0 );

    QwtGraphic icon;
    icon.setDefaultSize( size );
    icon.setRenderHint( QwtGraphic::RenderPensUnscaled, true );

    QPainter painter( &icon );
    painter.setRenderHint( QPainter::Antialiasing,
        testRenderHint( QwtPlotItem::RenderAntialiased ) );

    int barIndex = -1;
    if ( m_data->legendMode == QwtPlotBarChart::LegendBarTitles )
        barIndex = index;

    drawBar( &painter, barIndex, QPointF(), column );

    return icon;
}