2003/10/28 10:10:18

[org.ibex.core.git] / src / org / xwt / plat / Win32.cc

diff --git a/src/org/xwt/plat/Win32.cc b/src/org/xwt/plat/Win32.cc
index 37fcb3f..95fe5f7 100644 (file)
--- a/src/org/xwt/plat/Win32.cc
+++ b/src/org/xwt/plat/Win32.cc
@@ -354,25 +354,19 @@ static jint* scratch_bits = NULL;
 static jint scratch_w = 0;
 static jint scratch_h = 0;
 
-#define BLT(dest, dx1, dy1, dx2, dy2, src, sx1, sy1, sx2, sy2, op)                                   \
-    if ((dx2 - dx1 == sx2 - sx1) && (dy2 - dy1 == sy2 - sy1))                                        \
-        BitBlt(dest, dx1, dy1, dx2 - dx1, dy2 - dy1, src, sx1, sy1, op);                             \
-    else                                                                                             \
-        StretchBlt(dest, dx1, dy1, dx2 - dx1, dy2 - dy1, src, sx1, sy1, sx2 - sx1, sy2 - sy1, op);
-        
 void org::xwt::plat::Win32$Win32PixelBuffer::drawPicture(org::xwt::Picture* source0,
-                                                         jint dx1, jint dy1, jint dx2, jint dy2,
-                                                         jint sx1, jint sy1, jint sx2, jint sy2,
+                                                         jint dx, jint dy,
+                                                         jint cx1, jint cy1, jint cx2, jint cy2,
                                                          jint rgb, jboolean alphaOnly) {
     org::xwt::plat::Win32$Win32Picture* source = (org::xwt::plat::Win32$Win32Picture*)source0;
 
     if (source->hasalpha) {
 
-        if (scratch == NULL || scratch_w < dx2 - dx1 || scratch_h < dy2 - dy1) {
+        if (scratch == NULL || scratch_w < cx2 - cx1 || scratch_h < cy2 - cy1) {
             if (scratch_dc != NULL) DeleteDC(scratch_dc);
             if (scratch != NULL) DeleteObject(scratch);
-            scratch_w = max(dx2 - dx1, scratch_w);
-            scratch_h = max(dy2 - dy1, scratch_h);
+            scratch_w = max(cx2 - cx1, scratch_w);
+            scratch_h = max(cy2 - cy1, scratch_h);
 
             BITMAPINFO bitmapinfo;
             memset(&bitmapinfo, 0, sizeof(BITMAPINFO));
@@ -390,37 +384,35 @@ void org::xwt::plat::Win32$Win32PixelBuffer::drawPicture(org::xwt::Picture* sour
         }
 
         // copy from screen to scratch
-        BitBlt((HDC)scratch_dc, 0, 0, dx2 - dx1, dy2 - dy1, (HDC)hdc, dx1, dy1, SRCCOPY);
+        BitBlt((HDC)scratch_dc, 0, 0, cx2 - cx1, cy2 - cy1, (HDC)hdc, cx1, cy1, SRCCOPY);
 
         // apply alpha-blending to scratch
         jint* dat = elements(source->data);
 
-        for(int x = max(clipx1, dx1) - dx1; x < min(clipx2, dx2) - dx1; x++)
-            for(int y = max(clipy1, dy1) - dy1; y < min(clipy2, dy2) - dy1; y++) {
-                int sx = (x * (sx2 - sx1)) / (dx2 - dx1) + sx1;
-                int sy = (y * (sy2 - sy1)) / (dy2 - dy1) + sy1;
-                jint dst = scratch_bits[y * scratch_w + x];
+        for(int x = cx1; x < cx2; x++)
+            for(int y = cy1; y < cy2; y++) {
+                jint dst = scratch_bits[(y - dy) * scratch_w + (x - dx)];
 
                 // FEATURE: see if we can leverage GDI to do something more clever here with alphaOnly
-                jint src = alphaOnly ? rgb : dat[sy * source->getWidth() + sx];
-                jint alpha = (dat[sy * source->getWidth() + sx] & 0xFF000000) >> 24;
+                jint src = alphaOnly ? rgb : dat[(y - dy) * source->getWidth() + x - dx];
+                jint alpha = (dat[(y - dy) * source->getWidth() + x - dx] & 0xFF000000) >> 24;
                 jint r = (((src & 0x00FF0000) >> 16) * alpha + ((dst & 0x00FF0000) >> 16) * (0xFF - alpha)) / 0xFF;
                 jint g = (((src & 0x0000FF00) >> 8)  * alpha + ((dst & 0x0000FF00) >> 8)  * (0xFF - alpha)) / 0xFF;
                 jint b = (((src & 0x000000FF))       * alpha + ((dst & 0x000000FF))       * (0xFF - alpha)) / 0xFF;
-                scratch_bits[y * scratch_w + x] = (r << 16) | (g << 8) | b;
+                scratch_bits[(y - dy) * scratch_w + (x - dx)] = (r << 16) | (g << 8) | b;
             }
 
         // copy back from scratch to screen
-        BitBlt((HDC)hdc, dx1, dy1, dx2 - dx1, dy2 - dy1, (HDC)scratch_dc, 0, 0, SRCCOPY);
+        BitBlt((HDC)hdc, cx1, cy1, cx2, cy2, (HDC)scratch_dc, 0, 0, SRCCOPY);
 
     } else {
 
         // FIXME: support alphaOnly case here
         if (source->hasmask) {
-            BLT((HDC)hdc, dx1, dy1, dx2, dy2, (HDC)source->maskdc, sx1, sy1, sx2, sy2, SRCAND);
-            BLT((HDC)hdc, dx1, dy1, dx2, dy2, (HDC)source->hdc, sx1, sy1, sx2, sy2, SRCPAINT);
+            BitBlt((HDC)hdc, cx1, cy1, cx2, cy2, (HDC)source->maskdc, cx1 - dx, cy1 - dy, SRCAND);
+            BitBlt((HDC)hdc, cx1, cy1, cx2, cy2, (HDC)source->hdc, cx1 - dx, cy1 - dy, SRCPAINT);
         } else {
-            BLT((HDC)hdc, dx1, dy1, dx2, dy2, (HDC)source->hdc, sx1, sy1, sx2, sy2, SRCCOPY);
+            BitBlt((HDC)hdc, cx1, cy1, cx2, cy2, (HDC)source->hdc, cx1 - dx, cy1 - dy, SRCCOPY);
         }
 
     }
@@ -452,13 +444,6 @@ void org::xwt::plat::Win32$Win32PixelBuffer::natInit() {
     SelectObject((HDC)hdc, (HBITMAP)hbitmap);
 }
 
-void org::xwt::plat::Win32$Win32PixelBuffer::setClip(jint x, jint y, jint x2, jint y2) {
-    clipx1 = x; clipx2 = x2; clipy1 = y; clipy2 = y2;
-    HRGN hrgn = CreateRectRgn(x, y, x2, y2);
-    SelectClipRgn((HDC)hdc, hrgn);
-    DeleteObject(hrgn);
-}
-
 void org::xwt::plat::Win32$Win32PixelBuffer::finalize() {
     DeleteObject((void*)hdc);
     DeleteObject((void*)hbitmap);
@@ -552,7 +537,7 @@ void org::xwt::plat::Win32$Win32Surface::setLocation() {
     SetWindowPos((HWND)hwnd, NULL, root->x - (point.x - rect.left), root->y - (point.y - rect.top), 0, 0, SWP_NOZORDER | SWP_NOSIZE);
 }
 
-void org::xwt::plat::Win32$Win32Surface::setSize(jint w, jint h) {
+void org::xwt::plat::Win32$Win32Surface::_setSize(jint w, jint h) {
     RECT client_rect, window_rect;
     GetClientRect((HWND)hwnd, &client_rect);
     GetWindowRect((HWND)hwnd, &window_rect);
@@ -582,7 +567,7 @@ void org::xwt::plat::Win32$Win32Surface::setIcon(org::xwt::Picture* p0) {
     HBITMAP bit = CreateCompatibleBitmap((HDC)hdc, icon_width, icon_height);
     HDC memdc = CreateCompatibleDC((HDC)hdc);
     SelectObject(memdc, bit);
-    BLT((HDC)memdc, 0, 0, icon_width, icon_height, (HDC)(p->hdc), 0, 0, p->getWidth(), p->getHeight(), SRCCOPY);
+    BitBlt((HDC)memdc, 0, 0, icon_width, icon_height, (HDC)(p->hdc), 0, 0, SRCCOPY);
 
     // create the mask
     jint* dat = elements(p->data);