system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-14 16:31:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Authors: Alexandre Julliard <julliard@codeweavers.com> (for Corel), Albert den Haan <albertd@corel.com>

Browse source 
Added syslevel locking for GDI operations.
Propagate the changes through the graphics code.
This commit is contained in:
Alexandre Julliard 2000-08-19 21:38:55 +00:00
parent 9fcb4f551e
commit 2a2321bbca
63 changed files with 1846 additions and 1663 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
dlls/ddraw/dsurface/dga.c
View file

@ -107,7 +107,7 @@ HRESULT WINAPI DGA_IDirectDrawSurface4Impl_SetPalette(
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
}
TSXFlush(display);
}
@ -137,7 +137,7 @@ ULONG WINAPI DGA_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dib->colorMap = dspriv->oldDIBmap;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
SelectObject(This->s.hdc, This->s.holdbitmap);
DeleteDC(This->s.hdc);
@ -173,7 +173,7 @@ HRESULT WINAPI DGA_IDirectDrawSurface4Impl_GetDC(LPDIRECTDRAWSURFACE4 iface,HDC*
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dspriv->oldDIBmap = dib->colorMap;
dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
}
return result;
}

6
dlls/ddraw/dsurface/x11.c
View file

@ -401,7 +401,7 @@ HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_SetPalette(
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
}
}
return DD_OK;
@ -453,7 +453,7 @@ ULONG WINAPI Xlib_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dib->colorMap = dspriv->oldDIBmap;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
SelectObject(This->s.hdc, This->s.holdbitmap);
DeleteDC(This->s.hdc);
@ -479,7 +479,7 @@ HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_GetDC(LPDIRECTDRAWSURFACE4 iface,HDC
X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
dspriv->oldDIBmap = dib->colorMap;
dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
GDI_HEAP_UNLOCK(This->s.DIBsection);
GDI_ReleaseObj(This->s.DIBsection);
}
return result;
}

10
dlls/gdi/gdi_main.c
View file

@ -15,15 +15,9 @@
/***********************************************************************
* GDI initialisation routine
*/
BOOL WINAPI MAIN_GdiInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
BOOL WINAPI MAIN_GdiInit(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
{
HINSTANCE16 instance;
if ( GDI_HeapSel ) return TRUE;
/* Create GDI heap */
if ((instance = LoadLibrary16( "GDI.EXE" )) < 32) return FALSE;
GDI_HeapSel = GlobalHandleToSel16( instance );
if (reason != DLL_PROCESS_ATTACH) return TRUE;
if (!TWEAK_Init()) return FALSE;

46
dlls/gdi/printdrv.c
View file

@ -69,6 +69,7 @@ INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
*/
INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
@ -77,10 +78,12 @@ INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
if(!dc) return SP_ERROR;
if(dc->funcs->pStartDoc)
return dc->funcs->pStartDoc( dc, doc );
ret = dc->funcs->pStartDoc( dc, doc );
else
return Escape(hdc, STARTDOC, strlen(doc->lpszDocName),
ret = Escape(hdc, STARTDOC, strlen(doc->lpszDocName),
doc->lpszDocName, (LPVOID)doc);
GDI_ReleaseObj( hdc );
return ret;
}
/*************************************************************************
@ -128,13 +131,16 @@ INT16 WINAPI EndDoc16(HDC16 hdc)
*/
INT WINAPI EndDoc(HDC hdc)
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if(dc->funcs->pEndDoc)
return dc->funcs->pEndDoc( dc );
ret = dc->funcs->pEndDoc( dc );
else
return Escape(hdc, ENDDOC, 0, 0, 0);
ret = Escape(hdc, ENDDOC, 0, 0, 0);
GDI_ReleaseObj( hdc );
return ret;
}
/******************************************************************
@ -152,14 +158,16 @@ INT16 WINAPI StartPage16(HDC16 hdc)
*/
INT WINAPI StartPage(HDC hdc)
{
INT ret = 1;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if(dc->funcs->pStartPage)
return dc->funcs->pStartPage( dc );
FIXME("stub\n");
return 1;
ret = dc->funcs->pStartPage( dc );
else
FIXME("stub\n");
GDI_ReleaseObj( hdc );
return ret;
}
/******************************************************************
@ -177,13 +185,16 @@ INT16 WINAPI EndPage16( HDC16 hdc )
*/
INT WINAPI EndPage(HDC hdc)
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if(dc->funcs->pEndPage)
return dc->funcs->pEndPage( dc );
ret = dc->funcs->pEndPage( dc );
else
return Escape(hdc, NEWFRAME, 0, 0, 0);
ret = Escape(hdc, NEWFRAME, 0, 0, 0);
GDI_ReleaseObj( hdc );
return ret;
}
/******************************************************************************
@ -199,13 +210,16 @@ INT16 WINAPI AbortDoc16(HDC16 hdc)
*/
INT WINAPI AbortDoc(HDC hdc)
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) return SP_ERROR;
if(dc->funcs->pAbortDoc)
return dc->funcs->pAbortDoc( dc );
ret = dc->funcs->pAbortDoc( dc );
else
return Escape(hdc, ABORTDOC, 0, 0, 0);
ret = Escape(hdc, ABORTDOC, 0, 0, 0);
GDI_ReleaseObj( hdc );
return ret;
}
/**********************************************************************
@ -219,6 +233,7 @@ INT WINAPI AbortDoc(HDC hdc)
*/
BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
{
BOOL ret = TRUE;
DC *dc = DC_GetDCPtr( hdc );
if(!dc) {
@ -226,9 +241,9 @@ BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
return FALSE;
}
if(!dc->w.pAbortProc)
return TRUE;
return dc->w.pAbortProc(hdc, 0);
if (dc->w.pAbortProc) ret = dc->w.pAbortProc(hdc, 0);
GDI_ReleaseObj( hdc );
return ret;
}
/* ### start build ### */
@ -256,6 +271,7 @@ INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
if(dc->w.pAbortProc) THUNK_Free((FARPROC)dc->w.pAbortProc);
dc->w.pAbortProc = abrtprc;
GDI_ReleaseObj( hdc );
return TRUE;
}

8
dlls/gdi/wing.c
View file

@ -91,6 +91,7 @@ HBITMAP16 WINAPI WinGCreateBitmap16(HDC16 hdc, BITMAPINFO *bmpi,
SEGPTR WINAPI WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
{
BITMAPOBJ* bmp = (BITMAPOBJ *) GDI_GetObjPtr( hWinGBitmap, BITMAP_MAGIC );
SEGPTR res = 0;
TRACE("(%d,%p)\n", hWinGBitmap, bmpi);
if (!bmp) return (SEGPTR)NULL;
@ -99,10 +100,11 @@ SEGPTR WINAPI WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
FIXME(": Todo - implement setting BITMAPINFO\n");
#ifndef X_DISPLAY_MISSING
return PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0);
#else /* !defined(X_DISPLAY_MISSING) */
return NULL;
res = PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0);
#endif /* !defined(X_DISPLAY_MISSING) */
GDI_ReleaseObj( hWinGBitmap );
return res;
}
/***********************************************************************

5
dlls/opengl32/wgl.c
View file

@ -94,6 +94,7 @@ HGLRC WINAPI wglCreateContext(HDC hdc) {
if (vis == NULL) {
ERR("NULL visual !!!\n");
/* Need to set errors here */
GDI_ReleaseObj( hdc );
return NULL;
}
@ -106,6 +107,7 @@ HGLRC WINAPI wglCreateContext(HDC hdc) {
TRACE(" creating context %p (GL context creation delayed)\n", ret);
GDI_ReleaseObj( hdc );
return (HGLRC) ret;
}
@ -342,6 +344,7 @@ BOOL WINAPI wglMakeCurrent(HDC hdc,
physDev->drawable,
ctx->ctx);
LEAVE_GL();
GDI_ReleaseObj( hdc );
}
}
TRACE(" returning %s\n", (ret ? "True" : "False"));
@ -431,7 +434,7 @@ BOOL WINAPI wglUseFontBitmapsA(HDC hdc,
/* I assume that the glyphs are at the same position for X and for Windows */
glXUseXFont(fid, first, count, listBase);
LEAVE_GL();
GDI_ReleaseObj( hdc );
return TRUE;
}

6
dlls/ttydrv/bitmap.c
View file

@ -55,7 +55,7 @@ LONG TTYDRV_DC_BitmapBits(HBITMAP hbitmap, void *bits, LONG count, WORD flags)
result = 0;
}
GDI_HEAP_UNLOCK(hbitmap);
GDI_ReleaseObj(hbitmap);
return result;
}
@ -73,7 +73,7 @@ BOOL TTYDRV_DC_CreateBitmap(HBITMAP hbitmap)
return FALSE;
if(!(physBitmap = TTYDRV_DC_AllocBitmap(bitmap))) {
GDI_HEAP_UNLOCK(hbitmap);
GDI_ReleaseObj(hbitmap);
return FALSE;
}
@ -84,7 +84,7 @@ BOOL TTYDRV_DC_CreateBitmap(HBITMAP hbitmap)
DDB_SET );
}
GDI_HEAP_UNLOCK(hbitmap);
GDI_ReleaseObj(hbitmap);
return TRUE;
}

2
dlls/ttydrv/dc.c
View file

@ -232,7 +232,7 @@ BOOL TTYDRV_DC_CreateDC(DC *dc, LPCSTR driver, LPCSTR device,
dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
GDI_HEAP_UNLOCK( dc->w.hBitmap );
GDI_ReleaseObj( dc->w.hBitmap );
} else {
physDev->window = TTYDRV_GetRootWindow();
physDev->cellWidth = cell_width;

4
dlls/ttydrv/objects.c
View file

@ -98,7 +98,7 @@ HGDIOBJ TTYDRV_DC_SelectObject(DC *dc, HGDIOBJ handle)
ERR("handle (0x%04x) has unknown magic (0x%04x)\n", handle, ptr->wMagic);
}
GDI_HEAP_UNLOCK(handle);
GDI_ReleaseObj(handle);
return result;
}
@ -129,7 +129,7 @@ BOOL TTYDRV_DC_DeleteObject(HGDIOBJ handle)
result = FALSE;
}
GDI_HEAP_UNLOCK(handle);
GDI_ReleaseObj(handle);
return result;
}

24
dlls/ttydrv/wnd.c
View file

@ -230,20 +230,20 @@ void TTYDRV_WND_SetDrawable(WND *wndPtr, HDC hdc, WORD flags, BOOL bSetClipOrigi
if (!dc) return;
TRACE("(%p, %p, %d, %d)\n", wndPtr, dc, flags, bSetClipOrigin);
/* FIXME: Should be done in the common code instead */
if(!wndPtr) {
dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0;
} else {
if(flags & DCX_WINDOW) {
dc->w.DCOrgX = wndPtr->rectWindow.left;
dc->w.DCOrgY = wndPtr->rectWindow.top;
/* FIXME: Should be done in the common code instead */
if(!wndPtr) {
dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0;
} else {
dc->w.DCOrgX = wndPtr->rectClient.left;
dc->w.DCOrgY = wndPtr->rectClient.top;
if(flags & DCX_WINDOW) {
dc->w.DCOrgX = wndPtr->rectWindow.left;
dc->w.DCOrgY = wndPtr->rectWindow.top;
} else {
dc->w.DCOrgX = wndPtr->rectClient.left;
dc->w.DCOrgY = wndPtr->rectClient.top;
}
}
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
}
/***********************************************************************

20
dlls/wineps/brush.c
View file

@ -60,6 +60,7 @@ HBRUSH PSDRV_BRUSH_SelectObject( DC * dc, HBRUSH hbrush, BRUSHOBJ * brush )
*/
static BOOL PSDRV_SetBrush(DC *dc)
{
BOOL ret = TRUE;
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
BRUSHOBJ *brush = (BRUSHOBJ *)GDI_GetObjPtr( dc->w.hBrush, BRUSH_MAGIC );
@ -78,11 +79,12 @@ static BOOL PSDRV_SetBrush(DC *dc)
break;
default:
return FALSE;
ret = FALSE;
break;
}
physDev->brush.set = TRUE;
GDI_ReleaseObj( dc->w.hBrush );
return TRUE;
}
@ -121,6 +123,7 @@ static BOOL PSDRV_Clip(DC *dc, BOOL EO)
*/
BOOL PSDRV_Brush(DC *dc, BOOL EO)
{
BOOL ret = TRUE;
BRUSHOBJ *brush = (BRUSHOBJ *)GDI_GetObjPtr( dc->w.hBrush, BRUSH_MAGIC );
PSDRV_PDEVICE *physDev = dc->physDev;
@ -135,7 +138,6 @@ BOOL PSDRV_Brush(DC *dc, BOOL EO)
PSDRV_WriteGSave(dc);
PSDRV_Fill(dc, EO);
PSDRV_WriteGRestore(dc);
return TRUE;
break;
case BS_HATCHED:
@ -185,13 +187,12 @@ BOOL PSDRV_Brush(DC *dc, BOOL EO)
default:
ERR("Unknown hatch style\n");
return FALSE;
ret = FALSE;
break;
}
return TRUE;
break;
case BS_NULL:
return TRUE;
break;
case BS_PATTERN:
@ -212,18 +213,19 @@ BOOL PSDRV_Brush(DC *dc, BOOL EO)
PSDRV_WriteGRestore(dc);
} else {
FIXME("Trying to set a pattern brush on a level 1 printer\n");
ret = FALSE;
}
HeapFree(PSDRV_Heap, 0, bits);
return TRUE;
}
break;
default:
return FALSE;
ret = FALSE;
break;
}
GDI_ReleaseObj( dc->w.hBrush );
return ret;
}

25
dlls/wineps/font.c
View file

@ -8,6 +8,8 @@
#include "winspool.h"
#include "psdrv.h"
#include "debugtools.h"
#include "dc.h"
#include "winerror.h"
DEFAULT_DEBUG_CHANNEL(psdrv)
@ -265,11 +267,15 @@ BOOL PSDRV_SetFont( DC *dc )
/***********************************************************************
* PSDRV_GetFontMetric
*/
static UINT PSDRV_GetFontMetric(DC *dc, AFM *pafm, NEWTEXTMETRIC16 *pTM,
static UINT PSDRV_GetFontMetric(HDC hdc, AFM *pafm, NEWTEXTMETRIC16 *pTM,
ENUMLOGFONTEX16 *pLF, INT16 size)
{
DC *dc = DC_GetDCPtr( hdc );
float scale = size / (pafm->FullAscender - pafm->Descender);
if (!dc) return FALSE;
memset( pLF, 0, sizeof(*pLF) );
memset( pTM, 0, sizeof(*pTM) );
@ -300,8 +306,8 @@ static UINT PSDRV_GetFontMetric(DC *dc, AFM *pafm, NEWTEXTMETRIC16 *pTM,
*(INT*)&pTM->tmFirstChar = 32;
GDI_ReleaseObj( hdc );
/* return font type */
return DEVICE_FONTTYPE;
}
@ -309,7 +315,7 @@ static UINT PSDRV_GetFontMetric(DC *dc, AFM *pafm, NEWTEXTMETRIC16 *pTM,
/***********************************************************************
* PSDRV_EnumDeviceFonts
*/
BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
BOOL PSDRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC proc, LPARAM lp )
{
ENUMLOGFONTEX16 lf;
@ -317,7 +323,14 @@ BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
BOOL b, bRet = 0;
AFMLISTENTRY *afmle;
FONTFAMILY *family;
PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
PSDRV_PDEVICE *physDev;
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
physDev = (PSDRV_PDEVICE *)dc->physDev;
/* FIXME!! should reevaluate dc->physDev after every callback */
GDI_ReleaseObj( hdc );
if( plf->lfFaceName[0] ) {
TRACE("lfFaceName = '%s'\n", plf->lfFaceName);
@ -330,7 +343,7 @@ BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
for(afmle = family->afmlist; afmle; afmle = afmle->next) {
TRACE("Got '%s'\n", afmle->afm->FontName);
if( (b = (*proc)( &lf, &tm,
PSDRV_GetFontMetric( dc, afmle->afm, &tm, &lf, 200 ),
PSDRV_GetFontMetric( hdc, afmle->afm, &tm, &lf, 200 ),
lp )) )
bRet = b;
else break;
@ -343,7 +356,7 @@ BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
afmle = family->afmlist;
TRACE("Got '%s'\n", afmle->afm->FontName);
if( (b = (*proc)( &lf, &tm,
PSDRV_GetFontMetric( dc, afmle->afm, &tm, &lf, 200 ),
PSDRV_GetFontMetric( hdc, afmle->afm, &tm, &lf, 200 ),
lp )) )
bRet = b;
else break;

2
dlls/wineps/objects.c
View file

@ -57,6 +57,6 @@ HGDIOBJ PSDRV_SelectObject( DC *dc, HGDIOBJ handle )
ERR("Unknown object magic %04x\n", ptr->wMagic);
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}

2
dlls/wineps/psdrv.h
View file

@ -324,7 +324,7 @@ extern BOOL PSDRV_Ellipse( DC *dc, INT left, INT top, INT right,
INT bottom );
extern INT PSDRV_EndDoc( DC *dc );
extern INT PSDRV_EndPage( DC *dc );
extern BOOL PSDRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
extern BOOL PSDRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC proc, LPARAM lp );
extern INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
SEGPTR lpInData, SEGPTR lpOutData );

118
graphics/bitblt.c
View file

@ -7,9 +7,7 @@
#include "dc.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(bitblt)
DECLARE_DEBUG_CHANNEL(bitmap)
DECLARE_DEBUG_CHANNEL(gdi)
DEFAULT_DEBUG_CHANNEL(bitblt);
/***********************************************************************
@ -18,11 +16,7 @@ DECLARE_DEBUG_CHANNEL(gdi)
BOOL16 WINAPI PatBlt16( HDC16 hdc, INT16 left, INT16 top,
INT16 width, INT16 height, DWORD rop)
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
return PatBlt( hdc, left, top, width, height, rop );
}
@ -33,10 +27,17 @@ BOOL WINAPI PatBlt( HDC hdc, INT left, INT top,
INT width, INT height, DWORD rop)
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
BOOL bRet = FALSE;
TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
if (!dc) return FALSE;
if (dc->funcs->pPatBlt)
{
TRACE("%04x %d,%d %dx%d %06lx\n", hdc, left, top, width, height, rop );
bRet = dc->funcs->pPatBlt( dc, left, top, width, height, rop );
}
GDI_ReleaseObj( hdc );
return bRet;
}
@ -47,17 +48,7 @@ BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
DWORD rop )
{
DC *dcDst, *dcSrc;
if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pBitBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop );
return BitBlt( hdcDst, xDst, yDst, width, height, hdcSrc, xSrc, ySrc, rop );
}
@ -65,20 +56,26 @@ BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
* BitBlt (GDI32.10)
*/
BOOL WINAPI BitBlt( HDC hdcDst, INT xDst, INT yDst, INT width,
INT height, HDC hdcSrc, INT xSrc, INT ySrc,
DWORD rop )
INT height, HDC hdcSrc, INT xSrc, INT ySrc, DWORD rop )
{
BOOL ret = FALSE;
DC *dcDst, *dcSrc;
if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pBitBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop );
if ((dcSrc = DC_GetDCUpdate( hdcSrc ))) GDI_ReleaseObj( hdcSrc );
/* FIXME: there is a race condition here */
if ((dcDst = DC_GetDCUpdate( hdcDst )))
{
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE("hdcSrc=%04x %d,%d %d bpp->hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
if (dcDst->funcs->pBitBlt)
ret = dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, rop );
if (dcSrc) GDI_ReleaseObj( hdcSrc );
GDI_ReleaseObj( hdcDst );
}
return ret;
}
@ -90,19 +87,8 @@ BOOL16 WINAPI StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
INT16 widthSrc, INT16 heightSrc, DWORD rop )
{
DC *dcDst, *dcSrc;
if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pStretchBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc,
rop );
return StretchBlt( hdcDst, xDst, yDst, widthDst, heightDst,
hdcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
}
@ -112,21 +98,32 @@ BOOL16 WINAPI StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst,
INT widthDst, INT heightDst,
HDC hdcSrc, INT xSrc, INT ySrc,
INT widthSrc, INT heightSrc, DWORD rop )
INT widthSrc, INT heightSrc,
DWORD rop )
{
BOOL ret = FALSE;
DC *dcDst, *dcSrc;
if (!(dcDst = DC_GetDCPtr( hdcDst ))) return FALSE;
if (!dcDst->funcs->pStretchBlt) return FALSE;
dcSrc = DC_GetDCPtr( hdcSrc );
if ((dcSrc = DC_GetDCUpdate( hdcSrc ))) GDI_ReleaseObj( hdcSrc );
/* FIXME: there is a race condition here */
if ((dcDst = DC_GetDCUpdate( hdcDst )))
{
dcSrc = DC_GetDCPtr( hdcSrc );
TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc,
rop );
TRACE("%04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
if (dcSrc) {
if (dcDst->funcs->pStretchBlt)
ret = dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
GDI_ReleaseObj( hdcSrc );
}
GDI_ReleaseObj( hdcDst );
}
return ret;
}
@ -147,7 +144,10 @@ BOOL16 WINAPI FastWindowFrame16( HDC16 hdc, const RECT16 *rect,
rect->bottom - rect->top - height, rop );
SelectObject( hdc, hbrush );
return TRUE;
}
/***********************************************************************
* MaskBlt [GDI32.252]
*/
@ -156,7 +156,7 @@ BOOL WINAPI MaskBlt(HDC hdcDest, INT nXDest, INT nYDest,
INT nXSrc, INT nYSrc, HBITMAP hbmMask,
INT xMask, INT yMask, DWORD dwRop)
{
FIXME_(bitmap)("(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%ld): stub\n",
FIXME("(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%ld): stub\n",
hdcDest,nXDest,nYDest,nWidth,nHeight,hdcSource,nXSrc,nYSrc,
hbmMask,xMask,yMask,dwRop);
return 1;
@ -170,7 +170,7 @@ BOOL WINAPI PlgBlt( HDC hdcDest, const POINT *lpPoint,
HDC hdcSrc, INT nXDest, INT nYDest, INT nWidth,
INT nHeight, HBITMAP hbmMask, INT xMask, INT yMask)
{
FIXME_(gdi)("PlgBlt, stub\n");
FIXME("PlgBlt, stub\n");
return 1;
}

12
graphics/enhmetafiledrv/init.c
View file

@ -129,7 +129,7 @@ static BOOL EMFDRV_DeleteDC( DC *dc )
if (physDev->emh) HeapFree( GetProcessHeap(), 0, physDev->emh );
HeapFree( GetProcessHeap(), 0, physDev );
dc->physDev = NULL;
GDI_FreeObject(dc->hSelf);
GDI_FreeObject( dc->hSelf, dc );
return TRUE;
}
@ -245,6 +245,7 @@ HDC WINAPI CreateEnhMetaFileW(
LPCWSTR description /* optional description */
)
{
HDC ret;
DC *dc;
HDC hRefDC = hdc ? hdc : CreateDCA("DISPLAY",NULL,NULL,NULL); /* If no ref, use current display */
EMFDRV_PDEVICE *physDev;
@ -258,7 +259,7 @@ HDC WINAPI CreateEnhMetaFileW(
physDev = (EMFDRV_PDEVICE *)HeapAlloc(GetProcessHeap(),0,sizeof(*physDev));
if (!physDev) {
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
return 0;
}
dc->physDev = physDev;
@ -273,7 +274,7 @@ HDC WINAPI CreateEnhMetaFileW(
if (!(physDev->emh = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size))) {
HeapFree( GetProcessHeap(), 0, physDev );
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
return 0;
}
@ -337,8 +338,9 @@ HDC WINAPI CreateEnhMetaFileW(
DeleteDC( hRefDC );
TRACE("returning %04x\n", dc->hSelf);
return dc->hSelf;
ret = dc->hSelf;
GDI_ReleaseObj( dc->hSelf );
return ret;
}
/******************************************************************

10
graphics/enhmetafiledrv/objects.c
View file

@ -89,9 +89,9 @@ DWORD EMFDRV_CreateBrushIndirect( DC *dc, HBRUSH hBrush )
break;
default:
FIXME("Unknown style %x\n", brushObj->logbrush.lbStyle);
return FALSE;
break;
}
GDI_HEAP_UNLOCK( hBrush );
GDI_ReleaseObj( hBrush );
return index;
}
@ -170,7 +170,7 @@ static BOOL EMFDRV_CreateFontIndirect(DC *dc, HFONT hFont )
if(!EMFDRV_WriteRecord( dc, &emr.emr ))
index = 0;
GDI_HEAP_UNLOCK( hFont );
GDI_ReleaseObj( hFont );
return index;
}
@ -233,7 +233,7 @@ static HPEN EMFDRV_CreatePenIndirect(DC *dc, HPEN hPen )
if(!EMFDRV_WriteRecord( dc, &emr.emr ))
index = 0;
GDI_HEAP_UNLOCK( hPen );
GDI_ReleaseObj( hPen );
return index;
}
@ -303,7 +303,7 @@ HGDIOBJ EMFDRV_SelectObject( DC *dc, HGDIOBJ handle )
ret = EMFDRV_BITMAP_SelectObject( dc, handle );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}

21
graphics/escape.c
View file

@ -21,10 +21,18 @@ DEFAULT_DEBUG_CHANNEL(driver);
INT16 WINAPI Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput,
SEGPTR lpszInData, SEGPTR lpvOutData )
{
INT16 ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pEscape) return 0;
if(nEscape == SETABORTPROC) SetAbortProc16(hdc, lpszInData);
return dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData );
if (dc)
{
if (dc->funcs->pEscape)
{
if(nEscape == SETABORTPROC) SetAbortProc16(hdc, lpszInData);
ret = dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData );
}
GDI_ReleaseObj( hdc );
}
return ret;
}
/************************************************************************
@ -34,9 +42,10 @@ INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput,
LPCSTR lpszInData, LPVOID lpvOutData )
{
SEGPTR segin,segout;
INT ret;
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pEscape) return 0;
if (!dc) return 0;
if (!dc->funcs->pEscape) goto done;
segin = (SEGPTR)lpszInData;
segout = (SEGPTR)lpvOutData;
@ -227,6 +236,8 @@ INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput,
default:
break;
}
done:
GDI_ReleaseObj( hdc );
return ret;
}

175
graphics/mapping.c
View file

@ -48,6 +48,7 @@ BOOL16 WINAPI DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
points->y = YDPTOLP( dc, points->y );
points++;
}
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -63,10 +64,11 @@ BOOL WINAPI DPtoLP( HDC hdc, LPPOINT points, INT count )
while (count--)
{
if (!INTERNAL_DPTOLP( dc, points ))
return FALSE;
break;
points++;
}
return TRUE;
GDI_ReleaseObj( hdc );
return (count < 0);
}
@ -84,6 +86,7 @@ BOOL16 WINAPI LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
points->y = YLPTODP( dc, points->y );
points++;
}
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -101,6 +104,7 @@ BOOL WINAPI LPtoDP( HDC hdc, LPPOINT points, INT count )
INTERNAL_LPTODP( dc, points );
points++;
}
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -122,7 +126,11 @@ INT WINAPI SetMapMode( HDC hdc, INT mode )
INT prevMode;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
if (dc->funcs->pSetMapMode) return dc->funcs->pSetMapMode( dc, mode );
if (dc->funcs->pSetMapMode)
{
prevMode = dc->funcs->pSetMapMode( dc, mode );
goto done;
}
TRACE("%04x %d\n", hdc, mode );
@ -176,10 +184,12 @@ INT WINAPI SetMapMode( HDC hdc, INT mode )
break;
default:
return prevMode;
goto done;
}
dc->w.MapMode = mode;
DC_UpdateXforms( dc );
done:
GDI_ReleaseObj( hdc );
return prevMode;
}
@ -212,23 +222,33 @@ BOOL16 WINAPI SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
*/
BOOL WINAPI SetViewportExtEx( HDC hdc, INT x, INT y, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetViewportExt)
return dc->funcs->pSetViewportExt( dc, x, y );
{
ret = dc->funcs->pSetViewportExt( dc, x, y );
goto done;
}
if (size)
{
size->cx = dc->vportExtX;
size->cy = dc->vportExtY;
}
if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
return TRUE;
if (!x || !y) return FALSE;
goto done;
if (!x || !y)
{
ret = FALSE;
goto done;
}
dc->vportExtX = x;
dc->vportExtY = y;
if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
return TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
@ -260,19 +280,24 @@ BOOL16 WINAPI SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
*/
BOOL WINAPI SetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetViewportOrg)
return dc->funcs->pSetViewportOrg( dc, x, y );
if (pt)
ret = dc->funcs->pSetViewportOrg( dc, x, y );
else
{
pt->x = dc->vportOrgX;
pt->y = dc->vportOrgY;
if (pt)
{
pt->x = dc->vportOrgX;
pt->y = dc->vportOrgY;
}
dc->vportOrgX = x;
dc->vportOrgY = y;
DC_UpdateXforms( dc );
}
dc->vportOrgX = x;
dc->vportOrgY = y;
DC_UpdateXforms( dc );
return TRUE;
GDI_ReleaseObj( hdc );
return ret;
}
@ -304,22 +329,33 @@ BOOL16 WINAPI SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
*/
BOOL WINAPI SetWindowExtEx( HDC hdc, INT x, INT y, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetWindowExt) return dc->funcs->pSetWindowExt( dc, x, y );
if (dc->funcs->pSetWindowExt)
{
ret = dc->funcs->pSetWindowExt( dc, x, y );
goto done;
}
if (size)
{
size->cx = dc->wndExtX;
size->cy = dc->wndExtY;
}
if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
return TRUE;
if (!x || !y) return FALSE;
goto done;
if (!x || !y)
{
ret = FALSE;
goto done;
}
dc->wndExtX = x;
dc->wndExtY = y;
if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
return TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
@ -351,18 +387,23 @@ BOOL16 WINAPI SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
*/
BOOL WINAPI SetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pSetWindowOrg) return dc->funcs->pSetWindowOrg( dc, x, y );
if (pt)
if (dc->funcs->pSetWindowOrg) ret = dc->funcs->pSetWindowOrg( dc, x, y );
else
{
pt->x = dc->wndOrgX;
pt->y = dc->wndOrgY;
if (pt)
{
pt->x = dc->wndOrgX;
pt->y = dc->wndOrgY;
}
dc->wndOrgX = x;
dc->wndOrgY = y;
DC_UpdateXforms( dc );
}
dc->wndOrgX = x;
dc->wndOrgY = y;
DC_UpdateXforms( dc );
return TRUE;
GDI_ReleaseObj( hdc );
return ret;
}
@ -394,19 +435,24 @@ BOOL16 WINAPI OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt)
*/
BOOL WINAPI OffsetViewportOrgEx( HDC hdc, INT x, INT y, LPPOINT pt)
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pOffsetViewportOrg)
return dc->funcs->pOffsetViewportOrg( dc, x, y );
if (pt)
ret = dc->funcs->pOffsetViewportOrg( dc, x, y );
else
{
pt->x = dc->vportOrgX;
pt->y = dc->vportOrgY;
if (pt)
{
pt->x = dc->vportOrgX;
pt->y = dc->vportOrgY;
}
dc->vportOrgX += x;
dc->vportOrgY += y;
DC_UpdateXforms( dc );
}
dc->vportOrgX += x;
dc->vportOrgY += y;
DC_UpdateXforms( dc );
return TRUE;
GDI_ReleaseObj( hdc );
return ret;
}
@ -438,19 +484,24 @@ BOOL16 WINAPI OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
*/
BOOL WINAPI OffsetWindowOrgEx( HDC hdc, INT x, INT y, LPPOINT pt )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pOffsetWindowOrg)
return dc->funcs->pOffsetWindowOrg( dc, x, y );
if (pt)
ret = dc->funcs->pOffsetWindowOrg( dc, x, y );
else
{
pt->x = dc->wndOrgX;
pt->y = dc->wndOrgY;
if (pt)
{
pt->x = dc->wndOrgX;
pt->y = dc->wndOrgY;
}
dc->wndOrgX += x;
dc->wndOrgY += y;
DC_UpdateXforms( dc );
}
dc->wndOrgX += x;
dc->wndOrgY += y;
DC_UpdateXforms( dc );
return TRUE;
GDI_ReleaseObj( hdc );
return ret;
}
@ -487,25 +538,35 @@ BOOL16 WINAPI ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
BOOL WINAPI ScaleViewportExtEx( HDC hdc, INT xNum, INT xDenom,
INT yNum, INT yDenom, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pScaleViewportExt)
return dc->funcs->pScaleViewportExt( dc, xNum, xDenom, yNum, yDenom );
{
ret = dc->funcs->pScaleViewportExt( dc, xNum, xDenom, yNum, yDenom );
goto done;
}
if (size)
{
size->cx = dc->vportExtX;
size->cy = dc->vportExtY;
}
if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
return TRUE;
if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
goto done;
if (!xNum || !xDenom || !xNum || !yDenom)
{
ret = FALSE;
goto done;
}
dc->vportExtX = (dc->vportExtX * xNum) / xDenom;
dc->vportExtY = (dc->vportExtY * yNum) / yDenom;
if (dc->vportExtX == 0) dc->vportExtX = 1;
if (dc->vportExtY == 0) dc->vportExtY = 1;
if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
return TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
@ -542,23 +603,33 @@ BOOL16 WINAPI ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
BOOL WINAPI ScaleWindowExtEx( HDC hdc, INT xNum, INT xDenom,
INT yNum, INT yDenom, LPSIZE size )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pScaleWindowExt)
return dc->funcs->pScaleWindowExt( dc, xNum, xDenom, yNum, yDenom );
{
ret = dc->funcs->pScaleWindowExt( dc, xNum, xDenom, yNum, yDenom );
goto done;
}
if (size)
{
size->cx = dc->wndExtX;
size->cy = dc->wndExtY;
}
if ((dc->w.MapMode != MM_ISOTROPIC) && (dc->w.MapMode != MM_ANISOTROPIC))
return TRUE;
if (!xNum || !xDenom || !xNum || !yDenom) return FALSE;
goto done;
if (!xNum || !xDenom || !xNum || !yDenom)
{
ret = FALSE;
goto done;
}
dc->wndExtX = (dc->wndExtX * xNum) / xDenom;
dc->wndExtY = (dc->wndExtY * yNum) / yDenom;
if (dc->wndExtX == 0) dc->wndExtX = 1;
if (dc->wndExtY == 0) dc->wndExtY = 1;
if (dc->w.MapMode == MM_ISOTROPIC) MAPPING_FixIsotropic( dc );
DC_UpdateXforms( dc );
return TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}

