QWidgetBackingStore Class Reference

#include <qbackingstore_p.h>

Public Functions
void	flush (QWidget *widget=0, QWindowSurface *surface=0)
	Flushes the contents of the backing store into the top-level widget. More...
bool	isDirty () const
void	markDirty (const QRegion &rgn, QWidget *widget, bool updateImmediately=false, bool invalidateBuffer=false)
	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). More...
void	markDirty (const QRect &rect, QWidget *widget, bool updateImmediately=false, bool invalidateBuffer=false)
	This function is equivalent to calling markDirty(QRegion(rect), ...), but is more efficient as it eliminates QRegion operations/allocations and can use the rect more precisely for additional cut-offs. More...
	QWidgetBackingStore (QWidget *t)
QWindowSurface *	surface () const
void	sync (QWidget *exposedWidget, const QRegion &exposedRegion)
	Synchronizes the exposedRegion of the exposedWidget with the backing store. More...
void	sync ()
	Synchronizes the backing store, i.e. More...
QPoint	topLevelOffset () const
	~QWidgetBackingStore ()

Static Public Functions
static void	showYellowThing (QWidget *widget, const QRegion &rgn, int msec, bool)

Private Functions
void	addDirtyWidget (QWidget *widget, const QRegion &rgn)
void	addStaticWidget (QWidget *widget)
void	appendDirtyOnScreenWidget (QWidget *widget)
void	beginPaint (QRegion &toClean, QWidget *widget, QWindowSurface *windowSurface, BeginPaintInfo *returnInfo, bool toCleanIsInTopLevelCoordinates=true)
	Prepares the window surface to paint a\ toClean region of the widget and updates the BeginPaintInfo struct accordingly. More...
bool	bltRect (const QRect &rect, int dx, int dy, QWidget *widget)
void	dirtyOnScreenWidgetsRemoveAll (QWidget *widget)
QRegion	dirtyRegion (QWidget *widget=0) const
	Returns the region (in top-level coordinates) that needs repaint and/or flush. More...
void	dirtyWidgetsRemoveAll (QWidget *widget)
void	endPaint (const QRegion &cleaned, QWindowSurface *windowSurface, BeginPaintInfo *beginPaintInfo)
bool	hasStaticContents () const
void	markDirtyOnScreen (const QRegion &dirtyOnScreen, QWidget *widget, const QPoint &topLevelOffset)
	Marks the region of the widget as dirty on screen. More...
void	moveStaticWidgets (QWidget *reparented)
void	releaseBuffer ()
void	removeDirtyWidget (QWidget *w)
void	removeStaticWidget (QWidget *widget)
void	resetWidget (QWidget *widget)
QRegion	staticContents (QWidget *widget=0, const QRect &withinClipRect=QRect()) const
	Returns the static content inside the parent if non-zero; otherwise the static content for the entire backing store is returned. More...
QRect	topLevelRect () const
void	updateLists (QWidget *widget)
void	updateStaticContentsSize ()

Static Private Functions
static bool	flushPaint (QWidget *widget, const QRegion &rgn)
static void	unflushPaint (QWidget *widget, const QRegion &rgn)

Properties
QRegion	dirty
QRegion	dirtyFromPreviousSync
QRegion	dirtyOnScreen
QVector< QWidget * > *	dirtyOnScreenWidgets
QVector< QWidget * >	dirtyWidgets
uint	fullUpdatePending: 1
uint	hasDirtyFromPreviousSync: 1
QList< QWidget * >	staticWidgets
QWidget *	tlw
QPoint	tlwOffset
QWindowSurface *	windowSurface

Friends
class	QETWidget
QRegion	qt_dirtyRegion (QWidget *)
class	QWidget
class	QWidgetPrivate
class	QWindowSurface
class	QWSManagerPrivate
class	QWSWindowSurface

Detailed Description

Definition at line 75 of file qbackingstore_p.h.

Constructors and Destructors

QWidgetBackingStore()

QWidgetBackingStore::QWidgetBackingStore

(

QWidget *

t

)

Definition at line 884 of file qbackingstore.cpp.

    : tlw(topLevel), dirtyOnScreenWidgets(0), hasDirtyFromPreviousSync(false)
    , fullUpdatePending(0)
{
    windowSurface = tlw->windowSurface();
    if (!windowSurface)
        windowSurface = topLevel->d_func()->createDefaultWindowSurface();

    // The QWindowSurface constructor will call QWidget::setWindowSurface(),
    // but automatically created surfaces should not be added to the topdata.
#ifdef Q_BACKINGSTORE_SUBSURFACES
    Q_ASSERT(topLevel->d_func()->topData()->windowSurface == windowSurface);
#endif
    topLevel->d_func()->topData()->windowSurface = 0;

    // Ensure all existing subsurfaces and static widgets are added to their respective lists.
    updateLists(topLevel);
}

~QWidgetBackingStore()

QWidgetBackingStore::~QWidgetBackingStore

(

)

Definition at line 903 of file qbackingstore.cpp.

{
    for (int c = 0; c < dirtyWidgets.size(); ++c) {
        resetWidget(dirtyWidgets.at(c));
    }

    delete windowSurface;
    windowSurface = 0;
    delete dirtyOnScreenWidgets;
    dirtyOnScreenWidgets = 0;
}

