Changeset 751

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 "qwindowsurface_pm_p.h"
@@ -323 +325 @@
     QPMDiveWindowSurfaceFB(QWidget *widget);
     ~QPMDiveWindowSurfaceFB();
-    void doFlush(const QRect &from, const QPoint &to);
+    void doFlush(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
     {
+
         QRect from;
         QPoint to;
     };
     QList<FlushArgs> pending;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 QPMDiveWindowSurface::QPMDiveWindowSurface(QWidget* widget)
     : QWindowSurface(widget), d(new QPMDiveWindowSurfacePrivate)
 {
+
     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-> = 0;
 
     memset(&d->setup, 0, sizeof(SETUP_BLITTER));
@@ -369 +505 @@
     d->setup.fccDstColorFormat = FOURCC_SCRN;
 
-    window()->addPmEventFilter(this);
-    WinSetVisibleRegionNotify(window()->winId(), TRUE);
+    
+    );
 
     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;
+
+
+
+
 
     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(br, wbr.topLeft());
+}
+
+bool QPMDiveWindowSurface::adjustSetup()
 {
     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;
+
         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;
+        d->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_RECT || rc == RGN_COMPLEX) {
+
+
+
+
             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();
+        ->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 < ; ++i)
+            DEBUG(() << " " << i << ":" << s[i]);
 #endif
     }
 
+
+
+
+
+
+
+
+
+
+
+
     return setupDirty;
 }
 
-void QPMDiveWindowSurface::doFlush(const QRect &from, const QPoint &to)
-{
-    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window()
+void QPMDiveWindowSurface::doFlush(const QRect &from, const QPoint &to)
+{
+    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window()
              << "from" << from << "to" << to);
 
@@ -550 +732 @@
     QPoint dst = to + (src.topLeft() - from.topLeft());
 
-    bool setupDirty = adjustSetup();
+    bool setupDirty = adjustSetup();
 
     // 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(const QRect &from, const QPoint &to)
+{
+    DEBUG(() << "QPMDiveWindowSurfaceFB::doFlush:" << window()
              << "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 (wiHeight)
+        d->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;
+
 };