11
graphics/metafiledrv/init.c
View file

@ -133,7 +133,7 @@ static DC *MFDRV_AllocMetaFile(void)
physDev = (METAFILEDRV_PDEVICE *)HeapAlloc(GetProcessHeap(),0,sizeof(*physDev));
if (!physDev)
{
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
return NULL;
}
dc->physDev = physDev;
@ -141,7 +141,7 @@ static DC *MFDRV_AllocMetaFile(void)
if (!(physDev->mh = HeapAlloc( GetProcessHeap(), 0, sizeof(*physDev->mh) )))
{
HeapFree( GetProcessHeap(), 0, physDev );
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
return NULL;
}
@ -169,7 +169,7 @@ static BOOL MFDRV_DeleteDC( DC *dc )
if (physDev->mh) HeapFree( GetProcessHeap(), 0, physDev->mh );
HeapFree( GetProcessHeap(), 0, physDev );
dc->physDev = NULL;
GDI_FreeObject(dc->hSelf);
GDI_FreeObject( dc->hSelf, dc );
return TRUE;
}
@ -186,6 +186,7 @@ HDC16 WINAPI CreateMetaFile16(
LPCSTR filename /* Filename of disk metafile */
)
{
HDC ret;
DC *dc;
METAFILEDRV_PDEVICE *physDev;
HFILE hFile;
@ -217,7 +218,9 @@ HDC16 WINAPI CreateMetaFile16(
physDev->mh->mtType = METAFILE_MEMORY;
TRACE("returning %04x\n", dc->hSelf);
return dc->hSelf;
ret = dc->hSelf;
GDI_ReleaseObj( dc->hSelf );
return ret;
}
/**********************************************************************

13
graphics/metafiledrv/objects.c
View file

@ -35,7 +35,7 @@ static HBITMAP16 MFDRV_BITMAP_SelectObject( DC * dc, HBITMAP16 hbitmap,
INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
{
INT16 index;
INT16 index = -1;
DWORD size;
METARECORD *mr;
BRUSHOBJ *brushObj = (BRUSHOBJ *)GDI_GetObjPtr( hBrush, BRUSH_MAGIC );
@ -68,7 +68,7 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
GetObjectA(brushObj->logbrush.lbHatch, sizeof(bm), &bm);
if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
FIXME("Trying to store a colour pattern brush\n");
return FALSE;
goto done;
}
bmSize = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, 1);
@ -77,7 +77,7 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
sizeof(RGBQUAD) + bmSize;
mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
if(!mr) return FALSE;
if(!mr) goto done;
mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
mr->rdSize = size / 2;
mr->rdParm[0] = BS_PATTERN;
@ -114,7 +114,7 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
LOWORD(brushObj->logbrush.lbColor));
size = sizeof(METARECORD) + biSize + bmSize + 2;
mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
if(!mr) return FALSE;
if(!mr) goto done;
mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
mr->rdSize = size / 2;
*(mr->rdParm) = brushObj->logbrush.lbStyle;
@ -130,7 +130,8 @@ INT16 MFDRV_CreateBrushIndirect(DC *dc, HBRUSH hBrush )
if(!MFDRV_WriteRecord( dc, mr, mr->rdSize * 2))
index = -1;
HeapFree(GetProcessHeap(), 0, mr);
GDI_HEAP_UNLOCK( hBrush );
done:
GDI_ReleaseObj( hBrush );
return index;
}
@ -260,7 +261,7 @@ HGDIOBJ MFDRV_SelectObject( DC *dc, HGDIOBJ handle )
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}

473
graphics/painting.c
View file

@ -34,19 +34,20 @@ BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
*/
BOOL WINAPI LineTo( HDC hdc, INT x, INT y )
{
DC * dc = DC_GetDCPtr( hdc );
DC * dc = DC_GetDCUpdate( hdc );
BOOL ret;
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
ret = PATH_LineTo(hdc, x, y);
ret = PATH_LineTo(dc, x, y);
else
ret = dc->funcs->pLineTo && dc->funcs->pLineTo(dc,x,y);
if(ret) {
dc->w.CursPosX = x;
dc->w.CursPosY = y;
}
GDI_ReleaseObj( hdc );
return ret;
}
@ -83,7 +84,8 @@ BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
*/
BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, LPPOINT pt )
{
DC * dc = DC_GetDCPtr( hdc );
BOOL ret = TRUE;
DC * dc = DC_GetDCUpdate( hdc );
if(!dc) return FALSE;
@ -94,12 +96,10 @@ BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, LPPOINT pt )
dc->w.CursPosX = x;
dc->w.CursPosY = y;
if(PATH_IsPathOpen(dc->w.path))
return PATH_MoveTo(hdc);
if(dc->funcs->pMoveToEx)
return dc->funcs->pMoveToEx(dc,x,y,pt);
return TRUE;
if(PATH_IsPathOpen(dc->w.path)) ret = PATH_MoveTo(dc);
else if (dc->funcs->pMoveToEx) ret = dc->funcs->pMoveToEx(dc,x,y,pt);
GDI_ReleaseObj( hdc );
return ret;
}
@ -123,15 +123,17 @@ BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right,
INT bottom, INT xstart, INT ystart,
INT xend, INT yend )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if(PATH_IsPathOpen(dc->w.path))
return PATH_Arc(hdc, left, top, right, bottom, xstart, ystart, xend,
yend);
return dc->funcs->pArc &&
dc->funcs->pArc(dc,left,top,right,bottom,xstart,ystart,xend,yend);
ret = PATH_Arc(dc, left, top, right, bottom, xstart, ystart, xend, yend);
else if (dc->funcs->pArc)
ret = dc->funcs->pArc(dc,left,top,right,bottom,xstart,ystart,xend,yend);
GDI_ReleaseObj( hdc );
}
return ret;
}
/***********************************************************************
@ -144,37 +146,32 @@ BOOL WINAPI ArcTo( HDC hdc,
INT xend, INT yend )
{
BOOL result;
DC * dc = DC_GetDCPtr( hdc );
DC * dc = DC_GetDCUpdate( hdc );
if(!dc) return FALSE;
if(dc->funcs->pArcTo)
return dc->funcs->pArcTo( dc, left, top, right, bottom,
{
result = dc->funcs->pArcTo( dc, left, top, right, bottom,
xstart, ystart, xend, yend );
GDI_ReleaseObj( hdc );
return result;
}
GDI_ReleaseObj( hdc );
/*
* Else emulate it.
* According to the documentation, a line is drawn from the current
* position to the starting point of the arc.
*/
LineTo(hdc, xstart, ystart);
/*
* Then the arc is drawn.
*/
result = Arc(hdc,
left, top,
right, bottom,
xstart, ystart,
xend, yend);
result = Arc(hdc, left, top, right, bottom, xstart, ystart, xend, yend);
/*
* If no error occured, the current position is moved to the ending
* point of the arc.
*/
if (result)
{
MoveToEx(hdc, xend, yend, NULL);
}
if (result) MoveToEx(hdc, xend, yend, NULL);
return result;
}
@ -198,16 +195,17 @@ BOOL WINAPI Pie( HDC hdc, INT left, INT top,
INT right, INT bottom, INT xstart, INT ystart,
INT xend, INT yend )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path)) {
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (PATH_IsPathOpen(dc->w.path))
FIXME("-> Path: stub\n");
return FALSE;
else if (dc->funcs->pPie)
ret = dc->funcs->pPie(dc,left,top,right,bottom,xstart,ystart,xend,yend);
GDI_ReleaseObj( hdc );
}
return dc->funcs->pPie &&
dc->funcs->pPie(dc,left,top,right,bottom,xstart,ystart,xend,yend);
return ret;
}
@ -229,16 +227,17 @@ BOOL WINAPI Chord( HDC hdc, INT left, INT top,
INT right, INT bottom, INT xstart, INT ystart,
INT xend, INT yend )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path)) {
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if(PATH_IsPathOpen(dc->w.path))
FIXME("-> Path: stub\n");
return FALSE;
else if (dc->funcs->pChord)
ret = dc->funcs->pChord(dc,left,top,right,bottom,xstart,ystart,xend,yend);
GDI_ReleaseObj( hdc );
}
return dc->funcs->pChord &&
dc->funcs->pChord(dc,left,top,right,bottom,xstart,ystart,xend,yend);
return ret;
}
@ -258,16 +257,17 @@ BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
BOOL WINAPI Ellipse( HDC hdc, INT left, INT top,
INT right, INT bottom )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path)) {
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if(PATH_IsPathOpen(dc->w.path))
FIXME("-> Path: stub\n");
return FALSE;
else if (dc->funcs->pEllipse)
ret = dc->funcs->pEllipse(dc,left,top,right,bottom);
GDI_ReleaseObj( hdc );
}
return dc->funcs->pEllipse &&
dc->funcs->pEllipse(dc,left,top,right,bottom);
return ret;
}
@ -287,14 +287,17 @@ BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
BOOL WINAPI Rectangle( HDC hdc, INT left, INT top,
INT right, INT bottom )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if(PATH_IsPathOpen(dc->w.path))
return PATH_Rectangle(hdc, left, top, right, bottom);
return dc->funcs->pRectangle &&
dc->funcs->pRectangle(dc,left,top,right,bottom);
ret = PATH_Rectangle(dc, left, top, right, bottom);
else if (dc->funcs->pRectangle)
ret = dc->funcs->pRectangle(dc,left,top,right,bottom);
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -314,16 +317,18 @@ BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
INT bottom, INT ell_width, INT ell_height )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
BOOL ret = FALSE;
DC *dc = DC_GetDCUpdate( hdc );
if(PATH_IsPathOpen(dc->w.path)) {
if (dc)
{
if(PATH_IsPathOpen(dc->w.path))
FIXME("-> Path: stub\n");
return FALSE;
else if (dc->funcs->pRoundRect)
ret = dc->funcs->pRoundRect(dc,left,top,right,bottom,ell_width,ell_height);
GDI_ReleaseObj( hdc );
}
return dc->funcs->pRoundRect &&
dc->funcs->pRoundRect(dc,left,top,right,bottom,ell_width,ell_height);
return ret;
}
/***********************************************************************
@ -340,10 +345,14 @@ COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
*/
COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pSetPixel) return 0;
return dc->funcs->pSetPixel(dc,x,y,color);
COLORREF ret = 0;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (dc->funcs->pSetPixel) ret = dc->funcs->pSetPixel(dc,x,y,color);
GDI_ReleaseObj( hdc );
}
return ret;
}
/***********************************************************************
@ -351,11 +360,18 @@ COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
*/
BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pSetPixel) return FALSE;
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (dc->funcs->pSetPixel)
{
dc->funcs->pSetPixel(dc,x,y,color);
return TRUE;
ret = TRUE;
}
GDI_ReleaseObj( hdc );
}
return ret;
}
/***********************************************************************
@ -372,17 +388,19 @@ COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
*/
COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
#ifdef SOLITAIRE_SPEED_HACK
return 0;
#endif
COLORREF ret = 0;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
/* FIXME: should this be in the graphics driver? */
if (!PtVisible( hdc, x, y )) return 0;
if (!dc || !dc->funcs->pGetPixel) return 0;
return dc->funcs->pGetPixel(dc,x,y);
if (PtVisible( hdc, x, y ))
{
if (dc->funcs->pGetPixel) ret = dc->funcs->pGetPixel(dc,x,y);
}
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -400,17 +418,18 @@ COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y )
*/
INT WINAPI ChoosePixelFormat( HDC hdc, const LPPIXELFORMATDESCRIPTOR ppfd )
{
DC * dc = DC_GetDCPtr( hdc );
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
TRACE("(%08x,%p)\n",hdc,ppfd);
TRACE("(%08x,%p)\n",hdc,ppfd);
if (dc == NULL) return 0;
if (dc->funcs->pChoosePixelFormat == NULL) {
FIXME(" :stub\n");
return 0;
}
return dc->funcs->pChoosePixelFormat(dc,ppfd);
if (!dc) return 0;
if (!dc->funcs->pChoosePixelFormat) FIXME(" :stub\n");
else ret = dc->funcs->pChoosePixelFormat(dc,ppfd);
GDI_ReleaseObj( hdc );
return ret;
}
@ -428,16 +447,18 @@ INT WINAPI ChoosePixelFormat( HDC hdc, const LPPIXELFORMATDESCRIPTOR ppfd )
BOOL WINAPI SetPixelFormat( HDC hdc, INT iPixelFormat,
const PIXELFORMATDESCRIPTOR *ppfd)
{
DC * dc = DC_GetDCPtr( hdc );
INT bRet = FALSE;
DC * dc = DC_GetDCPtr( hdc );
TRACE("(%d,%d,%p)\n",hdc,iPixelFormat,ppfd);
TRACE("(%d,%d,%p)\n",hdc,iPixelFormat,ppfd);
if (dc == NULL) return 0;
if (dc->funcs->pSetPixelFormat == NULL) {
FIXME(" :stub\n");
return 0;
}
return dc->funcs->pSetPixelFormat(dc,iPixelFormat,ppfd);
if (!dc) return 0;
if (!dc->funcs->pSetPixelFormat) FIXME(" :stub\n");
else bRet = dc->funcs->pSetPixelFormat(dc,iPixelFormat,ppfd);
GDI_ReleaseObj( hdc );
return bRet;
}
@ -454,16 +475,18 @@ BOOL WINAPI SetPixelFormat( HDC hdc, INT iPixelFormat,
*/
INT WINAPI GetPixelFormat( HDC hdc )
{
DC * dc = DC_GetDCPtr( hdc );
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
TRACE("(%08x)\n",hdc);
TRACE("(%08x)\n",hdc);
if (dc == NULL) return 0;
if (dc->funcs->pGetPixelFormat == NULL) {
FIXME(" :stub\n");
return 0;
}
return dc->funcs->pGetPixelFormat(dc);
if (!dc) return 0;
if (!dc->funcs->pGetPixelFormat) FIXME(" :stub\n");
else ret = dc->funcs->pGetPixelFormat(dc);
GDI_ReleaseObj( hdc );
return ret;
}
@ -484,18 +507,24 @@ INT WINAPI GetPixelFormat( HDC hdc )
INT WINAPI DescribePixelFormat( HDC hdc, INT iPixelFormat, UINT nBytes,
LPPIXELFORMATDESCRIPTOR ppfd )
{
DC * dc = DC_GetDCPtr( hdc );
INT ret = 0;
DC * dc = DC_GetDCPtr( hdc );
TRACE("(%08x,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd);
TRACE("(%08x,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd);
if (dc == NULL) return 0;
if (dc->funcs->pDescribePixelFormat == NULL) {
FIXME(" :stub\n");
ppfd->nSize = nBytes;
ppfd->nVersion = 1;
return 3;
}
return dc->funcs->pDescribePixelFormat(dc,iPixelFormat,nBytes,ppfd);
if (!dc) return 0;
if (!dc->funcs->pDescribePixelFormat)
{
FIXME(" :stub\n");
ppfd->nSize = nBytes;
ppfd->nVersion = 1;
ret = 3;
}
else ret = dc->funcs->pDescribePixelFormat(dc,iPixelFormat,nBytes,ppfd);
GDI_ReleaseObj( hdc );
return ret;
}
@ -510,16 +539,22 @@ INT WINAPI DescribePixelFormat( HDC hdc, INT iPixelFormat, UINT nBytes,
*/
BOOL WINAPI SwapBuffers( HDC hdc )
{
DC * dc = DC_GetDCPtr( hdc );
INT bRet = FALSE;
DC * dc = DC_GetDCPtr( hdc );
TRACE("(%08x)\n",hdc);
TRACE("(%08x)\n",hdc);
if (dc == NULL) return 0;
if (dc->funcs->pSwapBuffers == NULL) {
FIXME(" :stub\n");
return TRUE;
}
return dc->funcs->pSwapBuffers(dc);
if (!dc) return TRUE;
if (!dc->funcs->pSwapBuffers)
{
FIXME(" :stub\n");
bRet = TRUE;
}
else bRet = dc->funcs->pSwapBuffers(dc);
GDI_ReleaseObj( hdc );
return bRet;
}
@ -537,10 +572,14 @@ BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
*/
BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
{
DC * dc = DC_GetDCPtr( hdc );
return dc && dc->funcs->pPaintRgn &&
dc->funcs->pPaintRgn(dc,hrgn);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (dc->funcs->pPaintRgn) ret = dc->funcs->pPaintRgn(dc,hrgn);
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -558,18 +597,19 @@ BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
*/
BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
{
BOOL retval;
BOOL retval = FALSE;
HBRUSH prevBrush;
DC * dc = DC_GetDCPtr( hdc );
DC * dc = DC_GetDCUpdate( hdc );
if (!dc) return FALSE;
if(dc->funcs->pFillRgn)
return dc->funcs->pFillRgn(dc, hrgn, hbrush);
prevBrush = SelectObject( hdc, hbrush );
if (!prevBrush) return FALSE;
retval = dc->funcs->pFillRgn(dc, hrgn, hbrush);
else if ((prevBrush = SelectObject( hdc, hbrush )))
{
retval = PaintRgn( hdc, hrgn );
SelectObject( hdc, prevBrush );
}
GDI_ReleaseObj( hdc );
return retval;
}
@ -590,17 +630,27 @@ BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush,
INT nWidth, INT nHeight )
{
HRGN tmp;
DC *dc = DC_GetDCPtr( hdc );
BOOL ret = FALSE;
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return FALSE;
if(dc->funcs->pFrameRgn)
return dc->funcs->pFrameRgn( dc, hrgn, hbrush, nWidth, nHeight );
tmp = CreateRectRgn( 0, 0, 0, 0 );
if(!REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) return FALSE;
ret = dc->funcs->pFrameRgn( dc, hrgn, hbrush, nWidth, nHeight );
else
{
HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
if (tmp)
{
if (REGION_FrameRgn( tmp, hrgn, nWidth, nHeight ))
{
FillRgn( hdc, tmp, hbrush );
ret = TRUE;
}
DeleteObject( tmp );
return TRUE;
}
}
GDI_ReleaseObj( hdc );
return ret;
}
@ -621,16 +671,20 @@ BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
HBRUSH prevBrush;
INT prevROP;
BOOL retval;
DC *dc = DC_GetDCPtr( hdc );
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return FALSE;
if(dc->funcs->pInvertRgn)
return dc->funcs->pInvertRgn( dc, hrgn );
retval = dc->funcs->pInvertRgn( dc, hrgn );
else
{
prevBrush = SelectObject( hdc, GetStockObject(BLACK_BRUSH) );
prevROP = SetROP2( hdc, R2_NOT );
retval = PaintRgn( hdc, hrgn );
SelectObject( hdc, prevBrush );
SetROP2( hdc, prevROP );
}
GDI_ReleaseObj( hdc );
return retval;
}
@ -657,14 +711,15 @@ BOOL16 WINAPI Polyline16( HDC16 hdc, const POINT16* pt, INT16 count )
*/
BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
return PATH_Polyline(hdc, pt, count);
return dc->funcs->pPolyline &&
dc->funcs->pPolyline(dc,pt,count);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (PATH_IsPathOpen(dc->w.path)) ret = PATH_Polyline(dc, pt, count);
else if (dc->funcs->pPolyline) ret = dc->funcs->pPolyline(dc,pt,count);
GDI_ReleaseObj( hdc );
}
return ret;
}
/**********************************************************************
@ -672,13 +727,13 @@ BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
*/
BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount )
{
DC * dc = DC_GetDCPtr( hdc );
BOOL ret;
DC * dc = DC_GetDCUpdate( hdc );
BOOL ret = FALSE;
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
ret = PATH_PolylineTo(hdc, pt, cCount);
ret = PATH_PolylineTo(dc, pt, cCount);
else if(dc->funcs->pPolylineTo)
ret = dc->funcs->pPolylineTo(dc, pt, cCount);
@ -686,18 +741,20 @@ BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount )
else { /* do it using Polyline */
POINT *pts = HeapAlloc( GetProcessHeap(), 0,
sizeof(POINT) * (cCount + 1) );
if(!pts) return FALSE;
if (pts)
{
pts[0].x = dc->w.CursPosX;
pts[0].y = dc->w.CursPosY;
memcpy( pts + 1, pt, sizeof(POINT) * cCount );
ret = Polyline( hdc, pts, cCount + 1 );
HeapFree( GetProcessHeap(), 0, pts );
}
}
if(ret) {
dc->w.CursPosX = pt[cCount-1].x;
dc->w.CursPosY = pt[cCount-1].y;
}
GDI_ReleaseObj( hdc );
return ret;
}
@ -724,14 +781,15 @@ BOOL16 WINAPI Polygon16( HDC16 hdc, const POINT16* pt, INT16 count )
*/
BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
return PATH_Polygon(hdc, pt, count);
return dc->funcs->pPolygon &&
dc->funcs->pPolygon(dc,pt,count);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (PATH_IsPathOpen(dc->w.path)) ret = PATH_Polygon(dc, pt, count);
else if (dc->funcs->pPolygon) ret = dc->funcs->pPolygon(dc,pt,count);
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -772,14 +830,15 @@ BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts,
UINT polygons )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
return PATH_PolyPolygon(hdc, pt, counts, polygons);
return dc->funcs->pPolyPolygon &&
dc->funcs->pPolyPolygon(dc,pt,counts,polygons);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (PATH_IsPathOpen(dc->w.path)) ret = PATH_PolyPolygon(dc, pt, counts, polygons);
else if (dc->funcs->pPolyPolygon) ret = dc->funcs->pPolyPolygon(dc,pt,counts,polygons);
GDI_ReleaseObj( hdc );
}
return ret;
}
/**********************************************************************
@ -788,14 +847,15 @@ BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts,
BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts,
DWORD polylines )
{
DC * dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
return PATH_PolyPolyline(hdc, pt, counts, polylines);
return dc->funcs->pPolyPolyline &&
dc->funcs->pPolyPolyline(dc,pt,counts,polylines);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (PATH_IsPathOpen(dc->w.path)) ret = PATH_PolyPolyline(dc, pt, counts, polylines);
else if (dc->funcs->pPolyPolyline) ret = dc->funcs->pPolyPolyline(dc,pt,counts,polylines);
GDI_ReleaseObj( hdc );
}
return ret;
}
/**********************************************************************
@ -814,10 +874,14 @@ BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color,
UINT fillType )
{
DC *dc = DC_GetDCPtr( hdc );
return dc && dc->funcs->pExtFloodFill &&
dc->funcs->pExtFloodFill(dc,x,y,color,fillType);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if (dc->funcs->pExtFloodFill) ret = dc->funcs->pExtFloodFill(dc,x,y,color,fillType);
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -884,30 +948,32 @@ BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
*/
BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints )
{
DC * dc = DC_GetDCPtr( hdc );
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
return PATH_PolyBezier(hdc, lppt, cPoints);
if(dc->funcs->pPolyBezier)
return dc->funcs->pPolyBezier(dc, lppt, cPoints);
/* We'll convert it into line segments and draw them using Polyline */
ret = PATH_PolyBezier(dc, lppt, cPoints);
else if (dc->funcs->pPolyBezier)
ret = dc->funcs->pPolyBezier(dc, lppt, cPoints);
else /* We'll convert it into line segments and draw them using Polyline */
{
POINT *Pts;
INT nOut;
BOOL ret;
Pts = GDI_Bezier( lppt, cPoints, &nOut );
if(!Pts) return FALSE;
if ((Pts = GDI_Bezier( lppt, cPoints, &nOut )))
{
TRACE("Pts = %p, no = %d\n", Pts, nOut);
ret = Polyline( dc->hSelf, Pts, nOut );
HeapFree( GetProcessHeap(), 0, Pts );
return ret;
}
}
GDI_ReleaseObj( hdc );
return ret;
}
/******************************************************************************
* PolyBezierTo [GDI32.269]
* Draws one or more Bezier curves
@ -921,13 +987,13 @@ BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints )
*/
BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints )
{
DC * dc = DC_GetDCPtr( hdc );
DC * dc = DC_GetDCUpdate( hdc );
BOOL ret;
if(!dc) return FALSE;
if(PATH_IsPathOpen(dc->w.path))
ret = PATH_PolyBezierTo(hdc, lppt, cPoints);
ret = PATH_PolyBezierTo(dc, lppt, cPoints);
else if(dc->funcs->pPolyBezierTo)
ret = dc->funcs->pPolyBezierTo(dc, lppt, cPoints);
else { /* We'll do it using PolyBezier */
@ -944,6 +1010,7 @@ BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints )
dc->w.CursPosX = lppt[cPoints-1].x;
dc->w.CursPosY = lppt[cPoints-1].y;
}
GDI_ReleaseObj( hdc );
return ret;
}

