qwt_plot_canvas.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_canvas.h"
#include "qwt_painter.h"
#include "qwt_plot.h"

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

class QwtPlotCanvas::PrivateData
{
  public:
    PrivateData()
        : backingStore( NULL )
    {
    }

    ~PrivateData()
    {
        delete backingStore;
    }

    QwtPlotCanvas::PaintAttributes paintAttributes;
    QPixmap* backingStore;
};

QwtPlotCanvas::QwtPlotCanvas( QwtPlot* plot )
    : QFrame( plot )
    , QwtPlotAbstractCanvas( this )
{
    m_data = new PrivateData;

    setPaintAttribute( QwtPlotCanvas::BackingStore, true );
    setPaintAttribute( QwtPlotCanvas::Opaque, true );
    setPaintAttribute( QwtPlotCanvas::HackStyledBackground, true );

    setLineWidth( 2 );
    setFrameShadow( QFrame::Sunken );
    setFrameShape( QFrame::Panel );
}

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

void QwtPlotCanvas::setPaintAttribute( PaintAttribute attribute, bool on )
{
    if ( bool( m_data->paintAttributes & attribute ) == on )
        return;

    if ( on )
        m_data->paintAttributes |= attribute;
    else
        m_data->paintAttributes &= ~attribute;

    switch ( attribute )
    {
        case BackingStore:
        {
            if ( on )
            {
                if ( m_data->backingStore == NULL )
                    m_data->backingStore = new QPixmap();

                if ( isVisible() )
                {
#if QT_VERSION >= 0x050000
                    *m_data->backingStore = grab( rect() );
#else
                    *m_data->backingStore =
                        QPixmap::grabWidget( this, rect() );
#endif
                }
            }
            else
            {
                delete m_data->backingStore;
                m_data->backingStore = NULL;
            }
            break;
        }
        case Opaque:
        {
            if ( on )
                setAttribute( Qt::WA_OpaquePaintEvent, true );

            break;
        }
        default:
        {
            break;
        }
    }
}

bool QwtPlotCanvas::testPaintAttribute( PaintAttribute attribute ) const
{
    return m_data->paintAttributes & attribute;
}

const QPixmap* QwtPlotCanvas::backingStore() const
{
    return m_data->backingStore;
}

void QwtPlotCanvas::invalidateBackingStore()
{
    if ( m_data->backingStore )
        *m_data->backingStore = QPixmap();
}

bool QwtPlotCanvas::event( QEvent* event )
{
    if ( event->type() == QEvent::PolishRequest )
    {
        if ( testPaintAttribute( QwtPlotCanvas::Opaque ) )
        {
            // Setting a style sheet changes the
            // Qt::WA_OpaquePaintEvent attribute, but we insist
            // on painting the background.

            setAttribute( Qt::WA_OpaquePaintEvent, true );
        }
    }

    if ( event->type() == QEvent::PolishRequest ||
        event->type() == QEvent::StyleChange )
    {
        updateStyleSheetInfo();
    }

    return QFrame::event( event );
}

void QwtPlotCanvas::paintEvent( QPaintEvent* event )
{
    QPainter painter( this );
    painter.setClipRegion( event->region() );

    if ( testPaintAttribute( QwtPlotCanvas::BackingStore ) &&
        m_data->backingStore != NULL )
    {
        QPixmap& bs = *m_data->backingStore;
        if ( bs.size() != size() * QwtPainter::devicePixelRatio( &bs ) )
        {
            bs = QwtPainter::backingStore( this, size() );

            if ( testAttribute(Qt::WA_StyledBackground) )
            {
                QPainter p( &bs );
                drawStyled( &p, testPaintAttribute( HackStyledBackground ) );
            }
            else
            {
                QPainter p;
                if ( borderRadius() <= 0.0 )
                {
                    QwtPainter::fillPixmap( this, bs );
                    p.begin( &bs );
                    drawCanvas( &p );
                }
                else
                {
                    p.begin( &bs );
                    drawUnstyled( &p );
                }

                if ( frameWidth() > 0 )
                    drawBorder( &p );
            }
        }

        painter.drawPixmap( 0, 0, *m_data->backingStore );
    }
    else
    {
        if ( testAttribute(Qt::WA_StyledBackground ) )
        {
            if ( testAttribute( Qt::WA_OpaquePaintEvent ) )
            {
                drawStyled( &painter, testPaintAttribute( HackStyledBackground ) );
            }
            else
            {
                drawCanvas( &painter );
            }
        }
        else
        {
            if ( testAttribute( Qt::WA_OpaquePaintEvent ) )
            {
                if ( autoFillBackground() )
                {
                    fillBackground( &painter );
                    drawBackground( &painter );
                }
            }
            else
            {
                if ( borderRadius() > 0.0 )
                {
                    QPainterPath clipPath;
                    clipPath.addRect( rect() );
                    clipPath = clipPath.subtracted( borderPath( rect() ) );

                    painter.save();

                    painter.setClipPath( clipPath, Qt::IntersectClip );
                    fillBackground( &painter );
                    drawBackground( &painter );

                    painter.restore();
                }
            }

            drawCanvas( &painter );

            if ( frameWidth() > 0 )
                drawBorder( &painter );
        }
    }

    if ( hasFocus() && focusIndicator() == CanvasFocusIndicator )
        drawFocusIndicator( &painter );
}

void QwtPlotCanvas::drawBorder( QPainter* painter )
{
    if ( borderRadius() <= 0 )
    {
        drawFrame( painter );
        return;
    }

    QwtPlotAbstractCanvas::drawBorder( painter );
}

void QwtPlotCanvas::resizeEvent( QResizeEvent* event )
{
    QFrame::resizeEvent( event );
    updateStyleSheetInfo();
}

void QwtPlotCanvas::replot()
{
    invalidateBackingStore();

    if ( testPaintAttribute( QwtPlotCanvas::ImmediatePaint ) )
        repaint( contentsRect() );
    else
        update( contentsRect() );
}

QPainterPath QwtPlotCanvas::borderPath( const QRect& rect ) const
{
    return canvasBorderPath( rect );
}

#if QWT_MOC_INCLUDE
#include "moc_qwt_plot_canvas.cpp"
#endif