Changeset 100 for trunk/src

Timestamp:

Aug 6, 2009, 2:24:58 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Implemented widget show/hide functions. Added widget mask (clip region) helpers.

Location:

trunk/src

Files:

• corelib/global/qt_os2.h (modified) (1 diff)
• gui/kernel/qapplication_pm.cpp (modified) (3 diffs)
• gui/kernel/qwidget_p.h (modified) (1 diff)
• gui/kernel/qwidget_pm.cpp (modified) (6 diffs)
• gui/kernel/qwindowdefs_pm.h (modified) (1 diff)
• gui/painting/qregion_pm.cpp (modified) (4 diffs)

trunk/src/corelib/global/qt_os2.h

@@ -50 +50 @@
 #include <os2.h>
 
+#if defined(__GNUC__) && defined(__INNOTEK_LIBC__)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Innotek GCC lacks some API functions in its version of OS/2 Toolkit headers
+
+#define QCRGN_ERROR                 0
+#define QCRGN_OK                    1
+#define QCRGN_NO_CLIP_REGION        2
+
+LONG APIENTRY WinQueryClipRegion(HWND hwnd, HRGN hrgnClip);
+BOOL APIENTRY WinSetClipRegion(HWND hwnd, HRGN hrgnClip);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // defined(Q_CC_GNU) && defined(__INNOTEK_LIBC__)
+
 #endif // QT_OS2_H

trunk/src/gui/kernel/qapplication_pm.cpp

@@ -205 +205 @@
  *****************************************************************************/
 
-Q_GUI_EXPORT HPS qt_display_dc()
+Q_GUI_EXPORT HPS qt_display_ps()
 {
     Q_ASSERT(qApp && qApp->thread() == QThread::currentThread());
@@ -424 +424 @@
 MRESULT EXPENTRY QtWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
-    // @todo implement
-    return FALSE;
+    // message handling indicators: if handled is true at the end of message
+    // processing, no default window proc is called but rc is returned.
+    bool handled = false;
+    MRESULT rc = (MRESULT) FALSE;
+    QETWidget *widget = 0;
+    HWND hwndC = NULLHANDLE;
+
+    do {
+        switch(msg) {
+        default:
+            break;
+        }
+        if (handled)
+            return rc;
+    } while(0);
+
+    return WinDefWindowProc(hwnd, msg, mp1, mp2);
 }
 
@@ -432 +447 @@
 MRESULT EXPENTRY QtFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
-    // @todo implement
-    return FALSE;
+    // message handling indicators: if handled is true at the end of message
+    // processing, no default window proc is called but rc is returned.
+    bool handled = false;
+    MRESULT rc = (MRESULT) FALSE;
+    QETWidget *widget = 0;
+    HWND hwndC = NULLHANDLE;
+
+    do {
+        switch(msg) {
+        default:
+            break;
+        }
+        if (handled)
+            return rc;
+    } while(0);
+
+    return QtOldFrameProc(hwnd, msg, mp1, mp2);
 }
 

trunk/src/gui/kernel/qwidget_p.h

@@ -156 +156 @@
 #if defined(Q_WS_PM)
     HWND fId;
+    HSWITCH swEntry;
 #endif
     QRect normalGeometry; // used by showMin/maximized/FullScreen

trunk/src/gui/kernel/qwidget_pm.cpp

@@ -51 +51 @@
 
 #include "private/qapplication_p.h"
+#include "private/qbackingstore_p.h"
 
 #include <qdebug.h>
 
 #define QT_DEBUGWINCREATEDESTROY
+#define QT_DEBUGWIDGETMASK
 
 QT_BEGIN_NAMESPACE
@@ -105 +107 @@
 }
 