614
graphics/path.c
View file

File diff suppressed because it is too large Load diff

11
graphics/win16drv/font.c
View file

@ -11,6 +11,7 @@
#include "module.h"
#include "font.h"
#include "heap.h"
#include "dc.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(win16drv)
@ -179,15 +180,21 @@ BOOL WIN16DRV_GetCharWidth( DC *dc, UINT firstChar, UINT lastChar,
* WIN16DRV_EnumDeviceFonts
*/
BOOL WIN16DRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
BOOL WIN16DRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC proc, LPARAM lp )
{
WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
WIN16DRV_PDEVICE *physDev;
WORD wRet;
WEPFC wepfc;
DC *dc;
/* EnumDFontCallback is GDI.158 */
FARPROC16 pfnCallback = NE_GetEntryPoint( GetModuleHandle16("GDI"), 158 );
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
physDev = (WIN16DRV_PDEVICE *)dc->physDev;
/* FIXME!! */
GDI_ReleaseObj( hdc );
wepfc.proc = (int (*)(LPENUMLOGFONT16,LPNEWTEXTMETRIC16,UINT16,LPARAM))proc;
wepfc.lp = lp;

2
graphics/win16drv/objects.c
View file

@ -54,6 +54,6 @@ HGDIOBJ WIN16DRV_SelectObject( DC *dc, HGDIOBJ handle )
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}

38
graphics/x11drv/bitmap.c
View file

@ -84,24 +84,20 @@ HBITMAP X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP hbitmap,
return 0;
}
hrgn = CreateRectRgn(0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight);
if (!hrgn) return 0;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = bmp->bitmap.bmWidth;
dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
if (dc->w.hVisRgn)
SetRectRgn( dc->w.hVisRgn, 0, 0,
bmp->bitmap.bmWidth, bmp->bitmap.bmHeight );
else
{
hrgn = CreateRectRgn(0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight);
if (!hrgn) return 0;
dc->w.hVisRgn = hrgn;
}
physDev->drawable = (Pixmap)bmp->physBitmap;
dc->w.hBitmap = hbitmap;
SelectVisRgn16( dc->hSelf, hrgn );
DeleteObject( hrgn );
/* Change GC depth if needed */
if (dc->w.bitsPerPixel != bmp->bitmap.bmBitsPixel)
@ -112,7 +108,6 @@ HBITMAP X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP hbitmap,
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
DC_InitDC( dc );
}
else CLIPPING_UpdateGCRegion( dc ); /* Just update GC clip region */
return prevHandle;
}
@ -158,13 +153,17 @@ BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
}
/* Check parameters */
if (bmp->bitmap.bmPlanes != 1) return 0;
if (bmp->bitmap.bmPlanes != 1)
{
GDI_ReleaseObj( hbitmap );
return 0;
}
if ((bmp->bitmap.bmBitsPixel != 1) &&
(bmp->bitmap.bmBitsPixel != X11DRV_GetDepth()))
{
ERR("Trying to make bitmap with planes=%d, bpp=%d\n",
bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel);
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return FALSE;
}
@ -177,7 +176,7 @@ BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
bmp->bitmap.bmBitsPixel)))
{
WARN("Can't create Pixmap\n");
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return FALSE;
}
bmp->funcs = &X11DRV_DC_Funcs;
@ -187,7 +186,7 @@ BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes,
DDB_SET );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return TRUE;
}
@ -476,8 +475,7 @@ LONG X11DRV_BitmapBits(HBITMAP hbitmap, void *bits, LONG count, WORD flags)
ERR("Unknown flags value %d\n", flags);
ret = 0;
}
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return ret;
}
@ -526,6 +524,7 @@ HBITMAP X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(Pixmap pixmap)
pBmp->funcs = &X11DRV_DC_Funcs;
pBmp->physBitmap = (void *)pixmap;
GDI_ReleaseObj( hBmp );
END:
TRACE("\tReturning HBITMAP %x\n", hBmp);
@ -612,7 +611,10 @@ Pixmap X11DRV_BITMAP_CreatePixmapFromBitmap( HBITMAP hBmp, HDC hdc )
*/
Pixmap X11DRV_BITMAP_Pixmap(HBITMAP hbitmap)
{
Pixmap pixmap;
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
return (Pixmap)bmp->physBitmap;
pixmap = (Pixmap)bmp->physBitmap;
GDI_ReleaseObj( hbitmap );
return pixmap;
}

11
graphics/x11drv/brush.c
View file

@ -172,17 +172,18 @@ static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
*/
static BOOL BRUSH_SelectPatternBrush( DC * dc, HBITMAP hbitmap )
{
BOOL ret = FALSE;
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
if(!bmp->physBitmap)
if(!X11DRV_CreateBitmap(hbitmap))
return 0;
goto done;
if(bmp->funcs != dc->funcs) {
WARN("Trying to select non-X11 DDB into an X11 dc\n");
return 0;
goto done;
}
if ((dc->w.bitsPerPixel == 1) && (bmp->bitmap.bmBitsPixel != 1))
@ -211,8 +212,10 @@ static BOOL BRUSH_SelectPatternBrush( DC * dc, HBITMAP hbitmap )
physDev->brush.fillStyle = FillOpaqueStippled;
physDev->brush.pixel = -1; /* Special case (see DC_SetupGCForBrush) */
}
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
ret = TRUE;
done:
GDI_ReleaseObj( hbitmap );
return ret;
}

4
graphics/x11drv/clipping.c
View file

@ -49,7 +49,7 @@ void X11DRV_SetDeviceClipping( DC * dc )
if(!pXrect)
{
WARN("Can't alloc buffer\n");
GDI_HEAP_UNLOCK( dc->w.hGCClipRgn );
GDI_ReleaseObj( dc->w.hGCClipRgn );
return;
}
@ -70,6 +70,6 @@ void X11DRV_SetDeviceClipping( DC * dc )
if(pXrect)
HeapFree( GetProcessHeap(), 0, pXrect );
GDI_HEAP_UNLOCK( dc->w.hGCClipRgn );
GDI_ReleaseObj( dc->w.hGCClipRgn );
}

31
graphics/x11drv/dib.c
View file

@ -2595,9 +2595,6 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
XImage *bmpImage;
if ( descr->dc && descr->dc->w.flags & DC_DIRTY )
CLIPPING_UpdateGCRegion( descr->dc );
if (descr->image)
bmpImage = descr->image;
else {
@ -2984,11 +2981,18 @@ INT X11DRV_DIB_GetDIBits(
*/
if( info->bmiHeader.biHeight < 0 && lines > 0) lines = -lines;
if( startscan >= bmp->bitmap.bmHeight ) return FALSE;
if( startscan >= bmp->bitmap.bmHeight )
{
lines = 0;
goto done;
}
if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &descr.lines,
&descr.infoBpp, &descr.compression ) == -1)
return FALSE;
{
lines = 0;
goto done;
}
switch (descr.infoBpp)
{
@ -3060,7 +3064,8 @@ INT X11DRV_DIB_GetDIBits(
info->bmiHeader.biCompression = 0;
GDI_HEAP_UNLOCK( dc->w.hPalette );
done:
GDI_ReleaseObj( dc->w.hPalette );
return lines;
}
@ -3193,7 +3198,7 @@ static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
break;
}
GDI_HEAP_UNLOCK( (HBITMAP)res );
GDI_ReleaseObj( (HBITMAP)res );
return handled;
}
@ -3276,7 +3281,7 @@ void X11DRV_DIB_UpdateDIBSection2(HBITMAP hbmp, BOOL toDIB)
X11DRV_DIB_CmnUpdateDIBSection(bmp, toDIB);
GDI_HEAP_UNLOCK(hbmp);
GDI_ReleaseObj(hbmp);
}
/***********************************************************************
@ -3325,12 +3330,11 @@ HBITMAP16 X11DRV_DIB_CreateDIBSection16(
TRACE("ptr = %p, size =%d, selector = %04x, segptr = %ld\n",
dib->dsBm.bmBits, size, ((X11DRV_DIBSECTION *) bmp->dib)->selector,
PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0));
}
GDI_HEAP_UNLOCK( res );
if ( bits )
*bits = PTR_SEG_OFF_TO_SEGPTR( ((X11DRV_DIBSECTION *) bmp->dib)->selector, 0 );
}
if (bmp) GDI_ReleaseObj( res );
}
return res;
}
@ -3545,6 +3549,7 @@ HBITMAP X11DRV_DIB_CreateDIBSection(
if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; }
if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; }
if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; }
if (bmp) { GDI_ReleaseObj(res); bmp = NULL; }
if (res) { DeleteObject(res); res = 0; }
}
@ -3567,7 +3572,7 @@ HBITMAP X11DRV_DIB_CreateDIBSection(
}
/* Return BITMAP handle and storage location */
if (res) GDI_HEAP_UNLOCK(res);
if (bmp) GDI_ReleaseObj(res);
if (bm.bmBits && bits) *bits = bm.bmBits;
return res;
}
@ -3642,6 +3647,7 @@ HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixma
pBmp->physBitmap = NULL;
pBmp->funcs = NULL;
}
GDI_ReleaseObj( hBmp );
DeleteObject(hBmp);
END:
@ -3695,6 +3701,7 @@ Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
pBmp->funcs = NULL;
/* Delete the DDB we created earlier now that we have stolen its pixmap */
GDI_ReleaseObj( hBmp );
DeleteObject(hBmp);
TRACE("\tReturning Pixmap %ld\n", pixmap);

6
graphics/x11drv/graphics.c
View file

@ -99,8 +99,6 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors )
val.background = X11DRV_PALETTE_XPixelToPalette[val.background];
}
if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
val.function = X11DRV_XROPfunction[dc->w.ROPmode-1];
/*
** Let's replace GXinvert by GXxor with (black xor white)
@ -187,8 +185,6 @@ BOOL X11DRV_SetupGCForPen( DC * dc )
if (physDev->pen.style == PS_NULL) return FALSE;
if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
switch (dc->w.ROPmode)
{
case R2_BLACK :
@ -275,8 +271,6 @@ BOOL X11DRV_SetupGCForText( DC * dc )
{
XGCValues val;
if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
val.function = GXcopy; /* Text is always GXcopy */
val.foreground = physDev->textPixel;
val.background = physDev->backgroundPixel;

13
graphics/x11drv/init.c
View file

@ -240,9 +240,13 @@ static BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
dc->w.devCaps = &X11DRV_DevCaps;
if (dc->w.flags & DC_MEMORY)
{
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->w.hBitmap,
BITMAP_MAGIC );
if (!bmp->physBitmap) X11DRV_CreateBitmap( dc->w.hBitmap );
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC );
if (!bmp)
{
HeapFree( GetProcessHeap(), 0, physDev );
return FALSE;
}
if (!bmp->physBitmap) X11DRV_CreateBitmap( dc->w.hBitmap );
physDev->drawable = (Pixmap)bmp->physBitmap;
physDev->gc = TSXCreateGC(display, physDev->drawable, 0, NULL);
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
@ -253,7 +257,7 @@ static BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
dc->w.hVisRgn = CreateRectRgnIndirect( &dc->w.totalExtent );
GDI_HEAP_UNLOCK( dc->w.hBitmap );
GDI_ReleaseObj( dc->w.hBitmap );
}
else
{
@ -274,6 +278,7 @@ static BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
if (!dc->w.hVisRgn)
{
TSXFreeGC( display, physDev->gc );
HeapFree( GetProcessHeap(), 0, physDev );
return FALSE;
}

4
graphics/x11drv/objects.c
View file

@ -58,7 +58,7 @@ HGDIOBJ X11DRV_SelectObject( DC *dc, HGDIOBJ handle )
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}
@ -83,7 +83,7 @@ BOOL X11DRV_DeleteObject( HGDIOBJ handle )
ret = FALSE;
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return ret;
}

26
graphics/x11drv/oembitmap.c
View file

@ -341,15 +341,12 @@ static BOOL OBM_InitColorSymbols()
static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
WORD bpp, Pixmap pixmap )
{
HBITMAP16 hbitmap;
HBITMAP hbitmap;
BITMAPOBJ * bmpObjPtr;
if (!pixmap) return 0;
hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
if (!hbitmap) return 0;
bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
if (!(bmpObjPtr = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC, &hbitmap ))) return 0;
bmpObjPtr->size.cx = width;
bmpObjPtr->size.cy = height;
bmpObjPtr->bitmap.bmType = 0;
@ -364,7 +361,7 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
bmpObjPtr->funcs = &X11DRV_DC_Funcs;
bmpObjPtr->physBitmap = (void *)pixmap;
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return hbitmap;
}
#endif /* defined(HAVE_LIBXXPM) */
@ -412,8 +409,8 @@ static BOOL OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
{
if (pixmap) XFreePixmap( display, pixmap );
if (pixmask) XFreePixmap( display, pixmask );
if (descr->bitmap) GDI_FreeObject( descr->bitmap );
if (descr->need_mask && descr->mask) GDI_FreeObject( descr->mask );
if (descr->bitmap) DeleteObject( descr->bitmap );
if (descr->need_mask && descr->mask) DeleteObject( descr->mask );
return FALSE;
}
else return TRUE;
@ -512,11 +509,7 @@ static HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL fCursor )
if (!(handle = GlobalAlloc16( GMEM_MOVEABLE,
sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
{
DeleteObject( descr.bitmap );
DeleteObject( descr.mask );
return 0;
}
goto done;
pInfo = (CURSORICONINFO *)GlobalLock16( handle );
pInfo->ptHotSpot.x = descr.hotspot.x;
@ -554,11 +547,12 @@ static HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL fCursor )
if (descr.mask) GetBitmapBits( descr.mask, sizeAnd, (char *)(pInfo + 1));
else memset( (char *)(pInfo + 1), 0xff, sizeAnd );
GetBitmapBits( descr.bitmap, sizeXor, (char *)(pInfo + 1) + sizeAnd );
if (fCursor) OBM_Cursors[id] = handle;
done:
GDI_ReleaseObj( descr.mask );
GDI_ReleaseObj( descr.bitmap );
DeleteObject( descr.bitmap );
DeleteObject( descr.mask );
if (fCursor) OBM_Cursors[id] = handle;
return handle;
}

17
graphics/x11drv/palette.c
View file

@ -692,14 +692,15 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
if( (idx = color & 0xffff) >= palPtr->logpalette.palNumEntries)
{
WARN("RGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx);
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return 0;
}
if( palPtr->mapping )
{
GDI_HEAP_UNLOCK( hPal );
return palPtr->mapping[idx];
int ret = palPtr->mapping[idx];
GDI_ReleaseObj( hPal );
return ret;
}
color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx);
break;
@ -711,7 +712,7 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
case 0: /* RGB */
if( dc && (dc->w.bitsPerPixel == 1) )
{
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return (((color >> 16) & 0xff) +
((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
}
@ -723,7 +724,7 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
if (X11DRV_PALETTE_Graymax)
{
/* grayscale only; return scaled value */
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return ( (red * 30 + green * 69 + blue * 11) * X11DRV_PALETTE_Graymax) / 25500;
}
else
@ -736,7 +737,7 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
if (X11DRV_PALETTE_Bluemax != 255)
blue = MulDiv(blue, X11DRV_PALETTE_Bluemax, 255);
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return (red << X11DRV_PALETTE_Redshift) | (green << X11DRV_PALETTE_Greenshift) | (blue << X11DRV_PALETTE_Blueshift);
}
}
@ -755,7 +756,7 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
case 0: /* RGB */
if( dc && (dc->w.bitsPerPixel == 1) )
{
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return (((color >> 16) & 0xff) +
((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
}
@ -786,7 +787,7 @@ int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color )
}
}
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return index;
}

2
graphics/x11drv/xfont.c
View file

@ -2991,7 +2991,7 @@ HFONT X11DRV_FONT_SelectObject( DC* dc, HFONT hfont, FONTOBJ* font )
*
* X11DRV_EnumDeviceFonts
*/
BOOL X11DRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
BOOL X11DRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC proc, LPARAM lp )
{
ENUMLOGFONTEX16 lf;

1
include/dc.h
View file

@ -16,6 +16,7 @@
extern DC * DC_AllocDC( const DC_FUNCTIONS *funcs );
extern DC * DC_GetDCPtr( HDC hdc );
extern DC * DC_GetDCUpdate( HDC hdc );
extern void DC_InitDC( DC * dc );
extern void DC_UpdateXforms( DC * dc );

30
include/gdi.h
View file

@ -193,7 +193,7 @@ typedef struct tagDC_FUNCS
INT (*pEndDoc)(DC*);
INT (*pEndPage)(DC*);
BOOL (*pEndPath)(DC*);
BOOL (*pEnumDeviceFonts)(DC*,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM);
BOOL (*pEnumDeviceFonts)(HDC,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM);
INT (*pEscape)(DC*,INT,INT,SEGPTR,SEGPTR);
INT (*pExcludeClipRect)(DC*,INT,INT,INT,INT);
INT (*pExtDeviceMode)(LPSTR,HWND,LPDEVMODEA,LPSTR,LPSTR,LPDEVMODEA,
@ -444,30 +444,12 @@ static inline void WINE_UNUSED INTERNAL_LPTODP(DC *dc, LPPOINT point)
/* GDI local heap */
extern WORD GDI_HeapSel;
#define GDI_HEAP_ALLOC(size) \
LOCAL_Alloc( GDI_HeapSel, LMEM_FIXED, (size) )
#define GDI_HEAP_ALLOC_MOVEABLE(size) \
LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, (size) )
#define GDI_HEAP_REALLOC(handle,size) \
LOCAL_ReAlloc( GDI_HeapSel, (handle), (size), LMEM_FIXED )
#define GDI_HEAP_FREE(handle) \
LOCAL_Free( GDI_HeapSel, (handle) )
#define GDI_HEAP_LOCK(handle) \
LOCAL_Lock( GDI_HeapSel, (handle) )
#define GDI_HEAP_LOCK_SEGPTR(handle) \
LOCAL_LockSegptr( GDI_HeapSel, (handle) )
#define GDI_HEAP_UNLOCK(handle) \
((((HGDIOBJ16)(handle) >= FIRST_STOCK_HANDLE) && \
((HGDIOBJ16)(handle)<=LAST_STOCK_HANDLE)) ? \
0 : LOCAL_Unlock( GDI_HeapSel, (handle) ))
extern BOOL GDI_Init(void);
extern HGDIOBJ GDI_AllocObject( WORD, WORD );
extern BOOL GDI_FreeObject( HGDIOBJ );
extern GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ, WORD );
extern void *GDI_AllocObject( WORD, WORD, HGDIOBJ * );
extern void *GDI_ReallocObject( WORD, HGDIOBJ, void *obj );
extern BOOL GDI_FreeObject( HGDIOBJ, void *obj );
extern void *GDI_GetObjPtr( HGDIOBJ, WORD );
extern void GDI_ReleaseObj( HGDIOBJ );
extern BOOL DRIVER_RegisterDriver( LPCSTR name, const DC_FUNCTIONS *funcs );
extern const DC_FUNCTIONS *DRIVER_FindDriver( LPCSTR name );

