/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qplatformdefs.h"

#include "qbackingstore_p.h"

#include <QtCore/qglobal.h>

#include <QtCore/qdebug.h>

#include <QtCore/qvarlengtharray.h>

#include <QtGui/qevent.h>

#include <QtGui/qapplication.h>

#include <QtGui/qpaintengine.h>

#include <QtGui/qgraphicsproxywidget.h>

#include <private/qwidget_p.h>

#include <private/qwindowsurface_raster_p.h>

#include <private/qapplication_p.h>

#include <private/qpaintengine_raster_p.h>

#include <private/qgraphicseffect_p.h>

#include "qgraphicssystem_p.h"

#ifdef Q_WS_QWS

#include <QtGui/qwsmanager_qws.h>

#include <private/qwsmanager_p.h>

#endif

QT_BEGIN_NAMESPACE

extern QRegion qt_dirtyRegion(QWidget *);

/*

   A version of QRect::intersects() that does not normalize the rects.

*/

static inline bool qRectIntersects(const QRect &r1, const QRect &r2)

{

    return (qMax(r1.left(), r2.left()) <= qMin(r1.right(), r2.right())

            && qMax(r1.top(), r2.top()) <= qMin(r1.bottom(), r2.bottom()));

}

/**

 * Flushes the contents of the \a windowSurface into the screen area of \a widget.

 * \a tlwOffset is the position of the top level widget relative to the window surface.

 * \a region is the region to be updated in \a widget coordinates.

 */

static inline void qt_flush(QWidget *widget, const QRegion &region, QWindowSurface *windowSurface,

                            QWidget *tlw, const QPoint &tlwOffset)

{

    Q_ASSERT(widget);

    Q_ASSERT(!region.isEmpty());

    Q_ASSERT(windowSurface);

    Q_ASSERT(tlw);

#if !defined(QT_NO_PAINT_DEBUG) && !defined(Q_WS_QWS)

    // QWS does flush update in QWindowSurface::flush (because it needs to lock the surface etc).

    static int flushUpdate = qgetenv("QT_FLUSH_UPDATE").toInt();

    if (flushUpdate > 0)

        QWidgetBackingStore::showYellowThing(widget, region, flushUpdate * 10, false);

#endif

    if (widget != tlw)

        windowSurface->flush(widget, region, tlwOffset + widget->mapTo(tlw, QPoint()));

    else

        windowSurface->flush(widget, region, tlwOffset);

}

#ifndef QT_NO_PAINT_DEBUG

#ifdef Q_WS_WIN

static void showYellowThing_win(QWidget *widget, const QRegion &region, int msec)

{

    HBRUSH brush;

    static int i = 0;

    switch (i) {

    case 0:

        brush = CreateSolidBrush(RGB(255, 255, 0));

        break;

    case 1:

        brush = CreateSolidBrush(RGB(255, 200, 55));

        break;

    case 2:

        brush = CreateSolidBrush(RGB(200, 255, 55));

        break;

    case 3:

        brush = CreateSolidBrush(RGB(200, 200, 0));

        break;

    }

    i = (i + 1) & 3;

    HDC hdc = widget->getDC();

    const QVector<QRect> &rects = region.rects();

    foreach (QRect rect, rects) {

        RECT winRect;

        SetRect(&winRect, rect.left(), rect.top(), rect.right(), rect.bottom());

        FillRect(hdc, &winRect, brush);

    }

    widget->releaseDC(hdc);

    ::Sleep(msec);

}

#endif

void QWidgetBackingStore::showYellowThing(QWidget *widget, const QRegion &toBePainted, int msec, bool unclipped)

