Changeset 751 for trunk/src

Timestamp:

Jun 15, 2010, 5:00:46 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: OS/2: Exclude children with real HWNDs (a.k.a native widgets) when flushing paint events to make sure they are not painted over by the parent (see #161 for details).

Location:

trunk/src/gui/painting

Files:

• qwindowsurface_pm.cpp (modified) (17 diffs)
• qwindowsurface_pm_p.h (modified) (2 diffs)

trunk/src/gui/painting/qwindowsurface_pm.cpp

@@ -58 +58 @@
 #include <qt_os2.h>
 #include <qlibrary.h>
+#include <qobject.h>
+#include <qevent.h>
 
 #include "qwindowsurface_pm_p.h"
@@ -323 +325 @@
     QPMDiveWindowSurfaceFB(QWidget *widget);
     ~QPMDiveWindowSurfaceFB();
-    void doFlush(const QRect &from, const QPoint &to);
+    void doFlush(QWidget *widget, const QRect &from, const QPoint &to);
 };
 
-struct QPMDiveWindowSurfacePrivate
-{
+struct QPMDiveWindowSurfacePrivate : public QObject, private QWidget::PmEventFilter
+{
+    QPMDiveWindowSurface *that;
+
     QImage *image;
     HDIVE hDive;
@@ -333 +337 @@
     ULONG bufNum;
     bool posDirty;
-    bool vrnDirty;
     bool vrnDisabled;
     bool inDrag;
-    int windowHeight;
     SETUP_BLITTER setup;
-    QVector<RECTL> rcls;
 
     struct FlushArgs
     {
+        QWidget *widget;
         QRect from;
         QPoint to;
     };
     QList<FlushArgs> pending;
+
+    struct WidgetData
+    {
+        QWidget *widget;
+        int widgetHeight;
+        bool vrnDirty;
+        size_t rclCount;
+        QVector<RECTL> rcls;
+    };
+
+    WidgetData data;
+    QMap<HWND, WidgetData> *subWidgets;
+
+    void addWidget(QWidget *widget);
+    void removeWidget(QWidget *widget);
+
+    WidgetData *widgetData(QWidget *widget) {
+        // check for the most common case (no sub-widgets with own HWNDs)
+        if (widget == that->window())
+            return &data;
+        if (!subWidgets || !subWidgets->contains(widget->winId()))
+            return 0;
+        return &(*subWidgets)[widget->winId()];
+    }
+
+    bool eventFilter(QObject *obj, QEvent *event);
+    bool pmEventFilter(QMSG *msg, MRESULT *result);
 };
+
+void QPMDiveWindowSurfacePrivate::addWidget(QWidget *widget)
+{
+    WidgetData *wd = &data;
+    if (widget != that->window()) {
+        // lazily create the sub-widget map (only when really necessary)
+        if (!subWidgets)
+            subWidgets = new QMap<HWND, WidgetData>();
+        wd = &(*subWidgets)[widget->winId()];
+    }
+
+    wd->widget = widget;
+    wd->vrnDirty = true;
+    wd->widgetHeight = 0;
+    wd->rclCount = 0;
+
+    if (widget == that->window()) {
+        // receive visible region change messages (note that we don't do this
+        // for sub-widgets as it causes some strange PM freezes if these widgets
+        // are embedded windows manipulated by other processes)
+        widget->addPmEventFilter(this);
+        WinSetVisibleRegionNotify(widget->winId(), TRUE);
+    } else {
+        // receive reparent/destruction messages from children
+        // to cleanup the map
+        widget->installEventFilter(this);
+    }
+}
+
+void QPMDiveWindowSurfacePrivate::removeWidget(QWidget *widget)
+{
+    if (widget == that->window()) {
+        WinSetVisibleRegionNotify(widget->winId(), FALSE);
+        widget->removePmEventFilter(this);
+    } else {
+        widget->removeEventFilter(this);
+    }
+
+    if (widget != that->window())
+        subWidgets->remove(widget->winId());
+}
+
+bool QPMDiveWindowSurfacePrivate::eventFilter(QObject *obj, QEvent *event)
+{
+    QWidget *widget = qobject_cast<QWidget *>(obj);
+    if (event->type() == QEvent::ParentAboutToChange ||
+        event->type() == QEvent::Destroy) {
+        removeWidget(widget);
+    }
+
+    return false;
+}
+
+bool QPMDiveWindowSurfacePrivate::pmEventFilter(QMSG *msg, MRESULT *result)
+{
+    switch (msg->msg) {
+        case WM_VRNDISABLED: {
+            if (!useFB)
+                DiveSetupBlitter(hDive, NULL);
+            vrnDisabled = true;
+            *result = 0;
+            return true;
+        }
+        case DM_DRAGOVER: {
+            inDrag = true;
+            break;
+        }
+        case DM_DRAGLEAVE:
+        case DM_DROP: {
+            inDrag = false;
+            break;
+        }
+        case WM_VRNENABLED: {
+            vrnDisabled = false;
+            // Note that when an overlapping window of *other* process is moved
+            // over this window, PM still sends WM_VRNENABLED to it but with
+            // ffVisRgnChanged set to FALSE although the visible region *does*
+            // actually change (it doesn't seem to be the case for windows of
+            // the same process). The solution is to ignore this flag and always
+            // assume that the visible region was changed when we get this msg
+#if 0
+            if (LONGFROMMP(msg->mp1)) // window's visible region changed
+#endif
+            {
+                // mark all widgets' visible regions as dirty
+                data.vrnDirty = true;
+                if (subWidgets) {
+                    foreach(HWND hwnd, subWidgets->keys())
+                        (*subWidgets)[hwnd].vrnDirty = true;
+                }
+            }
+            posDirty = true;
+
+            // process pending flush events
+            foreach(const QPMDiveWindowSurfacePrivate::FlushArgs &args, pending)
+                that->doFlush(args.widget, args.from, args.to);
+            pending.clear();
+
+            *result = 0;
+            return true;
+        }
+        default:
+            break;
+    }
+
+    return false;
+}
 
 QPMDiveWindowSurface::QPMDiveWindowSurface(QWidget* widget)
     : QWindowSurface(widget), d(new QPMDiveWindowSurfacePrivate)
 {
+    d->that = this;
     d->image = 0;
     d->hDive = NULLHANDLE;
@@ -356 +493 @@
     d->bufNum = 0;
     d->posDirty = true;
-    d->vrnDirty = true;
     d->vrnDisabled = false;
     d->inDrag = false;
-    d->windowHeight = 0;
+    d->subWidgets = 0;
 
     memset(&d->setup, 0, sizeof(SETUP_BLITTER));
@@ -369 +505 @@
     d->setup.fccDstColorFormat = FOURCC_SCRN;
 
-    window()->addPmEventFilter(this);
-    WinSetVisibleRegionNotify(window()->winId(), TRUE);
+    // add self to the map of participating widgets
+    d->addWidget(window());
 
     setStaticContentsSupport(true);
@@ -377 +513 @@
 QPMDiveWindowSurface::~QPMDiveWindowSurface()
 {
-    WinSetVisibleRegionNotify(window()->winId(), FALSE);
-    window()->removePmEventFilter(this);
+    if (d->subWidgets) {
+        foreach(HWND hwnd, d->subWidgets->keys())
+            d->removeWidget((*d->subWidgets)[hwnd].widget);
+        Q_ASSERT(d->subWidgets->count() == 0);
+        delete d->subWidgets;
+    }
+
+    d->removeWidget(window());
 
     if (d->bufNum)
@@ -400 +542 @@
     if (!d->image || rgn.rectCount() == 0)
         return;
+
+    // make sure the widget is known to us
+    if (!d->widgetData(widget))
+        d->addWidget(widget);
 
     QRect br = rgn.boundingRect();
@@ -465 +611 @@
     if (d->vrnDisabled) {
         // defer the flush
-        QPMDiveWindowSurfacePrivate::FlushArgs args = { br, wbr.topLeft() };
+        QPMDiveWindowSurfacePrivate::FlushArgs args = { widget,
+                                                        br, wbr.topLeft() };
         d->pending.append(args);
         return;
     }
 
-    doFlush(br, wbr.topLeft());
-}
-
-bool QPMDiveWindowSurface::adjustSetup()
+    doFlush(widget, br, wbr.topLeft());
+}
+
+bool QPMDiveWindowSurface::adjustSetup(QWidget *widget)
 {
     HWND hwnd = window()->winId();
@@ -481 +628 @@
     bool setupDirty = false;
 
-    if (d->posDirty || d->vrnDirty) {
+    QPMDiveWindowSurfacePrivate::WidgetData *wd = d->widgetData(widget);
+    Q_ASSERT(wd);
+
+    if (d->posDirty || wd->vrnDirty) {
         setupDirty = true;
         d->posDirty = false;
+        // the main widget moved, adjust the target poition
         POINTL ptl = { 0, 0 };
         WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1);
@@ -494 +645 @@
     }
 
-    if (d->vrnDirty) {
+    bool wasVrnDirty = wd->vrnDirty;
+
+    if (wd->vrnDirty) {
         setupDirty = true;
-        d->vrnDirty = false;
+        wd->vrnDirty = false;
 
         HPS hps = window()->getPS();
         HRGN hrgn = GpiCreateRegion(hps, 0L, NULL);
 
-        RGNRECT rgnCtl;
-        rgnCtl.ircStart = 1;
-        rgnCtl.crc = rgnCtl.crcReturned = 0;
-        rgnCtl.ulDirection = RECTDIR_LFRT_TOPBOT;
-
         ULONG rc = WinQueryVisibleRegion(hwnd, hrgn);
+        if (rc != RGN_ERROR) {
+            HWND hwndWidget = widget->winId();
+            POINTL ptlOffset = { 0, 0 };
+            if (hwnd != hwndWidget) {
+                // translate the main widget's visible region to this widget's
+                // coordinate space
+                WinMapWindowPoints(hwnd, hwndWidget, &ptlOffset, 1);
+                GpiOffsetRegion(hps, hrgn, &ptlOffset);
+            }
+            // substract children from the visible region, if any
+            rc = qt_WinProcessWindowObstacles(hwndWidget, NULL, hrgn,
+                                              CRGN_DIFF, PWO_Children);
+            if (rc != RGN_ERROR && hwnd != hwndWidget) {
+                // translate back to the main widget's coordinate space
+                ptlOffset.x = -ptlOffset.x;
+                ptlOffset.y = -ptlOffset.y;
+                GpiOffsetRegion(hps, hrgn, &ptlOffset);
+            }
+        }
+
         if (rc == RGN_RECT || rc == RGN_COMPLEX) {
+            RGNRECT rgnCtl;
+            rgnCtl.ircStart = 1;
+            rgnCtl.crc = rgnCtl.crcReturned = 0;
+            rgnCtl.ulDirection = RECTDIR_LFRT_TOPBOT;
             if (GpiQueryRegionRects(hps, hrgn, NULL, &rgnCtl, NULL) &&
                 rgnCtl.crcReturned) {
@@ -513 +685 @@
                 rgnCtl.crc = rgnCtl.crcReturned;
                 rgnCtl.ulDirection = RECTDIR_LFRT_TOPBOT;
-                if (d->rcls.size() < (int)rgnCtl.crc)
-                    d->rcls.resize((int)rgnCtl.crc);
-                GpiQueryRegionRects(hps, hrgn, NULL, &rgnCtl, d->rcls.data());
+                if (wd->rcls.size() < (int)rgnCtl.crc)
+                    wd->rcls.resize((int)rgnCtl.crc);
+                wd->rclCount = rgnCtl.crc;
+                GpiQueryRegionRects(hps, hrgn, NULL, &rgnCtl, wd->rcls.data());
             }
-        }
-
-        d->setup.ulNumDstRects = rgnCtl.crcReturned;
-        d->setup.pVisDstRects = rgnCtl.crcReturned ? d->rcls.data() : NULL;
-        d->setup.ulStructLen = sizeof(SETUP_BLITTER);
+        } else if (rc == RGN_NULL) {
+            wd->rclCount = 0;
+        }
 
         GpiDestroyRegion(hps, hrgn);
@@ -528 +699 @@
         // memorize the window height used for the additional visible region
         // validation in doFlush()
-        d->windowHeight = window()->height();
+        wd->widgetHeight = widget->height();
 
 #if defined(QDIVE_DEBUG)
         DEBUG(() << "QPMDiveWindowSurface::adjustSetup:" << "vrnDirty");
-        for (size_t i = 0; i < d->setup.ulNumDstRects; ++i)
-            DEBUG(() << " " << i << ":" << d->setup.pVisDstRects[i]);
+        for (size_t i = 0; i < wd->rclCount; ++i)
+            DEBUG(() << " " << i << ":" << wd->rcls[i]);
 #endif
     }
 
+    // make sure setup points to the correct visible rectangle array (note that
+    // we switch it even vrnDirty is false since the widget may change)
+    if (wasVrnDirty || d->setup.ulNumDstRects != wd->rclCount ||
+        (wd->rclCount && d->setup.pVisDstRects != wd->rcls.data()) ||
+        (!wd->rclCount && d->setup.pVisDstRects != NULL)) {
+        setupDirty = true;
+        d->setup.ulNumDstRects = wd->rclCount;
+        d->setup.pVisDstRects = wd->rclCount ? wd->rcls.data() : NULL;
+        d->setup.ulStructLen = sizeof(SETUP_BLITTER);
+    }
+
     return setupDirty;
 }
 
-void QPMDiveWindowSurface::doFlush(const QRect &from, const QPoint &to)
-{
-    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window()
+void QPMDiveWindowSurface::doFlush(QWidget *widget, const QRect &from, const QPoint &to)
+{
+    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window() << widget
              << "from" << from << "to" << to);
 
@@ -550 +732 @@
     QPoint dst = to + (src.topLeft() - from.topLeft());
 
-    bool setupDirty = adjustSetup();
+    bool setupDirty = adjustSetup(widget);
 
     // note that the source image is expected to be top-left oriented
@@ -578 +760 @@
 
     DiveBlitImage(d->hDive, d->bufNum, DIVE_BUFFER_SCREEN);
-}
-
-bool QPMDiveWindowSurface::pmEventFilter(QMSG *msg, MRESULT *result)
-{
-    switch (msg->msg) {
-        case WM_VRNDISABLED: {
-            if (!d->useFB)
-                DiveSetupBlitter(d->hDive, NULL);
-            d->vrnDisabled = true;
-            *result = 0;
-            return true;
-        }
-        case DM_DRAGOVER: {
-            d->inDrag = true;
-            break;
-        }
-        case DM_DRAGLEAVE:
-        case DM_DROP: {
-            d->inDrag = false;
-            break;
-        }
-        case WM_VRNENABLED: {
-            d->vrnDisabled = false;
-            // Note that when an overlapping window of *other* process is moved
-            // over this window, PM still sends WM_VRNENABLED to it but with
-            // ffVisRgnChanged set to FALSE although the visible region *does*
-            // actually change (it doesn't seem to be the case for windows of
-            // the same process). The solution is to ignore this flag and always
-            // assume that the visible region was changed when we get this msg
-#if 0
-            if (LONGFROMMP(msg->mp1)) // window's visible region changed
-#endif
-                d->vrnDirty = true;
-            d->posDirty = true;
-
-            // process pending flush events
-            foreach(const QPMDiveWindowSurfacePrivate::FlushArgs &args, d->pending)
-                doFlush(args.from, args.to);
-            d->pending.clear();
-
-            *result = 0;
-            return true;
-        }
-        default:
-            break;
-    }
-
-    return false;
 }
 
@@ -934 +1068 @@
 }
 