2
include/global.h
View file

@ -19,8 +19,6 @@ extern HGLOBAL16 GLOBAL_Alloc( WORD flags, DWORD size, HGLOBAL16 hOwner,
BOOL16 isCode, BOOL16 is32Bit,
BOOL16 isReadOnly );
extern WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle );
/* memory/virtual.c */
extern DWORD VIRTUAL_GetPageSize(void);
extern DWORD VIRTUAL_GetGranularity(void);

26
include/path.h
View file

@ -42,22 +42,24 @@ extern void PATH_DestroyGdiPath(GdiPath *pPath);
extern BOOL PATH_AssignGdiPath(GdiPath *pPathDest,
const GdiPath *pPathSrc);
extern BOOL PATH_MoveTo(HDC hdc);
extern BOOL PATH_LineTo(HDC hdc, INT x, INT y);
extern BOOL PATH_Rectangle(HDC hdc, INT x1, INT y1,
struct tagDC;
extern BOOL PATH_MoveTo(struct tagDC *dc);
extern BOOL PATH_LineTo(struct tagDC *dc, INT x, INT y);
extern BOOL PATH_Rectangle(struct tagDC *dc, INT x1, INT y1,
INT x2, INT y2);
extern BOOL PATH_Ellipse(HDC hdc, INT x1, INT y1,
extern BOOL PATH_Ellipse(struct tagDC *dc, INT x1, INT y1,
INT x2, INT y2);
extern BOOL PATH_Arc(HDC hdc, INT x1, INT y1, INT x2, INT y2,
extern BOOL PATH_Arc(struct tagDC *dc, INT x1, INT y1, INT x2, INT y2,
INT xStart, INT yStart, INT xEnd, INT yEnd);
extern BOOL PATH_PolyBezierTo(HDC hdc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolyBezier(HDC hdc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolylineTo(HDC hdc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_Polyline(HDC hdc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_Polygon(HDC hdc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolyPolyline(HDC hdc, const POINT *pt, const DWORD *counts,
extern BOOL PATH_PolyBezierTo(struct tagDC *dc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolyBezier(struct tagDC *dc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolylineTo(struct tagDC *dc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_Polyline(struct tagDC *dc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_Polygon(struct tagDC *dc, const POINT *pt, DWORD cbCount);
extern BOOL PATH_PolyPolyline(struct tagDC *dc, const POINT *pt, const DWORD *counts,
DWORD polylines);
extern BOOL PATH_PolyPolygon(HDC hdc, const POINT *pt, const INT *counts,
extern BOOL PATH_PolyPolygon(struct tagDC *dc, const POINT *pt, const INT *counts,
UINT polygons);
#endif /* __WINE_PATH_H */

1
include/win.h
View file

@ -54,7 +54,6 @@ typedef enum
struct tagCLASS;
struct tagDCE;
struct tagDC;
struct tagMESSAGEQUEUE;
struct tagWND_DRIVER;

2
include/win16drv.h
View file

@ -225,7 +225,7 @@ extern HGDIOBJ WIN16DRV_SelectObject( DC *dc, HGDIOBJ handle );
extern BOOL WIN16DRV_PatBlt( struct tagDC *dc, INT left, INT top,
INT width, INT height, DWORD rop );
extern BOOL WIN16DRV_Ellipse(DC *dc, INT left, INT top, INT right, INT bottom);
extern BOOL WIN16DRV_EnumDeviceFonts( DC* dc, LPLOGFONT16 plf,
extern BOOL WIN16DRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC proc, LPARAM lp );
extern INT WIN16DRV_ExtDeviceMode(LPSTR lpszDriver, HWND hwnd,

1
include/wine/winbase16.h
View file

@ -71,6 +71,7 @@ DWORD WINAPI GlobalDOSAlloc16(DWORD);
WORD WINAPI GlobalDOSFree16(WORD);
void WINAPI GlobalFreeAll16(HGLOBAL16);
DWORD WINAPI GlobalHandleNoRIP16(WORD);
WORD WINAPI GlobalHandleToSel16(HGLOBAL16);
HGLOBAL16 WINAPI GlobalLRUNewest16(HGLOBAL16);
HGLOBAL16 WINAPI GlobalLRUOldest16(HGLOBAL16);
VOID WINAPI GlobalNotify16(FARPROC16);

2
include/x11drv.h
View file

@ -90,7 +90,7 @@ extern const DC_FUNCTIONS X11DRV_DC_Funcs;
extern BOOL X11DRV_BitBlt( struct tagDC *dcDst, INT xDst, INT yDst,
INT width, INT height, struct tagDC *dcSrc,
INT xSrc, INT ySrc, DWORD rop );
extern BOOL X11DRV_EnumDeviceFonts( struct tagDC *dc, LPLOGFONT16 plf,
extern BOOL X11DRV_EnumDeviceFonts( HDC hdc, LPLOGFONT16 plf,
DEVICEFONTENUMPROC dfeproc, LPARAM lp );
extern BOOL X11DRV_GetCharWidth( struct tagDC *dc, UINT firstChar,
UINT lastChar, LPINT buffer );

36
memory/local.c
View file

@ -110,7 +110,6 @@ typedef struct
#define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
WORD USER_HeapSel = 0; /* USER heap selector */
WORD GDI_HeapSel = 0; /* GDI heap selector */
/* All local heap allocations are aligned on 4-byte boundaries */
#define LALIGN(word) (((word) + 3) & ~3)
@ -842,6 +841,29 @@ static HLOCAL16 LOCAL_FindFreeBlock( HANDLE16 ds, WORD size )
return 0;
}
/***********************************************************************
* get_heap_name
*/
static const char *get_heap_name( WORD ds )
{
HINSTANCE16 inst = LoadLibrary16( "GDI" );
if (ds == GlobalHandleToSel16( inst ))
{
FreeLibrary16( inst );
return "GDI";
}
FreeLibrary16( inst );
inst = LoadLibrary16( "USER" );
if (ds == GlobalHandleToSel16( inst ))
{
FreeLibrary16( inst );
return "USER";
}
FreeLibrary16( inst );
return "local";
}
/***********************************************************************
* LOCAL_GetBlock
* The segment may get moved around in this function, so all callers
@ -890,16 +912,8 @@ notify_done:
arena = LOCAL_FindFreeBlock( ds, size );
}
if (arena == 0) {
if (ds == GDI_HeapSel) {
ERR("not enough space in GDI local heap "
"(%04x) for %d bytes\n", ds, size );
} else if (ds == USER_HeapSel) {
ERR("not enough space in USER local heap "
"(%04x) for %d bytes\n", ds, size );
} else {
ERR("not enough space in local heap "
"%04x for %d bytes\n", ds, size );
}
ERR( "not enough space in %s heap %04x for %d bytes\n",
get_heap_name(ds), ds, size );
#if 0
if ((pInfo->notify) &&
/* FIXME: "size" correct ? (should indicate bytes needed) */

36
objects/bitmap.c
View file

@ -122,14 +122,11 @@ HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
if (width < 0) width = -width;
/* Create the BITMAPOBJ */
hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
if (!hbitmap) return 0;
if (!(bmp = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC, &hbitmap ))) return 0;
TRACE("%dx%d, %d colors returning %08x\n", width, height,
1 << (planes*bpp), hbitmap);
bmp = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
bmp->size.cx = 0;
bmp->size.cy = 0;
bmp->bitmap.bmType = 0;
@ -147,7 +144,7 @@ HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
if (bits) /* Set bitmap bits */
SetBitmapBits( hbitmap, height * bmp->bitmap.bmWidthBytes,
bits );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return hbitmap;
}
@ -193,7 +190,7 @@ HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
dc->funcs->pCreateBitmap( hbmpRet );
}
TRACE("\t\t%04x\n", hbmpRet);
GDI_HEAP_UNLOCK(hdc);
GDI_ReleaseObj(hdc);
return hbmpRet;
}
@ -251,7 +248,10 @@ LONG WINAPI GetBitmapBits(
/* If the bits vector is null, the function should return the read size */
if(bits == NULL)
return bmp->bitmap.bmWidthBytes * bmp->bitmap.bmHeight;
{
ret = bmp->bitmap.bmWidthBytes * bmp->bitmap.bmHeight;
goto done;
}
if (count < 0) {
WARN("(%ld): Negative number of bytes passed???\n", count );
@ -265,8 +265,8 @@ LONG WINAPI GetBitmapBits(
if (count == 0)
{
WARN("Less then one entire line requested\n");
GDI_HEAP_UNLOCK( hbitmap );
return 0;
ret = 0;
goto done;
}
@ -295,8 +295,8 @@ LONG WINAPI GetBitmapBits(
}
}
GDI_HEAP_UNLOCK( hbitmap );
done:
GDI_ReleaseObj( hbitmap );
return ret;
}
@ -365,7 +365,7 @@ LONG WINAPI SetBitmapBits(
}
}
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return ret;
}
@ -393,7 +393,7 @@ HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
HeapFree( GetProcessHeap(), 0, buf );
}
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return res;
}
@ -410,7 +410,7 @@ BOOL BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bmp )
DIB_DeleteDIBSection( bmp );
return GDI_FreeObject( hbitmap );
return GDI_FreeObject( hbitmap, bmp );
}
@ -523,7 +523,7 @@ BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
CONV_SIZE32TO16( &bmp->size, size );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return TRUE;
}
@ -542,7 +542,7 @@ BOOL WINAPI GetBitmapDimensionEx(
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
*size = bmp->size;
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return TRUE;
}
@ -569,7 +569,7 @@ BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y,
if (prevSize) CONV_SIZE32TO16( &bmp->size, prevSize );
bmp->size.cx = x;
bmp->size.cy = y;
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return TRUE;
}
@ -592,7 +592,7 @@ BOOL WINAPI SetBitmapDimensionEx(
if (prevSize) *prevSize = bmp->size;
bmp->size.cx = x;
bmp->size.cy = y;
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
return TRUE;
}

23
objects/brush.c
View file

@ -105,19 +105,19 @@ HBRUSH16 WINAPI CreateBrushIndirect16( const LOGBRUSH16 * brush )
{
BOOL success;
BRUSHOBJ * brushPtr;
HBRUSH16 hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
if (!hbrush) return 0;
brushPtr = (BRUSHOBJ *) GDI_HEAP_LOCK( hbrush );
HBRUSH hbrush;
if (!(brushPtr = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC, &hbrush ))) return 0;
brushPtr->logbrush.lbStyle = brush->lbStyle;
brushPtr->logbrush.lbColor = brush->lbColor;
brushPtr->logbrush.lbHatch = brush->lbHatch;
success = create_brush_indirect(brushPtr, TRUE);
GDI_HEAP_UNLOCK( hbrush );
if(!success)
{
GDI_FreeObject(hbrush);
GDI_FreeObject( hbrush, brushPtr );
hbrush = 0;
}
else GDI_ReleaseObj( hbrush );
TRACE("%04x\n", hbrush);
return hbrush;
}
@ -136,19 +136,18 @@ HBRUSH WINAPI CreateBrushIndirect( const LOGBRUSH * brush )
{
BOOL success;
BRUSHOBJ * brushPtr;
HBRUSH hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
if (!hbrush) return 0;
brushPtr = (BRUSHOBJ *) GDI_HEAP_LOCK( hbrush );
HBRUSH hbrush;
if (!(brushPtr = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC, &hbrush ))) return 0;
brushPtr->logbrush.lbStyle = brush->lbStyle;
brushPtr->logbrush.lbColor = brush->lbColor;
brushPtr->logbrush.lbHatch = brush->lbHatch;
success = create_brush_indirect(brushPtr, FALSE);
GDI_HEAP_UNLOCK( hbrush );
if(!success)
{
GDI_FreeObject(hbrush);
GDI_FreeObject( hbrush, brushPtr );
hbrush = 0;
}
else GDI_ReleaseObj( hbrush );
TRACE("%08x\n", hbrush);
return hbrush;
}
@ -319,6 +318,7 @@ DWORD WINAPI SetBrushOrg16( HDC16 hdc, INT16 x, INT16 y )
retval = dc->w.brushOrgX | (dc->w.brushOrgY << 16);
dc->w.brushOrgX = x;
dc->w.brushOrgY = y;
GDI_ReleaseObj( hdc );
return retval;
}
@ -338,6 +338,7 @@ BOOL WINAPI SetBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
}
dc->w.brushOrgX = x;
dc->w.brushOrgY = y;
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -365,7 +366,7 @@ BOOL BRUSH_DeleteObject( HBRUSH16 hbrush, BRUSHOBJ * brush )
GlobalFree16( (HGLOBAL16)brush->logbrush.lbHatch );
break;
}
return GDI_FreeObject( hbrush );
return GDI_FreeObject( hbrush, brush );
}

191
objects/clipping.c
View file

@ -12,15 +12,7 @@
#include "wingdi.h"
#include "wine/winuser16.h"
DEFAULT_DEBUG_CHANNEL(clipping)
DECLARE_DEBUG_CHANNEL(region)
#define UPDATE_DIRTY_DC(dc) \
do { \
if ((dc)->hookThunk && !((dc)->w.flags & (DC_SAVED | DC_MEMORY))) \
(dc)->hookThunk( (dc)->hSelf, DCHC_INVALIDVISRGN, (dc)->dwHookData, 0 ); \
} while(0)
DEFAULT_DEBUG_CHANNEL(clipping);
/***********************************************************************
@ -34,15 +26,11 @@ void CLIPPING_UpdateGCRegion( DC * dc )
if (!dc->w.hVisRgn)
{
ERR_(region)("hVisRgn is zero. Please report this.\n" );
ERR("hVisRgn is zero. Please report this.\n" );
exit(1);
}
if (dc->w.flags & DC_DIRTY)
{
UPDATE_DIRTY_DC(dc);
dc->w.flags &= ~DC_DIRTY;
}
if (dc->w.flags & DC_DIRTY) ERR( "DC is dirty. Please report this.\n" );
if (!dc->w.hClipRgn)
CombineRgn( dc->w.hGCClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
@ -83,7 +71,7 @@ INT16 WINAPI ExtSelectClipRgn16( HDC16 hdc, HRGN16 hrgn, INT16 fnMode )
INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
{
INT retval;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
DC * dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
TRACE("%04x %04x %d\n", hdc, hrgn, fnMode );
@ -99,6 +87,7 @@ INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
else
{
FIXME("Unimplemented: hrgn NULL in mode: %d\n", fnMode);
GDI_ReleaseObj( hdc );
return ERROR;
}
}
@ -119,9 +108,8 @@ INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
OffsetRgn( dc->w.hClipRgn, dc->w.DCOrgX, dc->w.DCOrgY );
}
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return retval;
}
@ -131,8 +119,10 @@ INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
INT16 WINAPI SelectVisRgn16( HDC16 hdc, HRGN16 hrgn )
{
int retval;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc || !hrgn) return ERROR;
DC * dc;
if (!hrgn) return ERROR;
if (!(dc = DC_GetDCPtr( hdc ))) return ERROR;
TRACE("%04x %04x\n", hdc, hrgn );
@ -140,7 +130,7 @@ INT16 WINAPI SelectVisRgn16( HDC16 hdc, HRGN16 hrgn )
retval = CombineRgn16( dc->w.hVisRgn, hrgn, 0, RGN_COPY );
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return retval;
}
@ -160,7 +150,7 @@ INT16 WINAPI OffsetClipRgn16( HDC16 hdc, INT16 x, INT16 y )
INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
{
INT ret = SIMPLEREGION;
DC *dc = DC_GetDCPtr( hdc );
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
TRACE("%04x %d,%d\n", hdc, x, y );
@ -171,7 +161,7 @@ INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
ret = OffsetRgn( dc->w.hClipRgn, XLSTODS(dc,x), YLSTODS(dc,y));
CLIPPING_UpdateGCRegion( dc );
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return ret;
}
@ -182,12 +172,12 @@ INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
INT16 WINAPI OffsetVisRgn16( HDC16 hdc, INT16 x, INT16 y )
{
INT16 retval;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
DC * dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
TRACE("%04x %d,%d\n", hdc, x, y );
retval = OffsetRgn( dc->w.hVisRgn, x, y );
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return retval;
}
@ -257,7 +247,7 @@ INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top,
INT right, INT bottom )
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
@ -272,7 +262,7 @@ INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top,
ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_EXCLUDE );
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return ret;
}
@ -294,7 +284,7 @@ INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top,
INT right, INT bottom )
{
INT ret;
DC *dc = DC_GetDCPtr( hdc );
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
@ -309,7 +299,7 @@ INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top,
ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_INTERSECT );
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return ret;
}
@ -346,12 +336,19 @@ INT CLIPPING_IntersectVisRect( DC * dc, INT left, INT top,
if (ret != ERROR)
{
RGNOBJ *newObj = (RGNOBJ*)GDI_GetObjPtr( newRgn, REGION_MAGIC);
RGNOBJ *prevObj = (RGNOBJ*)GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC);
if (newObj && prevObj) newObj->header.hNext = prevObj->header.hNext;
if (newObj)
{
RGNOBJ *prevObj = (RGNOBJ*)GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC);
if (prevObj)
{
newObj->header.hNext = prevObj->header.hNext;
GDI_ReleaseObj( dc->w.hVisRgn );
}
GDI_ReleaseObj( newRgn );
}
DeleteObject( dc->w.hVisRgn );
dc->w.hVisRgn = newRgn;
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( newRgn );
}
else DeleteObject( newRgn );
return ret;
@ -364,7 +361,8 @@ INT CLIPPING_IntersectVisRect( DC * dc, INT left, INT top,
INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
INT16 ret;
DC * dc = DC_GetDCUpdate( hdc );
if (!dc) return ERROR;
left = XLPTODP( dc, left );
@ -374,7 +372,9 @@ INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
ret = CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
GDI_ReleaseObj( hdc );
return ret;
}
@ -384,6 +384,7 @@ INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
INT16 WINAPI IntersectVisRect16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom )
{
INT16 ret;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return ERROR;
@ -394,7 +395,9 @@ INT16 WINAPI IntersectVisRect16( HDC16 hdc, INT16 left, INT16 top,
TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
ret = CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
GDI_ReleaseObj( hdc );
return ret;
}
@ -412,18 +415,19 @@ BOOL16 WINAPI PtVisible16( HDC16 hdc, INT16 x, INT16 y )
*/
BOOL WINAPI PtVisible( HDC hdc, INT x, INT y )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return ERROR;
BOOL ret = FALSE;
DC *dc = DC_GetDCUpdate( hdc );
TRACE("%04x %d,%d\n", hdc, x, y );
if (!dc->w.hGCClipRgn) return FALSE;
if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
dc->w.flags &= ~DC_DIRTY;
return PtInRegion( dc->w.hGCClipRgn, XLPTODP(dc,x) + dc->w.DCOrgX,
if (!dc) return FALSE;
if (dc->w.hGCClipRgn)
{
ret = PtInRegion( dc->w.hGCClipRgn, XLPTODP(dc,x) + dc->w.DCOrgX,
YLPTODP(dc,y) + dc->w.DCOrgY );
}
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
@ -431,20 +435,25 @@ BOOL WINAPI PtVisible( HDC hdc, INT x, INT y )
*/
BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect )
{
BOOL ret = FALSE;
RECT16 tmpRect;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
TRACE("%04x %d,%dx%d,%d\n",
hdc, rect->left, rect->top, rect->right, rect->bottom );
if (!dc->w.hGCClipRgn) return FALSE;
/* copy rectangle to avoid overwriting by LPtoDP */
tmpRect = *rect;
LPtoDP16( hdc, (LPPOINT16)&tmpRect, 2 );
tmpRect.left += dc->w.DCOrgX;
tmpRect.right += dc->w.DCOrgX;
tmpRect.top += dc->w.DCOrgY;
tmpRect.bottom += dc->w.DCOrgY;
return RectInRegion16( dc->w.hGCClipRgn, &tmpRect );
if (dc->w.hGCClipRgn)
{
/* copy rectangle to avoid overwriting by LPtoDP */
tmpRect = *rect;
LPtoDP16( hdc, (LPPOINT16)&tmpRect, 2 );
tmpRect.left += dc->w.DCOrgX;
tmpRect.right += dc->w.DCOrgX;
tmpRect.top += dc->w.DCOrgY;
tmpRect.bottom += dc->w.DCOrgY;
ret = RectInRegion16( dc->w.hGCClipRgn, &tmpRect );
}
GDI_ReleaseObj( hdc );
return ret;
}
@ -474,6 +483,7 @@ INT16 WINAPI GetClipBox16( HDC16 hdc, LPRECT16 rect )
rect->bottom -= dc->w.DCOrgY;
DPtoLP16( hdc, (LPPOINT16)rect, 2 );
TRACE("%d,%d-%d,%d\n", rect->left,rect->top,rect->right,rect->bottom );
GDI_ReleaseObj( hdc );
return ret;
}
@ -492,6 +502,7 @@ INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
rect->top -= dc->w.DCOrgY;
rect->bottom -= dc->w.DCOrgY;
DPtoLP( hdc, (LPPOINT)rect, 2 );
GDI_ReleaseObj( hdc );
return ret;
}
@ -501,8 +512,9 @@ INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
*/
INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if( dc && hRgn )
INT ret = -1;
DC * dc;
if (hRgn && (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )))
{
if( dc->w.hClipRgn )
{
@ -512,12 +524,13 @@ INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
if( CombineRgn(hRgn, dc->w.hClipRgn, 0, RGN_COPY) != ERROR )
{
OffsetRgn( hRgn, -dc->w.DCOrgX, -dc->w.DCOrgY );
return 1;
ret = 1;
}
}
else return 0;
else ret = 0;
GDI_ReleaseObj( hdc );
}
return -1;
return ret;
}
/***********************************************************************
@ -527,40 +540,35 @@ HRGN16 WINAPI SaveVisRgn16( HDC16 hdc )
{
HRGN copy;
RGNOBJ *obj, *copyObj;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
DC *dc = DC_GetDCUpdate( hdc );
if (!dc) return 0;
TRACE("%04x\n", hdc );
if (!dc->w.hVisRgn)
{
ERR_(region)("hVisRgn is zero. Please report this.\n" );
exit(1);
}
if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
dc->w.flags &= ~DC_DIRTY;
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
if (!(copy = CreateRectRgn( 0, 0, 0, 0 )))
{
GDI_HEAP_UNLOCK( dc->w.hVisRgn );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( dc->w.hVisRgn );
GDI_ReleaseObj( hdc );
return 0;
}
CombineRgn( copy, dc->w.hVisRgn, 0, RGN_COPY );
if (!(copyObj = (RGNOBJ *) GDI_GetObjPtr( copy, REGION_MAGIC )))
{
GDI_HEAP_UNLOCK( dc->w.hVisRgn );
GDI_HEAP_UNLOCK( hdc );
DeleteObject( copy );
GDI_ReleaseObj( dc->w.hVisRgn );
GDI_ReleaseObj( hdc );
return 0;
}
copyObj->header.hNext = obj->header.hNext;
obj->header.hNext = copy;
GDI_HEAP_UNLOCK( dc->w.hVisRgn );
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( copy );
GDI_ReleaseObj( copy );
GDI_ReleaseObj( dc->w.hVisRgn );
GDI_ReleaseObj( hdc );
return copy;
}
@ -573,37 +581,24 @@ INT16 WINAPI RestoreVisRgn16( HDC16 hdc )
HRGN saved;
RGNOBJ *obj, *savedObj;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
INT16 ret;
INT16 ret = ERROR;
if (!dc) return ERROR;
if (!dc->w.hVisRgn)
{
GDI_HEAP_UNLOCK( hdc );
return ERROR;
}
if (!dc->w.hVisRgn) goto done;
TRACE("%04x\n", hdc );
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
return ERROR;
}
if (!(saved = obj->header.hNext))
{
GDI_HEAP_UNLOCK( dc->w.hVisRgn );
GDI_HEAP_UNLOCK( hdc );
return ERROR;
}
if (!(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC )))
{
GDI_HEAP_UNLOCK( dc->w.hVisRgn );
GDI_HEAP_UNLOCK( hdc );
return ERROR;
}
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC ))) goto done;
saved = obj->header.hNext;
GDI_ReleaseObj( dc->w.hVisRgn );
if (!saved || !(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC ))) goto done;
DeleteObject( dc->w.hVisRgn );
dc->w.hVisRgn = saved;
dc->w.flags &= ~DC_DIRTY;
CLIPPING_UpdateGCRegion( dc );
GDI_HEAP_UNLOCK( hdc );
ret = savedObj->rgn->type; /* FIXME */
GDI_HEAP_UNLOCK( saved );
GDI_ReleaseObj( saved );
done:
GDI_ReleaseObj( hdc );
return ret;
}