{

#ifdef Q_WS_QWS

    Q_UNUSED(widget);

    Q_UNUSED(unclipped);

    static QWSYellowSurface surface(true);

    surface.setDelay(msec);

    surface.flush(widget, toBePainted, QPoint());

#else

    QRegion paintRegion = toBePainted;

    QRect widgetRect = widget->rect();

    if (!widget->internalWinId()) {

        QWidget *nativeParent = widget->nativeParentWidget();

        const QPoint offset = widget->mapTo(nativeParent, QPoint(0, 0));

        paintRegion.translate(offset);

        widgetRect.translate(offset);

        widget = nativeParent;

    }

#ifdef Q_WS_WIN

    Q_UNUSED(unclipped);

    showYellowThing_win(widget, paintRegion, msec);

#else

    //flags to fool painter

    bool paintUnclipped = widget->testAttribute(Qt::WA_PaintUnclipped);

    if (unclipped && !widget->d_func()->paintOnScreen())

        widget->setAttribute(Qt::WA_PaintUnclipped);

    const bool setFlag = !widget->testAttribute(Qt::WA_WState_InPaintEvent);

    if (setFlag)

        widget->setAttribute(Qt::WA_WState_InPaintEvent);

    //setup the engine

    QPaintEngine *pe = widget->paintEngine();

    if (pe) {

        pe->setSystemClip(paintRegion);

        {

            QPainter p(widget);

            p.setClipRegion(paintRegion);

            static int i = 0;

            switch (i) {

            case 0:

                p.fillRect(widgetRect, QColor(255,255,0));

                break;

            case 1:

                p.fillRect(widgetRect, QColor(255,200,55));

                break;

            case 2:

                p.fillRect(widgetRect, QColor(200,255,55));

                break;

            case 3:

                p.fillRect(widgetRect, QColor(200,200,0));

                break;

            }

            i = (i+1) & 3;

            p.end();

        }

    }

    if (setFlag)

        widget->setAttribute(Qt::WA_WState_InPaintEvent, false);

    //restore

    widget->setAttribute(Qt::WA_PaintUnclipped, paintUnclipped);

    if (pe)

        pe->setSystemClip(QRegion());

    QApplication::syncX();

#if defined(Q_OS_UNIX)

    ::usleep(1000 * msec);

#endif

#endif // Q_WS_WIN

#endif // Q_WS_QWS

}

bool QWidgetBackingStore::flushPaint(QWidget *widget, const QRegion &rgn)

{

    if (!widget)

        return false;

    int delay = 0;

    if (widget->testAttribute(Qt::WA_WState_InPaintEvent)) {

        static int flushPaintEvent = qgetenv("QT_FLUSH_PAINT_EVENT").toInt();

        if (!flushPaintEvent)

            return false;

        delay = flushPaintEvent;

    } else {

        static int flushPaint = qgetenv("QT_FLUSH_PAINT").toInt();

        if (!flushPaint)

            return false;

        delay = flushPaint;

    }

    QWidgetBackingStore::showYellowThing(widget, rgn, delay * 10, true);

    return true;

}

void QWidgetBackingStore::unflushPaint(QWidget *widget, const QRegion &rgn)

{

    if (widget->d_func()->paintOnScreen() || rgn.isEmpty())

        return;

    QWidget *tlw = widget->window();

    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();

    if (!tlwExtra)

        return;

    const QPoint offset = widget->mapTo(tlw, QPoint());

    qt_flush(widget, rgn, tlwExtra->backingStore->windowSurface, tlw, offset);

}

#endif // QT_NO_PAINT_DEBUG

/*

    Moves the whole rect by (dx, dy) in widget's coordinate system.

    Doesn't generate any updates.

*/

bool QWidgetBackingStore::bltRect(const QRect &rect, int dx, int dy, QWidget *widget)

{

    const QPoint pos(tlwOffset + widget->mapTo(tlw, rect.topLeft()));

    const QRect tlwRect(QRect(pos, rect.size()));

    if (dirty.intersects(tlwRect))

        return false; // We don't want to scroll junk.

    return windowSurface->scroll(tlwRect, dx, dy);

}

void QWidgetBackingStore::releaseBuffer()

{

    if (windowSurface)

        windowSurface->setGeometry(QRect());

#ifdef Q_BACKINGSTORE_SUBSURFACES

    for (int i = 0; i < subSurfaces.size(); ++i)

        subSurfaces.at(i)->setGeometry(QRect());

#endif

}

/*!

    Prepares the window surface to paint a\ toClean region of the \a widget and

    updates the BeginPaintInfo struct accordingly.

    The \a toClean region might be clipped by the window surface.

*/

void QWidgetBackingStore::beginPaint(QRegion &toClean, QWidget *widget, QWindowSurface *windowSurface,

                                     BeginPaintInfo *returnInfo, bool toCleanIsInTopLevelCoordinates)

