git.oblomov.eu Git - wine/blob - graphics/bitblt.c

   1 /*
   2  * GDI bit-blit operations
   3  *
   4  * Copyright 1993, 1994  Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "gdi.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(bitblt);
  25
  26
  27 /***********************************************************************
  28  *           PatBlt    (GDI.29)
  29  */
  30 BOOL16 WINAPI PatBlt16( HDC16 hdc, INT16 left, INT16 top,
  31                         INT16 width, INT16 height, DWORD rop)
  32 {
  33     return PatBlt( hdc, left, top, width, height, rop );
  34 }
  35
  36
  37 /***********************************************************************
  38  *           PatBlt    (GDI32.@)
  39  */
  40 BOOL WINAPI PatBlt( HDC hdc, INT left, INT top,
  41                         INT width, INT height, DWORD rop)
  42 {
  43     DC * dc = DC_GetDCUpdate( hdc );
  44     BOOL bRet = FALSE;
  45
  46     if (!dc) return FALSE;
  47
  48     if (dc->funcs->pPatBlt)
  49     {
  50         TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
  51         bRet = dc->funcs->pPatBlt( dc->physDev, left, top, width, height, rop );
  52     }
  53     GDI_ReleaseObj( hdc );
  54     return bRet;
  55 }
  56
  57
  58 /***********************************************************************
  59  *           BitBlt    (GDI.34)
  60  */
  61 BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
  62                         INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
  63                         DWORD rop )
  64 {
  65     return BitBlt( hdcDst, xDst, yDst, width, height, hdcSrc, xSrc, ySrc, rop );
  66 }
  67
  68
  69 /***********************************************************************
  70  *           BitBlt    (GDI32.@)
  71  */
  72 BOOL WINAPI BitBlt( HDC hdcDst, INT xDst, INT yDst, INT width,
  73                     INT height, HDC hdcSrc, INT xSrc, INT ySrc, DWORD rop )
  74 {
  75     BOOL ret = FALSE;
  76     DC *dcDst, *dcSrc;
  77
  78     if ((dcSrc = DC_GetDCUpdate( hdcSrc ))) GDI_ReleaseObj( hdcSrc );
  79     /* FIXME: there is a race condition here */
  80     if ((dcDst = DC_GetDCUpdate( hdcDst )))
  81     {
  82         dcSrc = DC_GetDCPtr( hdcSrc );
  83         TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
  84               hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->bitsPerPixel : 0,
  85               hdcDst, xDst, yDst, width, height, dcDst->bitsPerPixel, rop);
  86         if (dcDst->funcs->pBitBlt)
  87             ret = dcDst->funcs->pBitBlt( dcDst->physDev, xDst, yDst, width, height,
  88                                          dcSrc ? dcSrc->physDev : NULL, xSrc, ySrc, rop );
  89         if (dcSrc) GDI_ReleaseObj( hdcSrc );
  90         GDI_ReleaseObj( hdcDst );
  91     }
  92     return ret;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           StretchBlt    (GDI.35)
  98  */
  99 BOOL16 WINAPI StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
 100                             INT16 widthDst, INT16 heightDst,
 101                             HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
 102                             INT16 widthSrc, INT16 heightSrc, DWORD rop )
 103 {
 104     return StretchBlt( hdcDst, xDst, yDst, widthDst, heightDst,
 105                        hdcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
 106 }
 107
 108
 109 /***********************************************************************
 110  *           StretchBlt    (GDI32.@)
 111  */
 112 BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst,
 113                             INT widthDst, INT heightDst,
 114                             HDC hdcSrc, INT xSrc, INT ySrc,
 115                             INT widthSrc, INT heightSrc,
 116                         DWORD rop )
 117 {
 118     BOOL ret = FALSE;
 119     DC *dcDst, *dcSrc;
 120
 121     if ((dcSrc = DC_GetDCUpdate( hdcSrc ))) GDI_ReleaseObj( hdcSrc );
 122     /* FIXME: there is a race condition here */
 123     if ((dcDst = DC_GetDCUpdate( hdcDst )))
 124     {
 125         dcSrc = DC_GetDCPtr( hdcSrc );
 126
 127         TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
 128               hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
 129               dcSrc ? dcSrc->bitsPerPixel : 0, hdcDst, xDst, yDst,
 130               widthDst, heightDst, dcDst->bitsPerPixel, rop );
 131
 132         if (dcSrc) {
 133             if (dcDst->funcs->pStretchBlt)
 134                 ret = dcDst->funcs->pStretchBlt( dcDst->physDev, xDst, yDst, widthDst, heightDst,
 135                                                  dcSrc->physDev, xSrc, ySrc, widthSrc, heightSrc,
 136                                                  rop );
 137             GDI_ReleaseObj( hdcSrc );
 138         }
 139         GDI_ReleaseObj( hdcDst );
 140     }
 141     return ret;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           FastWindowFrame    (GDI.400)
 147  */
 148 BOOL16 WINAPI FastWindowFrame16( HDC16 hdc, const RECT16 *rect,
 149                                INT16 width, INT16 height, DWORD rop )
 150 {
 151     HBRUSH hbrush = SelectObject( hdc, GetStockObject( GRAY_BRUSH ) );
 152     PatBlt( hdc, rect->left, rect->top,
 153               rect->right - rect->left - width, height, rop );
 154     PatBlt( hdc, rect->left, rect->top + height, width,
 155               rect->bottom - rect->top - height, rop );
 156     PatBlt( hdc, rect->left + width, rect->bottom - 1,
 157               rect->right - rect->left - width, -height, rop );
 158     PatBlt( hdc, rect->right - 1, rect->top, -width,
 159               rect->bottom - rect->top - height, rop );
 160     SelectObject( hdc, hbrush );
 161     return TRUE;
 162
 163 }
 164
 165
 166 /***********************************************************************
 167  *           MaskBlt [GDI32.@]
 168  */
 169 BOOL WINAPI MaskBlt(HDC hdcDest, INT nXDest, INT nYDest,
 170                         INT nWidth, INT nHeight, HDC hdcSource,
 171                         INT nXSrc, INT nYSrc, HBITMAP hbmMask,
 172                         INT xMask, INT yMask, DWORD dwRop)
 173 {
 174     FIXME("(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%ld): stub\n",
 175              hdcDest,nXDest,nYDest,nWidth,nHeight,hdcSource,nXSrc,nYSrc,
 176              hbmMask,xMask,yMask,dwRop);
 177     return 1;
 178 }
 179
 180 /*********************************************************************
 181  *      PlgBlt [GDI32.@]
 182  *
 183  */
 184 BOOL WINAPI PlgBlt( HDC hdcDest, const POINT *lpPoint,
 185                         HDC hdcSrc, INT nXDest, INT nYDest, INT nWidth,
 186                         INT nHeight, HBITMAP hbmMask, INT xMask, INT yMask)
 187 {
 188     FIXME("PlgBlt, stub\n");
 189         return 1;
 190 }
 191