259
objects/dc.c
View file

@ -83,12 +83,10 @@ static void DC_Init_DC_INFO( WIN_DC_INFO *win_dc_info )
*/
DC *DC_AllocDC( const DC_FUNCTIONS *funcs )
{
HDC16 hdc;
HDC hdc;
DC *dc;
if (!(hdc = GDI_AllocObject( sizeof(DC), DC_MAGIC ))) return NULL;
dc = (DC *) GDI_HEAP_LOCK( hdc );
if (!(dc = GDI_AllocObject( sizeof(DC), DC_MAGIC, &hdc ))) return NULL;
dc->hSelf = hdc;
dc->funcs = funcs;
dc->physDev = NULL;
@ -117,16 +115,45 @@ DC *DC_AllocDC( const DC_FUNCTIONS *funcs )
*/
DC *DC_GetDCPtr( HDC hdc )
{
GDIOBJHDR *ptr = (GDIOBJHDR *)GDI_HEAP_LOCK( hdc );
GDIOBJHDR *ptr = GDI_GetObjPtr( hdc, MAGIC_DONTCARE );
if (!ptr) return NULL;
if ((ptr->wMagic == DC_MAGIC) || (ptr->wMagic == METAFILE_DC_MAGIC) ||
(ptr->wMagic == ENHMETAFILE_DC_MAGIC))
return (DC *)ptr;
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
SetLastError( ERROR_INVALID_HANDLE );
return NULL;
}
/***********************************************************************
* DC_GetDCUpdate
*
* Retrieve a DC ptr while making sure the visRgn is updated.
* This function may call up to USER so the GDI lock should _not_
* be held when calling it.
*/
DC *DC_GetDCUpdate( HDC hdc )
{
DC *dc = DC_GetDCPtr( hdc );
if (!dc) return NULL;
while (dc->w.flags & DC_DIRTY)
{
dc->w.flags &= ~DC_DIRTY;
if (!(dc->w.flags & (DC_SAVED | DC_MEMORY)))
{
DCHOOKPROC proc = dc->hookThunk;
if (proc)
{
DWORD data = dc->dwHookData;
GDI_ReleaseObj( hdc );
proc( hdc, DCHC_INVALIDVISRGN, data, 0 );
if (!(dc = DC_GetDCPtr( hdc ))) break;
/* otherwise restart the loop in case it became dirty again in the meantime */
}
}
}
return dc;
}
/***********************************************************************
* DC_InitDC
@ -217,16 +244,14 @@ void DC_UpdateXforms( DC *dc )
HDC16 WINAPI GetDCState16( HDC16 hdc )
{
DC * newdc, * dc;
HGDIOBJ16 handle;
HGDIOBJ handle;
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
if (!(handle = GDI_AllocObject( sizeof(DC), DC_MAGIC )))
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if (!(newdc = GDI_AllocObject( sizeof(DC), DC_MAGIC, &handle )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
newdc = (DC *) GDI_HEAP_LOCK( handle );
TRACE("(%04x): returning %04x\n", hdc, handle );
newdc->w.flags = dc->w.flags | DC_SAVED;
@ -295,8 +320,8 @@ HDC16 WINAPI GetDCState16( HDC16 hdc )
}
else
newdc->w.hClipRgn = 0;
GDI_HEAP_UNLOCK( handle );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( handle );
GDI_ReleaseObj( hdc );
return handle;
}
@ -311,13 +336,13 @@ void WINAPI SetDCState16( HDC16 hdc, HDC16 hdcs )
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return;
if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return;
}
if (!dcs->w.flags & DC_SAVED)
{
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hdcs );
GDI_ReleaseObj( hdc );
GDI_ReleaseObj( hdcs );
return;
}
TRACE("%04x %04x\n", hdc, hdcs );
@ -386,8 +411,8 @@ void WINAPI SetDCState16( HDC16 hdc, HDC16 hdcs )
SetBkColor( hdc, dcs->w.backgroundColor);
SetTextColor( hdc, dcs->w.textColor);
GDISelectPalette16( hdc, dcs->w.hPalette, FALSE );
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hdcs );
GDI_ReleaseObj( hdcs );
GDI_ReleaseObj( hdc );
}
@ -409,18 +434,22 @@ INT WINAPI SaveDC( HDC hdc )
DC * dc, * dcs;
INT ret;
dc = DC_GetDCPtr( hdc );
dc = DC_GetDCUpdate( hdc );
if (!dc) return 0;
if(dc->funcs->pSaveDC)
return dc->funcs->pSaveDC( dc );
{
ret = dc->funcs->pSaveDC( dc );
GDI_ReleaseObj( hdc );
return ret;
}
if (!(hdcs = GetDCState16( hdc )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
dcs = (DC *) GDI_HEAP_LOCK( hdcs );
dcs = GDI_GetObjPtr( hdcs, DC_MAGIC );
/* Copy path. The reason why path saving / restoring is in SaveDC/
* RestoreDC and not in GetDCState/SetDCState is that the ...DCState
@ -430,8 +459,8 @@ INT WINAPI SaveDC( HDC hdc )
*/
if (!PATH_AssignGdiPath( &dcs->w.path, &dc->w.path ))
{
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hdcs );
GDI_ReleaseObj( hdc );
GDI_ReleaseObj( hdcs );
DeleteDC( hdcs );
return 0;
}
@ -440,8 +469,8 @@ INT WINAPI SaveDC( HDC hdc )
dc->header.hNext = hdcs;
TRACE("(%04x): returning %d\n", hdc, dc->saveLevel+1 );
ret = ++dc->saveLevel;
GDI_HEAP_UNLOCK( hdcs );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdcs );
GDI_ReleaseObj( hdc );
return ret;
}
@ -467,13 +496,23 @@ BOOL WINAPI RestoreDC( HDC hdc, INT level )
dc = DC_GetDCPtr( hdc );
if(!dc) return FALSE;
if(dc->funcs->pRestoreDC)
return dc->funcs->pRestoreDC( dc, level );
{
success = dc->funcs->pRestoreDC( dc, level );
GDI_ReleaseObj( hdc );
return success;
}
if (level == -1) level = dc->saveLevel;
if ((level < 1) || (level > dc->saveLevel))
if ((level < 1)
/* This pair of checks disagrees with MSDN "Platform SDK:
Windows GDI" July 2000 which says all negative values
for level will be interpreted as an instance relative
to the current state. Restricting it to just -1 does
not satisfy this */
|| (level > dc->saveLevel))
{
GDI_HEAP_UNLOCK( hdc );
return FALSE;
GDI_ReleaseObj( hdc );
return FALSE;
}
success=TRUE;
@ -482,7 +521,7 @@ BOOL WINAPI RestoreDC( HDC hdc, INT level )
HDC16 hdcs = dc->header.hNext;
if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return FALSE;
}
dc->header.hNext = dcs->header.hNext;
@ -494,9 +533,10 @@ BOOL WINAPI RestoreDC( HDC hdc, INT level )
* returning FALSE but still destroying the saved DC state */
success=FALSE;
}
GDI_ReleaseObj( hdcs );
DeleteDC( hdcs );
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return success;
}
@ -507,6 +547,7 @@ BOOL WINAPI RestoreDC( HDC hdc, INT level )
HDC16 WINAPI CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
const DEVMODEA *initData )
{
HDC hdc;
DC * dc;
const DC_FUNCTIONS *funcs;
char buf[300];
@ -525,13 +566,14 @@ HDC16 WINAPI CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
!dc->funcs->pCreateDC( dc, buf, device, output, initData ))
{
WARN("creation aborted by device\n" );
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
return 0;
}
DC_InitDC( dc );
GDI_HEAP_UNLOCK( dc->hSelf );
return dc->hSelf;
hdc = dc->hSelf;
GDI_ReleaseObj( hdc );
return hdc;
}
@ -615,9 +657,12 @@ HDC WINAPI CreateCompatibleDC( HDC hdc )
if ((origDC = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC ))) funcs = origDC->funcs;
else funcs = DRIVER_FindDriver( "DISPLAY" );
if (!funcs) return 0;
if (!(dc = DC_AllocDC( funcs ))) return 0;
if (!funcs || !(dc = DC_AllocDC( funcs )))
{
if (origDC) GDI_ReleaseObj( hdc );
return 0;
}
TRACE("(%04x): returning %04x\n",
hdc, dc->hSelf );
@ -636,12 +681,14 @@ HDC WINAPI CreateCompatibleDC( HDC hdc )
!dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
{
WARN("creation aborted by device\n");
GDI_HEAP_FREE( dc->hSelf );
GDI_FreeObject( dc->hSelf, dc );
if (origDC) GDI_ReleaseObj( hdc );
return 0;
}
DC_InitDC( dc );
GDI_HEAP_UNLOCK( dc->hSelf );
GDI_ReleaseObj( dc->hSelf );
if (origDC) GDI_ReleaseObj( hdc );
return dc->hSelf;
}
@ -666,11 +713,16 @@ BOOL WINAPI DeleteDC( HDC hdc )
TRACE("%04x\n", hdc );
/* Call hook procedure to check whether is it OK to delete this DC */
if ( dc->hookThunk && !(dc->w.flags & (DC_SAVED | DC_MEMORY))
&& dc->hookThunk( hdc, DCHC_DELETEDC, dc->dwHookData, 0 ) == FALSE )
if (dc->hookThunk && !(dc->w.flags & (DC_SAVED | DC_MEMORY)))
{
GDI_HEAP_UNLOCK( hdc );
return FALSE;
DCHOOKPROC proc = dc->hookThunk;
if (proc)
{
DWORD data = dc->dwHookData;
GDI_ReleaseObj( hdc );
if (!proc( hdc, DCHC_DELETEDC, data, 0 )) return FALSE;
if (!(dc = DC_GetDCPtr( hdc ))) return FALSE;
}
}
while (dc->saveLevel)
@ -680,6 +732,7 @@ BOOL WINAPI DeleteDC( HDC hdc )
if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) break;
dc->header.hNext = dcs->header.hNext;
dc->saveLevel--;
GDI_ReleaseObj( hdcs );
DeleteDC( hdcs );
}
@ -698,7 +751,7 @@ BOOL WINAPI DeleteDC( HDC hdc )
if (dc->hookThunk) THUNK_Free( (FARPROC)dc->hookThunk );
PATH_DestroyGdiPath(&dc->w.path);
return GDI_FreeObject( hdc );
return GDI_FreeObject( hdc, dc );
}
@ -747,7 +800,7 @@ INT16 WINAPI GetDeviceCaps16( HDC16 hdc, INT16 cap )
INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
INT ret;
INT ret = 0;
POINT pt;
if (!dc) return 0;
@ -777,7 +830,7 @@ INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
if ((cap < 0) || (cap > sizeof(DeviceCaps)-sizeof(WORD)))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
@ -788,7 +841,7 @@ INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
TRACE("(%04x,%d): returning %d\n",
hdc, cap, *(WORD *)(((char *)dc->w.devCaps) + cap) );
ret = *(WORD *)(((char *)dc->w.devCaps) + cap);
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return ret;
}
@ -817,7 +870,7 @@ COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
oldColor = dc->w.backgroundColor;
dc->w.backgroundColor = color;
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return oldColor;
}
@ -846,7 +899,7 @@ COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
oldColor = dc->w.textColor;
dc->w.textColor = color;
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return oldColor;
}
@ -873,7 +926,7 @@ UINT WINAPI SetTextAlign( HDC hdc, UINT align )
prevAlign = dc->w.textAlign;
dc->w.textAlign = align;
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return prevAlign;
}
@ -891,7 +944,7 @@ BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
if (dc->funcs->pGetDCOrgEx) dc->funcs->pGetDCOrgEx( dc, lpp );
lpp->x += dc->w.DCOrgX;
lpp->y += dc->w.DCOrgY;
GDI_HEAP_UNLOCK( hDC );
GDI_ReleaseObj( hDC );
return TRUE;
}
@ -919,28 +972,17 @@ DWORD WINAPI SetDCOrg16( HDC16 hdc, INT16 x, INT16 y )
prevOrg = dc->w.DCOrgX | (dc->w.DCOrgY << 16);
dc->w.DCOrgX = x;
dc->w.DCOrgY = y;
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return prevOrg;
}
/***********************************************************************
* GetGraphicsMode (GDI32.188)
*/
INT WINAPI GetGraphicsMode( HDC hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
return dc->w.GraphicsMode;
}
/***********************************************************************
* SetGraphicsMode (GDI32.317)
*/
INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
{
INT ret;
INT ret = 0;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
/* One would think that setting the graphics mode to GM_COMPATIBLE
@ -950,36 +992,16 @@ INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
*/
if (!dc) return 0;
if ((mode <= 0) || (mode > GM_LAST)) return 0;
if ((mode > 0) || (mode <= GM_LAST))
{
ret = dc->w.GraphicsMode;
dc->w.GraphicsMode = mode;
}
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
* GetArcDirection16 (GDI.524)
*/
INT16 WINAPI GetArcDirection16( HDC16 hdc )
{
return GetArcDirection( (HDC)hdc );
}
/***********************************************************************
* GetArcDirection (GDI32.141)
*/
INT WINAPI GetArcDirection( HDC hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
return 0;
return dc->w.ArcDirection;
}
/***********************************************************************
* SetArcDirection16 (GDI.525)
*/
@ -994,11 +1016,8 @@ INT16 WINAPI SetArcDirection16( HDC16 hdc, INT16 nDirection )
*/
INT WINAPI SetArcDirection( HDC hdc, INT nDirection )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
INT nOldDirection;
if (!dc)
return 0;
DC * dc;
INT nOldDirection = 0;
if (nDirection!=AD_COUNTERCLOCKWISE && nDirection!=AD_CLOCKWISE)
{
@ -1006,9 +1025,12 @@ INT WINAPI SetArcDirection( HDC hdc, INT nDirection )
return 0;
}
if ((dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )))
{
nOldDirection = dc->w.ArcDirection;
dc->w.ArcDirection = nDirection;
GDI_ReleaseObj( hdc );
}
return nOldDirection;
}
@ -1018,15 +1040,11 @@ INT WINAPI SetArcDirection( HDC hdc, INT nDirection )
*/
BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
return FALSE;
if (!xform)
return FALSE;
DC * dc;
if (!xform) return FALSE;
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
*xform = dc->w.xformWorld2Wnd;
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -1036,6 +1054,7 @@ BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
*/
BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
{
BOOL ret = FALSE;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
@ -1044,18 +1063,17 @@ BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
return FALSE;
}
if (!xform)
return FALSE;
if (!xform) goto done;
/* Check that graphics mode is GM_ADVANCED */
if (dc->w.GraphicsMode!=GM_ADVANCED)
return FALSE;
if (dc->w.GraphicsMode!=GM_ADVANCED) goto done;
dc->w.xformWorld2Wnd = *xform;
DC_UpdateXforms( dc );
return TRUE;
ret = TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
@ -1084,6 +1102,7 @@ BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform,
DWORD iMode )
{
BOOL ret = FALSE;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
/* Check for illegal parameters */
@ -1092,12 +1111,10 @@ BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform,
SetLastError( ERROR_INVALID_HANDLE );
return FALSE;
}
if (!xform)
return FALSE;
if (!xform) goto done;
/* Check that graphics mode is GM_ADVANCED */
if (dc->w.GraphicsMode!=GM_ADVANCED)
return FALSE;
if (dc->w.GraphicsMode!=GM_ADVANCED) goto done;
switch (iMode)
{
@ -1118,12 +1135,14 @@ BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform,
xform );
break;
default:
return FALSE;
goto done;
}
DC_UpdateXforms( dc );
return TRUE;
ret = TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
@ -1206,7 +1225,7 @@ BOOL16 WINAPI SetDCHook( HDC16 hdc, FARPROC16 hookProc, DWORD dwHookData )
dc->hookThunk = (DCHOOKPROC)
THUNK_Alloc( hookProc, (RELAY)GDI_CallTo16_word_wwll );
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -1219,7 +1238,7 @@ DWORD WINAPI GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
*phookProc = dc->hookProc;
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return dc->dwHookData;
}
@ -1244,7 +1263,7 @@ WORD WINAPI SetHookFlags16(HDC16 hDC, WORD flags)
dc->w.flags |= DC_DIRTY;
else if( flags & DCHF_VALIDATEVISRGN || !flags )
dc->w.flags &= ~DC_DIRTY;
GDI_HEAP_UNLOCK( hDC );
GDI_ReleaseObj( hDC );
return wRet;
}
return 0;

135
objects/dcvalues.c
View file

@ -5,31 +5,55 @@
*
*/
#include "winbase.h"
#include "winerror.h"
#include "gdi.h"
#include "dc.h"
#define COLORREF16 COLORREF /*hack*/
#define DC_GET_VAL_16( func_type, func_name, dc_field ) \
func_type WINAPI func_name( HDC16 hdc ) \
{ \
func_type ret = 0; \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return 0; \
return dc->dc_field; \
if (dc) \
{ \
ret = dc->dc_field; \
GDI_ReleaseObj( hdc ); \
} \
return ret; \
}
#define DC_GET_VAL_32( func_type, func_name, dc_field ) \
#define DC_GET_VAL( func_type, func_name, dc_field ) \
func_type##16 WINAPI func_name##16( HDC16 hdc ) \
{ \
return func_name( hdc ); \
} \
\
func_type WINAPI func_name( HDC hdc ) \
{ \
func_type ret = 0; \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return 0; \
return dc->dc_field; \
if (dc) \
{ \
ret = dc->dc_field; \
GDI_ReleaseObj( hdc ); \
} \
return ret; \
}
#define DC_GET_X_Y( func_type, func_name, ret_x, ret_y ) \
func_type WINAPI func_name( HDC16 hdc ) \
{ \
func_type ret = 0; \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return 0; \
return MAKELONG( dc->ret_x, dc->ret_y ); \
if (dc) \
{ \
ret = MAKELONG( dc->ret_x, dc->ret_y ); \
GDI_ReleaseObj( hdc ); \
} \
return ret; \
}
/* DC_GET_VAL_EX is used to define functions returning a POINT or a SIZE. It is
@ -43,15 +67,17 @@ BOOL16 WINAPI func_name##16( HDC16 hdc, LP##type##16 pt ) \
if (!dc) return FALSE; \
((LPPOINT16)pt)->x = dc->ret_x; \
((LPPOINT16)pt)->y = dc->ret_y; \
GDI_ReleaseObj( hdc ); \
return TRUE; \
} \
\
BOOL WINAPI func_name( HDC hdc, LP##type pt ) \
{ \
DC * dc = (DC *) GDI_GetObjPtr( (HDC16)hdc, DC_MAGIC ); \
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); \
if (!dc) return FALSE; \
((LPPOINT)pt)->x = dc->ret_x; \
((LPPOINT)pt)->y = dc->ret_y; \
GDI_ReleaseObj( hdc ); \
return TRUE; \
}
@ -64,16 +90,19 @@ INT16 WINAPI func_name##16( HDC16 hdc, INT16 mode ) \
INT WINAPI func_name( HDC hdc, INT mode ) \
{ \
INT prevMode; \
DC *dc = DC_GetDCPtr( hdc ); \
if(!dc) return 0; \
if ((mode < min_val) || (mode > max_val)) return 0; \
DC *dc; \
if ((mode < min_val) || (mode > max_val)) { \
SetLastError(ERROR_INVALID_PARAMETER); \
return 0; \
} \
if (!(dc = DC_GetDCPtr( hdc ))) return 0; \
if (dc->funcs->p##func_name) { \
prevMode = dc->funcs->p##func_name( dc, mode ); \
} else { \
prevMode = dc->dc_field; \
dc->dc_field = mode; \
} \
GDI_HEAP_UNLOCK( hdc ); \
GDI_ReleaseObj( hdc ); \
return prevMode; \
}
@ -104,24 +133,14 @@ DC_SET_MODE( SetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
DC_SET_MODE( SetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
/***********************************************************************
* GetBkColor16 (GDI.75)
* GetBkColor (GDI.75) (GDI32.145)
*/
DC_GET_VAL_16( COLORREF, GetBkColor16, w.backgroundColor )
DC_GET_VAL( COLORREF, GetBkColor, w.backgroundColor )
/***********************************************************************
* GetBkColor (GDI32.145)
* GetBkMode (GDI.76) (GDI32.146)
*/
DC_GET_VAL_32( COLORREF, GetBkColor, w.backgroundColor )
/***********************************************************************
* GetBkMode16 (GDI.76)
*/
DC_GET_VAL_16( INT16, GetBkMode16, w.backgroundMode )
/***********************************************************************
* GetBkMode (GDI32.146)
*/
DC_GET_VAL_32( INT, GetBkMode, w.backgroundMode )
DC_GET_VAL( INT, GetBkMode, w.backgroundMode )
/***********************************************************************
* GetCurrentPosition16 (GDI.78)
@ -129,34 +148,19 @@ DC_GET_VAL_32( INT, GetBkMode, w.backgroundMode )
DC_GET_X_Y( DWORD, GetCurrentPosition16, w.CursPosX, w.CursPosY )
/***********************************************************************
* GetMapMode16 (GDI.81)
* GetMapMode (GDI.81) (GDI32.196)
*/
DC_GET_VAL_16( INT16, GetMapMode16, w.MapMode )
DC_GET_VAL( INT, GetMapMode, w.MapMode )
/***********************************************************************
* GetMapMode (GDI32.196)
* GetPolyFillMode (GDI.84) (GDI32.213)
*/
DC_GET_VAL_32( INT, GetMapMode, w.MapMode )
DC_GET_VAL( INT, GetPolyFillMode, w.polyFillMode )
/***********************************************************************
* GetPolyFillMode16 (GDI.84)
* GetROP2 (GDI.85) (GDI32.214)
*/
DC_GET_VAL_16( INT16, GetPolyFillMode16, w.polyFillMode )
/***********************************************************************
* GetPolyFillMode (GDI32.213)
*/
DC_GET_VAL_32( INT, GetPolyFillMode, w.polyFillMode )
/***********************************************************************
* GetROP216 (GDI.85)
*/
DC_GET_VAL_16( INT16, GetROP216, w.ROPmode )
/***********************************************************************
* GetROP2 (GDI32.214)
*/
DC_GET_VAL_32( INT, GetROP2, w.ROPmode )
DC_GET_VAL( INT, GetROP2, w.ROPmode )
/***********************************************************************
* GetRelAbs16 (GDI.86)
@ -164,24 +168,14 @@ DC_GET_VAL_32( INT, GetROP2, w.ROPmode )
DC_GET_VAL_16( INT16, GetRelAbs16, w.relAbsMode )
/***********************************************************************
* GetStretchBltMode16 (GDI.88)
* GetStretchBltMode (GDI.88) (GDI32.221)
*/
DC_GET_VAL_16( INT16, GetStretchBltMode16, w.stretchBltMode )
DC_GET_VAL( INT, GetStretchBltMode, w.stretchBltMode )
/***********************************************************************
* GetStretchBltMode (GDI32.221)
* GetTextColor (GDI.90) (GDI32.227)
*/
DC_GET_VAL_32( INT, GetStretchBltMode, w.stretchBltMode )
/***********************************************************************
* GetTextColor16 (GDI.90)
*/
DC_GET_VAL_16( COLORREF, GetTextColor16, w.textColor )
/***********************************************************************
* GetTextColor (GDI32.227)
*/
DC_GET_VAL_32( COLORREF, GetTextColor, w.textColor )
DC_GET_VAL( COLORREF, GetTextColor, w.textColor )
/***********************************************************************
* GetViewportExt16 (GDI.94)
@ -219,20 +213,25 @@ DC_GET_VAL_16( HRGN16, GetClipRgn16, w.hClipRgn )
DC_GET_X_Y( DWORD, GetBrushOrg16, w.brushOrgX, w.brushOrgY )
/***********************************************************************
* GetTextAlign16 (GDI.345)
* GetTextAlign (GDI.345) (GDI32,224)
*/
DC_GET_VAL_16( UINT16, GetTextAlign16, w.textAlign )
/***********************************************************************
* GetTextAlign (GDI32.224)
*/
DC_GET_VAL_32( UINT, GetTextAlign, w.textAlign )
DC_GET_VAL( UINT, GetTextAlign, w.textAlign )
/***********************************************************************
* GetCurLogFont16 (GDI.411)
*/
DC_GET_VAL_16( HFONT16, GetCurLogFont16, w.hFont )
/***********************************************************************
* GetArcDirection (GDI.524) (GDI32.141)
*/
DC_GET_VAL( INT, GetArcDirection, w.ArcDirection )
/***********************************************************************
* GetGraphicsMode (GDI32.188)
*/
DC_GET_VAL( INT, GetGraphicsMode, w.GraphicsMode)
/***********************************************************************
* GetBrushOrgEx (GDI.469) (GDI32.148)
*/