Functions

addDirtyWidget()

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

inlineprivate

Definition at line 147 of file qbackingstore_p.h.

Referenced by markDirty().

    {
        if (widget && !widget->d_func()->inDirtyList && !widget->data->in_destructor) {
            QWidgetPrivate *widgetPrivate = widget->d_func();
#ifndef QT_NO_GRAPHICSEFFECT
            if (widgetPrivate->graphicsEffect)
                widgetPrivate->dirty = widgetPrivate->effectiveRectFor(rgn.boundingRect());
            else
#endif //QT_NO_GRAPHICSEFFECT
                widgetPrivate->dirty = rgn;
            dirtyWidgets.append(widget);
            widgetPrivate->inDirtyList = true;
        }
    }

addStaticWidget()

void QWidgetBackingStore::addStaticWidget ( QWidget *  widget )

inlineprivate

Definition at line 173 of file qbackingstore_p.h.

Referenced by moveStaticWidgets(), and updateLists().

    {
        if (!widget)
            return;

        Q_ASSERT(widget->testAttribute(Qt::WA_StaticContents));
        if (!staticWidgets.contains(widget))
            staticWidgets.append(widget);
    }

appendDirtyOnScreenWidget()

void QWidgetBackingStore::appendDirtyOnScreenWidget ( QWidget *  widget )

inlineprivate

Definition at line 217 of file qbackingstore_p.h.

Referenced by markDirtyOnScreen().

    {
        if (!widget)
            return;

        if (!dirtyOnScreenWidgets) {
            dirtyOnScreenWidgets = new QVector<QWidget *>;
            dirtyOnScreenWidgets->append(widget);
        } else if (!dirtyOnScreenWidgets->contains(widget)) {
            dirtyOnScreenWidgets->append(widget);
        }
    }

beginPaint()

void QWidgetBackingStore::beginPaint ( QRegion &  toClean, QWidget *  widget, QWindowSurface *  windowSurface, BeginPaintInfo *  returnInfo, bool  toCleanIsInTopLevelCoordinates = true  )

private

Prepares the window surface to paint a\ toClean region of the widget and updates the BeginPaintInfo struct accordingly.

The toClean region might be clipped by the window surface.

Definition at line 306 of file qbackingstore.cpp.

Referenced by sync().

{
#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;

#if defined(Q_WS_QWS) && !defined(Q_BACKINGSTORE_SUBSURFACES)
    toClean.translate(tlwOffset);
#endif

#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);
}

bltRect()

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

private

Definition at line 277 of file qbackingstore.cpp.

Referenced by QWidgetPrivate::moveRect(), and QWidgetPrivate::scrollRect().

{
    const QPoint pos(tlwOffset + widget->mapTo(tlw, rect.topLeft()));
    const QRect tlwRect(QRect(pos, rect.size()));
    if (fullUpdatePending || dirty.intersects(tlwRect))
        return false; // We don't want to scroll junk.
    return windowSurface->scroll(tlwRect, dx, dy);
}

dirtyOnScreenWidgetsRemoveAll()

void QWidgetBackingStore::dirtyOnScreenWidgetsRemoveAll ( QWidget *  widget )

inlineprivate

Definition at line 230 of file qbackingstore_p.h.

Referenced by removeDirtyWidget().

    {
        if (!widget || !dirtyOnScreenWidgets)
            return;

        int i = 0;
        while (i < dirtyOnScreenWidgets->size()) {
            if (dirtyOnScreenWidgets->at(i) == widget)
                dirtyOnScreenWidgets->remove(i);
            else
                ++i;
        }
    }

dirtyRegion()

QRegion QWidgetBackingStore::dirtyRegion ( QWidget *  widget = 0 ) const

private

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.

Definition at line 419 of file qbackingstore.cpp.

Referenced by qt_dirtyRegion().

