qwt_paint_buffer.cpp

Go to the documentation of this file.

/*-*- c++ -*-******************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *****************************************************************************/

#include <qwidget.h>

#if QT_VERSION < 0x040000
#else
//Added by the Qt porting tool:
#include <QtGui/QPaintEngine>
#include <QtGui/QPixmap>
#endif

#include <qpainter.h>

#include "qwt_paint_buffer.h"

namespace hippodraw {

#if QT_VERSION < 0x040000
bool QwtPaintBuffer::d_enabled = TRUE;
#else
bool QwtPaintBuffer::d_enabled = true;
#endif

QwtPaintBuffer::QwtPaintBuffer():
    d_device(0),
    d_painter(0),
    d_devicePainter(0)
{
}

QwtPaintBuffer::QwtPaintBuffer(QPaintDevice *device, 
        const QRect &rect, QPainter *painter):
    d_device(0),
    d_painter(0),
    d_devicePainter(0)
{
    open(device, rect, painter);
}

QwtPaintBuffer::~QwtPaintBuffer()
{
    close();
}

QPainter *QwtPaintBuffer::painter() 
{ 
    return d_painter; 
}

const QPaintDevice *QwtPaintBuffer::device() 
{ 
    return d_device; 
}

void QwtPaintBuffer::setEnabled(bool enable) 
{ 
    d_enabled = enable; 
}

bool QwtPaintBuffer::isEnabled() 
{ 
    return d_enabled; 
}

void QwtPaintBuffer::open(QPaintDevice *device, 
        const QRect &rect, QPainter *painter)
{
    close();

    if ( device == 0 || !rect.isValid() )
        return;

    d_device = device;
    d_devicePainter = painter;
    d_rect = rect;

    if ( isEnabled() )
    {
        d_pixBuffer.resize(d_rect.size());

        d_painter = new QPainter();
        if ( d_device->devType() == QInternal::Widget )
        {
            QWidget *w = (QWidget *)d_device;
            d_pixBuffer.fill(w, d_rect.topLeft());
            d_painter->begin(&d_pixBuffer, w);
            d_painter->translate(-d_rect.x(), -d_rect.y());
        }
        else
        {
            d_painter->begin(&d_pixBuffer);
        }
    }
    else
    {
        if ( d_devicePainter )
            d_painter = d_devicePainter;
        else
        {
            d_painter = new QPainter(d_device);

            if ( d_device->devType() == QInternal::Widget )
            {
#if QT_VERSION < 0x040000
                QWidget *w = (QWidget *)d_device;
                if ( w->testWFlags( Qt::WRepaintNoErase | Qt::WResizeNoErase) )
// #else
//                 if ( w->testWFlags( Qt::WNoAutoErase | Qt::WResizeNoErase) )
#endif
                    d_painter->eraseRect(d_rect);
            }
        }
    }
}

void QwtPaintBuffer::flush()
{
    if ( d_enabled && d_device != 0 && d_rect.isValid())
    {
                // We need a painter to find out if
                // there is a painter redirection for d_device.

                QPainter *p;
                if ( d_devicePainter == 0 )
                        p = new QPainter(d_device);
                else 
                        p = d_devicePainter;

                QPaintDevice *device = p->device();
#if QT_VERSION < 0x040000
                if ( device->isExtDev() )
#else
                QPaintEngine * pe = device -> paintEngine ();
                QPaintEngine::Type type = pe-> type ();
                if ( type != QPaintEngine::PostScript )
#endif
                  d_devicePainter->drawPixmap(d_rect.topLeft(), d_pixBuffer);
                else
            bitBlt(device, d_rect.topLeft(), &d_pixBuffer );

                if ( d_devicePainter == 0 )
                        delete p;
    }
}

void QwtPaintBuffer::close()
{
    flush();

    if ( d_painter )
    {
        if ( d_painter->isActive() )
            d_painter->end();

        if ( d_painter != d_devicePainter )
            delete d_painter;
    }

    if ( !d_pixBuffer.isNull() )
        d_pixBuffer = QPixmap();

    d_device = 0;
    d_painter = 0;
    d_devicePainter = 0;
} 

} // namespace hippodraw