{

#ifdef Q_WS_QWS

    QWSWindowSurface *surface = static_cast<QWSWindowSurface *>(windowSurface);

    QWidget *surfaceWidget = surface->window();

    if (!surface->isValid()) {

        // this looks strange but it really just releases the surface

        surface->releaseSurface();

        // the old window surface is deleted in setWindowSurface, which is

        // called from QWindowSurface constructor.

        windowSurface = tlw->d_func()->createDefaultWindowSurface();

        surface = static_cast<QWSWindowSurface *>(windowSurface);

        // createDefaultWindowSurface() will set topdata->windowSurface on the

        // widget to zero. However, if this is a sub-surface, it should point

        // to the widget's sub windowSurface, so we set that here:

        if (!surfaceWidget->isWindow())

            surfaceWidget->d_func()->topData()->windowSurface = windowSurface;

        surface->setGeometry(topLevelRect());

        returnInfo->windowSurfaceRecreated = true;

    }

    const QRegion toCleanUnclipped(toClean);

    if (surfaceWidget->isWindow())

        tlwOffset = surface->painterOffset();

#ifdef Q_BACKINGSTORE_SUBSURFACES

    else if (toCleanIsInTopLevelCoordinates)

        toClean &= surface->clipRegion().translated(surfaceWidget->mapTo(tlw, QPoint()));

    if (!toCleanIsInTopLevelCoordinates && windowSurface == this->windowSurface)

        toClean &= surface->clipRegion().translated(-widget->mapTo(surfaceWidget, QPoint()));

#else

    toClean &= surface->clipRegion();

#endif

    if (toClean.isEmpty()) {

        if (surfaceWidget->isWindow()) {

            dirtyFromPreviousSync += toCleanUnclipped;

            hasDirtyFromPreviousSync = true;

        }

        returnInfo->nothingToPaint = true;

        // Nothing to repaint. However, we might have newly exposed areas on the

        // screen, so we have to make sure those are flushed.

        flush();

        return;

    }

    if (surfaceWidget->isWindow()) {

        if (toCleanUnclipped != toClean) {

            dirtyFromPreviousSync += (toCleanUnclipped - surface->clipRegion());

            hasDirtyFromPreviousSync = true;

        }

        if (hasDirtyFromPreviousSync) {

            dirtyFromPreviousSync -= toClean;

            hasDirtyFromPreviousSync = !dirtyFromPreviousSync.isEmpty();

        }

    }

#endif // Q_WS_QWS

    Q_UNUSED(widget);

    Q_UNUSED(toCleanIsInTopLevelCoordinates);

    // Always flush repainted areas.

    dirtyOnScreen += toClean;

#ifdef QT_NO_PAINT_DEBUG

    windowSurface->beginPaint(toClean);

#else

    returnInfo->wasFlushed = QWidgetBackingStore::flushPaint(tlw, toClean);

    // Avoid deadlock with QT_FLUSH_PAINT: the server will wait for

    // the BackingStore lock, so if we hold that, the server will

    // never release the Communication lock that we are waiting for in

    // sendSynchronousCommand

    if (!returnInfo->wasFlushed)

        windowSurface->beginPaint(toClean);

#endif

    Q_UNUSED(returnInfo);

}

void QWidgetBackingStore::endPaint(const QRegion &cleaned, QWindowSurface *windowSurface,

        BeginPaintInfo *beginPaintInfo)

{

#ifndef QT_NO_PAINT_DEBUG

    if (!beginPaintInfo->wasFlushed)

        windowSurface->endPaint(cleaned);

    else

        QWidgetBackingStore::unflushPaint(tlw, cleaned);

#else

    Q_UNUSED(beginPaintInfo);

    windowSurface->endPaint(cleaned);

#endif

#ifdef Q_BACKINGSTORE_SUBSURFACES

    flush(static_cast<QWSWindowSurface *>(windowSurface)->window(), windowSurface);

#else

    flush();

#endif

}

/*!

    Returns the region (in top-level coordinates) that needs repaint and/or flush.

    If the widget is non-zero, only the dirty region for the widget is returned

    and the region will be in widget coordinates.

*/

QRegion QWidgetBackingStore::dirtyRegion(QWidget *widget) const