101
objects/dib.c
View file

@ -133,11 +133,11 @@ INT WINAPI StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst,
INT heightSrc, const void *bits,
const BITMAPINFO *info, UINT wUsage, DWORD dwRop )
{
DC *dc = DC_GetDCPtr( hdc );
DC *dc = DC_GetDCUpdate( hdc );
if(!dc) return FALSE;
if(dc->funcs->pStretchDIBits)
return dc->funcs->pStretchDIBits(dc, xDst, yDst, widthDst,
heightSrc = dc->funcs->pStretchDIBits(dc, xDst, yDst, widthDst,
heightDst, xSrc, ySrc, widthSrc,
heightSrc, bits, info, wUsage,
dwRop);
@ -157,8 +157,9 @@ INT WINAPI StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst,
SelectObject( hdcMem, hOldBitmap );
DeleteDC( hdcMem );
DeleteObject( hBitmap );
return heightSrc;
}
GDI_ReleaseObj( hdc );
return heightSrc;
}
@ -198,16 +199,11 @@ INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
INT result;
/* Check parameters */
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if (!(bitmap = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
@ -215,8 +211,8 @@ INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
lines, bits, info,
coloruse, hbitmap);
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hbitmap );
GDI_ReleaseObj( hdc );
return result;
}
@ -246,7 +242,7 @@ INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
INT ret;
DC *dc;
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if(dc->funcs->pSetDIBitsToDevice)
ret = dc->funcs->pSetDIBitsToDevice( dc, xDest, yDest, cx, cy, xSrc,
@ -257,7 +253,7 @@ INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
ret = 0;
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return ret;
}
@ -281,15 +277,11 @@ UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries,
PALETTEOBJ * palette;
RGBQUAD *end;
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
{
GDI_ReleaseObj( hdc );
return 0;
}
@ -312,7 +304,8 @@ UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries,
} else {
entries = 0;
}
GDI_HEAP_UNLOCK( dc->w.hPalette );
GDI_ReleaseObj( dc->w.hPalette );
GDI_ReleaseObj( hdc );
return entries;
}
@ -336,15 +329,11 @@ UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries,
PALETTEOBJ * palette;
RGBQUAD *end;
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
{
GDI_ReleaseObj( hdc );
return 0;
}
@ -365,7 +354,8 @@ UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries,
} else {
entries = 0;
}
GDI_HEAP_UNLOCK( dc->w.hPalette );
GDI_ReleaseObj( dc->w.hPalette );
GDI_ReleaseObj( hdc );
return entries;
}
@ -456,21 +446,16 @@ INT WINAPI GetDIBits(
int i;
if (!info) return 0;
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
if (!(dc = DC_GetDCUpdate( hdc ))) return 0;
if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return 0;
}
if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
{
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hdc );
GDI_ReleaseObj( hbitmap );
return 0;
}
@ -530,7 +515,7 @@ INT WINAPI GetDIBits(
}
}
GDI_HEAP_UNLOCK( dc->w.hPalette );
GDI_ReleaseObj( dc->w.hPalette );
if (bits && lines)
{
@ -728,10 +713,10 @@ INT WINAPI GetDIBits(
/* Otherwise, get bits from the XImage */
else if(!BITMAP_Driver->pGetDIBits(bmp, dc, startscan, lines, bits, info, coloruse, hbitmap))
{
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hdc );
GDI_ReleaseObj( hbitmap );
return FALSE;
return 0;
}
}
else if( info->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
@ -763,8 +748,8 @@ INT WINAPI GetDIBits(
info->bmiHeader.biSizeImage, info->bmiHeader.biWidth,
info->bmiHeader.biHeight);
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hbitmap );
GDI_ReleaseObj( hdc );
GDI_ReleaseObj( hbitmap );
return lines;
}
@ -870,7 +855,7 @@ HBITMAP16 WINAPI CreateDIBSection16 (HDC16 hdc, BITMAPINFO *bmi, UINT16 usage,
SEGPTR *bits, HANDLE section,
DWORD offset)
{
HBITMAP16 hbitmap;
HBITMAP16 hbitmap = 0;
DC *dc;
BOOL bDesktopDC = FALSE;
@ -881,13 +866,11 @@ HBITMAP16 WINAPI CreateDIBSection16 (HDC16 hdc, BITMAPINFO *bmi, UINT16 usage,
bDesktopDC = TRUE;
}
dc = (DC *) GDI_GetObjPtr(hdc, DC_MAGIC);
if(!dc) dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if(!dc) return (HBITMAP16) NULL;
hbitmap = dc->funcs->pCreateDIBSection16(dc, bmi, usage, bits, section, offset, 0);
GDI_HEAP_UNLOCK(hdc);
if ((dc = DC_GetDCPtr( hdc )))
{
hbitmap = dc->funcs->pCreateDIBSection16(dc, bmi, usage, bits, section, offset, 0);
GDI_ReleaseObj(hdc);
}
if (bDesktopDC)
DeleteDC(hdc);
@ -902,7 +885,7 @@ HBITMAP DIB_CreateDIBSection(HDC hdc, BITMAPINFO *bmi, UINT usage,
LPVOID *bits, HANDLE section,
DWORD offset, DWORD ovr_pitch)
{
HBITMAP hbitmap;
HBITMAP hbitmap = 0;
DC *dc;
BOOL bDesktopDC = FALSE;
@ -913,13 +896,11 @@ HBITMAP DIB_CreateDIBSection(HDC hdc, BITMAPINFO *bmi, UINT usage,
bDesktopDC = TRUE;
}
dc = (DC *) GDI_GetObjPtr(hdc, DC_MAGIC);
if(!dc) dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if(!dc) return (HBITMAP) NULL;
hbitmap = dc->funcs->pCreateDIBSection(dc, bmi, usage, bits, section, offset, ovr_pitch);
GDI_HEAP_UNLOCK(hdc);
if ((dc = DC_GetDCPtr( hdc )))
{
hbitmap = dc->funcs->pCreateDIBSection(dc, bmi, usage, bits, section, offset, ovr_pitch);
GDI_ReleaseObj(hdc);
}
if (bDesktopDC)
DeleteDC(hdc);
@ -976,6 +957,7 @@ HGLOBAL DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
/* Get a pointer to the BITMAPOBJ structure */
pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
if (!pBmp) return hPackedDIB;
/* Get the bitmap dimensions */
width = pBmp->bitmap.bmWidth;
@ -1042,5 +1024,6 @@ HGLOBAL DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
}
END:
GDI_ReleaseObj( hBmp );
return hPackedDIB;
}

17
objects/enhmetafile.c
View file

@ -35,13 +35,16 @@ DEFAULT_DEBUG_CHANNEL(enhmetafile)
HENHMETAFILE EMF_Create_HENHMETAFILE(ENHMETAHEADER *emh, HFILE hFile, HANDLE
hMapping )
{
HENHMETAFILE hmf = GDI_AllocObject( sizeof(ENHMETAFILEOBJ),
ENHMETAFILE_MAGIC );
ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_HEAP_LOCK( hmf );
HENHMETAFILE hmf = 0;
ENHMETAFILEOBJ *metaObj = GDI_AllocObject( sizeof(ENHMETAFILEOBJ),
ENHMETAFILE_MAGIC, &hmf );
if (metaObj)
{
metaObj->emh = emh;
metaObj->hFile = hFile;
metaObj->hMapping = hMapping;
GDI_HEAP_UNLOCK( hmf );
GDI_ReleaseObj( hmf );
}
return hmf;
}
@ -59,7 +62,7 @@ static BOOL EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf )
CloseHandle( metaObj->hFile );
} else
HeapFree( GetProcessHeap(), 0, metaObj->emh );
return GDI_FreeObject( hmf );
return GDI_FreeObject( hmf, metaObj );
}
/******************************************************************
@ -81,9 +84,9 @@ static ENHMETAHEADER *EMF_GetEnhMetaHeader( HENHMETAFILE hmf )
*
* Releases ENHMETAHEADER associated with HENHMETAFILE
*/
static BOOL EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf )
static void EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf )
{
return GDI_HEAP_UNLOCK( hmf );
GDI_ReleaseObj( hmf );
}
/*****************************************************************************

196
objects/font.c
View file

@ -309,15 +309,13 @@ void FONT_TextMetric32Ato32W(const LPTEXTMETRICA ptm32A, LPTEXTMETRICW ptm32W )
*/
HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *font )
{
HFONT16 hFont = 0;
HFONT hFont = 0;
if (font)
{
hFont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
if( hFont )
{
FONTOBJ* fontPtr;
fontPtr = (FONTOBJ *) GDI_HEAP_LOCK( hFont );
if ((fontPtr = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC, &hFont )))
{
memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
TRACE("(%i %i %i %i) '%s' %s %s => %04x\n",
@ -334,7 +332,7 @@ HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *font )
"escapement angle %f for new font %04x\n",
font->lfOrientation/10., font->lfEscapement/10., hFont);
}
GDI_HEAP_UNLOCK( hFont );
GDI_ReleaseObj( hFont );
}
}
else WARN("(NULL) => NULL\n");
@ -535,10 +533,15 @@ INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
FONTENUMPROCEX16 efproc, LPARAM lParam,
DWORD dwFlags)
{
BOOL (*enum_func)(HDC,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM);
INT16 retVal = 0;
DC* dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
DC* dc = DC_GetDCPtr( hDC );
if( dc && dc->funcs->pEnumDeviceFonts )
if (!dc) return 0;
enum_func = dc->funcs->pEnumDeviceFonts;
GDI_ReleaseObj( hDC );
if (enum_func)
{
LPNEWTEXTMETRICEX16 lptm16 = SEGPTR_ALLOC( sizeof(NEWTEXTMETRICEX16) );
if( lptm16 )
@ -557,8 +560,7 @@ INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
fe16.segTextMetric = SEGPTR_GET(lptm16);
fe16.segLogFont = SEGPTR_GET(lplf16);
retVal = dc->funcs->pEnumDeviceFonts( dc, plf, FONT_EnumInstance16, (LPARAM)&fe16 );
retVal = enum_func( hDC, plf, FONT_EnumInstance16, (LPARAM)&fe16 );
SEGPTR_FREE(lplf16);
}
SEGPTR_FREE(lptm16);
@ -573,9 +575,15 @@ INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCEXW efproc,
LPARAM lParam, DWORD dwUnicode)
{
DC* dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
BOOL (*enum_func)(HDC,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM);
INT ret = 0;
DC *dc = DC_GetDCPtr( hDC );
if( dc && dc->funcs->pEnumDeviceFonts )
if (!dc) return 0;
enum_func = dc->funcs->pEnumDeviceFonts;
GDI_ReleaseObj( hDC );
if (enum_func)
{
LOGFONT16 lf16;
NEWTEXTMETRICEXW tm32w;
@ -602,9 +610,9 @@ static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCEXW efp
else lf16.lfFaceName[0] = '\0';
lf16.lfCharSet = plf->lfCharSet;
return dc->funcs->pEnumDeviceFonts( dc, &lf16, FONT_EnumInstance, (LPARAM)&fe32 );
ret = enum_func( hDC, &lf16, FONT_EnumInstance, (LPARAM)&fe32 );
}
return 0;
return ret;
}
/***********************************************************************
@ -708,10 +716,7 @@ INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
*/
INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
/ dc->vportExtX );
return (INT16)GetTextCharacterExtra( hdc );
}
@ -720,10 +725,13 @@ INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
*/
INT WINAPI GetTextCharacterExtra( HDC hdc )
{
INT ret;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
ret = abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
/ dc->vportExtX );
GDI_ReleaseObj( hdc );
return ret;
}
@ -745,11 +753,15 @@ INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
if (dc->funcs->pSetTextCharacterExtra)
return dc->funcs->pSetTextCharacterExtra( dc, extra );
extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
prev = dc->w.charExtra;
dc->w.charExtra = abs(extra);
return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
prev = dc->funcs->pSetTextCharacterExtra( dc, extra );
else
{
extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
prev = (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
dc->w.charExtra = abs(extra);
}
GDI_ReleaseObj( hdc );
return prev;
}
@ -767,26 +779,30 @@ INT16 WINAPI SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
*/
BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
{
BOOL ret = TRUE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
if (!dc) return FALSE;
if (dc->funcs->pSetTextJustification)
return dc->funcs->pSetTextJustification( dc, extra, breaks );
extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
if (!extra) breaks = 0;
dc->w.breakTotalExtra = extra;
dc->w.breakCount = breaks;
if (breaks)
{
dc->w.breakExtra = extra / breaks;
dc->w.breakRem = extra - (dc->w.breakCount * dc->w.breakExtra);
}
ret = dc->funcs->pSetTextJustification( dc, extra, breaks );
else
{
dc->w.breakExtra = 0;
dc->w.breakRem = 0;
extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
if (!extra) breaks = 0;
dc->w.breakTotalExtra = extra;
dc->w.breakCount = breaks;
if (breaks)
{
dc->w.breakExtra = extra / breaks;
dc->w.breakRem = extra - (dc->w.breakCount * dc->w.breakExtra);
}
else
{
dc->w.breakExtra = 0;
dc->w.breakRem = 0;
}
}
return 1;
GDI_ReleaseObj( hdc );
return ret;
}
@ -804,18 +820,23 @@ INT16 WINAPI GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
{
FONTOBJ *font;
INT ret = 0;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
DC * dc = (DC *) DC_GetDCPtr( hdc );
if (!dc) return 0;
if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
return 0;
if (name)
lstrcpynA( name, font->logfont.lfFaceName, count );
GDI_HEAP_UNLOCK( dc->w.hFont );
if (name)
return strlen(name);
else
return strlen(font->logfont.lfFaceName) + 1;
if ((font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
{
if (name)
{
lstrcpynA( name, font->logfont.lfFaceName, count );
ret = strlen(name);
}
else ret = strlen(font->logfont.lfFaceName) + 1;
GDI_ReleaseObj( dc->w.hFont );
}
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
@ -825,7 +846,7 @@ INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
{
LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, count );
INT res = GetTextFaceA(hdc,count,nameA);
lstrcpyAtoW( name, nameA );
if (name) lstrcpyAtoW( name, nameA );
HeapFree( GetProcessHeap(), 0, nameA );
return res;
}
@ -903,14 +924,17 @@ BOOL WINAPI GetTextExtentPoint32W(
INT count, /* [in] Number of characters in string */
LPSIZE size) /* [out] Address of structure for string size */
{
BOOL ret = FALSE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pGetTextExtentPoint ||
!dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
return FALSE;
if (dc)
{
if(dc->funcs->pGetTextExtentPoint)
ret = dc->funcs->pGetTextExtentPoint( dc, str, count, size );
GDI_ReleaseObj( hdc );
}
TRACE("(%08x %s %d %p): returning %d,%d\n",
hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
return TRUE;
return ret;
}
@ -966,14 +990,16 @@ BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
{
int index, nFit, extent;
SIZE tSize;
BOOL ret = FALSE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (!dc || !dc->funcs->pGetTextExtentPoint) return FALSE;
if (!dc->funcs->pGetTextExtentPoint) goto done;
size->cx = size->cy = nFit = extent = 0;
for(index = 0; index < count; index++)
{
if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) return FALSE;
if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) goto done;
if( extent+tSize.cx < maxExt )
{
extent+=tSize.cx;
@ -986,10 +1012,13 @@ BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
}
size->cx = extent;
*lpnFit = nFit;
ret = TRUE;
TRACE("(%08x %s %d) returning %d %d %d\n",
hdc,debugstr_wn(str,count),maxExt,nFit, size->cx,size->cy);
return TRUE;
done:
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
@ -1009,18 +1038,13 @@ BOOL16 WINAPI GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
* GetTextMetricsA (GDI32.236)
*/
BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
}
if (!dc->funcs->pGetTextMetrics ||
!dc->funcs->pGetTextMetrics( dc, metrics ))
return FALSE;
BOOL ret = FALSE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pGetTextMetrics && dc->funcs->pGetTextMetrics( dc, metrics ))
{
/* device layer returns values in device units
* therefore we have to convert them to logical */
@ -1039,6 +1063,7 @@ BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
metrics->tmAveCharWidth = WDPTOLP(metrics->tmAveCharWidth);
metrics->tmMaxCharWidth = WDPTOLP(metrics->tmMaxCharWidth);
metrics->tmOverhang = WDPTOLP(metrics->tmOverhang);
ret = TRUE;
TRACE("text metrics:\n"
" Weight = %03li\t FirstChar = %03i\t AveCharWidth = %li\n"
@ -1060,7 +1085,9 @@ BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
metrics->tmAscent,
metrics->tmDescent,
metrics->tmHeight );
return TRUE;
}
GDI_ReleaseObj( hdc );
return ret;
}
@ -1221,24 +1248,21 @@ BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
LPINT buffer )
{
UINT i, extra;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
BOOL ret = FALSE;
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
if (dc->funcs->pGetCharWidth && dc->funcs->pGetCharWidth( dc, firstChar, lastChar, buffer))
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
/* convert device units to logical */
extra = dc->vportExtX >> 1;
for( i = firstChar; i <= lastChar; i++, buffer++ )
*buffer = (*buffer * dc->wndExtX + extra) / dc->vportExtX;
ret = TRUE;
}
if (!dc->funcs->pGetCharWidth ||
!dc->funcs->pGetCharWidth( dc, firstChar, lastChar, buffer))
return FALSE;
/* convert device units to logical */
extra = dc->vportExtX >> 1;
for( i = firstChar; i <= lastChar; i++, buffer++ )
*buffer = (*buffer * dc->wndExtX + extra) / dc->vportExtX;
return TRUE;
GDI_ReleaseObj( hdc );
return ret;
}
@ -1276,7 +1300,7 @@ DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
ret = dc->funcs->pSetMapperFlags( dc, dwFlag );
else
FIXME("(0x%04x, 0x%08lx): stub - harmless\n", hDC, dwFlag);
GDI_HEAP_UNLOCK( hDC );
GDI_ReleaseObj( hDC );
return ret;
}

264
objects/gdiobj.c
View file