+// returns the human readable widget id in the form "name/class".
+// used for debugging.
+static QString widgetName(HWND hwnd)
+{
+    char buf[10];
+    if (WinQueryClassName(hwnd, sizeof(buf), buf)) {
+        if (!strcmp(buf, "#1")) // WC_FRAME
+            hwnd = WinWindowFromID(hwnd, FID_CLIENT);
+        QWidget *w = QWidget::find(hwnd);
+        if (w)
+            return QString().sprintf("%s/%s",
+                                     w->metaObject()->className(),
+                                     w->objectName().toLocal8Bit().constData());
+    }
+    return QLatin1String("<non-Qt-widget>");
+}
+
+/*!
+    \internal
+
+    Extended version of WinQueryClipRegion(). If the given window has a clip
+    region, the given region will receive a copy of the clip region clipped to
+    the current window rectangle. If there is no clip region, the given region
+    will contain only the window rectangle on return.
+ */
+static void qt_WinQueryClipRegionOrRect(HWND hwnd, HRGN hrgn)
+{
+    RECTL rcl;
+    WinQueryWindowRect(hwnd, &rcl);
+
+    HPS hps = qt_display_ps();
+    GpiSetRegion(hps, hrgn, 1, &rcl);
+    if (WinQueryClipRegion(hwnd, 0) != QCRGN_NO_CLIP_REGION) {
+        HRGN hrgnTemp = GpiCreateRegion(hps, 0, NULL);
+        WinQueryClipRegion(hwnd, hrgnTemp);
+        GpiCombineRegion(hps, hrgn, hrgnTemp, hrgn, CRGN_AND);
+        GpiDestroyRegion(hps, hrgnTemp);
+    }
+}
+
+/*!
+    \internal
+
+    Extended version of WinInvalidateRegion(): invalidates the specified region
+    of the given window and regions of children from \a hwndFrom to \a hwndTo
+    if they intersect with the invalid region. If either of child window
+    handles is NULLHANDLE, children are not invalidated at all. Also, HWND_TOP
+    can be used as \a hwndFrom, HWND_BOTTOM \a can be used as \a hwndTo.
+ */
+static BOOL qt_WinInvalidateRegionEx(HWND hwnd, HRGN hrgn,
+                                      HWND hwndFrom, HWND hwndTo)
+{
+#if defined(QT_DEBUGWIDGETMASK)
+    qDebug("qt_WinInvalidateRegionEx: hwnd=%08lX (%s) "
+           "hwndFrom=%08lX hwndTo=%08lX", hwnd,
+           widgetName(hwnd).toLocal8Bit().constData(),
+           hwndFrom, hwndTo);
+#endif
+
+    if (hwndFrom == HWND_TOP)
+        hwndFrom = WinQueryWindow(hwnd, QW_TOP);
+    if (hwndTo == HWND_BOTTOM)
+        hwndTo = WinQueryWindow(hwnd, QW_BOTTOM);
+
+    if (hwndFrom == 0 || hwndTo == 0)
+        return WinInvalidateRegion(hwnd, hrgn, FALSE);
+
+    if (WinQueryWindow(hwndFrom, QW_PARENT) != hwnd ||
+        WinQueryWindow(hwndTo, QW_PARENT) != hwnd)
+        return FALSE;
+
+    HPS hps = qt_display_ps();
+
+    SWP swp;
+    HWND child = hwndFrom;
+    HRGN hrgnChild = GpiCreateRegion(hps, 0, NULL);
+    HRGN hrgnInv = GpiCreateRegion(hps, 0, NULL);
+    GpiCombineRegion(hps, hrgnInv, hrgn, 0, CRGN_COPY);
+
+    LONG cmplx = RGN_RECT;
+
+    while (child) {
+        WinQueryWindowPos(child, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+        qDebug(" child=%08lX [fl=%08lX] (%s)", child, swp.fl,
+               widgetName(child).toLocal8Bit().constData());
+#endif
+        // proceed only if not hidden
+        if (swp.fl & SWP_SHOW) {
+            // get sibling's bounds (clip region or rect)
+            qt_WinQueryClipRegionOrRect(child, hrgnChild);
+            // translate the region to the parent's coordinate system
+            POINTL ptl = { swp.x, swp.y };
+            GpiOffsetRegion(hps, hrgnChild, &ptl);
+            // intersect the child's region with the invalid one
+            // and invalidate if not NULL
+            cmplx = GpiCombineRegion(hps, hrgnChild, hrgnChild, hrgnInv,
+                                      CRGN_AND);
+            if (cmplx != RGN_NULL) {
+                POINTL ptl2 = { -swp.x, -swp.y };
+                GpiOffsetRegion(hps, hrgnChild, &ptl2);
+                WinInvalidateRegion(child, hrgnChild, TRUE);
+                GpiOffsetRegion(hps, hrgnChild, &ptl);
+                // substract the invalidated area from the widget's region
+                // (no need to invalidate it any more)
+                cmplx = GpiCombineRegion(hps, hrgnInv, hrgnInv, hrgnChild,
+                                          CRGN_DIFF);
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug("  processed");
+#endif
+                // finish if nothing left
+                if (cmplx == RGN_NULL)
+                    break;
+            }
+        }
+        // iterate to the next window (below)
+        if (child == hwndTo)
+            break;
+        child = WinQueryWindow(child, QW_NEXT);
+    }
+
+    BOOL ok = (cmplx == RGN_NULL) || (child == hwndTo);
+
+    if (ok) {
+        // invalidate what's left invalid after substracting children
+        WinInvalidateRegion(hwnd, hrgnInv, FALSE);
+    }
+
+    GpiDestroyRegion(hps, hrgnInv);
+    GpiDestroyRegion(hps, hrgnChild);
+
+    return ok;
+}
+
+/** \internal flags for qt_WinProcessWindowObstacles() */
+enum {
+    PWO_Children = 0x01,
+    PWO_Sibings = 0x02,
+    PWO_Ancestors = 0x04,
+    PWO_Screen = 0x08,
+    PWO_TopLevel = 0x80000000,
+    // PWO_Default is suitable in most cases (for simple paint operations)
+    PWO_Default = PWO_Children | PWO_Sibings | PWO_Ancestors | PWO_Screen,
+};
+
+/*!
+    \internal
+
+    Helper function to collect all relative windows intersecting with the
+    given window and placed above it in z-order.
+
+    \param hwnd  window in question
+    \param prcl  rectangle (in window coordinates) to limit processing to
+                 (if null, the whole window rectange is used)
+    \param hrgn  region where to combine all obstacles
+                 (if 0, obstacles are directly validated instead of collecting)
+    \param op    region operation perfomed when combining obstacles (CRGN_*)
+    \param flags flags defining the scope (PWO_* ORed together)
+
+    \return complexity of the combined region (only when \a hrgn is not 0)
+ */
+static LONG qt_WinProcessWindowObstacles(HWND hwnd, PRECTL prcl, HRGN hrgn,
+                                         LONG op, LONG flags = PWO_Default)
+{
+    Q_ASSERT(hwnd);
+
+    HPS displayPS = qt_display_ps();
+
+#if defined(QT_DEBUGWIDGETMASK)
+    qDebug("qt_WinProcessWindowObstacles: hwnd=%08lX (%s), prcl=%p "
+           "hrgn=%08lX, op=%ld flags=%08lX", hwnd,
+           widgetName(hwnd).toLocal8Bit().constData(),
+           prcl, hrgn, op, flags);
+#endif
+
+    SWP swpSelf;
+    WinQueryWindowPos(hwnd, &swpSelf);
+
+    RECTL rclSelf = { 0, 0, swpSelf.cx, swpSelf.cy };
+    if (prcl)
+        rclSelf = *prcl;
+
+    HRGN whrgn = GpiCreateRegion(displayPS, 0, NULL);
+
+    LONG cmplx = RGN_NULL;
+    HWND relative;
+    SWP swp;
+
+    // first, process areas placed outside the screen bounds
+    if (flags & PWO_Screen) {
+        RECTL rclScr = { 0, 0, QApplication::desktop()->width(),
+                               QApplication::desktop()->height() };
+        WinMapWindowPoints(HWND_DESKTOP, hwnd, (PPOINTL) &rclScr, 2);
+        // rough check of whether some window part is outside bounds
+        if (rclSelf.xLeft < rclScr.xLeft ||
+            rclSelf.yBottom < rclScr.yBottom ||
+            rclSelf.xRight > rclScr.xRight ||
+            rclSelf.yTop > rclScr.yTop) {
+            GpiSetRegion(displayPS, whrgn, 1, &rclSelf);
+            HRGN hrgnScr = GpiCreateRegion(displayPS, 1, &rclScr);
+            // substract the screen region from this window's region
+            // to get parts placed outside
+            GpiCombineRegion(displayPS, whrgn, whrgn, hrgnScr, CRGN_DIFF);
+            GpiDestroyRegion(displayPS, hrgnScr);
+            // process the region
+            if (hrgn != NULLHANDLE) {
+                cmplx = GpiCombineRegion(displayPS, hrgn, hrgn, whrgn, op);
+            } else {
+                WinValidateRegion(hwnd, whrgn, FALSE);
+            }
+#if defined(QT_DEBUGWIDGETMASK)
+            qDebug(" collected areas outside screen bounds");
+#endif
+         }
+    }
+
+    // next, go through all children (in z-order)
+    if (flags & PWO_Children) {
+        relative = WinQueryWindow(hwnd, QW_BOTTOM);
+        if (relative != NULLHANDLE) {
+            for (; relative != HWND_TOP; relative = swp.hwndInsertBehind) {
+                WinQueryWindowPos(relative, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug(" child=%08lX [fl=%08lX] (%s)", relative, swp.fl,
+                       widgetName(relative).toLocal8Bit().constData());
+#endif
+                // skip if hidden
+                if (!(swp.fl & SWP_SHOW))
+                    continue;
+                // rough check for intersection
+                if (swp.x >= rclSelf.xRight || swp.y >= rclSelf.yTop ||
+                    swp.x + swp.cx <= rclSelf.xLeft ||
+                    swp.y + swp.cy <= rclSelf.yBottom)
+                    continue;
+                // get the bounds (clip region or rect)
+                qt_WinQueryClipRegionOrRect(relative, whrgn);
+                // translate the region to this window's coordinate system
+                POINTL ptl = { swp.x, swp.y };
+                GpiOffsetRegion(displayPS, whrgn, &ptl);
+                // process the region
+                if (hrgn != NULLHANDLE) {
+                    cmplx = GpiCombineRegion(displayPS, hrgn, hrgn, whrgn, op);
+                } else {
+                    WinValidateRegion(hwnd, whrgn, FALSE);
+                }
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug("  collected");
+#endif
+            }
+        }
+    }
+
+    HWND desktop = WinQueryDesktopWindow(0, 0);
+    HWND parent = WinQueryWindow(hwnd, QW_PARENT);
+
+    // next, go through all siblings placed above (in z-order),
+    // but only if they are not top-level windows (that cannot be
+    // non-rectangular and thus are always correctly clipped by the system)
+    if ((flags & PWO_Sibings) && parent != desktop) {
+        for (relative = swpSelf.hwndInsertBehind;
+              relative != HWND_TOP; relative = swp.hwndInsertBehind) {
+            WinQueryWindowPos(relative, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+            qDebug(" sibling=%08lX [fl=%08lX] (%s)", relative, swp.fl,
+                   widgetName(relative).toLocal8Bit().constData());
+#endif
+            // skip if hidden
+            if (!(swp.fl & SWP_SHOW))
+                continue;
+            // rough check for intersection
+            if (swp.x >= swpSelf.x + rclSelf.xRight ||
+                swp.y >= swpSelf.y + rclSelf.yTop ||
+                swp.x + swp.cx <= swpSelf.x + rclSelf.xLeft ||
+                swp.y + swp.cy <= swpSelf.y + rclSelf.yBottom)
+                continue;
+            // get the bounds (clip region or rect)
+            qt_WinQueryClipRegionOrRect(relative, whrgn);
+            // translate the region to this window's coordinate system
+            POINTL ptl = { swp.x - swpSelf.x, swp.y - swpSelf.y };
+            GpiOffsetRegion(displayPS, whrgn, &ptl);
+            // process the region
+            if (hrgn != NULLHANDLE) {
+                cmplx = GpiCombineRegion(displayPS, hrgn, hrgn, whrgn, op);
+            } else {
+                WinValidateRegion(hwnd, whrgn, FALSE);
+            }
+#if defined(QT_DEBUGWIDGETMASK)
+            qDebug("  collected");
+#endif
+        }
+    }
+
+    // last, go through all siblings of our parent and its ancestors
+    // placed above (in z-order)
+    if (flags & PWO_Ancestors) {
+        POINTL delta = { swpSelf.x, swpSelf.y };
+        while (parent != desktop) {
+            HWND grandParent = WinQueryWindow(parent, QW_PARENT);
+            if (!(flags & PWO_TopLevel)) {
+                // When PWO_TopLevel is not specified, top-level windows
+                // (children of the desktop) are not processed. It makes sense
+                // when qt_WinProcessWindowObstacles() is used to clip out
+                // overlying windows during regular paint operations (WM_PAINT
+                // processing or drawing in a window directly through
+                // WinGetPS()): in this case, top-level windows are always
+                // correctly clipped out by the system (because they cannot be
+                // non-rectangular).
+                if (grandParent == desktop)
+                    break;
+            }
+
+            WinQueryWindowPos(parent, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+            qDebug(" parent=%08lX [fl=%08lX] (%s)", parent, swp.fl,
+                   widgetName(parent).toLocal8Bit().constData());
+#endif
+            delta.x += swp.x;
+            delta.y += swp.y;
+            for (relative = swp.hwndInsertBehind;
+                 relative != HWND_TOP; relative = swp.hwndInsertBehind) {
+                WinQueryWindowPos(relative, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug(" ancestor=%08lX [fl=%08lX] (%s)", relative, swp.fl,
+                       widgetName(parent).toLocal8Bit().constData());
+#endif
+                // skip if hidden
+                if (!(swp.fl & SWP_SHOW))
+                    continue;
+                // rough check for intersection
+                if (swp.x - delta.x >= rclSelf.xRight ||
+                    swp.y - delta.y >= rclSelf.yTop ||
+                    swp.x - delta.x + swp.cx <= rclSelf.xLeft ||
+                    swp.y - delta.y + swp.cy <= rclSelf.yBottom)
+                    continue;
+                // get the bounds (clip region or rect)
+                qt_WinQueryClipRegionOrRect(relative, whrgn);
+                // translate the region to this window's coordinate system
+                POINTL ptl = { swp.x - delta.x, swp.y - delta.y };
+                GpiOffsetRegion(displayPS, whrgn, &ptl);
+                // process the region
+                if (hrgn != NULLHANDLE) {
+                    cmplx = GpiCombineRegion(displayPS, hrgn, hrgn, whrgn, op);
+                } else {
+                    WinValidateRegion(hwnd, whrgn, FALSE);
+                }
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug("  collected");
+#endif
+            }
+            parent = grandParent;
+        }
+    }
+
+    GpiDestroyRegion(displayPS, whrgn);
+
+    return cmplx;
+}
+
+/*!
+    \internal
+
+    Partial reimplementation of the WinSetWindowPos() API that obeys window clip
+    regions. Currently supported flags are SWP_ZORDER, SWP_SHOW, SWP_HIDE and
+    SWP_ACTIVATE. Other flags should not be used. Note that if any other flag is
+    specified (alone or in addition to the supported ones), or if the given
+    window is a top-level window, this function acts exactly like the original
+    WinSetWindowPos() function.
+ */
+static BOOL qt_WinSetWindowPos(HWND hwnd, HWND hwndInsertBehind,
+                               LONG x, LONG y, LONG cx, LONG cy,
+                               ULONG fl)
+{
+#if defined(QT_DEBUGWIDGETMASK)
+    qDebug("qt_WinSetWindowPos: hwnd=%08lX (%s) fl=%08lX", hwnd,
+           widgetName(hwnd).toLocal8Bit().constData(), fl);
+#endif
+
+    HWND desktop = WinQueryDesktopWindow(0, 0);
+
+    Q_ASSERT(((fl & ~(SWP_ZORDER | SWP_SHOW | SWP_HIDE)) == 0) ||
+             hwnd == desktop || WinQueryWindow(hwnd, QW_PARENT) == desktop);
+
+    if ((fl & ~(SWP_ZORDER | SWP_SHOW | SWP_HIDE)) != 0 ||
+         hwnd == desktop || WinQueryWindow(hwnd, QW_PARENT) == desktop) {
+        return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
+    }
+
+    SWP swpOld;
+    WinQueryWindowPos(hwnd, &swpOld);
+
+    // do some checks
+    if ((fl & SWP_ZORDER) && swpOld.hwndInsertBehind == hwndInsertBehind)
+        fl &= ~SWP_ZORDER;
+    if ((fl & SWP_SHOW) && (swpOld.fl & SWP_SHOW))
+        fl &= ~SWP_SHOW;
+    if ((fl & SWP_HIDE) && (swpOld.fl & SWP_HIDE))
+        fl &= ~SWP_HIDE;
+    if ((fl & (SWP_SHOW | SWP_HIDE)) == (SWP_SHOW | SWP_HIDE))
+        fl &= ~SWP_HIDE;
+
+    BOOL rc = WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy,
+                              fl | SWP_NOREDRAW);
+    if (rc == FALSE || (fl & SWP_NOREDRAW))
+        return rc;
+
+    SWP swpNew;
+    WinQueryWindowPos(hwnd, &swpNew);
+
+    if (swpOld.hwndInsertBehind == swpNew.hwndInsertBehind)
+        fl &= ~SWP_ZORDER;
+
+    if ((fl & (SWP_ZORDER | SWP_SHOW | SWP_HIDE)) == 0)
+        return rc;
+
+    HPS hps = qt_display_ps();
+    HWND hwndParent = WinQueryWindow(hwnd, QW_PARENT);
+
+    // get window bounds
+    HRGN hrgnSelf = GpiCreateRegion(hps, 0, NULL);
+    qt_WinQueryClipRegionOrRect(hwnd, hrgnSelf);
+
+    if (fl & SWP_SHOW) {
+        WinInvalidateRegion(hwnd, hrgnSelf, TRUE);
+    } else if (fl & SWP_HIDE) {
+        // translate the region to the parent coordinate system
+        POINTL ptl = { swpNew.x, swpNew.y };
+        GpiOffsetRegion(hps, hrgnSelf, &ptl);
+        // invalidate the parent and children below this window
+        qt_WinInvalidateRegionEx(hwndParent, hrgnSelf,
+                                  WinQueryWindow(hwnd, QW_NEXT), HWND_BOTTOM);
+    } else { // fl & SWP_ZORDER
+        // below we assume that WinSetWindowPos() returns FALSE if
+        // an incorrect (unrelated) hwndInsertBehind is passed when SWP_ZORDER
+        // is set
+
+        // first, detect whether we are moving up or down
+        BOOL up;
+        HWND hwndFrom, hwndTo;
+        if (swpOld.hwndInsertBehind == HWND_TOP) {
+            up = FALSE;
+            hwndFrom = WinQueryWindow(hwndParent, QW_TOP);
+            hwndTo = swpNew.hwndInsertBehind;
+        } else {
+            up = TRUE;
+            for (HWND hwndAbove = hwnd;
+                  (hwndAbove = WinQueryWindow(hwndAbove, QW_PREV)) != 0;) {
+                if (hwndAbove == swpOld.hwndInsertBehind) {
+                    up = FALSE;
+                    break;
+                }
+            }
+            if (up) {
+                hwndFrom = swpOld.hwndInsertBehind;
+                hwndTo = WinQueryWindow(hwnd, QW_NEXT);
+            } else {
+                hwndFrom = WinQueryWindow(swpOld.hwndInsertBehind, QW_NEXT);
+                hwndTo = swpNew.hwndInsertBehind;
+            }
+        }
+#if defined(QT_DEBUGWIDGETMASK)
+        qDebug(" moving up? %ld", up);
+        qDebug(" hwndFrom=%08lX (%s)", hwndFrom,
+               widgetName(hwndFrom).toLocal8Bit().constData());
+        qDebug(" hwndTo=%08lX (%s)", hwndTo,
+               widgetName(hwndTo).toLocal8Bit().constData());
+#endif
+
+        SWP swp;
+        HWND sibling = hwndFrom;
+        HRGN hrgn = GpiCreateRegion(hps, 0, NULL);
+        HRGN hrgnUpd = GpiCreateRegion(hps, 0, NULL);
+
+        if (up) {
+            // go upwards in z-order
+            while (1) {
+                WinQueryWindowPos(sibling, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug(" sibling=%08lX [fl=%08lX] (%s)", sibling, swp.fl,
+                       widgetName(sibling).toLocal8Bit().constData());
+#endif
+                // proceed only if not hidden
+                if (swp.fl & SWP_SHOW) {
+                    // get sibling's bounds (clip region or rect)
+                    qt_WinQueryClipRegionOrRect(sibling, hrgn);
+                    // translate the region to this window's coordinate system
+                    POINTL ptl = { swp.x - swpNew.x, swp.y - swpNew.y };
+                    GpiOffsetRegion(hps, hrgn, &ptl);
+                    // add to the region of siblings we're moving on top of
+                    GpiCombineRegion(hps, hrgnUpd, hrgnUpd, hrgn, CRGN_OR);
+#if defined(QT_DEBUGWIDGETMASK)
+                    qDebug("  processed");
+#endif
+                }
+                // iterate to the prev window (above)
+                if (sibling == hwndTo)
+                    break;
+                sibling = swp.hwndInsertBehind;
+            }
+            // intersect the resulting region with the widget region and
+            // invalidate
+            GpiCombineRegion(hps, hrgnUpd, hrgnSelf, hrgnUpd, CRGN_AND);
+            WinInvalidateRegion(hwnd, hrgnUpd, TRUE);
+        } else {
+            // go downwards in reverse z-order
+            POINTL ptl = { 0, 0 };
+            while (1) {
+                WinQueryWindowPos(sibling, &swp);
+#if defined(QT_DEBUGWIDGETMASK)
+                qDebug(" sibling=%08lX [fl=%08lX] (%s)", sibling, swp.fl,
+                       widgetName(sibling).toLocal8Bit().constData());
+#endif
+                // proceed only if not hidden
+                if (swp.fl & SWP_SHOW) {
+                    // get sibling's bounds (clip region or rect)
+                    qt_WinQueryClipRegionOrRect(sibling, hrgn);
+                    // undo the previous translation and translate this window's
+                    // region to the siblings's coordinate system
+                    ptl.x += swpNew.x - swp.x;
+                    ptl.y += swpNew.y - swp.y;
+                    GpiOffsetRegion(hps, hrgnSelf, &ptl);
+                    // intersect the sibling's region with the translated one
+                    // and invalidate the sibling
+                    GpiCombineRegion(hps, hrgnUpd, hrgnSelf, hrgn, CRGN_AND);
+                    WinInvalidateRegion(sibling, hrgnUpd, TRUE);
+                    // substract the invalidated area from the widget's region
+                    // (no need to invalidate it any more)
+                    GpiCombineRegion(hps, hrgnSelf, hrgnSelf, hrgnUpd, CRGN_DIFF);
+                    // prepare the translation from the sibling's
+                    // coordinates back to this window's coordinates
+                    ptl.x = swp.x - swpNew.x;
+                    ptl.y = swp.y - swpNew.y;
+#if defined(QT_DEBUGWIDGETMASK)
+                    qDebug("  processed");
+#endif
+                }
+                // iterate to the next window (below)
+                if (sibling == hwndTo)
+                    break;
+                sibling = WinQueryWindow(sibling, QW_NEXT);
+            }
+        }
+
+        GpiDestroyRegion(hps, hrgnUpd);
+        GpiDestroyRegion(hps, hrgn);
+    }
+
+    GpiDestroyRegion(hps, hrgnSelf);
+
+    return TRUE;
+}
+
 /*!
  * \internal
@@ -115 +668 @@
 static BOOL qt_WinDestroyWindow(HWND hwnd)
 {
-#if !defined (QT_NO_SESSIONMANAGER)
+#if !defined(QT_NO_SESSIONMANAGER)
     qt_about_to_destroy_wnd = true;
 #endif
     BOOL rc = WinDestroyWindow(hwnd);
-#if !defined (QT_NO_SESSIONMANAGER)
+#if !defined(QT_NO_SESSIONMANAGER)
     qt_about_to_destroy_wnd = false;
 #endif
@@ -321 +874 @@
             QWidget *parent = q->parentWidget();
 
-QWidgetPrivate *ppp;
-ppp->frameWinId();
             if (parent && !(parent->windowType() == Qt::Desktop))
                 ownerw = parent->window()->d_func()->frameWinId();
@@ -682 +1233 @@
 void QWidgetPrivate::hide_sys()
 {
-    // @todo implement
+    Q_Q(QWidget);
+    deactivateWidgetCleanup();
+    Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+    if (q->windowFlags() != Qt::Desktop) {
+        ULONG fl = SWP_HIDE;
+        if (q->isWindow() && frameWinId() != NULLHANDLE) {
+            if (!(q->windowFlags() & Qt::Popup))
+                fl |= SWP_DEACTIVATE;
+        }
+        qt_WinSetWindowPos(frameWinId(), 0, 0, 0, 0, 0, fl);
+        HSWITCH swEntry = maybeTopData() ? maybeTopData()->swEntry : NULLHANDLE;
+        if (swEntry != NULLHANDLE) {
+            SWCNTRL swc;
+            WinQuerySwitchEntry(swEntry, &swc);
+            swc.uchVisibility = SWL_INVISIBLE;
+            WinChangeSwitchEntry(swEntry, &swc);
+        }
+    }
+    if (q->isWindow()) {
+        if (QWidgetBackingStore *bs = maybeBackingStore())
+            bs->releaseBuffer();
+    } else {
+        invalidateBuffer(q->rect());
+    }
+    q->setAttribute(Qt::WA_Mapped, false);
 }
 
 void QWidgetPrivate::show_sys()
 {
-    // @todo implement
+    Q_Q(QWidget);
+#if defined(QT_NON_COMMERCIAL)
+    QT_NC_SHOW_WINDOW
+#endif
+    if (q->testAttribute(Qt::WA_OutsideWSRange))
+        return;
+    q->setAttribute(Qt::WA_Mapped);
+    Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+
+    if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
+        invalidateBuffer(q->rect());
+        return;
+    }
+
+    if (frameWinId() != NULLHANDLE) {
+        ULONG fl = SWP_SHOW;
+        if (q->isWindow()) {
+            if (q->isMinimized()) {
+                fl = SWP_MINIMIZE;
+            } else if (q->isMaximized()) {
+                fl |= SWP_MAXIMIZE;
+            } else {
+                fl |= SWP_RESTORE;
+            }
+
+            if (!(q->testAttribute(Qt::WA_ShowWithoutActivating)
+                  || (q->windowType() == Qt::Popup)
+                  || (q->windowType() == Qt::ToolTip)
+                  || (q->windowType() == Qt::Tool))) {
+                fl |= SWP_ACTIVATE;
+            }
+        }
+
+        qt_WinSetWindowPos(frameWinId(), 0, 0, 0, 0, 0, fl);
+
+        if (q->isWindow()) {
+            if (q->windowType() != Qt::Popup &&
+                q->windowType() != Qt::Tool &&
+                (q->windowType() != Qt::Dialog || !q->parentWidget())
+            ) {
+                HSWITCH &swEntry = topData()->swEntry;
+                if (!swEntry) {
+                    // lazily create a new window list entry
+                    HWND id = frameWinId();
+                    PID pid;
+                    WinQueryWindowProcess(id, &pid, NULL);
+                    SWCNTRL swc;
+                    memset(&swc, 0, sizeof(SWCNTRL));
+                    swc.hwnd = id;
+                    swc.idProcess = pid;
+                    swc.uchVisibility = SWL_VISIBLE;
+                    swc.fbJump = SWL_JUMPABLE;
+                    WinQueryWindowText(id, sizeof(swc.szSwtitle), swc.szSwtitle);
+                    swEntry = WinAddSwitchEntry(&swc);
+                } else {
+                    SWCNTRL swc;
+                    WinQuerySwitchEntry(swEntry, &swc);
+                    swc.uchVisibility = SWL_VISIBLE;
+                    WinChangeSwitchEntry(swEntry, &swc);
+                }
+            }
+
+            ULONG wstyle = WinQueryWindowULong(frameWinId(), QWL_STYLE);
+            if (wstyle & WS_MINIMIZED)
+                data.window_state |= Qt::WindowMinimized;
+            if (wstyle & WS_MAXIMIZED)
+                data.window_state |= Qt::WindowMaximized;
+        }
+    }
+
+    invalidateBuffer(q->rect());
 }
 
@@ -764 +1409 @@
 {
     extra->topextra->fId = NULLHANDLE;
+    extra->topextra->swEntry = NULLHANDLE;
 }
 
 void QWidgetPrivate::deleteTLSysExtra()
 {
+    if (extra->topextra->swEntry != NULLHANDLE)
+        WinRemoveSwitchEntry(extra->topextra->swEntry);
     // Note: extra->topextra->fId is cleaned up in QWidget::destroy()
 }

trunk/src/gui/kernel/qwindowdefs_pm.h

@@ -58 +58 @@
 typedef unsigned long LHANDLE;
 typedef LHANDLE HWND;
+typedef LHANDLE HPS;
 typedef struct _QMSG QMSG;
 typedef void *MRESULT;
 
 typedef HWND WId;
+
+Q_GUI_EXPORT HPS qt_display_ps();
 
 // constants to address extra window data

trunk/src/gui/painting/qregion_pm.cpp

@@ -60 +60 @@
 QRegion::QRegion(const QRect &r, RegionType t)
 {
+    d = new QRegionData;
+    d->ref = 1;
     // @todo implement
 }
@@ -65 +67 @@
 QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
 {
+    d = new QRegionData;
+    d->ref = 1;
     // @todo implement
 }
@@ -76 +80 @@
 QRegion::QRegion(const QBitmap &bm)
 {
+    d = new QRegionData;
+    d->ref = 1;
     // @todo implement
 }
@@ -81 +87 @@
 void QRegion::cleanUp(QRegion::QRegionData *x)
 {
+    delete x;
     // @todo implement
 }