{
    const bool widgetDirty = widget && widget != tlw;
    const QRect tlwRect(topLevelRect());
#if defined(Q_WS_QPA)
    const QRect surfaceGeometry(tlwRect.topLeft(), windowSurface->size());
#else
    const QRect surfaceGeometry(windowSurface->geometry());
#endif
    if (fullUpdatePending || (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;
}

dirtyWidgetsRemoveAll()

void QWidgetBackingStore::dirtyWidgetsRemoveAll ( QWidget *  widget )

inlineprivate

Definition at line 162 of file qbackingstore_p.h.

Referenced by removeDirtyWidget().

    {
        int i = 0;
        while (i < dirtyWidgets.size()) {
            if (dirtyWidgets.at(i) == widget)
                dirtyWidgets.remove(i);
            else
                ++i;
        }
    }

endPaint()

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

private

Definition at line 393 of file qbackingstore.cpp.

Referenced by sync().

{
#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
}

flush()

void QWidgetBackingStore::flush	(	QWidget *	widget = 0,
		QWindowSurface *	surface = 0
	)

Flushes the contents of the backing store into the top-level widget.

If the widget is non-zero, the content is flushed to the widget. If the surface is non-zero, the content of the surface is flushed.

Definition at line 1425 of file qbackingstore.cpp.

Referenced by beginPaint(), endPaint(), and sync().

{
#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
    paintWindowDecoration();
#endif

    if (!dirtyOnScreen.isEmpty()) {
        QWidget *target = widget ? widget : tlw;
        QWindowSurface *source = surface ? surface : windowSurface;
        qt_flush(target, dirtyOnScreen, source, tlw, tlwOffset);
        dirtyOnScreen = QRegion();
    }

    if (!dirtyOnScreenWidgets || dirtyOnScreenWidgets->isEmpty())
        return;

    for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {
        QWidget *w = dirtyOnScreenWidgets->at(i);
        QWidgetPrivate *wd = w->d_func();
        Q_ASSERT(wd->needsFlush);
        qt_flush(w, *wd->needsFlush, windowSurface, tlw, tlwOffset);
        *wd->needsFlush = QRegion();
    }
    dirtyOnScreenWidgets->clear();
}

flushPaint()

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

staticprivate

Definition at line 236 of file qbackingstore.cpp.

Referenced by beginPaint(), QWidgetPrivate::drawWidget(), and QWidgetPrivate::repaint_sys().

{
    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;
}

hasStaticContents()

bool QWidgetBackingStore::hasStaticContents ( ) const

inlineprivate

Definition at line 264 of file qbackingstore_p.h.

Referenced by qt_grab_cursor(), sync(), and QETWidget::translateConfigEvent().

    { return !staticWidgets.isEmpty() && windowSurface->hasFeature(QWindowSurface::StaticContents); }

isDirty()

bool QWidgetBackingStore::isDirty ( ) const

inline

Definition at line 91 of file qbackingstore_p.h.

Referenced by sync().

    {
        return !(dirtyWidgets.isEmpty() && dirty.isEmpty() && !hasDirtyFromPreviousSync
                 && !fullUpdatePending
#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
                 && !hasDirtyWindowDecoration()
#endif
                );
    }

markDirty() [1/2]

void QWidgetBackingStore::markDirty	(	const QRegion &	rgn,
		QWidget *	widget,
		bool	updateImmediately = false,
		bool	invalidateBuffer = false
	)

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).

Definition at line 553 of file qbackingstore.cpp.

Referenced by QETWidget::forceUpdate(), QWidgetPrivate::invalidateBuffer(), QWidgetPrivate::moveRect(), QWidget::repaint(), QWidgetPrivate::scrollRect(), and QWidget::update().

{
    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());
    Q_ASSERT(widget->window() == tlw);
    Q_ASSERT(!rgn.isEmpty());

#ifndef QT_NO_GRAPHICSEFFECT
    widget->d_func()->invalidateGraphicsEffectsRecursively();
#endif //QT_NO_GRAPHICSEFFECT

    if (widget->d_func()->paintOnScreen()) {
        if (widget->d_func()->dirty.isEmpty()) {
            widget->d_func()->dirty = rgn;
            sendUpdateRequest(widget, updateImmediately);
            return;
        } else if (qt_region_strictContains(widget->d_func()->dirty, widget->rect())) {
            if (updateImmediately)
                sendUpdateRequest(widget, updateImmediately);
            return; // Already dirty.
        }

        const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();
        widget->d_func()->dirty += rgn;
        if (!eventAlreadyPosted || updateImmediately)
            sendUpdateRequest(widget, updateImmediately);
        return;
    }

    if (fullUpdatePending) {
        if (updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (!windowSurface->hasFeature(QWindowSurface::PartialUpdates)) {
        fullUpdatePending = true;
        sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    const QPoint offset = widget->mapTo(tlw, QPoint());
    const QRect widgetRect = widget->d_func()->effectiveRectFor(widget->rect());
    if (qt_region_strictContains(dirty, widgetRect.translated(offset))) {
        if (updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return; // Already dirty.
    }

    if (invalidateBuffer) {
        const bool eventAlreadyPosted = !dirty.isEmpty();
#ifndef QT_NO_GRAPHICSEFFECT
        if (widget->d_func()->graphicsEffect)
            dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect()).translated(offset);
        else
#endif //QT_NO_GRAPHICSEFFECT
            dirty += rgn.translated(offset);
        if (!eventAlreadyPosted || updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (dirtyWidgets.isEmpty()) {
        addDirtyWidget(widget, rgn);
        sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (widget->d_func()->inDirtyList) {
        if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect)) {
#ifndef QT_NO_GRAPHICSEFFECT
            if (widget->d_func()->graphicsEffect)
                widget->d_func()->dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect());
            else
#endif //QT_NO_GRAPHICSEFFECT
                widget->d_func()->dirty += rgn;
        }
    } else {
        addDirtyWidget(widget, rgn);
    }

    if (updateImmediately)
        sendUpdateRequest(tlw, updateImmediately);
}

markDirty() [2/2]

void QWidgetBackingStore::markDirty	(	const QRect &	rect,
		QWidget *	widget,
		bool	updateImmediately = false,
		bool	invalidateBuffer = false
	)

This function is equivalent to calling markDirty(QRegion(rect), ...), but is more efficient as it eliminates QRegion operations/allocations and can use the rect more precisely for additional cut-offs.

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

Definition at line 648 of file qbackingstore.cpp.

{
    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());
    Q_ASSERT(widget->window() == tlw);
    Q_ASSERT(!rect.isEmpty());

#ifndef QT_NO_GRAPHICSEFFECT
    widget->d_func()->invalidateGraphicsEffectsRecursively();
#endif //QT_NO_GRAPHICSEFFECT

    if (widget->d_func()->paintOnScreen()) {
        if (widget->d_func()->dirty.isEmpty()) {
            widget->d_func()->dirty = QRegion(rect);
            sendUpdateRequest(widget, updateImmediately);
            return;
        } else if (qt_region_strictContains(widget->d_func()->dirty, rect)) {
            if (updateImmediately)
                sendUpdateRequest(widget, updateImmediately);
            return; // Already dirty.
        }

        const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();
        widget->d_func()->dirty += rect;
        if (!eventAlreadyPosted || updateImmediately)
            sendUpdateRequest(widget, updateImmediately);
        return;
    }

    if (fullUpdatePending) {
        if (updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (!windowSurface->hasFeature(QWindowSurface::PartialUpdates)) {
        fullUpdatePending = true;
        sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    const QRect widgetRect = widget->d_func()->effectiveRectFor(rect);
    const QRect translatedRect(widgetRect.translated(widget->mapTo(tlw, QPoint())));
    if (qt_region_strictContains(dirty, translatedRect)) {
        if (updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return; // Already dirty
    }

    if (invalidateBuffer) {
        const bool eventAlreadyPosted = !dirty.isEmpty();
        dirty += translatedRect;
        if (!eventAlreadyPosted || updateImmediately)
            sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (dirtyWidgets.isEmpty()) {
        addDirtyWidget(widget, rect);
        sendUpdateRequest(tlw, updateImmediately);
        return;
    }

    if (widget->d_func()->inDirtyList) {
        if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect))
            widget->d_func()->dirty += widgetRect;
    } else {
        addDirtyWidget(widget, rect);
    }

    if (updateImmediately)
        sendUpdateRequest(tlw, updateImmediately);
}

markDirtyOnScreen()

void QWidgetBackingStore::markDirtyOnScreen ( const QRegion &  region, QWidget *  widget, const QPoint &  topLevelOffset  )

private

Marks the region of the widget as dirty on screen.

The region will be copied from the backing store to the widget's native parent next time flush() is called.

Paint on screen widgets are ignored.

Definition at line 731 of file qbackingstore.cpp.

Referenced by QWidgetPrivate::drawWidget(), QWidgetPrivate::moveRect(), removeDirtyWidget(), QWidgetPrivate::scrollRect(), and sync().

{
    if (!widget || widget->d_func()->paintOnScreen() || region.isEmpty())
        return;

#if defined(Q_WS_QWS) || defined(Q_WS_MAC)
    if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
        dirtyOnScreen += region.translated(topLevelOffset);
    return;
#endif

    // Top-level.
    if (widget == tlw) {
        if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
            dirtyOnScreen += region;
        return;
    }

    // Alien widgets.
    if (!widget->internalWinId() && !widget->isWindow()) {
        QWidget *nativeParent = widget->nativeParentWidget();        // Alien widgets with the top-level as the native parent (common case).
        if (nativeParent == tlw) {
            if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
                dirtyOnScreen += region.translated(topLevelOffset);
            return;
        }

        // Alien widgets with native parent != tlw.
        QWidgetPrivate *nativeParentPrivate = nativeParent->d_func();
        if (!nativeParentPrivate->needsFlush)
            nativeParentPrivate->needsFlush = new QRegion;
        const QPoint nativeParentOffset = widget->mapTo(nativeParent, QPoint());
        *nativeParentPrivate->needsFlush += region.translated(nativeParentOffset);
        appendDirtyOnScreenWidget(nativeParent);
        return;
    }

    // Native child widgets.
    QWidgetPrivate *widgetPrivate = widget->d_func();
    if (!widgetPrivate->needsFlush)
        widgetPrivate->needsFlush = new QRegion;
    *widgetPrivate->needsFlush += region;
    appendDirtyOnScreenWidget(widget);
}

moveStaticWidgets()

void QWidgetBackingStore::moveStaticWidgets ( QWidget *  reparented )

inlineprivate

Definition at line 188 of file qbackingstore_p.h.

    {
        Q_ASSERT(reparented);
        QWidgetBackingStore *newBs = reparented->d_func()->maybeBackingStore();
        if (newBs == this)
            return;

        int i = 0;
        while (i < staticWidgets.size()) {
            QWidget *w = staticWidgets.at(i);
            if (reparented == w || reparented->isAncestorOf(w)) {
                staticWidgets.removeAt(i);
                if (newBs)
                    newBs->addStaticWidget(w);
            } else {
                ++i;
            }
        }
    }

releaseBuffer()

void QWidgetBackingStore::releaseBuffer ( )

private

Definition at line 286 of file qbackingstore.cpp.

Referenced by isServerProcess().

{
    if (windowSurface)
#if defined(Q_WS_QPA)
        windowSurface->resize(QSize());
#else
        windowSurface->setGeometry(QRect());
#endif
#ifdef Q_BACKINGSTORE_SUBSURFACES
    for (int i = 0; i < subSurfaces.size(); ++i)
        subSurfaces.at(i)->setGeometry(QRect());
#endif
}

removeDirtyWidget()

void QWidgetBackingStore::removeDirtyWidget ( QWidget *  w )

private

Definition at line 776 of file qbackingstore.cpp.

Referenced by QWidget::setParent().

{
    if (!w)
        return;

    dirtyWidgetsRemoveAll(w);
    dirtyOnScreenWidgetsRemoveAll(w);
    resetWidget(w);

    QWidgetPrivate *wd = w->d_func();
    const int n = wd->children.count();
    for (int i = 0; i < n; ++i) {
        if (QWidget *child = qobject_cast<QWidget*>(wd->children.at(i)))
            removeDirtyWidget(child);
    }
}

removeStaticWidget()

void QWidgetBackingStore::removeStaticWidget ( QWidget *  widget )

inlineprivate

Definition at line 183 of file qbackingstore_p.h.

    { staticWidgets.removeAll(widget); }

resetWidget()

void QWidgetBackingStore::resetWidget ( QWidget *  widget )

inlineprivate

Definition at line 244 of file qbackingstore_p.h.

Referenced by removeDirtyWidget(), sync(), and ~QWidgetBackingStore().

    {
        if (widget) {
            widget->d_func()->inDirtyList = false;
            widget->d_func()->isScrolled = false;
            widget->d_func()->isMoved = false;
            widget->d_func()->dirty = QRegion();
        }
    }

showYellowThing()

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

static

Definition at line 158 of file qbackingstore.cpp.

Referenced by flushPaint(), and qt_flush().

{
#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
}

staticContents()

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

private

Returns the static content inside the parent if non-zero; otherwise the static content for the entire backing store is returned.

The content will be clipped to withinClipRect if non-empty.

Definition at line 475 of file qbackingstore.cpp.

Referenced by QWidgetPrivate::invalidateBuffer_resizeHelper(), and sync().

{
    if (!parent && tlw->testAttribute(Qt::WA_StaticContents)) {
#if defined(Q_WS_QPA)
        const QSize surfaceGeometry(windowSurface->size());
#else
        const QRect surfaceGeometry(windowSurface->geometry());
#endif
        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;
}

surface()

QWindowSurface* QWidgetBackingStore::surface ( ) const

inline

Definition at line 89 of file qbackingstore_p.h.

Referenced by beginPaint(), flush(), QWidgetPrivate::moveRect(), QWidgetPrivate::scrollRect(), and showYellowThing().

{ return windowSurface; }

sync() [1/2]

void QWidgetBackingStore::sync	(	QWidget *	exposedWidget,
		const QRegion &	exposedRegion
	)

Synchronizes the exposedRegion of the exposedWidget with the backing store.

If there's nothing to repaint, the area is flushed and painting does not occur; otherwise the area is marked as dirty on screen and will be flushed right after we are done with all painting.

Definition at line 1135 of file qbackingstore.cpp.

{
    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
    if (discardSyncRequest(tlw, tlwExtra) || tlwExtra->inTopLevelResize)
        return;

    if (!exposedWidget || !exposedWidget->internalWinId() || !exposedWidget->isVisible()
        || !exposedWidget->updatesEnabled() || exposedRegion.isEmpty()) {
        return;
    }

    // If there's no preserved contents support we always need
    // to do a full repaint before flushing
    if (!windowSurface->hasFeature(QWindowSurface::PreservedContents))
        fullUpdatePending = true;

    // Nothing to repaint.
    if (!isDirty()) {
        qt_flush(exposedWidget, exposedRegion, windowSurface, tlw, tlwOffset);
        return;
    }

    if (exposedWidget != tlw)
        markDirtyOnScreen(exposedRegion, exposedWidget, exposedWidget->mapTo(tlw, QPoint()));
    else
        markDirtyOnScreen(exposedRegion, exposedWidget, QPoint());
    sync();
}

sync() [2/2]

void QWidgetBackingStore::sync

(

)

Synchronizes the backing store, i.e.

dirty areas are repainted and flushed.

Definition at line 1167 of file qbackingstore.cpp.

Referenced by sync().

{
    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
    if (discardSyncRequest(tlw, tlwExtra)) {
        // If the top-level is minimized, it's not visible on the screen so we can delay the
        // update until it's shown again. In order to do that we must keep the dirty states.
        // These will be cleared when we receive the first expose after showNormal().
        // However, if the widget is not visible (isVisible() returns false), everything will
        // be invalidated once the widget is shown again, so clear all dirty states.
        if (!tlw->isVisible()) {
            dirty = QRegion();
            for (int i = 0; i < dirtyWidgets.size(); ++i)
                resetWidget(dirtyWidgets.at(i));
            dirtyWidgets.clear();
            fullUpdatePending = false;
        }
        return;
    }

    const bool updatesDisabled = !tlw->updatesEnabled();
    bool repaintAllWidgets = false;

    const bool inTopLevelResize = tlwExtra->inTopLevelResize;
    const QRect tlwRect(topLevelRect());
#ifdef  Q_WS_QPA
    const QRect surfaceGeometry(tlwRect.topLeft(), windowSurface->size());
#else
    const QRect surfaceGeometry(windowSurface->geometry());
#endif
    if ((fullUpdatePending || inTopLevelResize || surfaceGeometry.size() != tlwRect.size()) && !updatesDisabled) {
        if (hasStaticContents()) {
            // Repaint existing dirty area and newly visible area.
            const QRect clipRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());
            const QRegion staticRegion(staticContents(0, clipRect));
            QRegion newVisible(0, 0, tlwRect.width(), tlwRect.height());
            newVisible -= staticRegion;
            dirty += newVisible;
            windowSurface->setStaticContents(staticRegion);
        } else {
            // Repaint everything.
            dirty = QRegion(0, 0, tlwRect.width(), tlwRect.height());
            for (int i = 0; i < dirtyWidgets.size(); ++i)
                resetWidget(dirtyWidgets.at(i));
            dirtyWidgets.clear();
            repaintAllWidgets = true;
        }
    }

#ifdef Q_WS_QPA
    if (inTopLevelResize || surfaceGeometry.size() != tlwRect.size())
        windowSurface->resize(tlwRect.size());
#else
    if (inTopLevelResize || surfaceGeometry != tlwRect)
        windowSurface->setGeometry(tlwRect);
#endif

    if (updatesDisabled)
        return;

    if (hasDirtyFromPreviousSync)
        dirty += dirtyFromPreviousSync;

    // Contains everything that needs repaint.
    QRegion toClean(dirty);

    // Loop through all update() widgets and remove them from the list before they are
    // painted (in case someone calls update() in paintEvent). If the widget is opaque
    // and does not have transparent overlapping siblings, append it to the
    // opaqueNonOverlappedWidgets list and paint it directly without composition.
    QVarLengthArray<QWidget *, 32> opaqueNonOverlappedWidgets;
    for (int i = 0; i < dirtyWidgets.size(); ++i) {
        QWidget *w = dirtyWidgets.at(i);
        QWidgetPrivate *wd = w->d_func();
        if (wd->data.in_destructor)
            continue;

        // Clip with mask() and clipRect().
        wd->dirty &= wd->clipRect();
        wd->clipToEffectiveMask(wd->dirty);

        // Subtract opaque siblings and children.
        bool hasDirtySiblingsAbove = false;
        // We know for sure that the widget isn't overlapped if 'isMoved' is true.
        if (!wd->isMoved)
            wd->subtractOpaqueSiblings(wd->dirty, &hasDirtySiblingsAbove);
        // Scrolled and moved widgets must draw all children.
        if (!wd->isScrolled && !wd->isMoved)
            wd->subtractOpaqueChildren(wd->dirty, w->rect());

        if (wd->dirty.isEmpty()) {
            resetWidget(w);
            continue;
        }

        const QRegion widgetDirty(w != tlw ? wd->dirty.translated(w->mapTo(tlw, QPoint()))
                                           : wd->dirty);
        toClean += widgetDirty;

#ifndef QT_NO_GRAPHICSVIEW
        if (tlw->d_func()->extra->proxyWidget) {
            resetWidget(w);
            continue;
        }
#endif

        if (!hasDirtySiblingsAbove && wd->isOpaque && !dirty.intersects(widgetDirty.boundingRect())) {
            opaqueNonOverlappedWidgets.append(w);
        } else {
            resetWidget(w);
            dirty += widgetDirty;
        }
    }
    dirtyWidgets.clear();

    fullUpdatePending = false;

    if (toClean.isEmpty()) {
        // Nothing to repaint. However, we might have newly exposed areas on the
        // screen if this function was called from sync(QWidget *, QRegion)), so
        // we have to make sure those are flushed.
        flush();
        return;
    }

#ifndef QT_NO_GRAPHICSVIEW
    if (tlw->d_func()->extra->proxyWidget) {
        updateStaticContentsSize();
        dirty = QRegion();
        const QVector<QRect> rects(toClean.rects());
        for (int i = 0; i < rects.size(); ++i)
            tlw->d_func()->extra->proxyWidget->update(rects.at(i));
        return;
    }
#endif

#ifndef Q_BACKINGSTORE_SUBSURFACES
    BeginPaintInfo beginPaintInfo;
    beginPaint(toClean, tlw, windowSurface, &beginPaintInfo);
    if (beginPaintInfo.nothingToPaint) {
        for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i)
            resetWidget(opaqueNonOverlappedWidgets[i]);
        dirty = QRegion();
        return;
    }
#endif

    // Must do this before sending any paint events because
    // the size may change in the paint event.
    updateStaticContentsSize();
    const QRegion dirtyCopy(dirty);
    dirty = QRegion();

    // Paint opaque non overlapped widgets.
    for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i) {
        QWidget *w = opaqueNonOverlappedWidgets[i];
        QWidgetPrivate *wd = w->d_func();

        int flags = QWidgetPrivate::DrawRecursive;
        // Scrolled and moved widgets must draw all children.
        if (!wd->isScrolled && !wd->isMoved)
            flags |= QWidgetPrivate::DontDrawOpaqueChildren;
        if (w == tlw)
            flags |= QWidgetPrivate::DrawAsRoot;

        QRegion toBePainted(wd->dirty);
        resetWidget(w);

#ifdef Q_BACKINGSTORE_SUBSURFACES
        QWindowSurface *subSurface = w->windowSurface();
        BeginPaintInfo beginPaintInfo;

        QPoint off = w->mapTo(tlw, QPoint());
        toBePainted.translate(off);
        beginPaint(toBePainted, w, subSurface, &beginPaintInfo, true);
        toBePainted.translate(-off);

        if (beginPaintInfo.nothingToPaint)
            continue;

        if (beginPaintInfo.windowSurfaceRecreated) {
            // Eep the window surface has changed. The old one may have been
            // deleted, in which case we will segfault on the call to
            // painterOffset() below. Use the new window surface instead.
            subSurface = w->windowSurface();
        }

        QPoint offset(tlwOffset);
        if (subSurface == windowSurface)
            offset += w->mapTo(tlw, QPoint());
        else
            offset = static_cast<QWSWindowSurface*>(subSurface)->painterOffset();
        wd->drawWidget(subSurface->paintDevice(), toBePainted, offset, flags, 0, this);

        endPaint(toBePainted, subSurface, &beginPaintInfo);
#else
        QPoint offset(tlwOffset);
        if (w != tlw)
            offset += w->mapTo(tlw, QPoint());
        wd->drawWidget(windowSurface->paintDevice(), toBePainted, offset, flags, 0, this);
#endif
    }

    // Paint the rest with composition.
#ifndef Q_BACKINGSTORE_SUBSURFACES
    if (repaintAllWidgets || !dirtyCopy.isEmpty()) {
        const int flags = QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawRecursive;
        tlw->d_func()->drawWidget(windowSurface->paintDevice(), dirtyCopy, tlwOffset, flags, 0, this);
    }

    endPaint(toClean, windowSurface, &beginPaintInfo);
#else
    if (!repaintAllWidgets && dirtyCopy.isEmpty())
        return; // Nothing more to paint.

    QList<QWindowSurface *> surfaceList(subSurfaces);
    surfaceList.prepend(windowSurface);
    const QRect dirtyBoundingRect(dirtyCopy.boundingRect());

    // Loop through all window surfaces (incl. the top-level surface) and
    // repaint those intersecting with the bounding rect of the dirty region.
    for (int i = 0; i < surfaceList.size(); ++i) {
        QWindowSurface *subSurface = surfaceList.at(i);
        QWidget *w = subSurface->window();
        QWidgetPrivate *wd = w->d_func();

        const QRect clipRect = wd->clipRect().translated(w->mapTo(tlw, QPoint()));
        if (!qRectIntersects(dirtyBoundingRect, clipRect))
            continue;

        toClean = dirtyCopy;
        BeginPaintInfo beginPaintInfo;
        beginPaint(toClean, w, subSurface, &beginPaintInfo);
        if (beginPaintInfo.nothingToPaint)
            continue;

        if (beginPaintInfo.windowSurfaceRecreated) {
            // Eep the window surface has changed. The old one may have been
            // deleted, in which case we will segfault on the call to
            // painterOffset() below. Use the new window surface instead.
            subSurface = w->windowSurface();
        }

        int flags = QWidgetPrivate::DrawRecursive;
        if (w == tlw)
            flags |= QWidgetPrivate::DrawAsRoot;
        const QPoint painterOffset = static_cast<QWSWindowSurface*>(subSurface)->painterOffset();
        wd->drawWidget(subSurface->paintDevice(), toClean, painterOffset, flags, 0, this);

        endPaint(toClean, subSurface, &beginPaintInfo);
    }
#endif
}

topLevelOffset()

QPoint QWidgetBackingStore::topLevelOffset ( ) const

inline

Definition at line 87 of file qbackingstore_p.h.

{ return tlwOffset; }

topLevelRect()

QRect QWidgetBackingStore::topLevelRect ( ) const

inlineprivate

Definition at line 208 of file qbackingstore_p.h.

Referenced by beginPaint(), dirtyRegion(), and sync().

    {
#ifdef Q_WS_QWS
        return tlw->frameGeometry();
#else
        return tlw->data->crect;
#endif
    }

unflushPaint()

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

staticprivate

Definition at line 258 of file qbackingstore.cpp.

Referenced by QWidgetPrivate::drawWidget(), endPaint(), and QWidgetPrivate::repaint_sys().

{
    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);
}

updateLists()

void QWidgetBackingStore::updateLists ( QWidget *  widget )

private

Definition at line 860 of file qbackingstore.cpp.

Referenced by QWidgetBackingStore().

{
    if (!cur)
        return;

    QList<QObject*> children = cur->children();
    for (int i = 0; i < children.size(); ++i) {
        QWidget *child = qobject_cast<QWidget*>(children.at(i));
        if (!child)
            continue;

        updateLists(child);
    }

    if (cur->testAttribute(Qt::WA_StaticContents))
        addStaticWidget(cur);

#ifdef Q_BACKINGSTORE_SUBSURFACES
    QTLWExtra *extra = cur->d_func()->maybeTopData();
    if (extra && extra->windowSurface && cur != tlw)
        subSurfaces.append(extra->windowSurface);
#endif
}

updateStaticContentsSize()

void QWidgetBackingStore::updateStaticContentsSize ( )

inlineprivate

Definition at line 254 of file qbackingstore_p.h.

Referenced by sync().

    {
        for (int i = 0; i < staticWidgets.size(); ++i) {
            QWidgetPrivate *wd = staticWidgets.at(i)->d_func();
            if (!wd->extra)
                wd->createExtra();
            wd->extra->staticContentsSize = wd->data.crect.size();
        }
    }

Friends and Related Functions

QETWidget

friend class QETWidget

friend

Definition at line 271 of file qbackingstore_p.h.

qt_dirtyRegion

QRegion qt_dirtyRegion ( QWidget *  )

friend

Definition at line 1111 of file qwidget.cpp.

{
    if (!widget)
        return QRegion();

    QWidgetBackingStore *bs = qt_widget_private(widget)->maybeBackingStore();
    if (!bs)
        return QRegion();

    return bs->dirtyRegion(widget);
}

QWidget

friend class QWidget

friend

Definition at line 269 of file qbackingstore_p.h.

QWidgetPrivate

friend class QWidgetPrivate

friend

Definition at line 268 of file qbackingstore_p.h.

QWindowSurface

friend class QWindowSurface

friend

Definition at line 272 of file qbackingstore_p.h.

QWSManagerPrivate

friend class QWSManagerPrivate

friend

Definition at line 270 of file qbackingstore_p.h.

Referenced by removeDirtyWidget().

QWSWindowSurface

friend class QWSWindowSurface

friend

Definition at line 273 of file qbackingstore_p.h.

Properties

dirty

QRegion QWidgetBackingStore::dirty

private

Definition at line 110 of file qbackingstore_p.h.

Referenced by bltRect(), dirtyRegion(), QWidgetPrivate::invalidateBuffer_resizeHelper(), markDirty(), QWidgetPrivate::scrollRect(), and sync().

dirtyFromPreviousSync

QRegion QWidgetBackingStore::dirtyFromPreviousSync

private

Definition at line 111 of file qbackingstore_p.h.

Referenced by beginPaint(), and sync().

dirtyOnScreen

QRegion QWidgetBackingStore::dirtyOnScreen

private

Definition at line 109 of file qbackingstore_p.h.

Referenced by beginPaint(), dirtyRegion(), flush(), and markDirtyOnScreen().

dirtyOnScreenWidgets

QVector<QWidget *>* QWidgetBackingStore::dirtyOnScreenWidgets

private

Definition at line 113 of file qbackingstore_p.h.

Referenced by dirtyRegion(), flush(), and ~QWidgetBackingStore().

dirtyWidgets

QVector<QWidget *> QWidgetBackingStore::dirtyWidgets

private

Definition at line 112 of file qbackingstore_p.h.

Referenced by dirtyRegion(), markDirty(), sync(), and ~QWidgetBackingStore().

fullUpdatePending

uint QWidgetBackingStore::fullUpdatePending

private

Definition at line 120 of file qbackingstore_p.h.

Referenced by bltRect(), dirtyRegion(), markDirty(), and sync().

hasDirtyFromPreviousSync

uint QWidgetBackingStore::hasDirtyFromPreviousSync

private

Definition at line 119 of file qbackingstore_p.h.

Referenced by beginPaint(), and sync().

staticWidgets

QList<QWidget *> QWidgetBackingStore::staticWidgets

private

Definition at line 114 of file qbackingstore_p.h.

Referenced by staticContents().

tlw

QWidget* QWidgetBackingStore::tlw

private

Definition at line 108 of file qbackingstore_p.h.

Referenced by beginPaint(), bltRect(), dirtyRegion(), endPaint(), flush(), markDirty(), markDirtyOnScreen(), QWidgetPrivate::moveRect(), QWidgetBackingStore(), removeDirtyWidget(), QWidgetPrivate::scrollRect(), staticContents(), sync(), unflushPaint(), and updateLists().

tlwOffset

QPoint QWidgetBackingStore::tlwOffset

private

Definition at line 122 of file qbackingstore_p.h.

Referenced by beginPaint(), bltRect(), flush(), removeDirtyWidget(), and sync().

windowSurface

QWindowSurface* QWidgetBackingStore::windowSurface

private

Definition at line 115 of file qbackingstore_p.h.

Referenced by beginPaint(), bltRect(), dirtyRegion(), effectiveState(), flush(), isServerProcess(), markDirty(), QWidgetBackingStore(), releaseBuffer(), removeDirtyWidget(), QWidgetPrivate::scrollRect(), QWidget::setWindowSurface(), staticContents(), sync(), unflushPaint(), QWidget::windowSurface(), and ~QWidgetBackingStore().

---

The documentation for this class was generated from the following files:

• /src/gui/painting/qbackingstore_p.h
• /src/gui/painting/qbackingstore.cpp