@ -6,9 +6,15 @@
#include "config.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "windef.h"
#include "wingdi.h"
#include "winerror.h"
#include "wine/winbase16.h"
#include "bitmap.h"
#include "brush.h"
#include "dc.h"
@ -21,8 +27,7 @@
#include "debugtools.h"
#include "gdi.h"
#include "tweak.h"
#include "windef.h"
#include "wingdi.h"
#include "syslevel.h"
DEFAULT_DEBUG_CHANNEL(gdi);
@ -177,6 +182,10 @@ static GDIOBJHDR * StockObjects[NB_STOCK_OBJECTS] =
HBITMAP hPseudoStockBitmap; /* 1x1 bitmap for memory DCs */
static SYSLEVEL GDI_level;
static WORD GDI_HeapSel;
/******************************************************************************
*
* void ReadFontInformation(
@ -308,7 +317,8 @@ static inline void FixStockFontSizeA(
*/
#define FixStockFontSizeW FixStockFontSizeA
#define TRACE_SEC(handle,text) \
TRACE("(%04x): " text " %ld\n", (handle), GDI_level.crst.RecursionCount)
/***********************************************************************
* GDI_Init
@ -318,6 +328,14 @@ static inline void FixStockFontSizeA(
BOOL GDI_Init(void)
{
BOOL systemIsBold = (TWEAK_WineLook == WIN31_LOOK);
HPALETTE16 hpalette;
HINSTANCE16 instance;
_CreateSysLevel( &GDI_level, 3 );
/* create GDI heap */
if ((instance = LoadLibrary16( "GDI.EXE" )) < 32) return FALSE;
GDI_HeapSel = GlobalHandleToSel16( instance );
/* Kill some warnings. */
(void)align_OEMFixedFont;
@ -340,12 +358,9 @@ BOOL GDI_Init(void)
/* Create default palette */
/* DR well *this* palette can't be moveable (?) */
{
HPALETTE16 hpalette = PALETTE_Init();
if( !hpalette )
return FALSE;
StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)GDI_HEAP_LOCK( hpalette );
}
hpalette = PALETTE_Init();
if( !hpalette ) return FALSE;
StockObjects[DEFAULT_PALETTE] = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, hpalette );
hPseudoStockBitmap = CreateBitmap( 1, 1, 1, 1, NULL );
return TRUE;
@ -355,74 +370,120 @@ BOOL GDI_Init(void)
/***********************************************************************
* GDI_AllocObject
*/
HGDIOBJ GDI_AllocObject( WORD size, WORD magic )
void *GDI_AllocObject( WORD size, WORD magic, HGDIOBJ *handle )
{
static DWORD count = 0;
GDIOBJHDR * obj;
HGDIOBJ16 handle;
if ( magic == DC_MAGIC || magic == METAFILE_DC_MAGIC )
handle = GDI_HEAP_ALLOC( size );
else
handle = GDI_HEAP_ALLOC_MOVEABLE( size );
if (!handle) return 0;
obj = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
GDIOBJHDR *obj;
_EnterSysLevel( &GDI_level );
if (!(*handle = LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, size )))
{
_LeaveSysLevel( &GDI_level );
return NULL;
}
obj = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, *handle );
obj->hNext = 0;
obj->wMagic = magic;
obj->dwCount = ++count;
GDI_HEAP_UNLOCK( handle );
return handle;
TRACE_SEC( *handle, "enter" );
return obj;
}
/***********************************************************************
* GDI_ReallocObject
*
* The object ptr must have been obtained with GDI_GetObjPtr.
* The new pointer must be released with GDI_ReleaseObj.
*/
void *GDI_ReallocObject( WORD size, HGDIOBJ handle, void *object )
{
HGDIOBJ new_handle;
LOCAL_Unlock( GDI_HeapSel, handle );
if (!(new_handle = LOCAL_ReAlloc( GDI_HeapSel, handle, size, LMEM_MOVEABLE )))
{
TRACE_SEC( handle, "leave" );
_LeaveSysLevel( &GDI_level );
return NULL;
}
assert( new_handle == handle ); /* moveable handle cannot change */
return LOCAL_Lock( GDI_HeapSel, handle );
}
/***********************************************************************
* GDI_FreeObject
*/
BOOL GDI_FreeObject( HGDIOBJ handle )
BOOL GDI_FreeObject( HGDIOBJ handle, void *ptr )
{
GDIOBJHDR * object;
GDIOBJHDR *object = ptr;
/* Can't free stock objects */
if ((handle >= FIRST_STOCK_HANDLE) && (handle <= LAST_STOCK_HANDLE))
return TRUE;
object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
if (!object) return FALSE;
object->wMagic = 0; /* Mark it as invalid */
/* Free object */
GDI_HEAP_FREE( handle );
/* can't free stock objects */
if (handle < FIRST_STOCK_HANDLE)
{
object->wMagic = 0; /* Mark it as invalid */
LOCAL_Unlock( GDI_HeapSel, handle );
LOCAL_Free( GDI_HeapSel, handle );
}
TRACE_SEC( handle, "leave" );
_LeaveSysLevel( &GDI_level );
return TRUE;
}
/***********************************************************************
* GDI_GetObjPtr
*
* Return a pointer to the GDI object associated to the handle.
* Return NULL if the object has the wrong magic number.
* Movable GDI objects are locked in memory: it is up to the caller to unlock
* it after the caller is done with the pointer.
* The object must be released with GDI_ReleaseObj.
*/
GDIOBJHDR * GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
void *GDI_GetObjPtr( HGDIOBJ handle, WORD magic )
{
GDIOBJHDR * ptr = NULL;
GDIOBJHDR *ptr = NULL;
_EnterSysLevel( &GDI_level );
if (handle >= FIRST_STOCK_HANDLE)
{
if (handle <= LAST_STOCK_HANDLE) ptr = StockObjects[handle - FIRST_STOCK_HANDLE];
if (ptr && (magic != MAGIC_DONTCARE) && (ptr->wMagic != magic)) ptr = NULL;
}
else
ptr = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
if (!ptr) return NULL;
if ((magic != MAGIC_DONTCARE) && (ptr->wMagic != magic))
else
{
GDI_HEAP_UNLOCK( handle );
return NULL;
ptr = (GDIOBJHDR *)LOCAL_Lock( GDI_HeapSel, handle );
if (ptr && (magic != MAGIC_DONTCARE) && (ptr->wMagic != magic))
{
LOCAL_Unlock( GDI_HeapSel, handle );
ptr = NULL;
}
}
if (!ptr)
{
_LeaveSysLevel( &GDI_level );
SetLastError( ERROR_INVALID_HANDLE );
}
else TRACE_SEC( handle, "enter" );
return ptr;
}
/***********************************************************************
* GDI_ReleaseObj
*
*/
void GDI_ReleaseObj( HGDIOBJ handle )
{
if (handle < FIRST_STOCK_HANDLE) LOCAL_Unlock( GDI_HeapSel, handle );
TRACE_SEC( handle, "leave" );
_LeaveSysLevel( &GDI_level );
}
/***********************************************************************
* DeleteObject16 (GDI.69)
*/
@ -441,10 +502,12 @@ BOOL WINAPI DeleteObject( HGDIOBJ obj )
GDIOBJHDR * header;
if (HIWORD(obj)) return FALSE;
if ((obj >= FIRST_STOCK_HANDLE) && (obj <= LAST_STOCK_HANDLE))
if ((obj >= FIRST_STOCK_HANDLE) && (obj <= LAST_STOCK_HANDLE)) {
TRACE("Preserving Stock object %04x\n", obj );
/* NOTE: No GDI_Release is necessary */
return TRUE;
if (obj == hPseudoStockBitmap) return TRUE;
if (!(header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj ))) return FALSE;
}
if (!(header = GDI_GetObjPtr( obj, MAGIC_DONTCARE ))) return FALSE;
TRACE("%04x\n", obj );
@ -452,19 +515,22 @@ BOOL WINAPI DeleteObject( HGDIOBJ obj )
switch(header->wMagic)
{
case PEN_MAGIC: return GDI_FreeObject( obj );
case PEN_MAGIC: return GDI_FreeObject( obj, header );
case BRUSH_MAGIC: return BRUSH_DeleteObject( obj, (BRUSHOBJ*)header );
case FONT_MAGIC: return GDI_FreeObject( obj );
case FONT_MAGIC: return GDI_FreeObject( obj, header );
case PALETTE_MAGIC: return PALETTE_DeleteObject(obj,(PALETTEOBJ*)header);
case BITMAP_MAGIC: return BITMAP_DeleteObject( obj, (BITMAPOBJ*)header);
case REGION_MAGIC: return REGION_DeleteObject( obj, (RGNOBJ*)header );
case DC_MAGIC: return DeleteDC(obj);
case DC_MAGIC:
GDI_ReleaseObj( obj );
return DeleteDC(obj);
case 0 :
WARN("Already deleted\n");
break;
default:
WARN("Unknown magic number (%d)\n",header->wMagic);
}
GDI_ReleaseObj( obj );
return FALSE;
}
@ -482,11 +548,12 @@ HGDIOBJ16 WINAPI GetStockObject16( INT16 obj )
*/
HGDIOBJ WINAPI GetStockObject( INT obj )
{
HGDIOBJ ret;
if ((obj < 0) || (obj >= NB_STOCK_OBJECTS)) return 0;
if (!StockObjects[obj]) return 0;
TRACE("returning %d\n",
FIRST_STOCK_HANDLE + obj );
return (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
ret = (HGDIOBJ16)(FIRST_STOCK_HANDLE + obj);
TRACE("returning %4x\n", ret );
return ret;
}
@ -527,7 +594,7 @@ INT16 WINAPI GetObject16( HANDLE16 handle, INT16 count, LPVOID buffer )
result = PALETTE_GetObject( (PALETTEOBJ *)ptr, count, buffer );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return result;
}
@ -585,7 +652,7 @@ INT WINAPI GetObjectA( HANDLE handle, INT count, LPVOID buffer )
ERR("Invalid GDI Magic %04x\n", ptr->wMagic);
return 0;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return result;
}
@ -630,7 +697,7 @@ INT WINAPI GetObjectW( HANDLE handle, INT count, LPVOID buffer )
ptr->wMagic );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return result;
}
@ -688,7 +755,7 @@ DWORD WINAPI GetObjectType( HANDLE handle )
ptr->wMagic );
break;
}
GDI_HEAP_UNLOCK( handle );
GDI_ReleaseObj( handle );
return result;
}
@ -697,21 +764,25 @@ DWORD WINAPI GetObjectType( HANDLE handle )
*/
HANDLE WINAPI GetCurrentObject(HDC hdc,UINT type)
{
HANDLE ret = 0;
DC * dc = DC_GetDCPtr( hdc );
if (!dc)
return 0;
if (dc)
{
switch (type) {
case OBJ_PEN: return dc->w.hPen;
case OBJ_BRUSH: return dc->w.hBrush;
case OBJ_PAL: return dc->w.hPalette;
case OBJ_FONT: return dc->w.hFont;
case OBJ_BITMAP: return dc->w.hBitmap;
case OBJ_PEN: ret = dc->w.hPen; break;
case OBJ_BRUSH: ret = dc->w.hBrush; break;
case OBJ_PAL: ret = dc->w.hPalette; break;
case OBJ_FONT: ret = dc->w.hFont; break;
case OBJ_BITMAP: ret = dc->w.hBitmap; break;
default:
/* the SDK only mentions those above */
WARN("(%08x,%d): unknown type.\n",hdc,type);
return 0;
break;
}
GDI_ReleaseObj( hdc );
}
return ret;
}
@ -729,10 +800,14 @@ HGDIOBJ16 WINAPI SelectObject16( HDC16 hdc, HGDIOBJ16 handle )
*/
HGDIOBJ WINAPI SelectObject( HDC hdc, HGDIOBJ handle )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pSelectObject) return 0;
HGDIOBJ ret = 0;
DC * dc = DC_GetDCUpdate( hdc );
if (!dc) return 0;
TRACE("hdc=%04x %04x\n", hdc, handle );
return dc->funcs->pSelectObject( dc, handle );
if (dc->funcs->pSelectObject)
ret = dc->funcs->pSelectObject( dc, handle );
GDI_ReleaseObj( hdc );
return ret;
}
@ -753,7 +828,7 @@ BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
BOOL result = TRUE;
/* Check if object is valid */
GDIOBJHDR * header = (GDIOBJHDR *) GDI_HEAP_LOCK( obj );
GDIOBJHDR * header = GDI_GetObjPtr( obj, MAGIC_DONTCARE );
if (!header) return FALSE;
TRACE("%04x\n", obj );
@ -770,7 +845,7 @@ BOOL WINAPI UnrealizeObject( HGDIOBJ obj )
/* Windows resets the brush origin. We don't need to. */
break;
}
GDI_HEAP_UNLOCK( obj );
GDI_ReleaseObj( obj );
return result;
}
@ -939,54 +1014,13 @@ BOOL16 WINAPI IsGDIObject16( HGDIOBJ16 handle )
{
UINT16 magic = 0;
if (handle >= FIRST_STOCK_HANDLE )
GDIOBJHDR *object = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
if (object)
{
switch (handle)
{
case STOCK_WHITE_BRUSH:
case STOCK_LTGRAY_BRUSH:
case STOCK_GRAY_BRUSH:
case STOCK_DKGRAY_BRUSH:
case STOCK_BLACK_BRUSH:
case STOCK_HOLLOW_BRUSH:
magic = BRUSH_MAGIC;
break;
case STOCK_WHITE_PEN:
case STOCK_BLACK_PEN:
case STOCK_NULL_PEN :
magic = PEN_MAGIC;
break;
case STOCK_OEM_FIXED_FONT:
case STOCK_ANSI_FIXED_FONT:
case STOCK_ANSI_VAR_FONT:
case STOCK_SYSTEM_FONT:
case STOCK_DEVICE_DEFAULT_FONT:
case STOCK_SYSTEM_FIXED_FONT:
case STOCK_DEFAULT_GUI_FONT:
magic = FONT_MAGIC;
break;
case STOCK_DEFAULT_PALETTE:
magic = PALETTE_MAGIC;
break;
}
magic = object->wMagic - PEN_MAGIC + 1;
GDI_ReleaseObj( handle );
}
else
{
GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LOCK( handle );
if (object)
{
magic = object->wMagic;
GDI_HEAP_UNLOCK( handle );
}
}
if (magic >= PEN_MAGIC && magic <= METAFILE_DC_MAGIC)
return magic - PEN_MAGIC + 1;
else
return FALSE;
return magic;
}

28
objects/metafile.c
View file

@ -73,10 +73,13 @@ static int MF_AddHandle(HANDLETABLE16 *ht, WORD htlen, HGDIOBJ16 hobj)
*/
HMETAFILE MF_Create_HMETAFILE(METAHEADER *mh)
{
HMETAFILE hmf = GDI_AllocObject( sizeof(METAFILEOBJ), METAFILE_MAGIC );
METAFILEOBJ *metaObj = (METAFILEOBJ *)GDI_HEAP_LOCK( hmf );
HMETAFILE hmf = 0;
METAFILEOBJ *metaObj = GDI_AllocObject( sizeof(METAFILEOBJ), METAFILE_MAGIC, &hmf );
if (metaObj)
{
metaObj->mh = mh;
GDI_HEAP_UNLOCK( hmf );
GDI_ReleaseObj( hmf );
}
return hmf;
}
@ -130,9 +133,9 @@ static METAHEADER *MF_GetMetaHeader16( HMETAFILE16 hmf )
*
* Releases METAHEADER associated with HMETAFILE
*/
static BOOL MF_ReleaseMetaHeader( HMETAFILE hmf )
static void MF_ReleaseMetaHeader( HMETAFILE hmf )
{
return GDI_HEAP_UNLOCK( hmf );
GDI_ReleaseObj( hmf );
}
/******************************************************************
@ -162,11 +165,10 @@ BOOL16 WINAPI DeleteMetaFile16( HMETAFILE16 hmf )
BOOL WINAPI DeleteMetaFile( HMETAFILE hmf )
{
METAHEADER *mh = MF_GetMetaHeader( hmf );
if(!mh) return FALSE;
HeapFree( GetProcessHeap(), 0, mh );
GDI_FreeObject( hmf );
METAFILEOBJ * metaObj = (METAFILEOBJ *)GDI_GetObjPtr( hmf, METAFILE_MAGIC );
if (!metaObj) return FALSE;
HeapFree( GetProcessHeap(), 0, metaObj->mh );
GDI_FreeObject( hmf, metaObj );
return TRUE;
}
@ -475,7 +477,7 @@ static BOOL MF_PlayMetaFile( HDC hdc, METAHEADER *mh)
BOOL loaded = FALSE;
if (!mh) return FALSE;
if(mh->mtType == METAFILE_DISK) { /* Create a memoery-based copy */
if(mh->mtType == METAFILE_DISK) { /* Create a memory-based copy */
mh = MF_LoadDiskBasedMetaFile(mh);
if(!mh) return FALSE;
loaded = TRUE;
@ -580,7 +582,7 @@ BOOL16 WINAPI EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
if(!mh) return FALSE;
if(mh->mtType == METAFILE_DISK) { /* Create a memoery-based copy */
if(mh->mtType == METAFILE_DISK) { /* Create a memory-based copy */
mh = MF_LoadDiskBasedMetaFile(mh);
if(!mh) return FALSE;
loaded = TRUE;
@ -668,7 +670,7 @@ BOOL WINAPI EnumMetaFile(
TRACE("(%08x,%08x,%p,%p)\n",
hdc, hmf, lpEnumFunc, (void*)lpData);
if (!mh) return 0;
if(mh->mtType == METAFILE_DISK) { /* Create a memoery-based copy */
if(mh->mtType == METAFILE_DISK) { /* Create a memory-based copy */
mh = MF_LoadDiskBasedMetaFile(mh);
if(!mh) return 0;
loaded = TRUE;

164
objects/palette.c
View file

@ -17,6 +17,7 @@
#include "wine/winuser16.h"
#include "gdi.h"
#include "color.h"
#include "dc.h"
#include "palette.h"
#include "debugtools.h"
#include "callback.h"
@ -71,9 +72,8 @@ HPALETTE16 PALETTE_Init(void)
{
if (!(palObj->mapping = HeapAlloc( GetProcessHeap(), 0, sizeof(int) * 20 )))
ERR("Can not create palette mapping -- out of memory!");
GDI_HEAP_UNLOCK( hpalette );
GDI_ReleaseObj( hpalette );
}
return hpalette;
}
@ -116,15 +116,13 @@ HPALETTE WINAPI CreatePalette(
size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
hpalette = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR) , PALETTE_MAGIC );
if (!hpalette) return 0;
palettePtr = (PALETTEOBJ *) GDI_HEAP_LOCK( hpalette );
if (!(palettePtr = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR),
PALETTE_MAGIC, &hpalette ))) return 0;
memcpy( &palettePtr->logpalette, palette, size );
PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
palettePtr->logpalette.palNumEntries);
palettePtr->mapping = NULL;
GDI_HEAP_UNLOCK( hpalette );
GDI_ReleaseObj( hpalette );
TRACE(" returning %04x\n", hpalette);
return hpalette;
@ -228,7 +226,7 @@ UINT WINAPI GetPaletteEntries(
{
if (start >= numEntries)
{
GDI_HEAP_UNLOCK( hpalette );
GDI_ReleaseObj( hpalette );
return 0;
}
memcpy( entries, &palPtr->logpalette.palPalEntry[start],
@ -236,9 +234,9 @@ UINT WINAPI GetPaletteEntries(
for( numEntries = 0; numEntries < count ; numEntries++ )
if (entries[numEntries].peFlags & 0xF0)
entries[numEntries].peFlags = 0;
GDI_HEAP_UNLOCK( hpalette );
}
GDI_ReleaseObj( hpalette );
return count;
}
@ -277,7 +275,7 @@ UINT WINAPI SetPaletteEntries(
numEntries = palPtr->logpalette.palNumEntries;
if (start >= numEntries)
{
GDI_HEAP_UNLOCK( hpalette );
GDI_ReleaseObj( hpalette );
return 0;
}
if (start+count > numEntries) count = numEntries - start;
@ -287,7 +285,7 @@ UINT WINAPI SetPaletteEntries(
palPtr->logpalette.palNumEntries);
HeapFree( GetProcessHeap(), 0, palPtr->mapping );
palPtr->mapping = NULL;
GDI_HEAP_UNLOCK( hpalette );
GDI_ReleaseObj( hpalette );
return count;
}
@ -328,11 +326,7 @@ BOOL WINAPI ResizePalette(
size += sizeof(int*) + sizeof(GDIOBJHDR);
mapping = palPtr->mapping;
GDI_HEAP_UNLOCK( hPal );
hPal = GDI_HEAP_REALLOC( hPal, size );
palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
if( !palPtr ) return FALSE;
if (!(palPtr = GDI_ReallocObject( size, hPal, palPtr ))) return FALSE;
if( mapping )
{
@ -341,7 +335,7 @@ BOOL WINAPI ResizePalette(
if(newMap == NULL)
{
ERR("Can not resize mapping -- out of memory!");
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return FALSE;
}
palPtr->mapping = newMap;
@ -357,7 +351,7 @@ BOOL WINAPI ResizePalette(
}
palPtr->logpalette.palNumEntries = cEntries;
palPtr->logpalette.palVersion = prevVer;
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return TRUE;
}
@ -403,9 +397,10 @@ BOOL WINAPI AnimatePalette(
PALETTE_Driver->
pSetMapping(palPtr, StartIndex, NumEntries,
hPal != hPrimaryPalette );
GDI_HEAP_UNLOCK( hPal );
GDI_ReleaseObj( hPal );
return TRUE;
}
GDI_ReleaseObj( hPal );
}
return FALSE;
}
@ -489,12 +484,19 @@ UINT WINAPI GetSystemPaletteEntries(
TRACE("hdc=%04x,start=%i,count=%i\n", hdc,start,count);
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
if (!entries) return dc->w.devCaps->sizePalette;
if (!entries)
{
count = dc->w.devCaps->sizePalette;
goto done;
}
if (start >= dc->w.devCaps->sizePalette)
{
GDI_HEAP_UNLOCK( hdc );
return 0;
count = 0;
goto done;
}
if (start+count >= dc->w.devCaps->sizePalette)
count = dc->w.devCaps->sizePalette - start;
for (i = 0; i < count; i++)
@ -504,7 +506,8 @@ UINT WINAPI GetSystemPaletteEntries(
TRACE("\tidx(%02x) -> RGB(%08lx)\n",
start + i, *(COLORREF*)(entries + i) );
}
GDI_HEAP_UNLOCK( hdc );
done:
GDI_ReleaseObj( hdc );
return count;
}
@ -536,12 +539,14 @@ UINT WINAPI GetNearestPaletteIndex(
UINT index = 0;
if( palObj )
{
index = COLOR_PaletteLookupPixel(palObj->logpalette.palPalEntry,
palObj->logpalette.palNumEntries,
NULL, color, FALSE );
GDI_ReleaseObj( hpalette );
}
TRACE("(%04x,%06lx): returning %d\n", hpalette, color, index );
GDI_HEAP_UNLOCK( hpalette );
return index;
}
@ -558,9 +563,6 @@ COLORREF WINAPI GetNearestColor16( HDC16 hdc, COLORREF color )
/***********************************************************************
* GetNearestColor [GDI32.202] Gets a system color to match
*
* NOTES
* Should this return CLR_INVALID instead of FadeCafe?
*
* RETURNS
* Success: Color from system palette that corresponds to given color
* Failure: CLR_INVALID
@ -569,24 +571,26 @@ COLORREF WINAPI GetNearestColor(
HDC hdc, /* [in] Handle of device context */
COLORREF color) /* [in] Color to be matched */
{
COLORREF nearest = 0xFADECAFE;
COLORREF nearest = CLR_INVALID;
DC *dc;
PALETTEOBJ *palObj;
if ( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
{
palObj = (PALETTEOBJ*)
GDI_GetObjPtr( (dc->w.hPalette)? dc->w.hPalette
: STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
if (!palObj) return nearest;
HPALETTE hpal = (dc->w.hPalette)? dc->w.hPalette : STOCK_DEFAULT_PALETTE;
palObj = GDI_GetObjPtr( hpal, PALETTE_MAGIC );
if (!palObj) {
GDI_ReleaseObj( hdc );
return nearest;
}
nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
palObj->logpalette.palNumEntries, color );
GDI_HEAP_UNLOCK( dc->w.hPalette );
nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
palObj->logpalette.palNumEntries, color );
GDI_ReleaseObj( hpal );
GDI_ReleaseObj( hdc );
}
TRACE("(%06lx): returning %06lx\n", color, nearest );
GDI_HEAP_UNLOCK( hdc );
return nearest;
}
@ -624,7 +628,7 @@ BOOL PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
{
HeapFree( GetProcessHeap(), 0, palette->mapping );
if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
return GDI_FreeObject( hpalette );
return GDI_FreeObject( hpalette, palette );
}
@ -638,15 +642,10 @@ HPALETTE16 WINAPI GDISelectPalette16( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
TRACE("%04x %04x\n", hdc, hpal );
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
prev = dc->w.hPalette;
dc->w.hPalette = hpal;
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
if (!wBkg) hPrimaryPalette = hpal;
return prev;
}
@ -659,37 +658,39 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
{
PALETTEOBJ* palPtr;
int realized = 0;
DC* dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
}
DC* dc = DC_GetDCPtr( hdc );
if (!dc) return 0;
TRACE("%04x...\n", hdc );
if( dc && dc->w.hPalette != hLastRealizedPalette )
if(dc->w.hPalette != hLastRealizedPalette )
{
if( dc->w.hPalette == STOCK_DEFAULT_PALETTE )
return RealizeDefaultPalette16( hdc );
if( dc->w.hPalette == STOCK_DEFAULT_PALETTE ) {
realized = RealizeDefaultPalette16( hdc );
GDI_ReleaseObj( hdc );
return (UINT16)realized;
}
palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
if (!palPtr) {
FIXME("invalid selected palette %04x\n",dc->w.hPalette);
return 0;
GDI_ReleaseObj( hdc );
FIXME("invalid selected palette %04x\n",dc->w.hPalette);
return 0;
}
realized = PALETTE_Driver->
pSetMapping(palPtr,0,palPtr->logpalette.palNumEntries,
(dc->w.hPalette != hPrimaryPalette) ||
(dc->w.hPalette == STOCK_DEFAULT_PALETTE));
GDI_HEAP_UNLOCK( dc->w.hPalette );
hLastRealizedPalette = dc->w.hPalette;
GDI_ReleaseObj( dc->w.hPalette );
}
else TRACE(" skipping (hLastRealizedPalette = %04x)\n",
hLastRealizedPalette);
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
TRACE(" realized %i colors.\n", realized );
return (UINT16)realized;
@ -701,33 +702,26 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc )
*/
UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc )
{
UINT16 ret = 0;
DC *dc;
PALETTEOBJ* palPtr;
TRACE("%04x\n", hdc );
dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
if (!(dc->w.flags & DC_MEMORY))
{
dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
if (!dc) return 0;
palPtr = (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
if (palPtr)
{
/* lookup is needed to account for SetSystemPaletteUse() stuff */
ret = PALETTE_Driver->pUpdateMapping(palPtr);
GDI_ReleaseObj( STOCK_DEFAULT_PALETTE );
}
}
if ( dc->w.flags & DC_MEMORY )
{
GDI_HEAP_UNLOCK( hdc );
return 0;
}
hPrimaryPalette = STOCK_DEFAULT_PALETTE;
hLastRealizedPalette = STOCK_DEFAULT_PALETTE;
palPtr = (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
if (!palPtr) return 0;
/* lookup is needed to account for SetSystemPaletteUse() stuff */
return PALETTE_Driver->pUpdateMapping(palPtr);
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
@ -738,8 +732,9 @@ BOOL16 WINAPI IsDCCurrentPalette16(HDC16 hDC)
DC* dc = (DC *)GDI_GetObjPtr( hDC, DC_MAGIC );
if (dc)
{
GDI_HEAP_UNLOCK( hDC );
return dc->w.hPalette == hPrimaryPalette;
BOOL bRet = dc->w.hPalette == hPrimaryPalette;
GDI_ReleaseObj( hDC );
return bRet;
}
return FALSE;
}
@ -798,11 +793,12 @@ UINT WINAPI RealizePalette(
/* Send palette change notification */
HWND hWnd;
GDI_ReleaseObj( hDC );
if( (hWnd = Callout.WindowFromDC( hDC )) )
Callout.SendMessageA( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L);
}
else GDI_ReleaseObj( hDC );
GDI_HEAP_UNLOCK( hDC );
return realized;
}
@ -814,19 +810,19 @@ INT16 WINAPI UpdateColors16( HDC16 hDC )
{
DC *dc;
HWND hWnd;
int size;
if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return 0;
size = dc->w.devCaps->sizePalette;
GDI_ReleaseObj( hDC );
hWnd = Callout.WindowFromDC( hDC );
/* Docs say that we have to remap current drawable pixel by pixel
* but it would take forever given the speed of XGet/PutPixel.
*/
if (hWnd && dc->w.devCaps->sizePalette )
if (hWnd && size)
Callout.RedrawWindow( hWnd, NULL, 0, RDW_INVALIDATE );
GDI_HEAP_UNLOCK( hDC );
return 0x666;
}

20
objects/pen.c
View file

@ -54,16 +54,14 @@ HPEN WINAPI CreatePen( INT style, INT width, COLORREF color )
HPEN16 WINAPI CreatePenIndirect16( const LOGPEN16 * pen )
{
PENOBJ * penPtr;
HPEN16 hpen;
HPEN hpen;
if (pen->lopnStyle > PS_INSIDEFRAME) return 0;
hpen = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC );
if (!hpen) return 0;
penPtr = (PENOBJ *)GDI_HEAP_LOCK( hpen );
if (!(penPtr = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC, &hpen ))) return 0;
penPtr->logpen.lopnStyle = pen->lopnStyle;
penPtr->logpen.lopnColor = pen->lopnColor;
CONV_POINT16TO32( &pen->lopnWidth, &penPtr->logpen.lopnWidth );
GDI_HEAP_UNLOCK( hpen );
GDI_ReleaseObj( hpen );
return hpen;
}
@ -77,13 +75,11 @@ HPEN WINAPI CreatePenIndirect( const LOGPEN * pen )
HPEN hpen;
if (pen->lopnStyle > PS_INSIDEFRAME) return 0;
hpen = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC );
if (!hpen) return 0;
penPtr = (PENOBJ *)GDI_HEAP_LOCK( hpen );
if (!(penPtr = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC, &hpen ))) return 0;
penPtr->logpen.lopnStyle = pen->lopnStyle;
penPtr->logpen.lopnWidth = pen->lopnWidth;
penPtr->logpen.lopnColor = pen->lopnColor;
GDI_HEAP_UNLOCK( hpen );
GDI_ReleaseObj( hpen );
return hpen;
}
@ -106,9 +102,7 @@ HPEN WINAPI ExtCreatePen( DWORD style, DWORD width,
if (brush->lbHatch)
FIXME("Hatches not implemented\n");
hpen = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC );
if (!hpen) return 0;
penPtr = (PENOBJ *)GDI_HEAP_LOCK( hpen );
if (!(penPtr = GDI_AllocObject( sizeof(PENOBJ), PEN_MAGIC, &hpen ))) return 0;
penPtr->logpen.lopnStyle = style & ~PS_TYPE_MASK;
/* PS_USERSTYLE and PS_ALTERNATE workaround */
@ -119,7 +113,7 @@ HPEN WINAPI ExtCreatePen( DWORD style, DWORD width,
penPtr->logpen.lopnWidth.x = (style & PS_GEOMETRIC) ? width : 1;
penPtr->logpen.lopnWidth.y = 0;
penPtr->logpen.lopnColor = brush->lbColor;
GDI_HEAP_UNLOCK( hpen );
GDI_ReleaseObj( hpen );
return hpen;
}

