+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: bitmaps.c,v 1.35 2003/08/20 20:45:28 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
+#include <win32k/gdiobj.h>
#include <win32k/bitmaps.h>
//#include <win32k/debug.h>
#include "../eng/handle.h"
+#include <include/inteng.h>
+#include <include/eng.h>
+#include <include/surface.h>
-//#define NDEBUG
+#define NDEBUG
#include <win32k/debug1.h>
-BOOL STDCALL W32kBitBlt(HDC hDCDest,
+//FIXME: where should CLR_INVALID be defined?
+#define CLR_INVALID 0xffffffff
+
+BOOL STDCALL NtGdiBitBlt(HDC hDCDest,
INT XDest,
INT YDest,
INT Width,
INT YSrc,
DWORD ROP)
{
- PDC DCDest = DC_HandleToPtr(hDCDest);
- PDC DCSrc = DC_HandleToPtr(hDCSrc);
+ GDIMULTILOCK Lock[2] = {{hDCDest, 0, GDI_OBJECT_TYPE_DC}, {hDCSrc, 0, GDI_OBJECT_TYPE_DC}};
+ PDC DCDest = NULL;
+ PDC DCSrc = NULL;
PSURFOBJ SurfDest, SurfSrc;
PSURFGDI SurfGDIDest, SurfGDISrc;
RECTL DestRect;
POINTL SourcePoint;
- PBITMAPOBJ DestBitmapObj;
- PBITMAPOBJ SrcBitmapObj;
- BOOL Status, SurfDestAlloc, SurfSrcAlloc;
+ //PBITMAPOBJ DestBitmapObj;
+ //PBITMAPOBJ SrcBitmapObj;
+ BOOL Status, SurfDestAlloc, SurfSrcAlloc, XlateAlloc;
PPALOBJ DCLogPal;
PPALGDI PalDestGDI, PalSourceGDI;
PXLATEOBJ XlateObj = NULL;
HPALETTE SourcePalette, DestPalette;
+ if ( !GDIOBJ_LockMultipleObj(Lock, sizeof(Lock)/sizeof(Lock[0])) )
+ {
+ DPRINT1("GDIOBJ_LockMultipleObj() failed\n" );
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ DCDest = Lock[0].pObj;
+ DCSrc = Lock[1].pObj;
+
+ if ( !DCDest || !DCSrc )
+ return STATUS_INVALID_PARAMETER;
+
+ /* Offset the destination and source by the origin of their DCs. */
+ XDest += DCDest->w.DCOrgX;
+ YDest += DCDest->w.DCOrgY;
+ XSrc += DCSrc->w.DCOrgX;
+ YSrc += DCSrc->w.DCOrgY;
+
DestRect.left = XDest;
DestRect.top = YDest;
DestRect.right = XDest+Width;
SurfDestAlloc = FALSE;
SurfSrcAlloc = FALSE;
+ XlateAlloc = FALSE;
// Determine surfaces to be used in the bitblt
- SurfDest = (PSURFOBJ)AccessUserObject(DCDest->Surface);
- SurfSrc = (PSURFOBJ)AccessUserObject(DCSrc->Surface);
+ SurfDest = (PSURFOBJ)AccessUserObject((ULONG)DCDest->Surface);
+ SurfSrc = (PSURFOBJ)AccessUserObject((ULONG)DCSrc->Surface);
SurfGDIDest = (PSURFGDI)AccessInternalObjectFromUserObject(SurfDest);
SurfGDISrc = (PSURFGDI)AccessInternalObjectFromUserObject(SurfSrc);
// Retrieve the logical palette of the destination DC
- DCLogPal = (PPALOBJ)AccessUserObject(DCDest->w.hPalette);
+ DCLogPal = (PPALOBJ)AccessUserObject((ULONG)DCDest->w.hPalette);
if(DCLogPal)
if(DCLogPal->logicalToSystem)
if((BitsPerFormat(SurfDest->iBitmapFormat) != BitsPerFormat(SurfSrc->iBitmapFormat)) && (XlateObj == NULL))
{
if(DCDest->w.hPalette != 0)
- {
DestPalette = DCDest->w.hPalette;
- } else
- DestPalette = W32kGetStockObject(DEFAULT_PALETTE);
+ else
+ DestPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
if(DCSrc->w.hPalette != 0)
- {
SourcePalette = DCSrc->w.hPalette;
- } else
- SourcePalette = W32kGetStockObject(DEFAULT_PALETTE);
+ else
+ SourcePalette = NtGdiGetStockObject(DEFAULT_PALETTE);
- PalDestGDI = (PPALGDI)AccessInternalObject(DestPalette);
- PalSourceGDI = (PPALGDI)AccessInternalObject(SourcePalette);
+ PalDestGDI = (PPALGDI)AccessInternalObject((ULONG)DestPalette);
+ PalSourceGDI = (PPALGDI)AccessInternalObject((ULONG)SourcePalette);
- XlateObj = (PXLATEOBJ)EngCreateXlate(PalDestGDI->Mode, PalSourceGDI->Mode, DestPalette, SourcePalette);
+ XlateObj = (PXLATEOBJ)IntEngCreateXlate(PalDestGDI->Mode, PalSourceGDI->Mode, DestPalette, SourcePalette);
+ XlateAlloc = TRUE;
}
// Perform the bitblt operation
- Status = EngBitBlt(SurfDest, SurfSrc, NULL, NULL, XlateObj, &DestRect, &SourcePoint, NULL, NULL, NULL, NULL);
+ Status = IntEngBitBlt(SurfDest, SurfSrc, NULL, DCDest->CombinedClip, XlateObj, &DestRect, &SourcePoint, NULL, NULL, NULL, ROP);
- if(SurfDestAlloc == TRUE) ExFreePool(SurfDest);
- if(SurfSrcAlloc == TRUE) ExFreePool(SurfSrc);
+ if (XlateAlloc) EngDeleteXlate(XlateObj);
+ if (SurfDestAlloc) ExFreePool(SurfDest);
+ if (SurfSrcAlloc) ExFreePool(SurfSrc);
- DC_ReleasePtr(hDCDest);
- DC_ReleasePtr(hDCSrc);
+ GDIOBJ_UnlockMultipleObj(Lock, sizeof(Lock)/sizeof(Lock[0]));
return Status;
}
-HBITMAP STDCALL W32kCreateBitmap(INT Width,
+HBITMAP STDCALL NtGdiCreateBitmap(INT Width,
INT Height,
UINT Planes,
UINT BitsPerPel,
hBitmap = BITMAPOBJ_AllocBitmap ();
if (!hBitmap)
{
- DPRINT("W32kCreateBitmap: BITMAPOBJ_AllocBitmap returned 0\n");
+ DPRINT("NtGdiCreateBitmap: BITMAPOBJ_AllocBitmap returned 0\n");
return 0;
}
- bmp = BITMAPOBJ_HandleToPtr( hBitmap );
+ bmp = BITMAPOBJ_LockBitmap( hBitmap );
- DPRINT("W32kCreateBitmap:%dx%d, %d (%d BPP) colors returning %08x\n", Width, Height,
+ DPRINT("NtGdiCreateBitmap:%dx%d, %d (%d BPP) colors returning %08x\n", Width, Height,
1 << (Planes * BitsPerPel), BitsPerPel, bmp);
bmp->size.cx = Width;
if (Bits) /* Set bitmap bits */
{
- W32kSetBitmapBits(hBitmap, Height * bmp->bitmap.bmWidthBytes, Bits);
+ NtGdiSetBitmapBits(hBitmap, Height * bmp->bitmap.bmWidthBytes, Bits);
}
- BITMAPOBJ_ReleasePtr( hBitmap );
+ BITMAPOBJ_UnlockBitmap( hBitmap );
return hBitmap;
}
-BOOL Bitmap_InternalDelete( PBITMAPOBJ pBmp )
+BOOL FASTCALL Bitmap_InternalDelete( PBITMAPOBJ pBmp )
{
- ASSERT( pBmp );
- ExFreePool(pBmp->bitmap.bmBits);
- return TRUE;
+ ASSERT( pBmp );
+
+ if (NULL != pBmp->bitmap.bmBits)
+ {
+ if (NULL != pBmp->dib)
+ {
+ if (NULL == pBmp->dib->dshSection)
+ {
+ EngFreeUserMem(pBmp->bitmap.bmBits);
+ }
+ else
+ {
+ /* This is a file-mapped section */
+ UNIMPLEMENTED;
+ }
+ }
+ else
+ {
+ ExFreePool(pBmp->bitmap.bmBits);
+ }
+ }
+
+ return TRUE;
}
-HBITMAP STDCALL W32kCreateCompatibleBitmap(HDC hDC,
+HBITMAP STDCALL NtGdiCreateCompatibleBitmap(HDC hDC,
INT Width,
INT Height)
{
PDC dc;
hbmpRet = 0;
- dc = DC_HandleToPtr (hDC);
+ dc = DC_LockDc(hDC);
- DbgPrint("W32kCreateCompatibleBitmap(%04x,%d,%d, bpp:%d) = \n", hDC, Width, Height, dc->w.bitsPerPixel);
+ DPRINT("NtGdiCreateCompatibleBitmap(%04x,%d,%d, bpp:%d) = \n", hDC, Width, Height, dc->w.bitsPerPixel);
if (!dc)
{
/* MS doc says if width or height is 0, return 1-by-1 pixel, monochrome bitmap */
if (!Width || !Height)
{
- hbmpRet = W32kCreateBitmap (1, 1, 1, 1, NULL);
+ hbmpRet = NtGdiCreateBitmap (1, 1, 1, 1, NULL);
}
else
{
- hbmpRet = W32kCreateBitmap(Width, Height, 1, dc->w.bitsPerPixel, NULL);
+ hbmpRet = NtGdiCreateBitmap(Width, Height, 1, dc->w.bitsPerPixel, NULL);
}
}
DPRINT ("\t\t%04x\n", hbmpRet);
- DC_ReleasePtr( hDC );
+ DC_UnlockDc( hDC );
return hbmpRet;
}
-HBITMAP STDCALL W32kCreateBitmapIndirect(CONST BITMAP *BM)
+HBITMAP STDCALL NtGdiCreateBitmapIndirect(CONST BITMAP *BM)
{
- return W32kCreateBitmap (BM->bmWidth,
+ return NtGdiCreateBitmap (BM->bmWidth,
BM->bmHeight,
BM->bmPlanes,
BM->bmBitsPixel,
BM->bmBits);
}
-HBITMAP STDCALL W32kCreateDiscardableBitmap(HDC hDC,
+HBITMAP STDCALL NtGdiCreateDiscardableBitmap(HDC hDC,
INT Width,
INT Height)
{
/* FIXME: this probably should do something else */
- return W32kCreateCompatibleBitmap(hDC, Width, Height);
+ return NtGdiCreateCompatibleBitmap(hDC, Width, Height);
}
-BOOL STDCALL W32kExtFloodFill(HDC hDC,
+BOOL STDCALL NtGdiExtFloodFill(HDC hDC,
INT XStart,
INT YStart,
COLORREF Color,
UNIMPLEMENTED;
}
-BOOL STDCALL W32kFloodFill(HDC hDC,
+BOOL STDCALL NtGdiFloodFill(HDC hDC,
INT XStart,
INT YStart,
COLORREF Fill)
UNIMPLEMENTED;
}
-BOOL STDCALL W32kGetBitmapDimensionEx(HBITMAP hBitmap,
+BOOL STDCALL NtGdiGetBitmapDimensionEx(HBITMAP hBitmap,
LPSIZE Dimension)
{
PBITMAPOBJ bmp;
- bmp = BITMAPOBJ_HandleToPtr (hBitmap);
+ bmp = BITMAPOBJ_LockBitmap(hBitmap);
if (bmp == NULL)
{
return FALSE;
*Dimension = bmp->size;
+ BITMAPOBJ_UnlockBitmap(hBitmap);
+
return TRUE;
}
-COLORREF STDCALL W32kGetPixel(HDC hDC,
+COLORREF STDCALL NtGdiGetPixel(HDC hDC,
INT XPos,
INT YPos)
{
- UNIMPLEMENTED;
+ PDC dc = NULL;
+ COLORREF cr = (COLORREF) 0;
+
+ dc = DC_LockDc (hDC);
+ if (NULL == dc)
+ {
+ return (COLORREF) CLR_INVALID;
+ }
+ //FIXME: get actual pixel RGB value
+ DC_UnlockDc (hDC);
+ return cr;
}
-BOOL STDCALL W32kMaskBlt(HDC hDCDest,
+BOOL STDCALL NtGdiMaskBlt(HDC hDCDest,
INT XDest,
INT YDest,
INT Width,
UNIMPLEMENTED;
}
-BOOL STDCALL W32kPlgBlt(HDC hDCDest,
+BOOL STDCALL NtGdiPlgBlt(HDC hDCDest,
CONST POINT *Point,
HDC hDCSrc,
INT XSrc,
UNIMPLEMENTED;
}
-LONG STDCALL W32kSetBitmapBits(HBITMAP hBitmap,
+LONG STDCALL NtGdiSetBitmapBits(HBITMAP hBitmap,
DWORD Bytes,
CONST VOID *Bits)
{
- DWORD height, ret;
- PBITMAPOBJ bmp;
+ LONG height, ret;
+ PBITMAPOBJ bmp;
- bmp = BITMAPOBJ_HandleToPtr (hBitmap);
+ bmp = BITMAPOBJ_LockBitmap(hBitmap);
if (bmp == NULL || Bits == NULL)
{
return 0;
return ret;
}
-BOOL STDCALL W32kSetBitmapDimensionEx(HBITMAP hBitmap,
+BOOL STDCALL NtGdiSetBitmapDimensionEx(HBITMAP hBitmap,
INT Width,
INT Height,
LPSIZE Size)
{
PBITMAPOBJ bmp;
- bmp = BITMAPOBJ_HandleToPtr (hBitmap);
+ bmp = BITMAPOBJ_LockBitmap(hBitmap);
if (bmp == NULL)
{
return FALSE;
bmp->size.cx = Width;
bmp->size.cy = Height;
+ BITMAPOBJ_UnlockBitmap (hBitmap);
+
return TRUE;
}
-COLORREF STDCALL W32kSetPixel(HDC hDC,
+COLORREF STDCALL NtGdiSetPixel(HDC hDC,
INT X,
INT Y,
COLORREF Color)
{
- UNIMPLEMENTED;
+ if(NtGdiSetPixelV(hDC,X,Y,Color))
+ {
+ COLORREF cr = NtGdiGetPixel(hDC,X,Y);
+ if(CLR_INVALID != cr) return(cr);
+ }
+ return ((COLORREF) -1);
}
-BOOL STDCALL W32kSetPixelV(HDC hDC,
+BOOL STDCALL NtGdiSetPixelV(HDC hDC,
INT X,
INT Y,
COLORREF Color)
{
- UNIMPLEMENTED;
+ PDC dc = NULL;
+ PBITMAPOBJ bmp = NULL;
+ BITMAP bm;
+
+ dc = DC_LockDc (hDC);
+ if(NULL == dc)
+ {
+ return(FALSE);
+ }
+ bmp = BITMAPOBJ_LockBitmap (dc->w.hBitmap);
+ if(NULL == bmp)
+ {
+ DC_UnlockDc (hDC);
+ return(FALSE);
+ }
+ bm = bmp->bitmap;
+ //FIXME: set the actual pixel value
+ BITMAPOBJ_UnlockBitmap (bmp);
+ DC_UnlockDc (hDC);
+ return(TRUE);
}
-BOOL STDCALL W32kStretchBlt(HDC hDCDest,
+BOOL STDCALL NtGdiStretchBlt(HDC hDCDest,
INT XOriginDest,
INT YOriginDest,
INT WidthDest,
/* Internal Functions */
-INT
+INT FASTCALL
BITMAPOBJ_GetWidthBytes (INT bmWidth, INT bpp)
{
+#if 0
switch(bpp)
{
case 1:
}
return -1;
+#endif
+
+ return ((bmWidth * bpp + 31) & ~31) >> 3;
}
-HBITMAP BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
+HBITMAP FASTCALL BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
{
PBITMAPOBJ bmp;
HBITMAP res;
BITMAP bm;
- bmp = BITMAPOBJ_HandleToPtr (hBitmap);
+ bmp = BITMAPOBJ_LockBitmap(hBitmap);
if (bmp == NULL)
{
return 0;
bm = bmp->bitmap;
bm.bmBits = NULL;
- res = W32kCreateBitmapIndirect(&bm);
+ res = NtGdiCreateBitmapIndirect(&bm);
if(res)
{
char *buf;
buf = ExAllocatePool (NonPagedPool, bm.bmWidthBytes * bm.bmHeight);
- W32kGetBitmapBits (hBitmap, bm.bmWidthBytes * bm.bmHeight, buf);
- W32kSetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
+ NtGdiGetBitmapBits (hBitmap, bm.bmWidthBytes * bm.bmHeight, buf);
+ NtGdiSetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
ExFreePool (buf);
}
return res;
}
-INT BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer)
+INT STDCALL BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer)
{
if(bmp->dib)
{
- if(count < sizeof(DIBSECTION))
+ if(count < (INT) sizeof(DIBSECTION))
{
- if (count > sizeof(BITMAP)) count = sizeof(BITMAP);
+ if (count > (INT) sizeof(BITMAP)) count = sizeof(BITMAP);
}
else
{
- if (count > sizeof(DIBSECTION)) count = sizeof(DIBSECTION);
+ if (count > (INT) sizeof(DIBSECTION)) count = sizeof(DIBSECTION);
}
memcpy(buffer, bmp->dib, count);
return count;
}
else
{
- if (count > sizeof(BITMAP)) count = sizeof(BITMAP);
+ if (count > (INT) sizeof(BITMAP)) count = sizeof(BITMAP);
memcpy(buffer, &bmp->bitmap, count);
return count;
}
}
+/* EOF */