-void QPMDiveWindowSurfaceFB::doFlush(const QRect &from, const QPoint &to)
-{
-    DEBUG(() << "QPMDiveWindowSurfaceFB::doFlush:" << window()
+void QPMDiveWindowSurfaceFB::doFlush(QWidget *widget, const QRect &from, const QPoint &to)
+{
+    DEBUG(() << "QPMDiveWindowSurfaceFB::doFlush:" << window() << widget
              << "from" << from << "to" << to);
 
@@ -946 +1080 @@
     QPoint dstDelta = from.topLeft() - to;
 
-    const int windowHeight = window()->height();
+    QPMDiveWindowSurfacePrivate::WidgetData *wd = d->widgetData(widget);
+    Q_ASSERT(wd);
+
+    int widgetHeight = widget->height();
 
     // sometimes PM does not send WM_VRNENABLED although the window size has
@@ -952 +1089 @@
     // application) which leads to screen corruption due to outdated visible
     // regions. A fix is to memorize the window height and check it here
-    if (windowHeight != d->windowHeight)
-        d->vrnDirty = true;
+    if (widgetHeight != wd->widgetHeight)
+        wd->vrnDirty = true;
 
     bool wasPosDirty = d->posDirty;
-    bool wasVrnDirty = d->vrnDirty;
-
-    adjustSetup();
+    bool wasVrnDirty = wd->vrnDirty;
+
+    adjustSetup(widget);
+
+    int windowHeight = window()->height();
 
     if (wasVrnDirty) {

trunk/src/gui/painting/qwindowsurface_pm_p.h

@@ -63 +63 @@
 struct QPMDiveWindowSurfacePrivate;
 
-class QPMDiveWindowSurface : public QWindowSurface, private QWidget::PmEventFilter
+class QPMDiveWindowSurface : public QWindowSurface
 {
 public:
@@ -77 +77 @@
 
 protected:
-    bool adjustSetup();
-    virtual void doFlush(const QRect &from, const QPoint &to);
-    bool pmEventFilter(QMSG *msg, MRESULT *result);
+    bool adjustSetup(QWidget *widget);
+    virtual void doFlush(QWidget *widget, const QRect &from, const QPoint &to);
 
     QScopedPointer<QPMDiveWindowSurfacePrivate> d;
+    friend struct QPMDiveWindowSurfacePrivate;
 };