119
objects/region.c
View file

@ -457,14 +457,12 @@ static HRGN REGION_CreateRegion( INT n )
HRGN hrgn;
RGNOBJ *obj;
if(!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )))
return 0;
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
if(!(obj = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC, &hrgn ))) return 0;
if(!(obj->rgn = REGION_AllocWineRegion(n))) {
GDI_FreeObject( hrgn );
GDI_FreeObject( hrgn, obj );
return 0;
}
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return hrgn;
}
@ -487,7 +485,7 @@ BOOL REGION_DeleteObject( HRGN hrgn, RGNOBJ * obj )
TRACE(" %04x\n", hrgn );
REGION_DestroyWineRegion( obj->rgn );
return GDI_FreeObject( hrgn );
return GDI_FreeObject( hrgn, obj );
}
/***********************************************************************
@ -530,7 +528,7 @@ INT WINAPI OffsetRgn( HRGN hrgn, INT x, INT y )
}
}
ret = obj->rgn->type;
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return ret;
}
@ -561,7 +559,7 @@ INT WINAPI GetRgnBox( HRGN hrgn, LPRECT rect )
rect->right = obj->rgn->extents.right;
rect->bottom = obj->rgn->extents.bottom;
ret = obj->rgn->type;
GDI_HEAP_UNLOCK(hrgn);
GDI_ReleaseObj(hrgn);
return ret;
}
return ERROR;
@ -664,7 +662,7 @@ BOOL WINAPI SetRectRgn( HRGN hrgn, INT left, INT top,
else
EMPTY_REGION(obj->rgn);
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return TRUE;
}
@ -717,7 +715,7 @@ HRGN WINAPI CreateRoundRectRgn( INT left, INT top,
d = (ellipse_height < 128) ? ((3 * ellipse_height) >> 2) : 64;
if (!(hrgn = REGION_CreateRegion(d))) return 0;
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
if (!(obj = GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return 0;
TRACE("(%d,%d-%d,%d %dx%d): ret=%04x\n",
left, top, right, bottom, ellipse_width, ellipse_height, hrgn );
@ -792,7 +790,7 @@ HRGN WINAPI CreateRoundRectRgn( INT left, INT top,
REGION_UnionRectWithRegion( &rect, obj->rgn );
}
obj->rgn->type = SIMPLEREGION; /* FIXME? */
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return hrgn;
}
@ -857,7 +855,7 @@ DWORD WINAPI GetRegionData(HRGN hrgn, DWORD count, LPRGNDATA rgndata)
size = obj->rgn->numRects * sizeof(RECT);
if(count < (size + sizeof(RGNDATAHEADER)) || rgndata == NULL)
{
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return size + sizeof(RGNDATAHEADER);
}
@ -872,7 +870,7 @@ DWORD WINAPI GetRegionData(HRGN hrgn, DWORD count, LPRGNDATA rgndata)
memcpy( rgndata->Buffer, obj->rgn->rects, size );
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return 1;
}
@ -912,13 +910,16 @@ HRGN WINAPI ExtCreateRegion( const XFORM* lpXform, DWORD dwCount, const RGNDATA*
RECT *pCurRect, *pEndRect;
RGNOBJ *obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;
for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)
REGION_UnionRectWithRegion( pCurRect, obj->rgn );
GDI_HEAP_UNLOCK( hrgn );
if (obj) {
pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;
for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)
REGION_UnionRectWithRegion( pCurRect, obj->rgn );
GDI_ReleaseObj( hrgn );
TRACE("%04x\n", hrgn );
return hrgn;
TRACE("%04x\n", hrgn );
return hrgn;
}
else ERR("Could not get pointer to newborn Region!");
}
fail:
WARN("Failed\n");
@ -940,20 +941,22 @@ BOOL16 WINAPI PtInRegion16( HRGN16 hrgn, INT16 x, INT16 y )
BOOL WINAPI PtInRegion( HRGN hrgn, INT x, INT y )
{
RGNOBJ * obj;
BOOL ret = FALSE;
if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
{
BOOL ret = FALSE;
int i;
if (obj->rgn->numRects > 0 && INRECT(obj->rgn->extents, x, y))
for (i = 0; i < obj->rgn->numRects; i++)
if (INRECT (obj->rgn->rects[i], x, y))
{
ret = TRUE;
GDI_HEAP_UNLOCK( hrgn );
return ret;
break;
}
GDI_ReleaseObj( hrgn );
}
return FALSE;
return ret;
}
@ -977,11 +980,11 @@ BOOL16 WINAPI RectInRegion16( HRGN16 hrgn, const RECT16 *rect )
BOOL WINAPI RectInRegion( HRGN hrgn, const RECT *rect )
{
RGNOBJ * obj;
BOOL ret = FALSE;
if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
{
RECT *pCurRect, *pRectEnd;
BOOL ret = FALSE;
/* this is (just) a useful optimization */
if ((obj->rgn->numRects > 0) && EXTENTCHECK(&obj->rgn->extents,
@ -993,10 +996,8 @@ BOOL WINAPI RectInRegion( HRGN hrgn, const RECT *rect )
if (pCurRect->bottom <= rect->top)
continue; /* not far enough down yet */
if (pCurRect->top >= rect->bottom) {
ret = FALSE; /* too far down */
break;
}
if (pCurRect->top >= rect->bottom)
break; /* too far down */
if (pCurRect->right <= rect->left)
continue; /* not far enough over yet */
@ -1009,10 +1010,9 @@ BOOL WINAPI RectInRegion( HRGN hrgn, const RECT *rect )
break;
}
}
GDI_HEAP_UNLOCK(hrgn);
return ret;
GDI_ReleaseObj(hrgn);
}
return FALSE;
return ret;
}
/***********************************************************************
@ -1058,9 +1058,9 @@ BOOL WINAPI EqualRgn( HRGN hrgn1, HRGN hrgn2 )
}
ret = TRUE;
done:
GDI_HEAP_UNLOCK(hrgn2);
GDI_ReleaseObj(hrgn2);
}
GDI_HEAP_UNLOCK(hrgn1);
GDI_ReleaseObj(hrgn1);
}
return ret;
}
@ -1093,7 +1093,7 @@ BOOL REGION_UnionRectWithRgn( HRGN hrgn, const RECT *lpRect )
if(!obj) return FALSE;
REGION_UnionRectWithRegion( lpRect, obj->rgn );
GDI_HEAP_UNLOCK(hrgn);
GDI_ReleaseObj(hrgn);
return TRUE;
}
@ -1108,6 +1108,7 @@ BOOL REGION_FrameRgn( HRGN hDest, HRGN hSrc, INT x, INT y )
BOOL bRet;
RGNOBJ *srcObj = (RGNOBJ*) GDI_GetObjPtr( hSrc, REGION_MAGIC );
if (!srcObj) return FALSE;
if (srcObj->rgn->numRects != 0)
{
RGNOBJ* destObj = (RGNOBJ*) GDI_GetObjPtr( hDest, REGION_MAGIC );
@ -1126,12 +1127,12 @@ BOOL REGION_FrameRgn( HRGN hDest, HRGN hSrc, INT x, INT y )
REGION_UnionRectWithRegion( &tempRect, destObj->rgn );
}
REGION_SubtractRegion( destObj->rgn, destObj->rgn, srcObj->rgn );
GDI_HEAP_UNLOCK ( hDest );
GDI_ReleaseObj ( hDest );
bRet = TRUE;
}
else
bRet = FALSE;
GDI_HEAP_UNLOCK( hSrc );
GDI_ReleaseObj( hSrc );
return bRet;
}
@ -1146,24 +1147,27 @@ BOOL REGION_LPTODP( HDC hdc, HRGN hDest, HRGN hSrc )
RGNOBJ *srcObj, *destObj;
DC * dc = DC_GetDCPtr( hdc );
RECT tmpRect;
BOOL ret = FALSE;
TRACE(" hdc=%04x dest=%04x src=%04x\n",
hdc, hDest, hSrc) ;
if (!dc) return ret;
if (dc->w.MapMode == MM_TEXT) /* Requires only a translation */
{
if( CombineRgn( hDest, hSrc, 0, RGN_COPY ) == ERROR ) return FALSE;
if( CombineRgn( hDest, hSrc, 0, RGN_COPY ) == ERROR ) goto done;
OffsetRgn( hDest, dc->vportOrgX - dc->wndOrgX,
dc->vportOrgY - dc->wndOrgY );
return TRUE;
ret = TRUE;
goto done;
}
if(!( srcObj = (RGNOBJ *) GDI_GetObjPtr( hSrc, REGION_MAGIC) ))
return FALSE;
goto done;
if(!( destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC) ))
{
GDI_HEAP_UNLOCK( hSrc );
return FALSE;
GDI_ReleaseObj( hSrc );
goto done;
}
EMPTY_REGION( destObj->rgn );
@ -1178,9 +1182,11 @@ BOOL REGION_LPTODP( HDC hdc, HRGN hDest, HRGN hSrc )
REGION_UnionRectWithRegion( &tmpRect, destObj->rgn );
}
GDI_HEAP_UNLOCK( hDest );
GDI_HEAP_UNLOCK( hSrc );
return TRUE;
GDI_ReleaseObj( hDest );
GDI_ReleaseObj( hSrc );
done:
GDI_ReleaseObj( hdc );
return ret;
}
/***********************************************************************
@ -1243,16 +1249,16 @@ INT WINAPI CombineRgn(HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode)
break;
}
result = destObj->rgn->type;
GDI_HEAP_UNLOCK( hSrc2 );
GDI_ReleaseObj( hSrc2 );
}
}
GDI_HEAP_UNLOCK( hSrc1 );
GDI_ReleaseObj( hSrc1 );
}
TRACE("dump:\n");
if(TRACE_ON(region))
REGION_DumpRegion(destObj->rgn);
GDI_HEAP_UNLOCK( hDest );
GDI_ReleaseObj( hDest );
} else {
ERR("Invalid rgn=%04x\n", hDest);
}
@ -2714,7 +2720,7 @@ HRGN WINAPI CreatePolyPolygonRgn(const POINT *Pts, const INT *Count,
{
SetRectRgn( hrgn, min(Pts[0].x, Pts[2].x), min(Pts[0].y, Pts[2].y),
max(Pts[0].x, Pts[2].x), max(Pts[0].y, Pts[2].y) );
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return hrgn;
}
@ -2811,6 +2817,7 @@ HRGN WINAPI CreatePolyPolygonRgn(const POINT *Pts, const INT *Count,
sizeof(POINTBLOCK) );
if(!tmpPtBlock) {
WARN("Can't alloc tPB\n");
REGION_DeleteObject( hrgn, obj );
return 0;
}
curPtBlock->next = tmpPtBlock;
@ -2845,7 +2852,7 @@ HRGN WINAPI CreatePolyPolygonRgn(const POINT *Pts, const INT *Count,
curPtBlock = tmpPtBlock;
}
HeapFree( GetProcessHeap(), 0, pETEs );
GDI_HEAP_UNLOCK( hrgn );
GDI_ReleaseObj( hrgn );
return hrgn;
}
@ -2910,6 +2917,8 @@ INT WINAPI GetRandomRgn(HDC hDC, HRGN hRgn, DWORD dwCode)
DC *dc = DC_GetDCPtr (hDC);
OSVERSIONINFOA vi;
POINT org;
if (!dc) return -1;
CombineRgn (hRgn, dc->w.hVisRgn, 0, RGN_COPY);
/*
* On Windows NT/2000,
@ -2925,7 +2934,7 @@ INT WINAPI GetRandomRgn(HDC hDC, HRGN hRgn, DWORD dwCode)
org.x -= dc->w.DCOrgX;
org.y -= dc->w.DCOrgY;
OffsetRgn (hRgn, org.x, org.y);
GDI_ReleaseObj( hDC );
return 1;
}
/* case 1:
@ -3167,7 +3176,7 @@ HRGN REGION_CropRgn( HRGN hDst, HRGN hSrc, const RECT *lpRect, const POINT *lpPt
{
if( hDst ) /* existing rgn */
{
GDI_HEAP_UNLOCK(hDst);
GDI_ReleaseObj(hDst);
hDst = 0;
goto done;
}
@ -3175,7 +3184,7 @@ HRGN REGION_CropRgn( HRGN hDst, HRGN hSrc, const RECT *lpRect, const POINT *lpPt
}
else if( hDst == 0 )
{
if(!(hDst = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )))
if (!(objDst = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC, &hDst )))
{
fail:
if( rgnDst->rects )
@ -3183,16 +3192,14 @@ fail:
HeapFree( GetProcessHeap(), 0, rgnDst );
goto done;
}
objDst = (RGNOBJ *) GDI_HEAP_LOCK( hDst );
objDst->rgn = rgnDst;
}
GDI_HEAP_UNLOCK(hDst);
GDI_ReleaseObj(hDst);
}
else hDst = 0;
done:
GDI_HEAP_UNLOCK(hSrc);
GDI_ReleaseObj(hSrc);
return hDst;
}
return 0;

12
objects/text.c
View file

@ -92,9 +92,15 @@ BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
const RECT *lprect, LPCWSTR str, UINT count,
const INT *lpDx )
{
DC * dc = DC_GetDCPtr( hdc );
return dc && dc->funcs->pExtTextOut &&
dc->funcs->pExtTextOut(dc,x,y,flags,lprect,str,count,lpDx);
BOOL ret = FALSE;
DC * dc = DC_GetDCUpdate( hdc );
if (dc)
{
if(dc->funcs->pExtTextOut)
ret = dc->funcs->pExtTextOut(dc,x,y,flags,lprect,str,count,lpDx);
GDI_ReleaseObj( hdc );
}
return ret;
}

19
windows/cursoricon.c
View file

@ -613,8 +613,8 @@ static HGLOBAL16 CURSORICON_CreateFromResource( HINSTANCE16 hInstance, HGLOBAL16
GlobalUnlock16( hObj );
}
DeleteObject( hXorBits );
DeleteObject( hAndBits );
DeleteObject( hXorBits );
return hObj;
}
@ -1897,7 +1897,7 @@ BOOL WINAPI DrawIconEx( HDC hdc, INT x0, INT y0, HICON hIcon,
{
CURSORICONINFO *ptr = (CURSORICONINFO *)GlobalLock16 (hIcon);
HDC hDC_off = 0, hMemDC = CreateCompatibleDC (hdc);
BOOL result = FALSE, DoOffscreen = FALSE;
BOOL result = FALSE, DoOffscreen;
HBITMAP hB_off = 0, hOld = 0;
if (!ptr) return FALSE;
@ -1923,17 +1923,8 @@ BOOL WINAPI DrawIconEx( HDC hdc, INT x0, INT y0, HICON hIcon,
cyWidth = ptr->nHeight;
}
if (!(DoOffscreen = (hbr >= STOCK_WHITE_BRUSH) && (hbr <=
STOCK_HOLLOW_BRUSH)))
{
GDIOBJHDR *object = (GDIOBJHDR *) GDI_HEAP_LOCK(hbr);
if (object)
{
UINT16 magic = object->wMagic;
GDI_HEAP_UNLOCK(hbr);
DoOffscreen = magic == BRUSH_MAGIC;
}
}
DoOffscreen = (GetObjectType( hbr ) == OBJ_BRUSH);
if (DoOffscreen) {
RECT r;
@ -1948,7 +1939,7 @@ BOOL WINAPI DrawIconEx( HDC hdc, INT x0, INT y0, HICON hIcon,
hOld = SelectObject(hDC_off, hB_off);
FillRect(hDC_off, &r, hbr);
}
};
}
if (hMemDC && (!DoOffscreen || (hDC_off && hB_off)))
{

7
windows/dce.c
View file

@ -603,7 +603,7 @@ static void DCE_OffsetVisRgn( HDC hDC, HRGN hVisRgn )
OffsetRgn( hVisRgn, dc->w.DCOrgX, dc->w.DCOrgY );
GDI_HEAP_UNLOCK( hDC );
GDI_ReleaseObj( hDC );
}
/***********************************************************************
@ -807,6 +807,8 @@ HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
/* recompute visible region */
wndPtr->pDriver->pSetDrawable( wndPtr, hdc, flags, bUpdateClipOrigin );
dc->w.flags &= ~DC_DIRTY;
GDI_ReleaseObj( hdc );
if( bUpdateVisRgn )
{
@ -846,7 +848,6 @@ HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
DCE_OffsetVisRgn( hdc, hrgnVisible );
}
dc->w.flags &= ~DC_DIRTY;
dce->DCXflags &= ~DCX_DCEDIRTY;
SelectVisRgn16( hdc, hrgnVisible );
}
@ -999,7 +1000,7 @@ BOOL16 WINAPI DCHook16( HDC16 hDC, WORD code, DWORD data, LPARAM lParam )
/* Update stale DC in DCX */
wndPtr = WIN_FindWndPtr( dce->hwndCurrent);
if (wndPtr) wndPtr->pDriver->pSetDrawable( wndPtr, hDC, dce->DCXflags, TRUE);
if (wndPtr) wndPtr->pDriver->pSetDrawable( wndPtr, dce->hDC, dce->DCXflags, TRUE);
SetHookFlags16(hDC, DCHF_VALIDATEVISRGN);
hVisRgn = DCE_GetVisRgn(dce->hwndCurrent, dce->DCXflags, 0, 0);

17
windows/scroll.c
View file

@ -81,7 +81,7 @@ BOOL WINAPI ScrollDC( HDC hdc, INT dx, INT dy, const RECT *rc,
{
RECT rect, rClip, rSrc;
POINT src, dest;
DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
DC *dc = DC_GetDCUpdate( hdc );
TRACE("%04x %d,%d hrgnUpdate=%04x rcUpdate = %p cliprc = (%d,%d-%d,%d), rc=(%d,%d-%d,%d)\n",
(HDC16)hdc, dx, dy, hrgnUpdate, rcUpdate,
@ -126,7 +126,7 @@ BOOL WINAPI ScrollDC( HDC hdc, INT dx, INT dy, const RECT *rc,
rSrc.right - rSrc.left, rSrc.bottom - rSrc.top,
hdc, src.x, src.y, SRCCOPY))
{
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return FALSE;
}
}
@ -171,7 +171,7 @@ BOOL WINAPI ScrollDC( HDC hdc, INT dx, INT dy, const RECT *rc,
if (rcUpdate) SetRectEmpty(rcUpdate);
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
return TRUE;
}
@ -254,7 +254,6 @@ INT WINAPI ScrollWindowEx( HWND hwnd, INT dx, INT dy,
if (!IsRectEmpty(&cliprc) && (dx || dy))
{
DC* dc;
HDC hDC;
BOOL bUpdate = (rcUpdate || hrgnUpdate || flags & (SW_INVALIDATE | SW_ERASE));
HRGN hrgnClip = CreateRectRgnIndirect(&cliprc);
@ -276,13 +275,15 @@ rc.left, rc.top, rc.right, rc.bottom, (UINT16)flags );
hDC = GetDCEx( hwnd, hrgnClip, DCX_CACHE | DCX_USESTYLE |
DCX_KEEPCLIPRGN | DCX_INTERSECTRGN |
((flags & SW_SCROLLCHILDREN) ? DCX_NOCLIPCHILDREN : 0) );
if( (dc = (DC *)GDI_GetObjPtr(hDC, DC_MAGIC)) )
if (hDC)
{
if (dc->w.hVisRgn) {
wnd->pDriver->pSurfaceCopy(wnd,hDC,dx,dy,&rc,bUpdate);
if( bUpdate )
{
DC* dc;
if( (dc = DC_GetDCPtr(hDC)) )
{
OffsetRgn( hrgnTemp, dc->w.DCOrgX, dc->w.DCOrgY );
CombineRgn( hrgnTemp, hrgnTemp, dc->w.hVisRgn,
RGN_AND );
@ -295,10 +296,10 @@ rc.left, rc.top, rc.right, rc.bottom, (UINT16)flags );
RGN_DIFF );
if( rcUpdate ) GetRgnBox( hrgnUpdate, rcUpdate );
GDI_ReleaseObj( hDC );
}
}
ReleaseDC(hwnd, hDC);
GDI_HEAP_UNLOCK( hDC );
}
if( wnd->hrgnUpdate > 1 )

18
windows/user.c
View file

@ -12,7 +12,6 @@
#include "winuser.h"
#include "heap.h"
#include "user.h"
#include "gdi.h"
#include "task.h"
#include "queue.h"
#include "class.h"
@ -43,8 +42,13 @@ DECLARE_DEBUG_CHANNEL(win32);
*/
WORD WINAPI GetFreeSystemResources16( WORD resType )
{
HINSTANCE16 gdi_inst;
WORD gdi_heap;
int userPercent, gdiPercent;
if ((gdi_inst = LoadLibrary16( "GDI" )) < 32) return 0;
gdi_heap = GlobalHandleToSel16( gdi_inst );
switch(resType)
{
case GFSR_USERRESOURCES:
@ -54,21 +58,23 @@ WORD WINAPI GetFreeSystemResources16( WORD resType )
break;
case GFSR_GDIRESOURCES:
gdiPercent = (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
LOCAL_HeapSize( GDI_HeapSel );
gdiPercent = (int)LOCAL_CountFree( gdi_inst ) * 100 /
LOCAL_HeapSize( gdi_inst );
userPercent = 100;
break;
case GFSR_SYSTEMRESOURCES:
userPercent = (int)LOCAL_CountFree( USER_HeapSel ) * 100 /
LOCAL_HeapSize( USER_HeapSel );
gdiPercent = (int)LOCAL_CountFree( GDI_HeapSel ) * 100 /
LOCAL_HeapSize( GDI_HeapSel );
gdiPercent = (int)LOCAL_CountFree( gdi_inst ) * 100 /
LOCAL_HeapSize( gdi_inst );
break;
default:
return 0;
userPercent = gdiPercent = 0;
break;
}
FreeLibrary16( gdi_inst );
return (WORD)min( userPercent, gdiPercent );
}

4
windows/x11drv/wnd.c
View file

@ -890,10 +890,10 @@ void X11DRV_WND_SurfaceCopy(WND* wndPtr, HDC hdc, INT dx, INT dy,
dst.x, dst.y );
if (bUpdate)
TSXSetGraphicsExposures( display, physDev->gc, False );
GDI_ReleaseObj( hdc );
if (bUpdate) /* Make sure exposure events have been processed */
EVENT_Synchronize();
GDI_HEAP_UNLOCK( hdc );
}
/***********************************************************************
@ -975,7 +975,7 @@ void X11DRV_WND_SetDrawable(WND *wndPtr, HDC hdc, WORD flags, BOOL bSetClipOrigi
TSXSetClipOrigin( display, physDev->gc, dc->w.DCOrgX, dc->w.DCOrgY );
#endif
}
GDI_HEAP_UNLOCK( hdc );
GDI_ReleaseObj( hdc );
}
/***********************************************************************