Changeset 59 for trunk/src/kernel/qpaintdevice_pm.cpp

Timestamp:

Jan 29, 2006, 8:56:21 PM (20 years ago)

Author:

dmik

Message:

Implemented alpha blending for pixmaps.
Improved blitting of masked pixmaps.

File:

• trunk/src/kernel/qpaintdevice_pm.cpp (modified) (5 diffs)

trunk/src/kernel/qpaintdevice_pm.cpp

@@ -125 +125 @@
 
 // draws the pixmap with a mask using the black source method
-void drawMaskedPixmap(
-    HPS dst_ps, int dst_depth, HPS src_ps, int src_w, int src_h, HPS mask_ps,
-    int dx, int dy, int sx, int sy, int w, int h, Qt::RasterOp rop
-) {
-    // all rectangles for different operations combined together
-    POINTL ptls[] = {
-        { dx, dy }, { dx + w, dy + h },         // 0: src/buf => dst
-        { sx, sy }, { sx + w, sy + h },         // 2: src <=> buf
-        { sx, sy }, { sx + w, sy + h },         // 4: dst => buf
-        { dx, dy }
-    };
+static void drawMaskedPixmap(
+    HPS dst_ps, int dst_depth, bool grab_dest, HPS src_ps, HPS mask_ps,
+    int dx, int dy, int sx, int sy, int w, int h, Qt::RasterOp rop )
+{
     IMAGEBUNDLE oldIb;
 
     if ( !mask_ps ) {
         // self-masked pixmap
+        POINTL ptls[] = { { dx, dy }, { dx + w, dy + h },
+                          { sx, sy } };
         IMAGEBUNDLE newIb;
         GpiQueryAttrs( dst_ps, PRIM_IMAGE, IBB_BACK_MIX_MODE, (PBUNDLE) &oldIb );
@@ -148 +143 @@
     } else {
         bool simple = (rop == Qt::CopyROP) || (rop == Qt::XorROP);
-        // helper hps for dblbuf
-        HPS hpsBuf = qt_alloc_mem_ps( src_w, simple ? src_h : src_h * 2, dst_ps );
-        // helper bitmap for dblbuf
-        BITMAPINFOHEADER2 bmh;
-        memset( &bmh, 0, sizeof(BITMAPINFOHEADER2) );
-        bmh.cbFix = sizeof(BITMAPINFOHEADER2);
-        bmh.cx = src_w;
-        bmh.cy = simple ? src_h : src_h * 2;
-        bmh.cPlanes = 1;
-        bmh.cBitCount = dst_depth;
-        HBITMAP hbmBuf = GpiCreateBitmap( hpsBuf, &bmh, 0, NULL, NULL );
-        GpiSetBitmap( hpsBuf, hbmBuf );
-
+        // origial helper buffer handles 
+        HPS hpsBuf = 0;
+        HBITMAP hbmBuf = 0;
+        // two pointers to the helper buffer 
+        HPS hpsBuf1 = dst_ps;
+        HPS hpsBuf2 = 0;
+        // first helper buffer's coordinates 
+        int buf1_x = dx, buf1_y = dy;
+        // second helper buffer's coordinates 
+        int buf2_x = -1, buf2_y = -1;
+        
+        if ( grab_dest || !simple ) {
+            // create the helper buffer (we need two buffers if grab_dest and
+            // not simple -- double the height in this case)
+            BITMAPINFOHEADER2 bmh;
+            memset( &bmh, 0, sizeof(BITMAPINFOHEADER2) );
+            bmh.cbFix = sizeof(BITMAPINFOHEADER2);
+            bmh.cx = w;
+            bmh.cy = grab_dest && !simple ? h * 2 : h;
+            bmh.cPlanes = 1;
+            bmh.cBitCount = dst_depth;
+            hpsBuf = qt_alloc_mem_ps( bmh.cx, bmh.cy, dst_ps );
+            hbmBuf = GpiCreateBitmap( hpsBuf, &bmh, 0, NULL, NULL );
+            GpiSetBitmap( hpsBuf, hbmBuf );
+            // setup buffer handles and coordinates
+            if ( grab_dest && !simple ) {
+                hpsBuf1 = hpsBuf2 = hpsBuf;
+                buf1_x = buf1_y = 0;
+                buf2_x = 0;
+                buf2_y = h;
+            } else if ( grab_dest ) {
+                hpsBuf1 = hpsBuf;
+                buf1_x = buf1_y = 0;
+            } else { // i.e. !grab_dest && !simple
+                hpsBuf2 = hpsBuf;
+                buf2_x = buf2_y = 0;
+            }
+        }
+
+        // save current destination colors
+        ULONG oldColor = GpiQueryColor( dst_ps );
+        ULONG oldBackColor = GpiQueryBackColor( dst_ps );
+        
         // query the destination color for 1-bpp bitmaps
         GpiQueryAttrs( dst_ps, PRIM_IMAGE, IBB_COLOR, (PBUNDLE) &oldIb );
-        // setup colors for the masking
-        GpiSetColor( hpsBuf, CLR_TRUE );
-        GpiSetBackColor( hpsBuf, CLR_FALSE );
-
-        // grab the destination
-        GpiBitBlt( hpsBuf, dst_ps, 3, &ptls[4], ROP_SRCCOPY, BBO_IGNORE );
+        // setup colors for masking
+        GpiSetColor( hpsBuf1, CLR_TRUE );
+        GpiSetBackColor( hpsBuf1, CLR_FALSE );
+        if ( hpsBuf2 != hpsBuf1 ) {
+            GpiSetColor( hpsBuf2, CLR_TRUE );
+            GpiSetBackColor( hpsBuf2, CLR_FALSE );
+        }
+
+        if ( grab_dest ) {
+            // grab the destination
+            POINTL ptls[] = { { buf1_x, buf1_y }, { buf1_x + w, buf1_y + h },
+                              { dx, dy } };
+            GpiBitBlt( hpsBuf1, dst_ps, 3, ptls, ROP_SRCCOPY, BBO_IGNORE );
+        }
+        
+        // compose a masked pixmap with a given rop into the second buffer
+        if ( !simple ) {
+            // grab the destination to the 2nd buffer
+            POINTL ptDB2[] = { { buf2_x, buf2_y }, { buf2_x + w, buf2_y + h },
+                               { dx, dy } };
+            GpiBitBlt( hpsBuf2, dst_ps, 3, ptDB2, ROP_SRCCOPY, BBO_IGNORE );
+            // bitblt pixmap using rop
+            POINTL ptSB2[] = { { buf2_x, buf2_y }, { buf2_x + w, buf2_y + h },
+                               { sx, sy } };
+            GpiSetColor( hpsBuf2, oldIb.lColor );
+            GpiBitBlt( hpsBuf2, src_ps, 3, ptSB2, qt_ropCodes_2ROP[rop], BBO_IGNORE );
+            // make transparent pixels black
+            GpiSetColor( hpsBuf2, CLR_TRUE );
+            GpiBitBlt( hpsBuf2, mask_ps, 3, ptSB2, ROP_SRCAND, BBO_IGNORE );
+        }
+
         // draw the mask: make non-transparent pixels (corresponding to
         // ones in the mask) black. skip this step when rop = XorROP
         // to get the XOR effect.
-        if ( rop != Qt::XorROP )
-            GpiBitBlt( hpsBuf, mask_ps, 3, &ptls[2], 0x22, BBO_IGNORE );
-
-        // compose a masked pixmap with a given rop into the second buffer
+        if ( rop != Qt::XorROP ) {
+            POINTL ptls[] = { { buf1_x, buf1_y }, { buf1_x + w, buf1_y + h },
+                              { sx, sy } };
+            GpiBitBlt( hpsBuf1, mask_ps, 3, ptls, 0x22, BBO_IGNORE );
+        }
+        
         if ( !simple ) {
-            // grab the destination to the 2nd buffer
-            ptls[4].y += h; ptls[5].y += h;
-            GpiBitBlt( hpsBuf, dst_ps, 3, &ptls[4], ROP_SRCCOPY, BBO_IGNORE );
-            ptls[4].y -= h; ptls[5].y -= h;
-            // bitblt pixmap using rop
-            ptls[2].y += h; ptls[3].y += h;
-            GpiSetColor( hpsBuf, oldIb.lColor );
-            GpiBitBlt( hpsBuf, src_ps, 3, &ptls[2], qt_ropCodes_2ROP[rop], BBO_IGNORE );
-            // make transparent pixels black
-            GpiSetColor( hpsBuf, CLR_TRUE );
-            GpiBitBlt( hpsBuf, mask_ps, 3, &ptls[2], ROP_SRCAND, BBO_IGNORE );
-            // draw masked pixmap from the 2nd buffer to the 1rd
-            ptls[2].y -= h; ptls[3].y -= h;
-            ptls[4].y += h; ptls[5].y += h;
-            GpiBitBlt( hpsBuf, hpsBuf, 3, &ptls[2], ROP_SRCPAINT, BBO_IGNORE );
+            // draw masked pixmap from the 2nd buffer to the 1st
+            POINTL ptB2B1[] = { { buf1_x, buf1_y }, { buf1_x + w, buf1_y + h },
+                                { buf2_x, buf2_y } };
+            GpiBitBlt( hpsBuf1, hpsBuf2, 3, ptB2B1, ROP_SRCPAINT, BBO_IGNORE );
         } else {
             // draw masked pixmap; transparent pixels are zeroed there
             // by prepareForMasking( TRUE )
-            GpiSetColor( hpsBuf, oldIb.lColor );
-            GpiBitBlt( hpsBuf, src_ps, 3, &ptls[2], ROP_SRCINVERT, BBO_IGNORE );
+            POINTL ptls[] = { { buf1_x, buf1_y }, { buf1_x + w, buf1_y + h },
+                              { sx, sy } };
+            GpiSetColor( hpsBuf1, oldIb.lColor );
+            GpiBitBlt( hpsBuf1, src_ps, 3, ptls, ROP_SRCINVERT, BBO_IGNORE );
         }
 
         // flush the buffer
-        GpiBitBlt( dst_ps, hpsBuf, 3, &ptls[0], ROP_SRCCOPY, BBO_IGNORE );
+        if ( hpsBuf1 != dst_ps ) {
+            POINTL ptls[] = { { dx, dy }, { dx + w, dy + h },
+                              { buf1_x, buf1_y } };
+            GpiBitBlt( dst_ps, hpsBuf1, 3, ptls, ROP_SRCCOPY, BBO_IGNORE );
+        }
+        
         // free resources
+        if ( hpsBuf ) {
+            GpiSetBitmap( hpsBuf, 0 );
+            GpiDeleteBitmap( hbmBuf );
+            qt_free_mem_ps( hpsBuf );
+        }
+        
+        // restore current destination colors
+        GpiSetColor( dst_ps, oldColor );
+        GpiSetBackColor( dst_ps, oldBackColor );
+    }
+}
+
+// draws the pixmap with a mask using the black source method
+static void drawAlphaPixmap (
+    HPS dst_ps, int dst_w, HPS src_ps, int src_w, uchar *alpha,
+    int dx, int dy, int sx, int sy, int w, int h, int depth )
+{
+    Q_ASSERT( depth == 32 || depth == 24 );
+
+    bool grab_dest = false;
+    int dst_x = dx;
+    
+    if ( dst_w == 0 ) {
+        grab_dest = true;
+        dst_w = w;
+        dst_x = 0;
+    }
+    
+    int dst_bpl = ((depth * dst_w + 31) / 32) * 4;
+    int src_bpl = ((depth * src_w + 31) / 32) * 4;
+    
+    uchar *dst = new uchar [dst_bpl * h];
+    uchar *src = new uchar [src_bpl * h];
+    
+    BITMAPINFOHEADER2 bmh;
+    memset( &bmh, 0, sizeof(BITMAPINFOHEADER2) );
+    bmh.cbFix = sizeof(BITMAPINFOHEADER2);
+    bmh.cPlanes = 1;
+    bmh.cBitCount = depth;
+    if ( grab_dest ) {
+        bmh.cx = w;
+        bmh.cy = h;
+        
+        // helper hps for dblbuf
+        HPS hpsBuf = qt_alloc_mem_ps( w, h, dst_ps );
+        // helper bitmap for dblbuf
+        HBITMAP hbmBuf = GpiCreateBitmap( hpsBuf, &bmh, 0, NULL, NULL );
+        GpiSetBitmap( hpsBuf, hbmBuf );
+        
+        // grab the destination and get bits
+        POINTL ptls[] = { { 0, 0 }, { w, h }, { dx, dy } };
+        GpiBitBlt ( hpsBuf, dst_ps, 3, ptls, ROP_SRCCOPY, BBO_IGNORE );
+        GpiQueryBitmapBits( hpsBuf, 0, h, (PBYTE) dst, (PBITMAPINFO2) &bmh );
+    
+        // free dblbuf
         GpiSetBitmap( hpsBuf, 0 );
         GpiDeleteBitmap( hbmBuf );
         qt_free_mem_ps( hpsBuf );
-    }
-}
-
-//@@TODO (dmik): later
-//
-//#ifndef Q_OS_TEMP
-//// For alpha blending, we must load the AlphaBlend() function at run time.
-//#if !defined(AC_SRC_ALPHA)
-//#define AC_SRC_ALPHA 0x01
-//#endif
-//typedef BOOL (WINAPI *ALPHABLEND)( HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION );
-//static HINSTANCE msimg32Lib = 0;
-//static ALPHABLEND alphaBlend = 0;
-//static bool loadAlphaBlendFailed = FALSE;
-//static void cleanup_msimg32Lib()
-//{
-//    if ( msimg32Lib != 0 ) {
-//      FreeLibrary( msimg32Lib );
-//      msimg32Lib = 0;
-//      alphaBlend = 0;
-//      loadAlphaBlendFailed = FALSE;
-//    }
-//}
-//#endif
-//
-///*
-//   Try to do an AlphaBlend(). If it fails for some reasons, use BitBlt()
-//   instead. The arguments are like in the BitBlt() call.
-//*/
-//void qt_AlphaBlend( HDC dst_dc, int dx, int dy, int sw, int sh, HDC src_dc, int sx, int sy, DWORD rop )
-//{
-//#ifndef Q_OS_TEMP
-//    BLENDFUNCTION blend = {
-//      AC_SRC_OVER,
-//      0,
-//      255,
-//      AC_SRC_ALPHA
-//    };
-//    if ( alphaBlend ) {
-//      alphaBlend( dst_dc, dx, dy, sw, sh, src_dc, sx, sy, sw, sh, blend );
-//    } else {
-//      if ( !loadAlphaBlendFailed ) {
-//          // try to load msimg32.dll and get the function
-//          // AlphaBlend()
-//          loadAlphaBlendFailed = TRUE;
-//          msimg32Lib = LoadLibraryA( "msimg32" );
-//          if ( msimg32Lib != 0 ) {
-//              qAddPostRoutine( cleanup_msimg32Lib );
-//              alphaBlend = (ALPHABLEND) GetProcAddress( msimg32Lib, "AlphaBlend" );
-//              loadAlphaBlendFailed = ( alphaBlend == 0 );
-//          }
-//      }
-//      if ( loadAlphaBlendFailed )
-//          BitBlt( dst_dc, dx, dy, sw, sh, src_dc, sx, sy, rop );
-//      else
-//          alphaBlend( dst_dc, dx, dy, sw, sh, src_dc, sx, sy, sw, sh, blend );
-//    }
-//#else
-//    BitBlt( dst_dc, dx, dy, sw, sh, src_dc, sx, sy, rop );
-//#endif
-//}
+    } else {
+        // get bits of the destination
+        GpiQueryBitmapBits( dst_ps, dy, h, (PBYTE) dst, (PBITMAPINFO2) &bmh );
+    }
+    
+    // get bits of the source pixmap
+    GpiQueryBitmapBits( src_ps, sy, h, (PBYTE) src, (PBITMAPINFO2) &bmh );
+    
+    uchar px_sz = depth / 8;
+    uchar *dst_ptr = dst + px_sz * dst_x;
+    uchar *src_ptr = src + px_sz * sx;
+    uchar *a_ptr = alpha ? alpha + sx : 0; 
+    int dst_inc = dst_bpl - px_sz * w;
+    int src_inc = src_bpl - px_sz * w;
+    int px_skip = px_sz - 3;
+    
+    // use two separate code paths to increase the speed slightly by
+    // eliminating one comparison op (a_ptr != 0) inside the most nested loop 
+    if ( a_ptr ) {
+        for ( int y = 0; y < h; y++ ) {
+            for ( int x = 0; x < w; x++ ) {
+                uchar a = *(a_ptr++);
+                if ( a == 0 ) {
+                    dst_ptr += px_sz;
+                    src_ptr += px_sz;
+                    continue;
+                } else if ( a == 255 ) {
+                    *(dst_ptr++) = *(src_ptr++);
+                    *(dst_ptr++) = *(src_ptr++);
+                    *(dst_ptr++) = *(src_ptr++);
+                } else {
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                }
+                dst_ptr += px_skip;
+                src_ptr += px_skip;
+            }
+            dst_ptr += dst_inc;
+            src_ptr += src_inc;
+        }
+    } else {
+        for ( int y = 0; y < h; y++ ) {
+            for ( int x = 0; x < w; x++ ) {
+                uchar a = src_ptr [3];
+                if ( a == 0 ) {
+                    dst_ptr += px_sz;
+                    src_ptr += px_sz;
+                    continue;
+                } else if ( a == 255 ) {
+                    *(dst_ptr++) = *(src_ptr++);
+                    *(dst_ptr++) = *(src_ptr++);
+                    *(dst_ptr++) = *(src_ptr++);
+                } else {
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                    *dst_ptr += (*(src_ptr++) - *dst_ptr) * a / 255;
+                    dst_ptr ++;
+                }
+                dst_ptr += px_skip;
+                src_ptr += px_skip;
+            }
+            dst_ptr += dst_inc;
+            src_ptr += src_inc;
+        }
+    }
+    
+    // flush the dst buffer
+    {
+        bmh.cx = dst_w;
+        bmh.cy = h;
+        POINTL ptls[] = { { dx, dy }, { dx + w - 1, dy + h - 1 },
+                          { dst_x, 0 }, { dst_x + w, h } };
+        GpiDrawBits( dst_ps, (PVOID) dst, (PBITMAPINFO2) &bmh, 4, ptls,
+                     ROP_SRCCOPY, BBO_IGNORE );
+    }
+
+    delete[] src;
+    delete[] dst;
+}
 
 void bitBlt( QPaintDevice *dst, int dx, int dy,
@@ -271 +398 @@
              Qt::RasterOp rop, bool ignoreMask  )
 {
-    if ( !src || !dst ) {
+    if ( !src || !dst || sw == 0 || sh == 0 ) {
 #if defined(QT_CHECK_NULL)
         Q_ASSERT( src != 0 );
@@ -288 +415 @@
     int td = dst->devType();                    // to device type
 
-    if ( sw <= 0 ) {                            // special width
-        if ( sw < 0 )
-            sw = src->metric(QPaintDeviceMetrics::PdmWidth) - sx;
-        else
-            return;
-    }
-    if ( sh <= 0 ) {                            // special height
-        if ( sh < 0 )
-            sh = src->metric(QPaintDeviceMetrics::PdmHeight) - sy;
-        else
-            return;
-    }
-
+    int src_w = src->metric(QPaintDeviceMetrics::PdmWidth);
+    int src_h = src->metric(QPaintDeviceMetrics::PdmHeight);
+    int dst_w = dst->metric(QPaintDeviceMetrics::PdmWidth);
+    int dst_h = dst->metric(QPaintDeviceMetrics::PdmHeight);
+    
+    if ( sw < 0 )                               // special width
+        sw = src_w - sx;
+    if ( sh < 0 )                               // special height
+        sh = src_h - sy;
+
+    // ensure coordinates are within borders, clip if necessary
+    if ( sx < 0 || sy < 0 || sx + sw > src_w || sy + sh > src_h ||
+         dx < 0 || dy < 0 || dx + sw > dst_w || dy + sh > dst_h )
+    {
+        int tx = dx - sx;
+        int ty = dy - sy;
+        QRect dr( 0, 0, dst_w, dst_h );  // dst rect
+        QRect sr( tx, ty, src_w, src_h ); // src rect in dst coords
+        QRect bltr( dx, dy, sw, sh ); // blit rect in dst coords
+        bltr &= (dr & sr);
+        if (bltr.isEmpty())
+            return;
+        dx = bltr.x();
+        dy = bltr.y();
+        sx = dx - tx;
+        sy = dy - ty;
+        sw = bltr.width();
+        sh = bltr.height();
+    }
+    
     if ( dst->paintingActive() && dst->isExtDev() ) {
         QPixmap *pm;                            // output to picture/printer
@@ -423 +567 @@
     };
 
-    if ( src_pm && src_pm->data->realAlphaBits ) {
-        qWarning( "::bitBlt() for pixmaps with alpha is not yet implemented on OS/2" );
-//@@TODO (dmik): later
-//      if ( td == QInternal::Pixmap && ((QPixmap *)dst)->data->realAlphaBits )
-//          QPixmap::bitBltAlphaPixmap( ((QPixmap *)dst), dx, dy, src_pm, sx, sy, sw, sh, TRUE );
-//      else
-//          qt_AlphaBlend( dst_dc, dx, dy, sw, sh, src_dc, sx, sy, ropCodes[rop] );
+    if ( td == QInternal::Pixmap ) {
+        // Ensure the auxiliary masked bitmap created for masking is destroyed
+        // (to cause it to be recreated when the destination is blitted next
+        // time). Also ensure the alpha channel of the destination pixmap is
+        // unfolded -- any GPI call will clear the high byte that may be storing
+        // the alpha bits, so the pixmap will appear as fully transparent.
+        QPixmap *dst_pm = (QPixmap *) dst;
+        if ( dst_pm->data->mask )
+            dst_pm->prepareForMasking( FALSE, TRUE );
+        if ( dst_pm->data->hasRealAlpha )
+            dst_pm->unfoldAlphaChannel();
+    }
+
+    if ( src_pm && src_pm->data->hasRealAlpha && !ignoreMask ) {
+        int dst_w = 0; // implies grab_dest = true
+        if ( td == QInternal::Pixmap )
+            dst_w = ((QPixmap *) dst)->data->w; // implies grab_dest = false
+        drawAlphaPixmap( dst_ps, dst_w, src_ps, src_pm->data->w,
+                         src_pm->data->realAlphaBits,
+                         dx, fdy, sx, fsy, sw, sh, QPixmap::trueColorDepth() );
     } else if ( mask ) {
-        if ( /*src_pm &&*/ td==QInternal::Pixmap && ((QPixmap *)dst)->data->realAlphaBits ) {
-            qWarning( "::bitBlt() for pixmaps with alpha is not yet implemented on OS/2" );
-//@@TODO (dmik): later
-//          src_pm->convertToAlphaPixmap();
-//          QPixmap::bitBltAlphaPixmap( (QPixmap *)dst, dx, dy, src_pm, sx, sy, sw, sh, TRUE );
-        } else {
 #if 0
-//@@TODO (dmik): unfortunately, this nice method of setting the mask as a
-//  pattern and using the corresponding ROPs to do masking in one step
-//  will not apways work on many video drivers (including SDD/SNAP) since
-//  they can spontaneously simplify the bitmap set as a pattern (for example,
-//  take only first 8 pixels of the mask width), which will produce wrong
-//  results.
-            const ULONG AllAreaAttrs =
-                ABB_COLOR | ABB_BACK_COLOR |
-                ABB_MIX_MODE | ABB_BACK_MIX_MODE |
-                ABB_SET | ABB_SYMBOL | ABB_REF_POINT;
-            AREABUNDLE oldAb;
-            GpiQueryAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, (PBUNDLE) &oldAb );
-            AREABUNDLE newAb = {
-                CLR_TRUE, CLR_FALSE, FM_OVERPAINT, BM_OVERPAINT,
-                LCID_QTMaskBitmap, 0, ptls [0]
-            };
-            GpiSetBitmap( mask->hps, 0 );
-            GpiSetBitmapId( dst_ps, mask->hbm(), LCID_QTMaskBitmap );
-            GpiSetAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, 0, (PBUNDLE) &newAb );
-            // we use the same rop codes for masked bitblt after setting the
-            // low half of the rop byte to 0xA, which means destination bits
-            // should be preserved where the corresponding bits in the mask
-            // are zeroes.
-            GpiBitBlt( dst_ps, src_ps, 3, ptls, (qt_ropCodes_2ROP[rop] & 0xF0) | 0x0A, BBO_IGNORE );
-            GpiSetAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, 0, (PBUNDLE) &oldAb );
-            GpiDeleteSetId( dst_ps, LCID_QTMaskBitmap );
-            GpiSetBitmap( mask->hps, mask->hbm() );
+        //  Unfortunately, this nice method of setting the mask as a pattern
+        //  and using the corresponding ROPs to do masking in one step will
+        //  not apways work on many video drivers (including SDD/SNAP) since
+        //  they can spontaneously simplify the bitmap set as a pattern (for
+        //  example, take only first 8 pixels of the mask width), which will
+        //  produce wrong results.
+        const ULONG AllAreaAttrs =
+            ABB_COLOR | ABB_BACK_COLOR |
+            ABB_MIX_MODE | ABB_BACK_MIX_MODE |
+            ABB_SET | ABB_SYMBOL | ABB_REF_POINT;
+        AREABUNDLE oldAb;
+        GpiQueryAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, (PBUNDLE) &oldAb );
+        AREABUNDLE newAb = {
+            CLR_TRUE, CLR_FALSE, FM_OVERPAINT, BM_OVERPAINT,
+            LCID_QTMaskBitmap, 0, ptls [0]
+        };
+        GpiSetBitmap( mask->hps, 0 );
+        GpiSetBitmapId( dst_ps, mask->hbm(), LCID_QTMaskBitmap );
+        GpiSetAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, 0, (PBUNDLE) &newAb );
+        // we use the same rop codes for masked bitblt after setting the
+        // low half of the rop byte to 0xA, which means destination bits
+        // should be preserved where the corresponding bits in the mask
+        // are zeroes.
+        GpiBitBlt( dst_ps, src_ps, 3, ptls, (qt_ropCodes_2ROP[rop] & 0xF0) | 0x0A, BBO_IGNORE );
+        GpiSetAttrs( dst_ps, PRIM_AREA, AllAreaAttrs, 0, (PBUNDLE) &oldAb );
+        GpiDeleteSetId( dst_ps, LCID_QTMaskBitmap );
+        GpiSetBitmap( mask->hps, mask->hbm() );
 #else
-            src_pm->prepareForMasking( TRUE );
-            drawMaskedPixmap(
-                dst_ps, dst->metric( QPaintDeviceMetrics::PdmDepth ),
-                src_ps, src_pm->data->w, src_pm->data->h,
-                src_pm->data->selfmask ? 0 : mask->hps,
-                dx, fdy, sx, fsy, sw, sh, rop
-            );
-            src_pm->prepareForMasking( FALSE );
-#endif
-        }
+        bool grab_dest = td != QInternal::Pixmap;
+        src_pm->prepareForMasking( TRUE );
+        drawMaskedPixmap(
+            dst_ps, dst->metric( QPaintDeviceMetrics::PdmDepth ), grab_dest,
+            src_ps, src_pm->data->selfmask ? 0 : mask->hps,
+            dx, fdy, sx, fsy, sw, sh, rop );
+        src_pm->prepareForMasking( FALSE );
+#endif
     } else {
-        if ( td==QInternal::Pixmap && ((QPixmap *)dst)->isQBitmap() ) {
-            GpiBitBlt( dst_ps, src_ps, 3, ptls, qt_ropCodes_2ROP[rop], BBO_IGNORE );
-        } else if ( src_pm && td==QInternal::Pixmap && ((QPixmap *)dst)->data->realAlphaBits ) {
-            qWarning( "::bitBlt() for pixmaps with alpha is not yet implemented on OS/2" );
-//@@TODO (dmik): later
-//          QPixmap *dst_pm = (QPixmap *)dst;
-//          if ( rop == Qt::CopyROP ) {
-//              src_pm->convertToAlphaPixmap();
-//              QPixmap::bitBltAlphaPixmap( dst_pm, dx, dy, src_pm, sx, sy, sw, sh, TRUE );
-//          } else {
-//              src_pm->convertToAlphaPixmap();
-//              if ( dst_pm->mask() ) {
-//                  int width = QMIN( dst_pm->mask()->width()-dx, sw );
-//                  int height = QMIN( dst_pm->mask()->height()-dy, sh );
-//                  MaskBlt( dst_dc, dx, dy, width, height, src_pm->hdc, sx, sy, dst_pm->mask()->hbm(),
-//                          dx, dy, MAKEROP4(0x00aa0000,ropCodes[rop]) );
-//              } else {
-//                  BitBlt( dst_dc, dx, dy, sw, sh, src_pm->hdc, sx, sy, ropCodes[rop] );
-//              }
-//          }
-        } else {
-            GpiBitBlt( dst_ps, src_ps, 3, ptls, qt_ropCodes_2ROP[rop], BBO_IGNORE );
-        }
-    }
+        GpiBitBlt( dst_ps, src_ps, 3, ptls, qt_ropCodes_2ROP[rop], BBO_IGNORE );
+    }
+
     if ( src_tmp )
         WinReleasePS( src_ps );