{

    const bool widgetDirty = widget && widget != tlw;

    const QRect tlwRect(topLevelRect());

    const QRect surfaceGeometry(windowSurface->geometry());

    if (surfaceGeometry != tlwRect && surfaceGeometry.size() != tlwRect.size()) {

        if (widgetDirty) {

            const QRect dirtyTlwRect = QRect(QPoint(), tlwRect.size());

            const QPoint offset(widget->mapTo(tlw, QPoint()));

            const QRect dirtyWidgetRect(dirtyTlwRect & widget->rect().translated(offset));

            return dirtyWidgetRect.translated(-offset);

        }

        return QRect(QPoint(), tlwRect.size());

    }

    // Calculate the region that needs repaint.

    QRegion r(dirty);

    for (int i = 0; i < dirtyWidgets.size(); ++i) {

        QWidget *w = dirtyWidgets.at(i);

        if (widgetDirty && w != widget && !widget->isAncestorOf(w))

            continue;

        r += w->d_func()->dirty.translated(w->mapTo(tlw, QPoint()));

    }

    // Append the region that needs flush.

    r += dirtyOnScreen;

    if (dirtyOnScreenWidgets) { // Only in use with native child widgets.

        for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {

            QWidget *w = dirtyOnScreenWidgets->at(i);

            if (widgetDirty && w != widget && !widget->isAncestorOf(w))

                continue;

            QWidgetPrivate *wd = w->d_func();

            Q_ASSERT(wd->needsFlush);

            r += wd->needsFlush->translated(w->mapTo(tlw, QPoint()));

        }

    }

    if (widgetDirty) {

        // Intersect with the widget geometry and translate to its coordinates.

        const QPoint offset(widget->mapTo(tlw, QPoint()));

        r &= widget->rect().translated(offset);

        r.translate(-offset);

    }

    return r;

}

/*!

    Returns the static content inside the \a parent if non-zero; otherwise the static content

    for the entire backing store is returned. The content will be clipped to \a withingClipRect

    if non-empty.

*/

QRegion QWidgetBackingStore::staticContents(QWidget *parent, const QRect &withinClipRect) const

{

    if (!parent && tlw->testAttribute(Qt::WA_StaticContents)) {

        const QRect surfaceGeometry(windowSurface->geometry());

        QRect surfaceRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());

        if (!withinClipRect.isEmpty())

            surfaceRect &= withinClipRect;

        return QRegion(surfaceRect);

    }

    QRegion region;

    if (parent && parent->d_func()->children.isEmpty())

        return region;

    const bool clipToRect = !withinClipRect.isEmpty();

    const int count = staticWidgets.count();

    for (int i = 0; i < count; ++i) {

        QWidget *w = staticWidgets.at(i);

        QWidgetPrivate *wd = w->d_func();

        if (!wd->isOpaque || !wd->extra || wd->extra->staticContentsSize.isEmpty()

            || !w->isVisible() || (parent && !parent->isAncestorOf(w))) {

            continue;

        }

        QRect rect(0, 0, wd->extra->staticContentsSize.width(), wd->extra->staticContentsSize.height());

        const QPoint offset = w->mapTo(parent ? parent : tlw, QPoint());

        if (clipToRect)

            rect &= withinClipRect.translated(-offset);

        if (rect.isEmpty())

            continue;

        rect &= wd->clipRect();

        if (rect.isEmpty())

            continue;

        QRegion visible(rect);

        wd->clipToEffectiveMask(visible);

        if (visible.isEmpty())

            continue;

        wd->subtractOpaqueSiblings(visible, 0, /*alsoNonOpaque=*/true);

        visible.translate(offset);

        region += visible;

    }

    return region;

}

static inline void sendUpdateRequest(QWidget *widget, bool updateImmediately)

{

    if (!widget)

        return;

    if (updateImmediately) {

        QEvent event(QEvent::UpdateRequest);

        QApplication::sendEvent(widget, &event);

    } else {

        QApplication::postEvent(widget, new QEvent(QEvent::UpdateRequest), Qt::LowEventPriority);

    }

}

/*!

    Marks the region of the widget as dirty (if not already marked as dirty) and

    posts an UpdateRequest event to the top-level widget (if not already posted).

    If updateImmediately is true, the event is sent immediately instead of posted.

    If invalidateBuffer is true, all widgets intersecting with the region will be dirty.

    If the widget paints directly on screen, the event is sent to the widget

    instead of the top-level widget, and invalidateBuffer is completely ignored.

    ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).

*/

void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget, bool updateImmediately,

                                    bool invalidateBuffer)

{

    Q_ASSERT(tlw->d_func()->extra);

    Q_ASSERT(tlw->d_func()->extra->topextra);

    Q_ASSERT(!tlw->d_func()->extra->topextra->inTopLevelResize);

    Q_ASSERT(widget->isVisible() && widget->updatesEnabled());