qwt_plot_directpainter.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_directpainter.h"
#include "qwt_scale_map.h"
#include "qwt_plot.h"
#include "qwt_plot_canvas.h"
#include "qwt_plot_seriesitem.h"

#include <qpainter.h>
#include <qevent.h>
#include <qpixmap.h>

static inline void qwtRenderItem(
    QPainter* painter, const QRect& canvasRect,
    QwtPlotSeriesItem* seriesItem, int from, int to )
{
    // A minor performance improvement is possible
    // with caching the maps. TODO ...

    QwtPlot* plot = seriesItem->plot();
    const QwtScaleMap xMap = plot->canvasMap( seriesItem->xAxis() );
    const QwtScaleMap yMap = plot->canvasMap( seriesItem->yAxis() );

    painter->setRenderHint( QPainter::Antialiasing,
        seriesItem->testRenderHint( QwtPlotItem::RenderAntialiased ) );
    seriesItem->drawSeries( painter, xMap, yMap, canvasRect, from, to );
}

static inline bool qwtHasBackingStore( const QwtPlotCanvas* canvas )
{
    return canvas->testPaintAttribute( QwtPlotCanvas::BackingStore )
           && canvas->backingStore() && !canvas->backingStore()->isNull();
}

class QwtPlotDirectPainter::PrivateData
{
  public:
    PrivateData()
        : hasClipping( false )
        , seriesItem( NULL )
        , from( 0 )
        , to( 0 )
    {
    }

    QwtPlotDirectPainter::Attributes attributes;

    bool hasClipping;
    QRegion clipRegion;

    QPainter painter;

    QwtPlotSeriesItem* seriesItem;
    int from;
    int to;
};

QwtPlotDirectPainter::QwtPlotDirectPainter( QObject* parent )
    : QObject( parent )
{
    m_data = new PrivateData;
}

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

void QwtPlotDirectPainter::setAttribute( Attribute attribute, bool on )
{
    if ( bool( m_data->attributes & attribute ) != on )
    {
        if ( on )
            m_data->attributes |= attribute;
        else
            m_data->attributes &= ~attribute;

        if ( ( attribute == AtomicPainter ) && on )
            reset();
    }
}

bool QwtPlotDirectPainter::testAttribute( Attribute attribute ) const
{
    return m_data->attributes & attribute;
}

void QwtPlotDirectPainter::setClipping( bool enable )
{
    m_data->hasClipping = enable;
}

bool QwtPlotDirectPainter::hasClipping() const
{
    return m_data->hasClipping;
}

void QwtPlotDirectPainter::setClipRegion( const QRegion& region )
{
    m_data->clipRegion = region;
    m_data->hasClipping = true;
}

QRegion QwtPlotDirectPainter::clipRegion() const
{
    return m_data->clipRegion;
}

void QwtPlotDirectPainter::drawSeries(
    QwtPlotSeriesItem* seriesItem, int from, int to )
{
    if ( seriesItem == NULL || seriesItem->plot() == NULL )
        return;

    QWidget* canvas = seriesItem->plot()->canvas();
    const QRect canvasRect = canvas->contentsRect();

    QwtPlotCanvas* plotCanvas = qobject_cast< QwtPlotCanvas* >( canvas );

    if ( plotCanvas && qwtHasBackingStore( plotCanvas ) )
    {
        QPainter painter( const_cast< QPixmap* >( plotCanvas->backingStore() ) );

        if ( m_data->hasClipping )
            painter.setClipRegion( m_data->clipRegion );

        qwtRenderItem( &painter, canvasRect, seriesItem, from, to );

        painter.end();

        if ( testAttribute( QwtPlotDirectPainter::FullRepaint ) )
        {
            plotCanvas->repaint();
            return;
        }
    }

    bool immediatePaint = true;
    if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
    {
#if QT_VERSION < 0x050000
        if ( !canvas->testAttribute( Qt::WA_PaintOutsidePaintEvent ) )
#endif
        immediatePaint = false;
    }

    if ( immediatePaint )
    {
        if ( !m_data->painter.isActive() )
        {
            reset();

            m_data->painter.begin( canvas );
            canvas->installEventFilter( this );
        }

        if ( m_data->hasClipping )
        {
            m_data->painter.setClipRegion(
                QRegion( canvasRect ) & m_data->clipRegion );
        }
        else
        {
            if ( !m_data->painter.hasClipping() )
                m_data->painter.setClipRect( canvasRect );
        }

        qwtRenderItem( &m_data->painter, canvasRect, seriesItem, from, to );

        if ( m_data->attributes & QwtPlotDirectPainter::AtomicPainter )
        {
            reset();
        }
        else
        {
            if ( m_data->hasClipping )
                m_data->painter.setClipping( false );
        }
    }
    else
    {
        reset();

        m_data->seriesItem = seriesItem;
        m_data->from = from;
        m_data->to = to;

        QRegion clipRegion = canvasRect;
        if ( m_data->hasClipping )
            clipRegion &= m_data->clipRegion;

        canvas->installEventFilter( this );
        canvas->repaint(clipRegion);
        canvas->removeEventFilter( this );

        m_data->seriesItem = NULL;
    }
}

void QwtPlotDirectPainter::reset()
{
    if ( m_data->painter.isActive() )
    {
        QWidget* w = static_cast< QWidget* >( m_data->painter.device() );
        if ( w )
            w->removeEventFilter( this );

        m_data->painter.end();
    }
}

bool QwtPlotDirectPainter::eventFilter( QObject*, QEvent* event )
{
    if ( event->type() == QEvent::Paint )
    {
        reset();

        if ( m_data->seriesItem )
        {
            const QPaintEvent* pe = static_cast< QPaintEvent* >( event );

            QWidget* canvas = m_data->seriesItem->plot()->canvas();

            QPainter painter( canvas );
            painter.setClipRegion( pe->region() );

            bool doCopyCache = testAttribute( CopyBackingStore );

            if ( doCopyCache )
            {
                QwtPlotCanvas* plotCanvas =
                    qobject_cast< QwtPlotCanvas* >( canvas );
                if ( plotCanvas )
                {
                    doCopyCache = qwtHasBackingStore( plotCanvas );
                    if ( doCopyCache )
                    {
                        painter.drawPixmap( plotCanvas->rect().topLeft(),
                            *plotCanvas->backingStore() );
                    }
                }
            }

            if ( !doCopyCache )
            {
                qwtRenderItem( &painter, canvas->contentsRect(),
                    m_data->seriesItem, m_data->from, m_data->to );
            }

            return true; // don't call QwtPlotCanvas::paintEvent()
        }
    }

    return false;
}