From c7c2a79d5b2dc129891bece4638e66bab3a2bd7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Gardou?= Date: Mon, 27 Dec 2010 16:23:59 +0000 Subject: [PATCH] [GDI32] - Consistent formatting, no code change. svn path=/trunk/; revision=50163 --- reactos/dll/win32/gdi32/include/gdi32p.h | 170 +- reactos/dll/win32/gdi32/main/dllmain.c | 28 +- reactos/dll/win32/gdi32/misc/gdientry.c | 805 ++++----- reactos/dll/win32/gdi32/misc/heap.c | 36 +- reactos/dll/win32/gdi32/misc/misc.c | 258 +-- reactos/dll/win32/gdi32/misc/stubs.c | 1001 +++++------ reactos/dll/win32/gdi32/misc/stubsa.c | 82 +- reactos/dll/win32/gdi32/misc/stubsw.c | 127 +- reactos/dll/win32/gdi32/misc/wingl.c | 82 +- reactos/dll/win32/gdi32/objects/arc.c | 326 ++-- reactos/dll/win32/gdi32/objects/bitmap.c | 1071 ++++++------ reactos/dll/win32/gdi32/objects/brush.c | 500 +++--- reactos/dll/win32/gdi32/objects/coord.c | 978 +++++------ reactos/dll/win32/gdi32/objects/dc.c | 1792 ++++++++++---------- reactos/dll/win32/gdi32/objects/eng.c | 62 +- reactos/dll/win32/gdi32/objects/enhmfile.c | 592 +++---- reactos/dll/win32/gdi32/objects/font.c | 1391 +++++++-------- reactos/dll/win32/gdi32/objects/icm.c | 142 +- reactos/dll/win32/gdi32/objects/linedda.c | 10 +- reactos/dll/win32/gdi32/objects/metafile.c | 268 +-- reactos/dll/win32/gdi32/objects/painting.c | 858 +++++----- reactos/dll/win32/gdi32/objects/palette.c | 50 +- reactos/dll/win32/gdi32/objects/path.c | 88 +- reactos/dll/win32/gdi32/objects/pen.c | 4 +- reactos/dll/win32/gdi32/objects/printdrv.c | 776 ++++----- reactos/dll/win32/gdi32/objects/region.c | 1252 +++++++------- reactos/dll/win32/gdi32/objects/text.c | 575 +++---- reactos/dll/win32/gdi32/objects/utils.c | 460 ++--- 28 files changed, 6911 insertions(+), 6873 deletions(-) diff --git a/reactos/dll/win32/gdi32/include/gdi32p.h b/reactos/dll/win32/gdi32/include/gdi32p.h index e8b5e63952d..d76f21a534d 100644 --- a/reactos/dll/win32/gdi32/include/gdi32p.h +++ b/reactos/dll/win32/gdi32/include/gdi32p.h @@ -44,55 +44,55 @@ typedef INT // Based on wmfapi.h and Wine. typedef struct tagMETAFILEDC { - PVOID pvMetaBuffer; - HANDLE hFile; - DWORD Size; - DWORD dwWritten; - METAHEADER mh; - WORD reserved; - HLOCAL MFObjList; - HPEN hPen; - HBRUSH hBrush; - HDC hDc; - HGDIOBJ hMetaDc; - HPALETTE hPalette; - HFONT hFont; - HBITMAP hBitmap; - HRGN hRegion; - HGDIOBJ hMetafile; - HGDIOBJ hMemDc; - HPEN hExtPen; - HGDIOBJ hEnhMetaDc; - HGDIOBJ hEnhMetaFile; - HCOLORSPACE hColorSpace; - WCHAR Filename[MAX_PATH+2]; + PVOID pvMetaBuffer; + HANDLE hFile; + DWORD Size; + DWORD dwWritten; + METAHEADER mh; + WORD reserved; + HLOCAL MFObjList; + HPEN hPen; + HBRUSH hBrush; + HDC hDc; + HGDIOBJ hMetaDc; + HPALETTE hPalette; + HFONT hFont; + HBITMAP hBitmap; + HRGN hRegion; + HGDIOBJ hMetafile; + HGDIOBJ hMemDc; + HPEN hExtPen; + HGDIOBJ hEnhMetaDc; + HGDIOBJ hEnhMetaFile; + HCOLORSPACE hColorSpace; + WCHAR Filename[MAX_PATH+2]; } METAFILEDC,*PMETAFILEDC; // Metafile Entry handle typedef struct tagMF_ENTRY { - LIST_ENTRY List; - HGDIOBJ hmDC; // Handle return from NtGdiCreateClientObj. - PMETAFILEDC pmfDC; + LIST_ENTRY List; + HGDIOBJ hmDC; // Handle return from NtGdiCreateClientObj. + PMETAFILEDC pmfDC; } MF_ENTRY, *PMF_ENTRY; typedef struct tagENHMETAFILE { - PVOID pvMetaBuffer; - HANDLE hFile; /* Handle for disk based MetaFile */ - DWORD Size; - INT iType; - PENHMETAHEADER emf; - UINT handles_size, cur_handles; - HGDIOBJ *handles; - INT horzres, vertres; - INT horzsize, vertsize; - INT logpixelsx, logpixelsy; - INT bitspixel; - INT textcaps; - INT rastercaps; - INT technology; - INT planes; + PVOID pvMetaBuffer; + HANDLE hFile; /* Handle for disk based MetaFile */ + DWORD Size; + INT iType; + PENHMETAHEADER emf; + UINT handles_size, cur_handles; + HGDIOBJ *handles; + INT horzres, vertres; + INT horzsize, vertsize; + INT logpixelsx, logpixelsy; + INT bitspixel; + INT textcaps; + INT rastercaps; + INT technology; + INT planes; } ENHMETAFILE,*PENHMETAFILE; @@ -102,26 +102,26 @@ typedef struct tagENHMETAFILE #define UMPDEV_SUPPORT_ESCAPE 0x0004 typedef struct _UMPDEV { - DWORD Sig; // Init with PDEV_UMPD_ID - struct _UMPDEV *pumpdNext; - PDRIVER_INFO_5W pdi5Info; - HMODULE hModule; - DWORD dwFlags; - DWORD dwDriverAttributes; - DWORD dwConfigVersion; // Number of times the configuration - // file for this driver has been upgraded - // or downgraded since the last spooler restart. - DWORD dwDriverCount; // After init should be 2 - DWORD WOW64_UMPDev; - DWORD WOW64_hMod; - DWORD Unknown; - PVOID apfn[INDEX_LAST]; // Print Driver pfn + DWORD Sig; // Init with PDEV_UMPD_ID + struct _UMPDEV *pumpdNext; + PDRIVER_INFO_5W pdi5Info; + HMODULE hModule; + DWORD dwFlags; + DWORD dwDriverAttributes; + DWORD dwConfigVersion; // Number of times the configuration + // file for this driver has been upgraded + // or downgraded since the last spooler restart. + DWORD dwDriverCount; // After init should be 2 + DWORD WOW64_UMPDev; + DWORD WOW64_hMod; + DWORD Unknown; + PVOID apfn[INDEX_LAST]; // Print Driver pfn } UMPDEV, *PUMPDEV; #define LOCALFONT_COUNT 10 typedef struct _LOCALFONT { - FONT_ATTR lfa[LOCALFONT_COUNT]; + FONT_ATTR lfa[LOCALFONT_COUNT]; } LOCALFONT, *PLOCALFONT; // sdk/winspool.h @@ -322,35 +322,35 @@ GdiAllocBatchCommand( /* Get the size of the entry */ switch(Cmd) { - case GdiBCPatBlt: - ulSize = 0; - break; - case GdiBCPolyPatBlt: - ulSize = 0; - break; - case GdiBCTextOut: - ulSize = 0; - break; - case GdiBCExtTextOut: - ulSize = 0; - break; - case GdiBCSetBrushOrg: - ulSize = 0; - break; - case GdiBCExtSelClipRgn: - ulSize = 0; - break; - case GdiBCSelObj: - ulSize = sizeof(GDIBSOBJECT); - break; - case GdiBCDelRgn: - ulSize = sizeof(GDIBSOBJECT); - break; - case GdiBCDelObj: - ulSize = sizeof(GDIBSOBJECT); - break; - default: - return NULL; + case GdiBCPatBlt: + ulSize = 0; + break; + case GdiBCPolyPatBlt: + ulSize = 0; + break; + case GdiBCTextOut: + ulSize = 0; + break; + case GdiBCExtTextOut: + ulSize = 0; + break; + case GdiBCSetBrushOrg: + ulSize = 0; + break; + case GdiBCExtSelClipRgn: + ulSize = 0; + break; + case GdiBCSelObj: + ulSize = sizeof(GDIBSOBJECT); + break; + case GdiBCDelRgn: + ulSize = sizeof(GDIBSOBJECT); + break; + case GdiBCDelObj: + ulSize = sizeof(GDIBSOBJECT); + break; + default: + return NULL; } /* Unsupported operation */ @@ -358,7 +358,7 @@ GdiAllocBatchCommand( /* Check if the buffer is full */ if ((pTeb->GdiBatchCount >= GDI_BatchLimit) || - ((pTeb->GdiTebBatch.Offset + ulSize) > GDIBATCHBUFSIZE)) + ((pTeb->GdiTebBatch.Offset + ulSize) > GDIBATCHBUFSIZE)) { /* Call win32k, the kernel will call NtGdiFlushUserBatch to flush the current batch */ diff --git a/reactos/dll/win32/gdi32/main/dllmain.c b/reactos/dll/win32/gdi32/main/dllmain.c index 5dedf6ef4c3..9936c9521bb 100644 --- a/reactos/dll/win32/gdi32/main/dllmain.c +++ b/reactos/dll/win32/gdi32/main/dllmain.c @@ -29,12 +29,12 @@ DllMain ( { switch (dwReason) { - case DLL_PROCESS_ATTACH : - DisableThreadLibraryCalls(hDll); - break; + case DLL_PROCESS_ATTACH : + DisableThreadLibraryCalls(hDll); + break; - default: - break; + default: + break; } return TRUE; } @@ -69,17 +69,17 @@ GdiDllInitialize ( { switch (dwReason) { - case DLL_PROCESS_ATTACH: - GdiProcessSetup (); - break; + case DLL_PROCESS_ATTACH: + GdiProcessSetup (); + break; - case DLL_THREAD_ATTACH: - NtCurrentTeb()->GdiTebBatch.Offset = 0; - NtCurrentTeb()->GdiBatchCount = 0; - break; + case DLL_THREAD_ATTACH: + NtCurrentTeb()->GdiTebBatch.Offset = 0; + NtCurrentTeb()->GdiBatchCount = 0; + break; - default: - return FALSE; + default: + return FALSE; } // Very simple, the list will fill itself as it is needed. diff --git a/reactos/dll/win32/gdi32/misc/gdientry.c b/reactos/dll/win32/gdi32/misc/gdientry.c index eb510654ecc..6e51ea19d17 100644 --- a/reactos/dll/win32/gdi32/misc/gdientry.c +++ b/reactos/dll/win32/gdi32/misc/gdientry.c @@ -39,8 +39,8 @@ DdAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA Attach) { /* Call win32k */ return NtGdiDdAddAttachedSurface((HANDLE)Attach->lpDDSurface->hDDSurface, - (HANDLE)Attach->lpSurfAttached->hDDSurface, - (PDD_ADDATTACHEDSURFACEDATA)Attach); + (HANDLE)Attach->lpSurfAttached->hDDSurface, + (PDD_ADDATTACHEDSURFACEDATA)Attach); } /* @@ -55,7 +55,7 @@ DdBlt(LPDDHAL_BLTDATA Blt) HANDLE Surface = 0; /* Use the right surface */ - if (Blt->lpDDSrcSurface) + if (Blt->lpDDSrcSurface) { Surface = (HANDLE)Blt->lpDDSrcSurface->hDDSurface; } @@ -79,10 +79,10 @@ DdDestroySurface(LPDDHAL_DESTROYSURFACEDATA pDestroySurface) if (pDestroySurface->lpDDSurface->hDDSurface) { /* Check if we shoudl really destroy it */ - RealDestroy = !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_DRIVERMANAGED) || - !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_INVALID); + RealDestroy = !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_DRIVERMANAGED) || + !(pDestroySurface->lpDDSurface->dwFlags & DDRAWISURF_INVALID); - /* Call win32k */ + /* Call win32k */ Return = NtGdiDdDestroySurface((HANDLE)pDestroySurface->lpDDSurface->hDDSurface, RealDestroy); } @@ -100,17 +100,17 @@ DdFlip(LPDDHAL_FLIPDATA Flip) { /* Note : * See http://msdn2.microsoft.com/en-us/library/ms794213.aspx and - * http://msdn2.microsoft.com/en-us/library/ms792675.aspx + * http://msdn2.microsoft.com/en-us/library/ms792675.aspx */ HANDLE hSurfaceCurrentLeft = NULL; HANDLE hSurfaceTargetLeft = NULL; - + /* Auto flip off or on */ if (Flip->dwFlags & DDFLIP_STEREO ) { if ( (Flip->lpSurfTargLeft) && - (Flip->lpSurfCurrLeft)) + (Flip->lpSurfCurrLeft)) { /* Auto flip on */ hSurfaceTargetLeft = (HANDLE) Flip->lpSurfTargLeft->hDDSurface; @@ -138,8 +138,8 @@ DdLock(LPDDHAL_LOCKDATA Lock) /* Call win32k */ return NtGdiDdLock((HANDLE)Lock->lpDDSurface->hDDSurface, - (PDD_LOCKDATA)Lock, - (HANDLE)Lock->lpDDSurface->hDC); + (PDD_LOCKDATA)Lock, + (HANDLE)Lock->lpDDSurface->hDC); } /* @@ -153,7 +153,7 @@ DdUnlock(LPDDHAL_UNLOCKDATA Unlock) { /* Call win32k */ return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface, - (PDD_UNLOCKDATA)Unlock); + (PDD_UNLOCKDATA)Unlock); } /* @@ -167,7 +167,7 @@ DdGetBltStatus(LPDDHAL_GETBLTSTATUSDATA GetBltStatus) { /* Call win32k */ return NtGdiDdGetBltStatus((HANDLE)GetBltStatus->lpDDSurface->hDDSurface, - (PDD_GETBLTSTATUSDATA)GetBltStatus); + (PDD_GETBLTSTATUSDATA)GetBltStatus); } /* @@ -181,7 +181,7 @@ DdGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA GetFlipStatus) { /* Call win32k */ return NtGdiDdGetFlipStatus((HANDLE)GetFlipStatus->lpDDSurface->hDDSurface, - (PDD_GETFLIPSTATUSDATA)GetFlipStatus); + (PDD_GETFLIPSTATUSDATA)GetFlipStatus); } /* @@ -218,8 +218,8 @@ DdUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA UpdateOverlay) /* Call win32k */ return NtGdiDdUpdateOverlay((HANDLE)UpdateOverlay->lpDDDestSurface->hDDSurface, - (HANDLE)UpdateOverlay->lpDDSrcSurface->hDDSurface, - (PDD_UPDATEOVERLAYDATA)UpdateOverlay); + (HANDLE)UpdateOverlay->lpDDSrcSurface->hDDSurface, + (PDD_UPDATEOVERLAYDATA)UpdateOverlay); } /* @@ -248,7 +248,7 @@ DdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA WaitForVerticalBlank) { /* Call win32k */ return NtGdiDdWaitForVerticalBlank(GetDdHandle( - WaitForVerticalBlank->lpDD->hDD), + WaitForVerticalBlank->lpDD->hDD), (PDD_WAITFORVERTICALBLANKDATA) WaitForVerticalBlank); } @@ -262,11 +262,11 @@ DWORD WINAPI DdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA CanCreateSurface) { - /* - * Note : This functions are basic same, in win32k - * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs - * toghter in win32k at end and retrurn same data, it is still sepreated - * at user mode but in kmode it is not. + /* + * Note : This functions are basic same, in win32k + * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs + * toghter in win32k at end and retrurn same data, it is still sepreated + * at user mode but in kmode it is not. */ /* Call win32k */ @@ -303,18 +303,19 @@ DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface) LPDDSURFACEDESC pSurfaceDesc = NULL; /* TODO: Optimize speed. Most games/dx apps/programs do not want one surface, they want at least two. - * So we need increase the stack to contain two surfaces instead of one. This will increase + * So we need increase the stack to contain two surfaces instead of one. This will increase * the speed of the apps when allocating buffers. How to increase the surface stack space: * we need to create a struct for DD_SURFACE_LOCAL DdSurfaceLocal, DD_SURFACE_MORE DdSurfaceMore * DD_SURFACE_GLOBAL DdSurfaceGlobal, HANDLE hPrevSurface, hSurface like * struct { DD_SURFACE_LOCAL DdSurfaceLocal1, DD_SURFACE_LOCAL DdSurfaceLocal2 } - * in a way that it may contain two surfaces, maybe even four. We need to watch what is most common before + * in a way that it may contain two surfaces, maybe even four. We need to watch what is most common before * we create the size. Activate this IF when you start doing the optimze and please also * take reports from users which value they got here. - */ + */ #if 1 { - char buffer[1024]; \ + char buffer[1024]; + \ sprintf ( buffer, "Function %s : Optimze max to %d Surface ? (%s:%d)\n", __FUNCTION__, (int)SurfaceCount,__FILE__,__LINE__ ); OutputDebugStringA(buffer); } @@ -396,10 +397,10 @@ DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface) ptmpDdSurfaceLocal->ddsCaps.dwCaps = lcl->ddsCaps.dwCaps; ptmpDdSurfaceLocal->dwFlags = (ptmpDdSurfaceLocal->dwFlags & - (0xB0000000 | DDRAWISURF_INMASTERSPRITELIST | - DDRAWISURF_HELCB | DDRAWISURF_FRONTBUFFER | - DDRAWISURF_BACKBUFFER | DDRAWISURF_INVALID | - DDRAWISURF_DCIBUSY | DDRAWISURF_DCILOCK)) | + (0xB0000000 | DDRAWISURF_INMASTERSPRITELIST | + DDRAWISURF_HELCB | DDRAWISURF_FRONTBUFFER | + DDRAWISURF_BACKBUFFER | DDRAWISURF_INVALID | + DDRAWISURF_DCIBUSY | DDRAWISURF_DCILOCK)) | (lcl->dwFlags & DDRAWISURF_DRIVERMANAGED); ptmpDdSurfaceGlobal->wWidth = gpl->wWidth; @@ -424,9 +425,9 @@ DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface) sizeof(DDPIXELFORMAT)); } - /* Note if lcl->lpSurfMore is NULL zero out + /* Note if lcl->lpSurfMore is NULL zero out * ptmpDdSurfaceMore->ddsCapsEx.dwCaps2, - * dwCaps3, dwCaps4, ptmpDdSurfaceMore->dwSurfaceHandle + * dwCaps3, dwCaps4, ptmpDdSurfaceMore->dwSurfaceHandle */ if (lcl->lpSurfMore) { @@ -448,13 +449,13 @@ DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface) pCreateSurface->ddRVal = DDERR_GENERIC; Return = NtGdiDdCreateSurface(GetDdHandle(pCreateSurface->lpDD->hDD), - (HANDLE *)phSurface, - pSurfaceDesc, - pDdSurfaceGlobal, - pDdSurfaceLocal, - pDdSurfaceMore, - (PDD_CREATESURFACEDATA)pCreateSurface, - puhSurface); + (HANDLE *)phSurface, + pSurfaceDesc, + pDdSurfaceGlobal, + pDdSurfaceLocal, + pDdSurfaceMore, + (PDD_CREATESURFACEDATA)pCreateSurface, + puhSurface); if (SurfaceCount == 0) { @@ -466,7 +467,7 @@ DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface) ptmpDdSurfaceGlobal = pDdSurfaceGlobal; ptmpDdSurfaceLocal = pDdSurfaceLocal; - for (i=0;ilplpSList[i]; LPDDRAWI_DDRAWSURFACE_GBL gpl = pCreateSurface->lplpSList[i]->lpGbl; @@ -555,7 +556,7 @@ DdSetColorKey(LPDDHAL_SETCOLORKEYDATA pSetColorKey) { /* Call win32k */ return NtGdiDdSetColorKey((HANDLE)pSetColorKey->lpDDSurface->hDDSurface, - (PDD_SETCOLORKEYDATA)pSetColorKey); + (PDD_SETCOLORKEYDATA)pSetColorKey); } /* @@ -569,7 +570,7 @@ DdGetScanLine(LPDDHAL_GETSCANLINEDATA pGetScanLine) { /* Call win32k */ return NtGdiDdGetScanLine(GetDdHandle(pGetScanLine->lpDD->hDD), - (PDD_GETSCANLINEDATA)pGetScanLine); + (PDD_GETSCANLINEDATA)pGetScanLine); } @@ -581,11 +582,11 @@ DdGetScanLine(LPDDHAL_GETSCANLINEDATA pGetScanLine) BOOL WINAPI DvpCreateVideoPort(LPDDHAL_CREATEVPORTDATA pDvdCreatePort) -{ - pDvdCreatePort->lpVideoPort->hDDVideoPort = - NtGdiDvpCreateVideoPort(GetDdHandle(pDvdCreatePort->lpDD->lpGbl->hDD), - (PDD_CREATEVPORTDATA) pDvdCreatePort); - +{ + pDvdCreatePort->lpVideoPort->hDDVideoPort = + NtGdiDvpCreateVideoPort(GetDdHandle(pDvdCreatePort->lpDD->lpGbl->hDD), + (PDD_CREATEVPORTDATA) pDvdCreatePort); + return TRUE; } @@ -598,7 +599,7 @@ DWORD WINAPI DvpDestroyVideoPort(LPDDHAL_DESTROYVPORTDATA pDvdDestoryPort) { - return NtGdiDvpDestroyVideoPort(pDvdDestoryPort->lpVideoPort->hDDVideoPort, (PDD_DESTROYVPORTDATA)pDvdDestoryPort); + return NtGdiDvpDestroyVideoPort(pDvdDestoryPort->lpVideoPort->hDDVideoPort, (PDD_DESTROYVPORTDATA)pDvdDestoryPort); } /* @@ -698,8 +699,8 @@ WINAPI DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort) { /* - * Windows XP limit to max 10 handles of videoport surface and Vbi - * ReactOS doing same to keep compatible, if it is more that 10 + * Windows XP limit to max 10 handles of videoport surface and Vbi + * ReactOS doing same to keep compatible, if it is more that 10 * videoport surface or vbi the stack will be curpted in windows xp * ReactOS safe guard againts that * @@ -707,7 +708,7 @@ DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort) HANDLE phSurfaceVideo[10]; HANDLE phSurfaceVbi[10]; - + if (pDvdUpdateVideoPort->dwFlags != DDRAWI_VPORTSTOP) { DWORD dwNumAutoflip; @@ -716,28 +717,28 @@ DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort) /* Take copy of lplpDDSurface for the handle value will be modify in dxg */ dwNumAutoflip = pDvdUpdateVideoPort->dwNumAutoflip; if ((dwNumAutoflip == 0) && - (pDvdUpdateVideoPort->lplpDDSurface == 0)) - { - dwNumAutoflip++; + (pDvdUpdateVideoPort->lplpDDSurface == 0)) + { + dwNumAutoflip++; } - + if (dwNumAutoflip != 0) - { + { if (dwNumAutoflip>10) { dwNumAutoflip = 10; } - memcpy(phSurfaceVideo,pDvdUpdateVideoPort->lplpDDSurface,dwNumAutoflip*sizeof(HANDLE)); + memcpy(phSurfaceVideo,pDvdUpdateVideoPort->lplpDDSurface,dwNumAutoflip*sizeof(HANDLE)); } - + /* Take copy of lplpDDVBISurface for the handle value will be modify in dxg */ - dwNumVBIAutoflip = pDvdUpdateVideoPort->dwNumVBIAutoflip; + dwNumVBIAutoflip = pDvdUpdateVideoPort->dwNumVBIAutoflip; if ( (dwNumVBIAutoflip == 0) && - (pDvdUpdateVideoPort->lplpDDVBISurface == 0) ) + (pDvdUpdateVideoPort->lplpDDVBISurface == 0) ) { dwNumVBIAutoflip++; } - + if (dwNumVBIAutoflip != 0) { if (dwNumVBIAutoflip>10) @@ -745,7 +746,7 @@ DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort) dwNumVBIAutoflip = 10; } memcpy(phSurfaceVbi,pDvdUpdateVideoPort->lplpDDVBISurface,dwNumVBIAutoflip*sizeof(HANDLE)); - } + } } /* Call Win32k */ @@ -821,7 +822,7 @@ DWORD WINAPI DdGetAvailDriverMemory(LPDDHAL_GETAVAILDRIVERMEMORYDATA pDdGetAvailDriverMemory) { - return NtGdiDdGetAvailDriverMemory(GetDdHandle( pDdGetAvailDriverMemory->lpDD->hDD), (PDD_GETAVAILDRIVERMEMORYDATA) pDdGetAvailDriverMemory); + return NtGdiDdGetAvailDriverMemory(GetDdHandle( pDdGetAvailDriverMemory->lpDD->hDD), (PDD_GETAVAILDRIVERMEMORYDATA) pDdGetAvailDriverMemory); } /* @@ -833,13 +834,13 @@ DWORD WINAPI DdAlphaBlt(LPDDHAL_BLTDATA pDdAlphaBlt) { - HANDLE hDDSrcSurface = 0; + HANDLE hDDSrcSurface = 0; if (pDdAlphaBlt->lpDDSrcSurface != 0) { hDDSrcSurface = (HANDLE) pDdAlphaBlt->lpDDSrcSurface->hDDSurface; } - + return NtGdiDdAlphaBlt((HANDLE)pDdAlphaBlt->lpDDDestSurface->hDDSurface, hDDSrcSurface, (PDD_BLTDATA)&pDdAlphaBlt); } @@ -853,8 +854,8 @@ WINAPI DdCreateSurfaceEx(LPDDHAL_CREATESURFACEEXDATA pDdCreateSurfaceEx) { pDdCreateSurfaceEx->ddRVal = NtGdiDdCreateSurfaceEx( GetDdHandle(pDdCreateSurfaceEx->lpDDLcl->lpGbl->hDD), - (HANDLE)pDdCreateSurfaceEx->lpDDSLcl->hDDSurface, - pDdCreateSurfaceEx->lpDDSLcl->lpSurfMore->dwSurfaceHandle); + (HANDLE)pDdCreateSurfaceEx->lpDDSLcl->hDDSurface, + pDdCreateSurfaceEx->lpDDSLcl->lpSurfMore->dwSurfaceHandle); return TRUE; } @@ -898,330 +899,330 @@ DdFlipToGDISurface(LPDDHAL_FLIPTOGDISURFACEDATA pDdFlipToGDISurface) DWORD WINAPI DdGetDriverInfo(LPDDHAL_GETDRIVERINFODATA pData) -{ +{ DDHAL_GETDRIVERINFODATA pDrvInfoData; DWORD retValue = DDHAL_DRIVER_NOTHANDLED; HANDLE hDD; /* FIXME add SEH around this functions */ - RtlZeroMemory(&pDrvInfoData, sizeof (DDHAL_GETDRIVERINFODATA)); - RtlCopyMemory(&pDrvInfoData.guidInfo, &pData->guidInfo, sizeof(GUID)); - - hDD = GetDdHandle(pData->dwContext); + RtlZeroMemory(&pDrvInfoData, sizeof (DDHAL_GETDRIVERINFODATA)); + RtlCopyMemory(&pDrvInfoData.guidInfo, &pData->guidInfo, sizeof(GUID)); - pDrvInfoData.dwSize = sizeof (DDHAL_GETDRIVERINFODATA); - pDrvInfoData.ddRVal = DDERR_GENERIC; - pDrvInfoData.dwContext = (ULONG_PTR)hDD; - - - /* Videoport Callbacks check and setup for DirectX/ ReactX */ - if (IsEqualGUID(&pData->guidInfo, &GUID_VideoPortCallbacks)) - { - DDHAL_DDVIDEOPORTCALLBACKS pDvdPort; - DDHAL_DDVIDEOPORTCALLBACKS* pUserDvdPort = (DDHAL_DDVIDEOPORTCALLBACKS *)pData->lpvData; + hDD = GetDdHandle(pData->dwContext); - /* Clear internal out buffer and set it up*/ - RtlZeroMemory(&pDvdPort, DDVIDEOPORTCALLBACKSSIZE); - pDvdPort.dwSize = DDVIDEOPORTCALLBACKSSIZE; + pDrvInfoData.dwSize = sizeof (DDHAL_GETDRIVERINFODATA); + pDrvInfoData.ddRVal = DDERR_GENERIC; + pDrvInfoData.dwContext = (ULONG_PTR)hDD; - /* set up internal buffer */ - pDrvInfoData.lpvData = (PVOID)&pDvdPort; - pDrvInfoData.dwExpectedSize = DDVIDEOPORTCALLBACKSSIZE ; - - /* Call win32k */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - /* Setup user out buffer and convert kmode callbacks to user mode */ - pUserDvdPort->dwSize = DDVIDEOPORTCALLBACKSSIZE; - pUserDvdPort->dwFlags = pDrvInfoData.dwFlags = 0; - - pUserDvdPort->dwFlags = (pDrvInfoData.dwFlags & ~(DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP | - DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE | DDHAL_VPORT32_WAITFORSYNC)) | - (DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP | - DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE); + /* Videoport Callbacks check and setup for DirectX/ ReactX */ + if (IsEqualGUID(&pData->guidInfo, &GUID_VideoPortCallbacks)) + { + DDHAL_DDVIDEOPORTCALLBACKS pDvdPort; + DDHAL_DDVIDEOPORTCALLBACKS* pUserDvdPort = (DDHAL_DDVIDEOPORTCALLBACKS *)pData->lpvData; - pData->dwActualSize = DDVIDEOPORTCALLBACKSSIZE; - pUserDvdPort->CreateVideoPort = (LPDDHALVPORTCB_CREATEVIDEOPORT) DvpCreateVideoPort; - pUserDvdPort->FlipVideoPort = (LPDDHALVPORTCB_FLIP) DvpFlipVideoPort; - pUserDvdPort->DestroyVideoPort = (LPDDHALVPORTCB_DESTROYVPORT) DvpDestroyVideoPort; - pUserDvdPort->UpdateVideoPort = (LPDDHALVPORTCB_UPDATE) DvpUpdateVideoPort; + /* Clear internal out buffer and set it up*/ + RtlZeroMemory(&pDvdPort, DDVIDEOPORTCALLBACKSSIZE); + pDvdPort.dwSize = DDVIDEOPORTCALLBACKSSIZE; - if (pDvdPort.CanCreateVideoPort) - { - pUserDvdPort->CanCreateVideoPort = (LPDDHALVPORTCB_CANCREATEVIDEOPORT) DvpCanCreateVideoPort; - } + /* set up internal buffer */ + pDrvInfoData.lpvData = (PVOID)&pDvdPort; + pDrvInfoData.dwExpectedSize = DDVIDEOPORTCALLBACKSSIZE ; - if (pDvdPort.GetVideoPortBandwidth) - { - pUserDvdPort->GetVideoPortBandwidth = (LPDDHALVPORTCB_GETBANDWIDTH) DvpGetVideoPortBandwidth; - } + /* Call win32k */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - if (pDvdPort.GetVideoPortInputFormats) - { - pUserDvdPort->GetVideoPortInputFormats = (LPDDHALVPORTCB_GETINPUTFORMATS) DvpGetVideoPortInputFormats; - } + /* Setup user out buffer and convert kmode callbacks to user mode */ + pUserDvdPort->dwSize = DDVIDEOPORTCALLBACKSSIZE; + pUserDvdPort->dwFlags = pDrvInfoData.dwFlags = 0; - if (pDvdPort.GetVideoPortOutputFormats) - { - pUserDvdPort->GetVideoPortOutputFormats = (LPDDHALVPORTCB_GETOUTPUTFORMATS) DvpGetVideoPortOutputFormats; - } + pUserDvdPort->dwFlags = (pDrvInfoData.dwFlags & ~(DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP | + DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE | DDHAL_VPORT32_WAITFORSYNC)) | + (DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP | + DDHAL_VPORT32_DESTROY | DDHAL_VPORT32_UPDATE); - if (pDvdPort.GetVideoPortField) - { - pUserDvdPort->GetVideoPortField = (LPDDHALVPORTCB_GETFIELD) DvpGetVideoPortField; - } + pData->dwActualSize = DDVIDEOPORTCALLBACKSSIZE; + pUserDvdPort->CreateVideoPort = (LPDDHALVPORTCB_CREATEVIDEOPORT) DvpCreateVideoPort; + pUserDvdPort->FlipVideoPort = (LPDDHALVPORTCB_FLIP) DvpFlipVideoPort; + pUserDvdPort->DestroyVideoPort = (LPDDHALVPORTCB_DESTROYVPORT) DvpDestroyVideoPort; + pUserDvdPort->UpdateVideoPort = (LPDDHALVPORTCB_UPDATE) DvpUpdateVideoPort; - if (pDvdPort.GetVideoPortLine) - { - pUserDvdPort->GetVideoPortLine = (LPDDHALVPORTCB_GETLINE) DvpGetVideoPortLine; - } - - if (pDvdPort.GetVideoPortConnectInfo) - { - pUserDvdPort->GetVideoPortConnectInfo = (LPDDHALVPORTCB_GETVPORTCONNECT) DvpGetVideoPortConnectInfo; - } - - if (pDvdPort.GetVideoPortFlipStatus) - { - pUserDvdPort->GetVideoPortFlipStatus = (LPDDHALVPORTCB_GETFLIPSTATUS) DvpGetVideoPortFlipStatus; - } - - if (pDvdPort.WaitForVideoPortSync) - { - pUserDvdPort->WaitForVideoPortSync = (LPDDHALVPORTCB_WAITFORSYNC) DvpWaitForVideoPortSync; - } - - if (pDvdPort.GetVideoSignalStatus) - { - pUserDvdPort->GetVideoSignalStatus = (LPDDHALVPORTCB_GETSIGNALSTATUS) DvpGetVideoSignalStatus; - } - - if (pDvdPort.ColorControl) - { - pUserDvdPort->ColorControl = (LPDDHALVPORTCB_COLORCONTROL) DvpColorControl; - } - - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; - } - - /* Color Control Callbacks check and setup for DirectX/ ReactX */ - if (IsEqualGUID(&pData->guidInfo, &GUID_ColorControlCallbacks)) + if (pDvdPort.CanCreateVideoPort) { - DDHAL_DDCOLORCONTROLCALLBACKS pColorControl; - DDHAL_DDCOLORCONTROLCALLBACKS* pUserColorControl = (DDHAL_DDCOLORCONTROLCALLBACKS *)pData->lpvData; - - /* Clear internal out buffer and set it up*/ - RtlZeroMemory(&pColorControl, DDCOLORCONTROLCALLBACKSSIZE); - pColorControl.dwSize = DDCOLORCONTROLCALLBACKSSIZE; - - /* set up internal buffer */ - pDrvInfoData.lpvData = (PVOID)&pColorControl; - pDrvInfoData.dwExpectedSize = DDCOLORCONTROLCALLBACKSSIZE ; - - /* Call win32k */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - - pData->dwActualSize = DDCOLORCONTROLCALLBACKSSIZE; - pData->dwFlags = pDrvInfoData.dwFlags; - - pUserColorControl->dwSize = DDCOLORCONTROLCALLBACKSSIZE; - pUserColorControl->dwFlags = pUserColorControl->dwFlags; - - if (pColorControl.ColorControl != NULL) - { - pUserColorControl->ColorControl = (LPDDHALCOLORCB_COLORCONTROL) DdColorControl; - } - - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; + pUserDvdPort->CanCreateVideoPort = (LPDDHALVPORTCB_CANCREATEVIDEOPORT) DvpCanCreateVideoPort; } - /* Misc Callbacks check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_MiscellaneousCallbacks)) + if (pDvdPort.GetVideoPortBandwidth) { - DDHAL_DDMISCELLANEOUSCALLBACKS pMisc; - DDHAL_DDMISCELLANEOUSCALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUSCALLBACKS *)pData->lpvData; - - /* Clear internal out buffer and set it up*/ - RtlZeroMemory(&pMisc, DDMISCELLANEOUSCALLBACKSSIZE); - pMisc.dwSize = DDMISCELLANEOUSCALLBACKSSIZE; - - /* set up internal buffer */ - pDrvInfoData.lpvData = (PVOID)&pMisc; - pDrvInfoData.dwExpectedSize = DDMISCELLANEOUSCALLBACKSSIZE ; - - /* Call win32k */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - - pData->dwActualSize = DDMISCELLANEOUSCALLBACKSSIZE; - - /* Only one callbacks are supported */ - pUserMisc->dwFlags = pMisc.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY; - pUserMisc->GetAvailDriverMemory = (LPDDHAL_GETAVAILDRIVERMEMORY) DdGetAvailDriverMemory; - - /* This callbacks are only for win9x and theirfor it is not longer use in NT or ReactOS - * pUserMisc->UpdateNonLocalHeap; - * pUserMisc->GetHeapAlignment; - * pUserMisc->GetSysmemBltStatus; */ - - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; + pUserDvdPort->GetVideoPortBandwidth = (LPDDHALVPORTCB_GETBANDWIDTH) DvpGetVideoPortBandwidth; } - /* Misc 2 Callbacks check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_Miscellaneous2Callbacks)) + if (pDvdPort.GetVideoPortInputFormats) { - DDHAL_DDMISCELLANEOUS2CALLBACKS pMisc; - DDHAL_DDMISCELLANEOUS2CALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUS2CALLBACKS *)pData->lpvData; - - /* Clear internal out buffer and set it up*/ - RtlZeroMemory(&pMisc, DDMISCELLANEOUS2CALLBACKSSIZE); - pMisc.dwSize = DDMISCELLANEOUS2CALLBACKSSIZE; - - /* set up internal buffer */ - pDrvInfoData.lpvData = (PVOID)&pMisc; - pDrvInfoData.dwExpectedSize = DDMISCELLANEOUS2CALLBACKSSIZE ; - - /* Call win32k */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - - pData->dwActualSize = DDMISCELLANEOUS2CALLBACKSSIZE; - - pUserMisc->dwFlags = pMisc.dwFlags; - - /* This functions are not documneted in MSDN for this struct, here is directx/reactx alpha blend */ - if ( pMisc.Reserved ) - { - pUserMisc->Reserved = (LPVOID) DdAlphaBlt; - } - - if ( pMisc.CreateSurfaceEx ) - { - pUserMisc->CreateSurfaceEx = (LPDDHAL_CREATESURFACEEX) DdCreateSurfaceEx; - } - - if ( pMisc.GetDriverState ) - { - pUserMisc->GetDriverState = (LPDDHAL_GETDRIVERSTATE) NtGdiDdGetDriverState; - } - - /* NOTE : pUserMisc->DestroyDDLocal is outdated and are not beign tuch */ - - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; + pUserDvdPort->GetVideoPortInputFormats = (LPDDHALVPORTCB_GETINPUTFORMATS) DvpGetVideoPortInputFormats; } - /* NT Callbacks check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_NTCallbacks)) + if (pDvdPort.GetVideoPortOutputFormats) { - /* MS does not have DHAL_* version of this callbacks - * so we are force using PDD_* callbacks here - */ - DD_NTCALLBACKS pNtKernel; - PDD_NTCALLBACKS pUserNtKernel = (PDD_NTCALLBACKS)pData->lpvData; - - /* Clear internal out buffer and set it up*/ - RtlZeroMemory(&pNtKernel, sizeof(DD_NTCALLBACKS)); - pNtKernel.dwSize = sizeof(DD_NTCALLBACKS); - - /* set up internal buffer */ - pDrvInfoData.lpvData = (PVOID)&pNtKernel; - pDrvInfoData.dwExpectedSize = sizeof(DD_NTCALLBACKS) ; - - /* Call win32k */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - - pData->dwActualSize = sizeof(DD_NTCALLBACKS); - - pUserNtKernel->dwSize = sizeof(DD_NTCALLBACKS); - pUserNtKernel->dwFlags = pNtKernel.dwFlags; - pUserNtKernel->FreeDriverMemory = 0; - - if (pNtKernel.SetExclusiveMode) - { - pUserNtKernel->SetExclusiveMode = (PDD_SETEXCLUSIVEMODE) DdSetExclusiveMode; - } - - if (pNtKernel.FlipToGDISurface) - { - pUserNtKernel->FlipToGDISurface = (PDD_FLIPTOGDISURFACE) DdFlipToGDISurface; - } - - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; + pUserDvdPort->GetVideoPortOutputFormats = (LPDDHALVPORTCB_GETOUTPUTFORMATS) DvpGetVideoPortOutputFormats; } - /* D3D Callbacks version 2 check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks2)) + if (pDvdPort.GetVideoPortField) { - // FIXME GUID_D3DCallbacks2 + pUserDvdPort->GetVideoPortField = (LPDDHALVPORTCB_GETFIELD) DvpGetVideoPortField; } - /* D3D Callbacks version 3 check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks3)) + if (pDvdPort.GetVideoPortLine) { - // FIXME GUID_D3DCallbacks3 + pUserDvdPort->GetVideoPortLine = (LPDDHALVPORTCB_GETLINE) DvpGetVideoPortLine; } - /* D3DParseUnknownCommand Callbacks check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DParseUnknownCommandCallback)) + if (pDvdPort.GetVideoPortConnectInfo) { - // FIXME GUID_D3DParseUnknownCommandCallback + pUserDvdPort->GetVideoPortConnectInfo = (LPDDHALVPORTCB_GETVPORTCONNECT) DvpGetVideoPortConnectInfo; } - /* MotionComp Callbacks check and setup for DirectX/ ReactX */ - else if (IsEqualGUID(&pData->guidInfo, &GUID_MotionCompCallbacks)) + if (pDvdPort.GetVideoPortFlipStatus) { - // FIXME GUID_MotionCompCallbacks + pUserDvdPort->GetVideoPortFlipStatus = (LPDDHALVPORTCB_GETFLIPSTATUS) DvpGetVideoPortFlipStatus; } - /* FIXME VPE2 Callbacks check and setup for DirectX/ ReactX */ - //else if (IsEqualGUID(&pData->guidInfo, &GUID_VPE2Callbacks)) - //{ - // FIXME GUID_VPE2Callbacks - //} - else + if (pDvdPort.WaitForVideoPortSync) { - /* set up internal buffer */ - pDrvInfoData.dwExpectedSize = pData->dwExpectedSize; - pDrvInfoData.lpvData = pData->lpvData; - - /* We do not cover all callbacks for user mode, they are only cover by kmode */ - retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); - - /* Setup return data */ - pData->dwActualSize = pDrvInfoData.dwActualSize; - pData->lpvData = pDrvInfoData.lpvData; - /* Windows XP never repot back the true return value, - * it only report back if we have a driver or not - * ReactOS keep this behoir to be compatible with - * Windows XP - */ - pData->ddRVal = retValue; + pUserDvdPort->WaitForVideoPortSync = (LPDDHALVPORTCB_WAITFORSYNC) DvpWaitForVideoPortSync; } + if (pDvdPort.GetVideoSignalStatus) + { + pUserDvdPort->GetVideoSignalStatus = (LPDDHALVPORTCB_GETSIGNALSTATUS) DvpGetVideoSignalStatus; + } + + if (pDvdPort.ColorControl) + { + pUserDvdPort->ColorControl = (LPDDHALVPORTCB_COLORCONTROL) DvpColorControl; + } + + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + + /* Color Control Callbacks check and setup for DirectX/ ReactX */ + if (IsEqualGUID(&pData->guidInfo, &GUID_ColorControlCallbacks)) + { + DDHAL_DDCOLORCONTROLCALLBACKS pColorControl; + DDHAL_DDCOLORCONTROLCALLBACKS* pUserColorControl = (DDHAL_DDCOLORCONTROLCALLBACKS *)pData->lpvData; + + /* Clear internal out buffer and set it up*/ + RtlZeroMemory(&pColorControl, DDCOLORCONTROLCALLBACKSSIZE); + pColorControl.dwSize = DDCOLORCONTROLCALLBACKSSIZE; + + /* set up internal buffer */ + pDrvInfoData.lpvData = (PVOID)&pColorControl; + pDrvInfoData.dwExpectedSize = DDCOLORCONTROLCALLBACKSSIZE ; + + /* Call win32k */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); + + pData->dwActualSize = DDCOLORCONTROLCALLBACKSSIZE; + pData->dwFlags = pDrvInfoData.dwFlags; + + pUserColorControl->dwSize = DDCOLORCONTROLCALLBACKSSIZE; + pUserColorControl->dwFlags = pUserColorControl->dwFlags; + + if (pColorControl.ColorControl != NULL) + { + pUserColorControl->ColorControl = (LPDDHALCOLORCB_COLORCONTROL) DdColorControl; + } + + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + + /* Misc Callbacks check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_MiscellaneousCallbacks)) + { + DDHAL_DDMISCELLANEOUSCALLBACKS pMisc; + DDHAL_DDMISCELLANEOUSCALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUSCALLBACKS *)pData->lpvData; + + /* Clear internal out buffer and set it up*/ + RtlZeroMemory(&pMisc, DDMISCELLANEOUSCALLBACKSSIZE); + pMisc.dwSize = DDMISCELLANEOUSCALLBACKSSIZE; + + /* set up internal buffer */ + pDrvInfoData.lpvData = (PVOID)&pMisc; + pDrvInfoData.dwExpectedSize = DDMISCELLANEOUSCALLBACKSSIZE ; + + /* Call win32k */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); + + pData->dwActualSize = DDMISCELLANEOUSCALLBACKSSIZE; + + /* Only one callbacks are supported */ + pUserMisc->dwFlags = pMisc.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY; + pUserMisc->GetAvailDriverMemory = (LPDDHAL_GETAVAILDRIVERMEMORY) DdGetAvailDriverMemory; + + /* This callbacks are only for win9x and theirfor it is not longer use in NT or ReactOS + * pUserMisc->UpdateNonLocalHeap; + * pUserMisc->GetHeapAlignment; + * pUserMisc->GetSysmemBltStatus; */ + + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + + /* Misc 2 Callbacks check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_Miscellaneous2Callbacks)) + { + DDHAL_DDMISCELLANEOUS2CALLBACKS pMisc; + DDHAL_DDMISCELLANEOUS2CALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUS2CALLBACKS *)pData->lpvData; + + /* Clear internal out buffer and set it up*/ + RtlZeroMemory(&pMisc, DDMISCELLANEOUS2CALLBACKSSIZE); + pMisc.dwSize = DDMISCELLANEOUS2CALLBACKSSIZE; + + /* set up internal buffer */ + pDrvInfoData.lpvData = (PVOID)&pMisc; + pDrvInfoData.dwExpectedSize = DDMISCELLANEOUS2CALLBACKSSIZE ; + + /* Call win32k */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); + + pData->dwActualSize = DDMISCELLANEOUS2CALLBACKSSIZE; + + pUserMisc->dwFlags = pMisc.dwFlags; + + /* This functions are not documneted in MSDN for this struct, here is directx/reactx alpha blend */ + if ( pMisc.Reserved ) + { + pUserMisc->Reserved = (LPVOID) DdAlphaBlt; + } + + if ( pMisc.CreateSurfaceEx ) + { + pUserMisc->CreateSurfaceEx = (LPDDHAL_CREATESURFACEEX) DdCreateSurfaceEx; + } + + if ( pMisc.GetDriverState ) + { + pUserMisc->GetDriverState = (LPDDHAL_GETDRIVERSTATE) NtGdiDdGetDriverState; + } + + /* NOTE : pUserMisc->DestroyDDLocal is outdated and are not beign tuch */ + + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + + /* NT Callbacks check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_NTCallbacks)) + { + /* MS does not have DHAL_* version of this callbacks + * so we are force using PDD_* callbacks here + */ + DD_NTCALLBACKS pNtKernel; + PDD_NTCALLBACKS pUserNtKernel = (PDD_NTCALLBACKS)pData->lpvData; + + /* Clear internal out buffer and set it up*/ + RtlZeroMemory(&pNtKernel, sizeof(DD_NTCALLBACKS)); + pNtKernel.dwSize = sizeof(DD_NTCALLBACKS); + + /* set up internal buffer */ + pDrvInfoData.lpvData = (PVOID)&pNtKernel; + pDrvInfoData.dwExpectedSize = sizeof(DD_NTCALLBACKS) ; + + /* Call win32k */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); + + pData->dwActualSize = sizeof(DD_NTCALLBACKS); + + pUserNtKernel->dwSize = sizeof(DD_NTCALLBACKS); + pUserNtKernel->dwFlags = pNtKernel.dwFlags; + pUserNtKernel->FreeDriverMemory = 0; + + if (pNtKernel.SetExclusiveMode) + { + pUserNtKernel->SetExclusiveMode = (PDD_SETEXCLUSIVEMODE) DdSetExclusiveMode; + } + + if (pNtKernel.FlipToGDISurface) + { + pUserNtKernel->FlipToGDISurface = (PDD_FLIPTOGDISURFACE) DdFlipToGDISurface; + } + + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + + /* D3D Callbacks version 2 check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks2)) + { + // FIXME GUID_D3DCallbacks2 + } + + /* D3D Callbacks version 3 check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks3)) + { + // FIXME GUID_D3DCallbacks3 + } + + /* D3DParseUnknownCommand Callbacks check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DParseUnknownCommandCallback)) + { + // FIXME GUID_D3DParseUnknownCommandCallback + } + + /* MotionComp Callbacks check and setup for DirectX/ ReactX */ + else if (IsEqualGUID(&pData->guidInfo, &GUID_MotionCompCallbacks)) + { + // FIXME GUID_MotionCompCallbacks + } + + /* FIXME VPE2 Callbacks check and setup for DirectX/ ReactX */ + //else if (IsEqualGUID(&pData->guidInfo, &GUID_VPE2Callbacks)) + //{ + // FIXME GUID_VPE2Callbacks + //} + else + { + /* set up internal buffer */ + pDrvInfoData.dwExpectedSize = pData->dwExpectedSize; + pDrvInfoData.lpvData = pData->lpvData; + + /* We do not cover all callbacks for user mode, they are only cover by kmode */ + retValue = NtGdiDdGetDriverInfo(hDD, (PDD_GETDRIVERINFODATA)&pDrvInfoData); + + /* Setup return data */ + pData->dwActualSize = pDrvInfoData.dwActualSize; + pData->lpvData = pDrvInfoData.lpvData; + /* Windows XP never repot back the true return value, + * it only report back if we have a driver or not + * ReactOS keep this behoir to be compatible with + * Windows XP + */ + pData->ddRVal = retValue; + } + return retValue; } @@ -1231,8 +1232,8 @@ DdGetDriverInfo(LPDDHAL_GETDRIVERINFODATA pData) * * D3dContextCreate */ -BOOL -WINAPI +BOOL +WINAPI D3dContextCreate(LPD3DHAL_CONTEXTCREATEDATA pdcci) { HANDLE hSurfZ = NULL; @@ -1241,8 +1242,8 @@ D3dContextCreate(LPD3DHAL_CONTEXTCREATEDATA pdcci) { hSurfZ = (HANDLE)pdcci->lpDDSZLcl->hDDSurface; } - - return NtGdiD3dContextCreate(GetDdHandle(pdcci->lpDDLcl->hDD), + + return NtGdiD3dContextCreate(GetDdHandle(pdcci->lpDDLcl->hDD), (HANDLE)pdcci->lpDDSLcl->hDDSurface, hSurfZ, (D3DNTHAL_CONTEXTCREATEI *)pdcci); @@ -1257,16 +1258,16 @@ DWORD WINAPI DdCanCreateD3DBuffer(LPDDHAL_CANCREATESURFACEDATA CanCreateD3DBuffer) { - /* - * Note : This functions are basic same, in win32k - * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs - * toghter in win32k at end and retrurn same data, it is still sepreated - * at user mode but in kmode it is not. + /* + * Note : This functions are basic same, in win32k + * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs + * toghter in win32k at end and retrurn same data, it is still sepreated + * at user mode but in kmode it is not. */ /* Call win32k */ return NtGdiDdCanCreateD3DBuffer(GetDdHandle(CanCreateD3DBuffer->lpDD->hDD), - (PDD_CANCREATESURFACEDATA)CanCreateD3DBuffer); + (PDD_CANCREATESURFACEDATA)CanCreateD3DBuffer); } @@ -1383,7 +1384,7 @@ DdUnlockD3D(LPDDHAL_UNLOCKDATA Unlock) { /* Call win32k */ return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface, - (PDD_UNLOCKDATA)Unlock); + (PDD_UNLOCKDATA)Unlock); } @@ -1434,11 +1435,11 @@ bDDCreateSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface, /* Create the object */ pSurface->hDDSurface = (DWORD)NtGdiDdCreateSurfaceObject(GetDdHandle(pSurface->lpGbl->lpDD->hDD), - (HANDLE)pSurface->hDDSurface, - &SurfaceLocal, - &SurfaceMore, - &SurfaceGlobal, - bComplete); + (HANDLE)pSurface->hDDSurface, + &SurfaceLocal, + &SurfaceMore, + &SurfaceGlobal, + bComplete); /* Return status */ if (pSurface->hDDSurface) return TRUE; @@ -1490,7 +1491,7 @@ DdCreateDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, else { /* Using the per-process object, so create it */ - pDirectDrawGlobal->hDD = (ULONG_PTR)NtGdiDdCreateDirectDrawObject(hdc); + pDirectDrawGlobal->hDD = (ULONG_PTR)NtGdiDdCreateDirectDrawObject(hdc); /* Set the return value */ Return = pDirectDrawGlobal->hDD ? TRUE : FALSE; @@ -1518,7 +1519,7 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, LPDDSURFACEDESC pD3dTextureFormats, LPDWORD pdwFourCC, LPVIDMEM pvmList) - { +{ PVIDEOMEMORY VidMemList = NULL; DD_HALINFO HalInfo; D3DNTHAL_CALLBACKS D3dCallbacks; @@ -1538,9 +1539,9 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, /* Note : XP always alloc 24*sizeof(VIDEOMEMORY) of pvmlist so we change it to it */ if ( (pvmList != NULL) && - (pHalInfo->vmiData.dwNumHeaps != 0) ) + (pHalInfo->vmiData.dwNumHeaps != 0) ) { - VidMemList = (PVIDEOMEMORY) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(VIDEOMEMORY) * 24 ) * pHalInfo->vmiData.dwNumHeaps); + VidMemList = (PVIDEOMEMORY) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(VIDEOMEMORY) * 24 ) * pHalInfo->vmiData.dwNumHeaps); } @@ -1573,7 +1574,7 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, /* Check for NT5+ D3D Data */ if ( (D3dCallbacks.dwSize != 0) && - (D3dDriverData.dwSize != 0) ) + (D3dDriverData.dwSize != 0) ) { /* Write these down */ pHalInfo->lpD3DGlobalDriverData = (ULONG_PTR)pD3dDriverData; @@ -1601,30 +1602,30 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, pHalInfo->vmiData.dwOffscreenAlign = HalInfo.vmiData.dwOffscreenAlign; pHalInfo->vmiData.dwOverlayAlign = HalInfo.vmiData.dwOverlayAlign; pHalInfo->vmiData.dwTextureAlign = HalInfo.vmiData.dwTextureAlign; - pHalInfo->vmiData.dwZBufferAlign = HalInfo.vmiData.dwZBufferAlign; + pHalInfo->vmiData.dwZBufferAlign = HalInfo.vmiData.dwZBufferAlign; pHalInfo->vmiData.dwAlphaAlign = HalInfo.vmiData.dwAlphaAlign; pHalInfo->vmiData.dwNumHeaps = dwNumHeaps; pHalInfo->vmiData.pvmList = pvmList; - RtlCopyMemory( &pHalInfo->ddCaps, + RtlCopyMemory( &pHalInfo->ddCaps, &HalInfo.ddCaps, sizeof(DDCORECAPS )); pHalInfo->ddCaps.dwNumFourCCCodes = FourCCs; pHalInfo->lpdwFourCC = pdwFourCC; - - /* always force rope 0x1000 for hal it mean only source copy is supported */ - pHalInfo->ddCaps.dwRops[6] = 0x1000; - /* Set the HAL flags what ReactX got from the driver - * Windows XP force setting DDHALINFO_GETDRIVERINFOSET if the driver does not set it - * and ReactX doing same to keep compatible with drivers, but the driver are - * force support DdGetDriverInfo acoriding MSDN but it seam some driver do not set + /* always force rope 0x1000 for hal it mean only source copy is supported */ + pHalInfo->ddCaps.dwRops[6] = 0x1000; + + /* Set the HAL flags what ReactX got from the driver + * Windows XP force setting DDHALINFO_GETDRIVERINFOSET if the driver does not set it + * and ReactX doing same to keep compatible with drivers, but the driver are + * force support DdGetDriverInfo acoriding MSDN but it seam some driver do not set * this flag even it is being supported. that is mean. It is small hack to keep * bad driver working, that trust this is always being setting by it self at end */ - pHalInfo->dwFlags = (HalInfo.dwFlags & ~DDHALINFO_GETDRIVERINFOSET) | DDHALINFO_GETDRIVERINFOSET; + pHalInfo->dwFlags = (HalInfo.dwFlags & ~DDHALINFO_GETDRIVERINFOSET) | DDHALINFO_GETDRIVERINFOSET; pHalInfo->GetDriverInfo = (LPDDHAL_GETDRIVERINFO) DdGetDriverInfo; /* Now check if we got any DD callbacks */ @@ -1634,16 +1635,16 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, RtlZeroMemory(pDDCallbacks, sizeof(DDHAL_DDCALLBACKS)); pDDCallbacks->dwSize = sizeof(DDHAL_DDCALLBACKS); - /* Set the flags for this structure - * Windows XP force setting DDHAL_CB32_CREATESURFACE if the driver does not set it - * and ReactX doing same to keep compatible with drivers, but the driver are - * force support pDDCallbacks acoriding MSDN but it seam some driver do not set + /* Set the flags for this structure + * Windows XP force setting DDHAL_CB32_CREATESURFACE if the driver does not set it + * and ReactX doing same to keep compatible with drivers, but the driver are + * force support pDDCallbacks acoriding MSDN but it seam some driver do not set * this flag even it is being supported. that is mean. It is small hack to keep * bad driver working, that trust this is always being setting by it self at end */ Flags = (CallbackFlags[0] & ~DDHAL_CB32_CREATESURFACE) | DDHAL_CB32_CREATESURFACE; pDDCallbacks->dwFlags = Flags; - + /* Write the always-on functions */ pDDCallbacks->CreateSurface = DdCreateSurface; @@ -1663,29 +1664,29 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, } /* Check for DD Surface Callbacks */ - if (pDDSurfaceCallbacks) + if (pDDSurfaceCallbacks) { /* Zero the structures */ RtlZeroMemory(pDDSurfaceCallbacks, sizeof(DDHAL_DDSURFACECALLBACKS)); pDDSurfaceCallbacks->dwSize = sizeof(DDHAL_DDSURFACECALLBACKS); - /* Set the flags for this structure - * Windows XP force setting DDHAL_SURFCB32_LOCK, DDHAL_SURFCB32_UNLOCK, - * DDHAL_SURFCB32_SETCOLORKEY, DDHAL_SURFCB32_DESTROYSURFACE if the driver - * does not set it and ReactX doing same to keep compatible with drivers, - * but the driver are force support pDDSurfaceCallbacks acoriding MSDN but it seam - * some driver do not set this flag even it is being supported. that is mean. - * It is small hack to keep bad driver working, that trust this is always being + /* Set the flags for this structure + * Windows XP force setting DDHAL_SURFCB32_LOCK, DDHAL_SURFCB32_UNLOCK, + * DDHAL_SURFCB32_SETCOLORKEY, DDHAL_SURFCB32_DESTROYSURFACE if the driver + * does not set it and ReactX doing same to keep compatible with drivers, + * but the driver are force support pDDSurfaceCallbacks acoriding MSDN but it seam + * some driver do not set this flag even it is being supported. that is mean. + * It is small hack to keep bad driver working, that trust this is always being * setting by it self at end */ Flags = (CallbackFlags[1] & ~(DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK | DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE)) | - (DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK | - DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE); - + (DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK | + DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE); + pDDSurfaceCallbacks->dwFlags = Flags; - + /* Write the always-on functions */ pDDSurfaceCallbacks->Lock = DdLock; pDDSurfaceCallbacks->Unlock = DdUnlock; @@ -1723,8 +1724,8 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, } } - /* Check for DD Palette Callbacks, This interface are dead for user mode, - * only what it can support are being report back. + /* Check for DD Palette Callbacks, This interface are dead for user mode, + * only what it can support are being report back. */ if (pDDPaletteCallbacks) { @@ -1778,7 +1779,7 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, { /* Zero the struct */ RtlZeroMemory(pD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS)); - + if ( D3dBufferCallbacks.dwSize) { pD3dBufferCallbacks->dwSize = D3dBufferCallbacks.dwSize; @@ -1808,8 +1809,8 @@ DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, { pD3dBufferCallbacks->UnlockExecuteBuffer = (LPDDHALEXEBUFCB_UNLOCKEXEBUF) DdUnlockD3D; } - - } + + } } /* FIXME VidMemList */ @@ -1820,7 +1821,7 @@ cleanup: HeapFree(GetProcessHeap(), 0, VidMemList); } - return retVal; + return retVal; } /* @@ -2032,7 +2033,7 @@ ULONG WINAPI DdQueryDisplaySettingsUniqueness() { - return GdiSharedHandleTable->flDeviceUniq; + return GdiSharedHandleTable->flDeviceUniq; } /* diff --git a/reactos/dll/win32/gdi32/misc/heap.c b/reactos/dll/win32/gdi32/misc/heap.c index 14c10fc94ca..5c2f7bb3d19 100644 --- a/reactos/dll/win32/gdi32/misc/heap.c +++ b/reactos/dll/win32/gdi32/misc/heap.c @@ -35,36 +35,36 @@ HANDLE hProcessHeap = NULL; PVOID HEAP_alloc ( DWORD len ) { - /* make sure hProcessHeap gets initialized by GdiProcessSetup before we get here */ - assert(hProcessHeap); - return RtlAllocateHeap ( hProcessHeap, 0, len ); + /* make sure hProcessHeap gets initialized by GdiProcessSetup before we get here */ + assert(hProcessHeap); + return RtlAllocateHeap ( hProcessHeap, 0, len ); } NTSTATUS HEAP_strdupA2W ( LPWSTR* ppszW, LPCSTR lpszA ) { - ULONG len; - NTSTATUS Status; + ULONG len; + NTSTATUS Status; - *ppszW = NULL; - if ( !lpszA ) - return STATUS_SUCCESS; - len = lstrlenA(lpszA); + *ppszW = NULL; + if ( !lpszA ) + return STATUS_SUCCESS; + len = lstrlenA(lpszA); - *ppszW = HEAP_alloc ( (len+1) * sizeof(WCHAR) ); - if ( !*ppszW ) - return STATUS_NO_MEMORY; - Status = RtlMultiByteToUnicodeN ( *ppszW, len*sizeof(WCHAR), NULL, (PCHAR)lpszA, len ); - (*ppszW)[len] = L'\0'; - return Status; + *ppszW = HEAP_alloc ( (len+1) * sizeof(WCHAR) ); + if ( !*ppszW ) + return STATUS_NO_MEMORY; + Status = RtlMultiByteToUnicodeN ( *ppszW, len*sizeof(WCHAR), NULL, (PCHAR)lpszA, len ); + (*ppszW)[len] = L'\0'; + return Status; } VOID HEAP_free ( LPVOID memory ) { - /* make sure hProcessHeap gets initialized by GdiProcessSetup before we get here */ - assert(hProcessHeap); + /* make sure hProcessHeap gets initialized by GdiProcessSetup before we get here */ + assert(hProcessHeap); - RtlFreeHeap ( hProcessHeap, 0, memory ); + RtlFreeHeap ( hProcessHeap, 0, memory ); } diff --git a/reactos/dll/win32/gdi32/misc/misc.c b/reactos/dll/win32/gdi32/misc/misc.c index 3a3ce0ac584..408a658d72e 100644 --- a/reactos/dll/win32/gdi32/misc/misc.c +++ b/reactos/dll/win32/gdi32/misc/misc.c @@ -39,36 +39,36 @@ DWORD GDI_BatchLimit = 1; BOOL WINAPI GdiAlphaBlend( - HDC hDCDst, - int DstX, - int DstY, - int DstCx, - int DstCy, - HDC hDCSrc, - int SrcX, - int SrcY, - int SrcCx, - int SrcCy, - BLENDFUNCTION BlendFunction - ) + HDC hDCDst, + int DstX, + int DstY, + int DstCx, + int DstCy, + HDC hDCSrc, + int SrcX, + int SrcY, + int SrcCx, + int SrcCy, + BLENDFUNCTION BlendFunction +) { - if ( hDCSrc == NULL ) return FALSE; + if ( hDCSrc == NULL ) return FALSE; - if (GDI_HANDLE_GET_TYPE(hDCSrc) == GDI_OBJECT_TYPE_METADC) return FALSE; + if (GDI_HANDLE_GET_TYPE(hDCSrc) == GDI_OBJECT_TYPE_METADC) return FALSE; - return NtGdiAlphaBlend( - hDCDst, - DstX, - DstY, - DstCx, - DstCy, - hDCSrc, - SrcX, - SrcY, - SrcCx, - SrcCy, + return NtGdiAlphaBlend( + hDCDst, + DstX, + DstY, + DstCx, + DstCy, + hDCSrc, + SrcX, + SrcY, + SrcCx, + SrcCy, BlendFunction, - 0 ); + 0 ); } /* @@ -89,7 +89,7 @@ GdiFixUpHandle(HGDIOBJ hGdiObj) Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); - /* Rebuild handle for Object */ + /* Rebuild handle for Object */ return hGdiObj = (HGDIOBJ)(((LONG_PTR)(hGdiObj)) | (Entry->Type << GDI_ENTRY_UPPER_SHIFT)); } @@ -100,99 +100,99 @@ PVOID WINAPI GdiQueryTable(VOID) { - return (PVOID)GdiHandleTable; + return (PVOID)GdiHandleTable; } BOOL GdiIsHandleValid(HGDIOBJ hGdiObj) { - PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); + PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); // We are only looking for TYPE not the rest here, and why is FullUnique filled up with CRAP!? // DPRINT1("FullUnique -> %x\n", Entry->FullUnique); - if((Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 && - ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == - GDI_HANDLE_GET_TYPE(hGdiObj)) - { - HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); - if(pid == NULL || pid == CurrentProcessId) + if((Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 && + ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == + GDI_HANDLE_GET_TYPE(hGdiObj)) { - return TRUE; + HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); + if(pid == NULL || pid == CurrentProcessId) + { + return TRUE; + } } - } - return FALSE; + return FALSE; } BOOL GdiGetHandleUserData(HGDIOBJ hGdiObj, DWORD ObjectType, PVOID *UserData) { - PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); - if((Entry->Type & GDI_ENTRY_BASETYPE_MASK) == ObjectType && - ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == - GDI_HANDLE_GET_TYPE(hGdiObj)) - { - HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); - if(pid == NULL || pid == CurrentProcessId) + PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hGdiObj); + if((Entry->Type & GDI_ENTRY_BASETYPE_MASK) == ObjectType && + ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == + GDI_HANDLE_GET_TYPE(hGdiObj)) { - // - // Need to test if we have Read & Write access to the VM address space. - // - BOOL Result = TRUE; - if(Entry->UserData) - { - volatile CHAR *Current = (volatile CHAR*)Entry->UserData; - _SEH2_TRY - { - *Current = *Current; - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Result = FALSE; - } - _SEH2_END - } - else - Result = FALSE; // Can not be zero. - if (Result) *UserData = Entry->UserData; - return Result; + HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); + if(pid == NULL || pid == CurrentProcessId) + { + // + // Need to test if we have Read & Write access to the VM address space. + // + BOOL Result = TRUE; + if(Entry->UserData) + { + volatile CHAR *Current = (volatile CHAR*)Entry->UserData; + _SEH2_TRY + { + *Current = *Current; + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Result = FALSE; + } + _SEH2_END + } + else + Result = FALSE; // Can not be zero. + if (Result) *UserData = Entry->UserData; + return Result; + } } - } - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; } PLDC FASTCALL GdiGetLDC(HDC hDC) { - PDC_ATTR Dc_Attr; - PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX((HGDIOBJ) hDC); - HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); - // Don't check the mask, just the object type. - if ( Entry->ObjectType == GDIObjType_DC_TYPE && - (pid == NULL || pid == CurrentProcessId) ) - { - BOOL Result = TRUE; - if (Entry->UserData) - { - volatile CHAR *Current = (volatile CHAR*)Entry->UserData; - _SEH2_TRY + PDC_ATTR Dc_Attr; + PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX((HGDIOBJ) hDC); + HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); + // Don't check the mask, just the object type. + if ( Entry->ObjectType == GDIObjType_DC_TYPE && + (pid == NULL || pid == CurrentProcessId) ) + { + BOOL Result = TRUE; + if (Entry->UserData) { - *Current = *Current; + volatile CHAR *Current = (volatile CHAR*)Entry->UserData; + _SEH2_TRY + { + *Current = *Current; + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Result = FALSE; + } + _SEH2_END } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Result = FALSE; - } - _SEH2_END - } - else - Result = FALSE; + else + Result = FALSE; - if (Result) - { - Dc_Attr = (PDC_ATTR)Entry->UserData; - return Dc_Attr->pvLDC; - } - } - return NULL; + if (Result) + { + Dc_Attr = (PDC_ATTR)Entry->UserData; + return Dc_Attr->pvLDC; + } + } + return NULL; } VOID GdiSAPCallback(PLDC pldc) @@ -207,8 +207,8 @@ VOID GdiSAPCallback(PLDC pldc) if ( !pldc->pAbortProc(pldc->hDC, 0) ) { - CancelDC(pldc->hDC); - AbortDoc(pldc->hDC); + CancelDC(pldc->hDC); + AbortDoc(pldc->hDC); } } @@ -222,7 +222,7 @@ GdiSetBatchLimit(DWORD Limit) DWORD OldLimit = GDI_BatchLimit; if ( (!Limit) || - (Limit >= GDI_BATCH_LIMIT)) + (Limit >= GDI_BATCH_LIMIT)) { return Limit; } @@ -289,40 +289,40 @@ HGDIOBJ FASTCALL hGetPEBHandle(HANDLECACHETYPE Type, COLORREF cr) { - int Number; - HANDLE Lock; - HGDIOBJ Handle = NULL; + int Number; + HANDLE Lock; + HGDIOBJ Handle = NULL; - Lock = InterlockedCompareExchangePointer( (PVOID*)&GdiHandleCache->ulLock, - NtCurrentTeb(), - NULL ); - - if (Lock) return Handle; + Lock = InterlockedCompareExchangePointer( (PVOID*)&GdiHandleCache->ulLock, + NtCurrentTeb(), + NULL ); - Number = GdiHandleCache->ulNumHandles[Type]; + if (Lock) return Handle; - if ( Number && Number <= CACHE_REGION_ENTRIES ) - { - if ( Type == hctRegionHandle) - { - PRGN_ATTR pRgn_Attr; - HGDIOBJ *hPtr; - hPtr = GdiHandleCache->Handle + CACHE_BRUSH_ENTRIES+CACHE_PEN_ENTRIES; - Handle = hPtr[Number - 1]; + Number = GdiHandleCache->ulNumHandles[Type]; - if (GdiGetHandleUserData( Handle, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) - { - if (pRgn_Attr->AttrFlags & ATTR_CACHED) + if ( Number && Number <= CACHE_REGION_ENTRIES ) + { + if ( Type == hctRegionHandle) + { + PRGN_ATTR pRgn_Attr; + HGDIOBJ *hPtr; + hPtr = GdiHandleCache->Handle + CACHE_BRUSH_ENTRIES+CACHE_PEN_ENTRIES; + Handle = hPtr[Number - 1]; + + if (GdiGetHandleUserData( Handle, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) { - DPRINT("Get Handle! Count %d PEB 0x%x\n", GdiHandleCache->ulNumHandles[Type], NtCurrentTeb()->ProcessEnvironmentBlock); - pRgn_Attr->AttrFlags &= ~ATTR_CACHED; - hPtr[Number - 1] = NULL; - GdiHandleCache->ulNumHandles[Type]--; + if (pRgn_Attr->AttrFlags & ATTR_CACHED) + { + DPRINT("Get Handle! Count %d PEB 0x%x\n", GdiHandleCache->ulNumHandles[Type], NtCurrentTeb()->ProcessEnvironmentBlock); + pRgn_Attr->AttrFlags &= ~ATTR_CACHED; + hPtr[Number - 1] = NULL; + GdiHandleCache->ulNumHandles[Type]--; + } } - } - } - } - (void)InterlockedExchangePointer((PVOID*)&GdiHandleCache->ulLock, Lock); - return Handle; + } + } + (void)InterlockedExchangePointer((PVOID*)&GdiHandleCache->ulLock, Lock); + return Handle; } diff --git a/reactos/dll/win32/gdi32/misc/stubs.c b/reactos/dll/win32/gdi32/misc/stubs.c index 5dc10b33284..42a3415d22f 100644 --- a/reactos/dll/win32/gdi32/misc/stubs.c +++ b/reactos/dll/win32/gdi32/misc/stubs.c @@ -48,30 +48,30 @@ BOOL WINAPI CancelDC(HDC hDC) { - PDC_ATTR pDc_Attr; + PDC_ATTR pDc_Attr; - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC && - GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC ) - { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - /* If a document has started set it to die. */ - if (pLDC->Flags & LDC_INIT_DOCUMENT) pLDC->Flags |= LDC_KILL_DOCUMENT; + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC && + GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC ) + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + /* If a document has started set it to die. */ + if (pLDC->Flags & LDC_INIT_DOCUMENT) pLDC->Flags |= LDC_KILL_DOCUMENT; - return NtGdiCancelDC(hDC); - } + return NtGdiCancelDC(hDC); + } - if (GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &pDc_Attr)) - { - pDc_Attr->ulDirty_ &= ~DC_PLAYMETAFILE; - return TRUE; - } + if (GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &pDc_Attr)) + { + pDc_Attr->ulDirty_ &= ~DC_PLAYMETAFILE; + return TRUE; + } - return FALSE; + return FALSE; } @@ -85,25 +85,25 @@ DrawEscape(HDC hDC, INT cbInput, LPCSTR lpszInData) { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) - return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData); + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) + return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData); - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC) - { - PLDC pLDC = GdiGetLDC(hDC); - if ( pLDC ) - { - if (pLDC->Flags & LDC_META_PRINT) + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC) + { + PLDC pLDC = GdiGetLDC(hDC); + if ( pLDC ) { + if (pLDC->Flags & LDC_META_PRINT) + { // if (nEscape != QUERYESCSUPPORT) // return EMFDRV_WriteEscape(hDC, nEscape, cbInput, lpszInData, EMR_DRAWESCAPE); - return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData); + return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData); + } } - } - SetLastError(ERROR_INVALID_HANDLE); - } - return 0; + SetLastError(ERROR_INVALID_HANDLE); + } + return 0; } @@ -125,17 +125,17 @@ EnumObjects(HDC hdc, switch (nObjectType) { - case OBJ_BRUSH: - Size = sizeof(LOGBRUSH); - break; + case OBJ_BRUSH: + Size = sizeof(LOGBRUSH); + break; - case OBJ_PEN: - Size = sizeof(LOGPEN); - break; + case OBJ_PEN: + Size = sizeof(LOGPEN); + break; - default: - SetLastError(ERROR_INVALID_PARAMETER); - return 0; + default: + SetLastError(ERROR_INVALID_PARAMETER); + return 0; } ObjectsCount = NtGdiEnumObjects(hdc, nObjectType, 0, NULL); @@ -172,10 +172,10 @@ EnumObjects(HDC hdc, UINT WINAPI GetBoundsRect( - HDC hdc, - LPRECT lprcBounds, - UINT flags - ) + HDC hdc, + LPRECT lprcBounds, + UINT flags +) { return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET); } @@ -186,14 +186,14 @@ GetBoundsRect( UINT WINAPI GetMetaFileBitsEx( - HMETAFILE a0, - UINT a1, - LPVOID a2 - ) + HMETAFILE a0, + UINT a1, + LPVOID a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -202,13 +202,13 @@ GetMetaFileBitsEx( BOOL WINAPI PlayMetaFile( - HDC a0, - HMETAFILE a1 - ) + HDC a0, + HMETAFILE a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* @@ -230,24 +230,24 @@ SetBoundsRect(HDC hdc, HMETAFILE WINAPI SetMetaFileBitsEx( - UINT size, - CONST BYTE *lpData - ) + UINT size, + CONST BYTE *lpData +) { const METAHEADER *mh_in = (const METAHEADER *)lpData; if (size & 1) return 0; if (!size || mh_in->mtType != METAFILE_MEMORY || mh_in->mtVersion != 0x300 || - mh_in->mtHeaderSize != sizeof(METAHEADER) / 2) + mh_in->mtHeaderSize != sizeof(METAHEADER) / 2) { SetLastError(ERROR_INVALID_DATA); return 0; } - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -256,15 +256,15 @@ SetMetaFileBitsEx( BOOL WINAPI PlayMetaFileRecord( - HDC a0, - LPHANDLETABLE a1, - LPMETARECORD a2, - UINT a3 - ) + HDC a0, + LPHANDLETABLE a1, + LPMETARECORD a2, + UINT a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -274,15 +274,15 @@ PlayMetaFileRecord( BOOL WINAPI EnumMetaFile( - HDC a0, - HMETAFILE a1, - MFENUMPROC a2, - LPARAM a3 - ) + HDC a0, + HMETAFILE a1, + MFENUMPROC a2, + LPARAM a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* @@ -291,12 +291,12 @@ EnumMetaFile( BOOL WINAPI DeleteEnhMetaFile( - HENHMETAFILE a0 - ) + HENHMETAFILE a0 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* @@ -305,12 +305,12 @@ DeleteEnhMetaFile( BOOL WINAPI EnumEnhMetaFile( - HDC hdc, - HENHMETAFILE hmf, - ENHMFENUMPROC callback, - LPVOID data, - CONST RECT *lpRect - ) + HDC hdc, + HENHMETAFILE hmf, + ENHMFENUMPROC callback, + LPVOID data, + CONST RECT *lpRect +) { if(!lpRect && hdc) { @@ -318,9 +318,9 @@ EnumEnhMetaFile( return FALSE; } - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* @@ -329,14 +329,14 @@ EnumEnhMetaFile( UINT WINAPI GetEnhMetaFileBits( - HENHMETAFILE a0, - UINT a1, - LPBYTE a2 - ) + HENHMETAFILE a0, + UINT a1, + LPBYTE a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -346,14 +346,14 @@ GetEnhMetaFileBits( UINT WINAPI GetEnhMetaFileHeader( - HENHMETAFILE a0, - UINT a1, - LPENHMETAHEADER a2 - ) + HENHMETAFILE a0, + UINT a1, + LPENHMETAHEADER a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -362,14 +362,14 @@ GetEnhMetaFileHeader( UINT WINAPI GetEnhMetaFilePaletteEntries( - HENHMETAFILE a0, - UINT a1, - LPPALETTEENTRY a2 - ) + HENHMETAFILE a0, + UINT a1, + LPPALETTEENTRY a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -378,16 +378,16 @@ GetEnhMetaFilePaletteEntries( UINT WINAPI GetWinMetaFileBits( - HENHMETAFILE a0, - UINT a1, - LPBYTE a2, - INT a3, - HDC a4 - ) + HENHMETAFILE a0, + UINT a1, + LPBYTE a2, + INT a3, + HDC a4 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -397,14 +397,14 @@ GetWinMetaFileBits( BOOL WINAPI PlayEnhMetaFile( - HDC a0, - HENHMETAFILE a1, - CONST RECT *a2 - ) + HDC a0, + HENHMETAFILE a1, + CONST RECT *a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -414,15 +414,15 @@ PlayEnhMetaFile( BOOL WINAPI PlayEnhMetaFileRecord( - HDC a0, - LPHANDLETABLE a1, - CONST ENHMETARECORD *a2, - UINT a3 - ) + HDC a0, + LPHANDLETABLE a1, + CONST ENHMETARECORD *a2, + UINT a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -432,13 +432,13 @@ PlayEnhMetaFileRecord( HENHMETAFILE WINAPI SetEnhMetaFileBits( - UINT a0, - CONST BYTE *a1 - ) + UINT a0, + CONST BYTE *a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -448,14 +448,14 @@ SetEnhMetaFileBits( HENHMETAFILE WINAPI SetWinMetaFileBits( - UINT a0, - CONST BYTE *a1, - HDC a2, - CONST METAFILEPICT *a3) + UINT a0, + CONST BYTE *a1, + HDC a2, + CONST METAFILEPICT *a3) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -465,27 +465,28 @@ SetWinMetaFileBits( BOOL WINAPI GdiComment( - HDC hDC, - UINT bytes, - CONST BYTE *buffer - ) + HDC hDC, + UINT bytes, + CONST BYTE *buffer +) { #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF) - { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { // Wine port - return EMFDRV_GdiComment( hDC, bytes, buffer ); - } - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF) + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + // Wine port + return EMFDRV_GdiComment( hDC, bytes, buffer ); + } + } #endif - return FALSE; + return FALSE; } @@ -495,13 +496,13 @@ GdiComment( BOOL WINAPI SetColorAdjustment( - HDC hdc, - CONST COLORADJUSTMENT *a1 - ) + HDC hdc, + CONST COLORADJUSTMENT *a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* @@ -512,19 +513,19 @@ WINAPI UnrealizeObject(HGDIOBJ hgdiobj) { BOOL retValue = TRUE; -/* - Win 2k Graphics API, Black Book. by coriolis.com - Page 62, Note that Steps 3, 5, and 6 are not required for Windows NT(tm) - and Windows 2000(tm). + /* + Win 2k Graphics API, Black Book. by coriolis.com + Page 62, Note that Steps 3, 5, and 6 are not required for Windows NT(tm) + and Windows 2000(tm). - Step 5. UnrealizeObject(hTrackBrush); - */ -/* - msdn.microsoft.com, - "Windows 2000/XP: If hgdiobj is a brush, UnrealizeObject does nothing, - and the function returns TRUE. Use SetBrushOrgEx to set the origin of - a brush." - */ + Step 5. UnrealizeObject(hTrackBrush); + */ + /* + msdn.microsoft.com, + "Windows 2000/XP: If hgdiobj is a brush, UnrealizeObject does nothing, + and the function returns TRUE. Use SetBrushOrgEx to set the origin of + a brush." + */ if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH) { retValue = NtGdiUnrealizeObject(hgdiobj); @@ -552,18 +553,18 @@ GdiFlush() int WINAPI SetICMMode( - HDC hdc, - int iEnableICM - ) + HDC hdc, + int iEnableICM +) { /*FIXME: Assume that ICM is always off, and cannot be turned on */ if (iEnableICM == ICM_OFF) return ICM_OFF; if (iEnableICM == ICM_ON) return 0; if (iEnableICM == ICM_QUERY) return ICM_OFF; - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -573,15 +574,15 @@ SetICMMode( BOOL WINAPI CheckColorsInGamut( - HDC a0, - LPVOID a1, - LPVOID a2, - DWORD a3 - ) + HDC a0, + LPVOID a1, + LPVOID a2, + DWORD a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -635,14 +636,14 @@ SetDeviceGammaRamp(HDC hdc, BOOL WINAPI ColorMatchToTarget( - HDC a0, - HDC a1, - DWORD a2 - ) + HDC a0, + HDC a1, + DWORD a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* === AFTER THIS POINT I GUESS... ========= @@ -656,13 +657,13 @@ ColorMatchToTarget( DWORD WINAPI IsValidEnhMetaRecord( - DWORD a0, - DWORD a1 - ) + DWORD a0, + DWORD a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -672,15 +673,15 @@ IsValidEnhMetaRecord( DWORD WINAPI IsValidEnhMetaRecordOffExt( - DWORD a0, - DWORD a1, - DWORD a2, - DWORD a3 - ) + DWORD a0, + DWORD a1, + DWORD a2, + DWORD a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -690,18 +691,18 @@ IsValidEnhMetaRecordOffExt( DWORD WINAPI GetGlyphOutlineWow( - DWORD a0, - DWORD a1, - DWORD a2, - DWORD a3, - DWORD a4, - DWORD a5, - DWORD a6 - ) + DWORD a0, + DWORD a1, + DWORD a2, + DWORD a3, + DWORD a4, + DWORD a5, + DWORD a6 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -710,17 +711,17 @@ GetGlyphOutlineWow( DWORD WINAPI gdiPlaySpoolStream( - DWORD a0, - DWORD a1, - DWORD a2, - DWORD a3, - DWORD a4, - DWORD a5 - ) + DWORD a0, + DWORD a1, + DWORD a2, + DWORD a3, + DWORD a4, + DWORD a5 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -729,18 +730,18 @@ gdiPlaySpoolStream( HANDLE WINAPI AddFontMemResourceEx( - PVOID pbFont, - DWORD cbFont, - PVOID pdv, - DWORD *pcFonts + PVOID pbFont, + DWORD cbFont, + PVOID pdv, + DWORD *pcFonts ) { - if ( pbFont && cbFont && pcFonts) - { - return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts); - } - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; + if ( pbFont && cbFont && pcFonts) + { + return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts); + } + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; } /* @@ -749,13 +750,13 @@ AddFontMemResourceEx( int WINAPI AddFontResourceTracking( - LPCSTR lpString, - int unknown + LPCSTR lpString, + int unknown ) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -767,9 +768,9 @@ HBITMAP WINAPI ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -779,9 +780,9 @@ HBRUSH WINAPI ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -791,9 +792,9 @@ BOOL WINAPI ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -803,9 +804,9 @@ BOOL WINAPI GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -815,10 +816,10 @@ BOOL WINAPI GdiCleanCacheDC(HDC hdc) { - if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_DC_TYPE) - return TRUE; - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; + if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_DC_TYPE) + return TRUE; + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; } /* @@ -828,20 +829,20 @@ HDC WINAPI GdiConvertAndCheckDC(HDC hdc) { - PLDC pldc; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - return hdc; - pldc = GdiGetLDC(hdc); - if (pldc) - { - if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc); - if (pldc->Flags & LDC_KILL_DOCUMENT) return NULL; - if (pldc->Flags & LDC_STARTPAGE) StartPage(hdc); - return hdc; - } - SetLastError(ERROR_INVALID_HANDLE); - return NULL; + PLDC pldc; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + return hdc; + pldc = GdiGetLDC(hdc); + if (pldc) + { + if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc); + if (pldc->Flags & LDC_KILL_DOCUMENT) return NULL; + if (pldc->Flags & LDC_STARTPAGE) StartPage(hdc); + return hdc; + } + SetLastError(ERROR_INVALID_HANDLE); + return NULL; } /* @@ -875,22 +876,22 @@ BOOL WINAPI GdiIsMetaFileDC(HDC hDC) { - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return TRUE; - else - { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return TRUE; + else { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if ( pLDC->iType == LDC_EMFLDC) return TRUE; } - if ( pLDC->iType == LDC_EMFLDC) return TRUE; - } - } - return FALSE; + } + return FALSE; } /* @@ -901,22 +902,22 @@ WINAPI GdiIsMetaPrintDC(HDC hDC) { - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else - { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if ( pLDC->Flags & LDC_META_PRINT) return TRUE; } - if ( pLDC->Flags & LDC_META_PRINT) return TRUE; - } - } - return FALSE; + } + return FALSE; } /* @@ -926,12 +927,12 @@ BOOL WINAPI GdiIsPlayMetafileDC(HDC hDC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( pLDC ) - { - if ( pLDC->Flags & LDC_PLAY_MFDC ) return TRUE; - } - return FALSE; + PLDC pLDC = GdiGetLDC(hDC); + if ( pLDC ) + { + if ( pLDC->Flags & LDC_PLAY_MFDC ) return TRUE; + } + return FALSE; } /* @@ -941,18 +942,18 @@ BOOL WINAPI GdiValidateHandle(HGDIOBJ hobj) { - PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hobj); - if ( (Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 && - ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == - GDI_HANDLE_GET_TYPE(hobj) ) - { - HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); - if(pid == NULL || pid == CurrentProcessId) + PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hobj); + if ( (Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 && + ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) == + GDI_HANDLE_GET_TYPE(hobj) ) { - return TRUE; + HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1); + if(pid == NULL || pid == CurrentProcessId) + { + return TRUE; + } } - } - return FALSE; + return FALSE; } @@ -1042,12 +1043,12 @@ BOOL WINAPI RemoveFontMemResourceEx(HANDLE fh) { - if (fh) - { - return NtGdiRemoveFontMemResourceEx(fh); - } - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + if (fh) + { + return NtGdiRemoveFontMemResourceEx(fh); + } + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; } /* @@ -1057,9 +1058,9 @@ int WINAPI RemoveFontResourceTracking(LPCSTR lpString,int unknown) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -1069,9 +1070,9 @@ HBITMAP WINAPI SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -1081,9 +1082,9 @@ HBRUSH WINAPI SetBrushAttributes(HBRUSH hbm, DWORD dwFlags) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -1127,12 +1128,12 @@ WINAPI GetETM(HDC hdc, EXTTEXTMETRIC *petm) { - BOOL Ret = NtGdiGetETM(hdc, petm); + BOOL Ret = NtGdiGetETM(hdc, petm); - if (Ret && petm) - petm->emKernPairs = GetKerningPairsA(hdc, 0, 0); + if (Ret && petm) + petm->emKernPairs = GetKerningPairsA(hdc, 0, 0); - return Ret; + return Ret; } /* @@ -1142,7 +1143,7 @@ int WINAPI Escape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpvInData, LPVOID lpvOutData) { - int retValue = SP_ERROR; + int retValue = SP_ERROR; HGDIOBJ hObject = hdc; UINT Type = 0; LPVOID pUserData = NULL; @@ -1159,165 +1160,165 @@ Escape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpvInData, LPVOID lpvOutData) { switch (nEscape) { - case ABORTDOC: - /* Note Winodws check see if the handle have any user data for ABORTDOC command - * ReactOS copy this behavior to be compatible with windows 2003 - */ - if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || - (pUserData == NULL) ) - { - GdiSetLastError(ERROR_INVALID_HANDLE); - retValue = FALSE; - } - else - { - retValue = AbortDoc(hdc); - } - break; - - case DRAFTMODE: - case FLUSHOUTPUT: - case SETCOLORTABLE: - /* Note 1: DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE is outdated and been replace with other api */ - /* Note 2: Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command - * ReactOS copy this behavior to be compatible with windows 2003 - */ - if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || - (pUserData == NULL) ) - { - GdiSetLastError(ERROR_INVALID_HANDLE); - } + case ABORTDOC: + /* Note Winodws check see if the handle have any user data for ABORTDOC command + * ReactOS copy this behavior to be compatible with windows 2003 + */ + if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || + (pUserData == NULL) ) + { + GdiSetLastError(ERROR_INVALID_HANDLE); retValue = FALSE; - break; + } + else + { + retValue = AbortDoc(hdc); + } + break; - case SETABORTPROC: - /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command - * ReactOS copy this behavior to be compatible with windows 2003 - */ - if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || - (pUserData == NULL) ) - { - GdiSetLastError(ERROR_INVALID_HANDLE); - retValue = FALSE; - } - retValue = SetAbortProc(hdc, (ABORTPROC)lpvInData); - break; + case DRAFTMODE: + case FLUSHOUTPUT: + case SETCOLORTABLE: + /* Note 1: DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE is outdated and been replace with other api */ + /* Note 2: Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command + * ReactOS copy this behavior to be compatible with windows 2003 + */ + if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || + (pUserData == NULL) ) + { + GdiSetLastError(ERROR_INVALID_HANDLE); + } + retValue = FALSE; + break; - case GETCOLORTABLE: - retValue = GetSystemPaletteEntries(hdc, (UINT)*lpvInData, 1, (LPPALETTEENTRY)lpvOutData); - if ( !retValue ) - { - retValue = SP_ERROR; - } - break; - - case ENDDOC: - /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command - * ReactOS copy this behavior to be compatible with windows 2003 - */ - if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || - (pUserData == NULL) ) - { - GdiSetLastError(ERROR_INVALID_HANDLE); - retValue = FALSE; - } - retValue = EndDoc(hdc); - break; - - - case GETSCALINGFACTOR: - /* Note GETSCALINGFACTOR is outdated have been replace by GetDeviceCaps */ - if ( Type == GDI_OBJECT_TYPE_DC ) - { - if ( lpvOutData ) - { - PPOINT ptr = (PPOINT) lpvOutData; - ptr->x = 0; - ptr->y = 0; - } - } + case SETABORTPROC: + /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command + * ReactOS copy this behavior to be compatible with windows 2003 + */ + if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || + (pUserData == NULL) ) + { + GdiSetLastError(ERROR_INVALID_HANDLE); retValue = FALSE; - break; + } + retValue = SetAbortProc(hdc, (ABORTPROC)lpvInData); + break; - case GETEXTENDEDTEXTMETRICS: - retValue = (int) GetETM( hdc, (EXTTEXTMETRIC *) lpvOutData) != 0; - break; + case GETCOLORTABLE: + retValue = GetSystemPaletteEntries(hdc, (UINT)*lpvInData, 1, (LPPALETTEENTRY)lpvOutData); + if ( !retValue ) + { + retValue = SP_ERROR; + } + break; - case STARTDOC: + case ENDDOC: + /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command + * ReactOS copy this behavior to be compatible with windows 2003 + */ + if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) || + (pUserData == NULL) ) + { + GdiSetLastError(ERROR_INVALID_HANDLE); + retValue = FALSE; + } + retValue = EndDoc(hdc); + break; + + + case GETSCALINGFACTOR: + /* Note GETSCALINGFACTOR is outdated have been replace by GetDeviceCaps */ + if ( Type == GDI_OBJECT_TYPE_DC ) + { + if ( lpvOutData ) { - DOCINFOA *pUserDatalpdi; - DOCINFOA lpdi; + PPOINT ptr = (PPOINT) lpvOutData; + ptr->x = 0; + ptr->y = 0; + } + } + retValue = FALSE; + break; - /* Note : Winodws check see if the handle have any user data for STARTDOC command - * ReactOS copy this behavior to be compatible with windows 2003 + case GETEXTENDEDTEXTMETRICS: + retValue = (int) GetETM( hdc, (EXTTEXTMETRIC *) lpvOutData) != 0; + break; + + case STARTDOC: + { + DOCINFOA *pUserDatalpdi; + DOCINFOA lpdi; + + /* Note : Winodws check see if the handle have any user data for STARTDOC command + * ReactOS copy this behavior to be compatible with windows 2003 + */ + if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserDatalpdi)) || + (pUserData == NULL) ) + { + GdiSetLastError(ERROR_INVALID_HANDLE); + retValue = FALSE; + } + + lpdi.cbSize = sizeof(DOCINFOA); + + /* NOTE lpszOutput will be store in handle userdata */ + lpdi.lpszOutput = 0; + + lpdi.lpszDatatype = 0; + lpdi.fwType = 0; + lpdi.lpszDocName = lpvInData; + + /* NOTE : doc for StartDocA/W at msdn http://msdn2.microsoft.com/en-us/library/ms535793(VS.85).aspx */ + retValue = StartDocA(hdc, &lpdi); + + /* StartDocA fail */ + if (retValue < 0) + { + /* check see if outbuffer contain any data, if it does abort */ + if ( (pUserDatalpdi->lpszOutput != 0) && + ( (*(WCHAR *)pUserDatalpdi->lpszOutput) != UNICODE_NULL) ) + { + retValue = SP_APPABORT; + } + else + { + retValue = GetLastError(); + + /* Translate StartDocA error code to STARTDOC error code + * see msdn http://msdn2.microsoft.com/en-us/library/ms535472.aspx */ - if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserDatalpdi)) || - (pUserData == NULL) ) + switch(retValue) { - GdiSetLastError(ERROR_INVALID_HANDLE); - retValue = FALSE; - } + case ERROR_NOT_ENOUGH_MEMORY: + retValue = SP_OUTOFMEMORY; + break; - lpdi.cbSize = sizeof(DOCINFOA); + case ERROR_PRINT_CANCELLED: + retValue = SP_USERABORT; + break; - /* NOTE lpszOutput will be store in handle userdata */ - lpdi.lpszOutput = 0; + case ERROR_DISK_FULL: + retValue = SP_OUTOFDISK; + break; - lpdi.lpszDatatype = 0; - lpdi.fwType = 0; - lpdi.lpszDocName = lpvInData; - - /* NOTE : doc for StartDocA/W at msdn http://msdn2.microsoft.com/en-us/library/ms535793(VS.85).aspx */ - retValue = StartDocA(hdc, &lpdi); - - /* StartDocA fail */ - if (retValue < 0) - { - /* check see if outbuffer contain any data, if it does abort */ - if ( (pUserDatalpdi->lpszOutput != 0) && - ( (*(WCHAR *)pUserDatalpdi->lpszOutput) != UNICODE_NULL) ) - { - retValue = SP_APPABORT; - } - else - { - retValue = GetLastError(); - - /* Translate StartDocA error code to STARTDOC error code - * see msdn http://msdn2.microsoft.com/en-us/library/ms535472.aspx - */ - switch(retValue) - { - case ERROR_NOT_ENOUGH_MEMORY: - retValue = SP_OUTOFMEMORY; - break; - - case ERROR_PRINT_CANCELLED: - retValue = SP_USERABORT; - break; - - case ERROR_DISK_FULL: - retValue = SP_OUTOFDISK; - break; - - default: - retValue = SP_ERROR; - break; - } - } + default: + retValue = SP_ERROR; + break; } } - break; - - + } + } + break; - default: - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + + + default: + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); } } - + return retValue; } @@ -1375,14 +1376,14 @@ GdiConvertToDevmodeW(const DEVMODEA *dmA) if (!dmW) return NULL; MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmDeviceName, CCHDEVICENAME, - dmW->dmDeviceName, CCHDEVICENAME); + dmW->dmDeviceName, CCHDEVICENAME); /* copy slightly more, to avoid long computations */ memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion, dmA_size - CCHDEVICENAME); if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME) { MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmFormName, CCHFORMNAME, - dmW->dmFormName, CCHFORMNAME); + dmW->dmFormName, CCHFORMNAME); if (dmA_size > FIELD_OFFSET(DEVMODEA, dmLogPixels)) memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA_size - FIELD_OFFSET(DEVMODEA, dmLogPixels)); } @@ -1559,7 +1560,7 @@ GdiPlayEMF(LPWSTR pwszPrinterName, LPWSTR pwszDocName, EMFPLAYPROC pfnEMFPlayFn, HANDLE hPageQuery -) + ) { UNIMPLEMENTED; SetLastError(ERROR_CALL_NOT_IMPLEMENTED); @@ -1622,7 +1623,7 @@ GdiTransparentBlt(IN HDC hdcDst, IN INT cxSrc, IN INT cySrc, IN COLORREF TransColor -) + ) { /* FIXME some part need be done in user mode */ return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor); @@ -1695,7 +1696,7 @@ GetFontData(HDC hdc, { if (!lpvBuffer) { - cbData = 0; + cbData = 0; } return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData); } diff --git a/reactos/dll/win32/gdi32/misc/stubsa.c b/reactos/dll/win32/gdi32/misc/stubsa.c index 9f11cedb38c..5a3727e093f 100644 --- a/reactos/dll/win32/gdi32/misc/stubsa.c +++ b/reactos/dll/win32/gdi32/misc/stubsa.c @@ -31,14 +31,14 @@ PolyTextOutA( HDC hdc, const POLYTEXTA *pptxt, INT cStrings ) BOOL WINAPI GetLogColorSpaceA( - HCOLORSPACE a0, - LPLOGCOLORSPACEA a1, - DWORD a2 - ) + HCOLORSPACE a0, + LPLOGCOLORSPACEA a1, + DWORD a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -48,10 +48,10 @@ GetLogColorSpaceA( BOOL WINAPI GetICMProfileA( - HDC hdc, - LPDWORD pBufSize, - LPSTR pszFilename - ) + HDC hdc, + LPDWORD pBufSize, + LPSTR pszFilename +) { WCHAR filenameW[MAX_PATH]; DWORD buflen = MAX_PATH; @@ -81,13 +81,13 @@ GetICMProfileA( BOOL WINAPI SetICMProfileA( - HDC a0, - LPSTR a1 - ) + HDC a0, + LPSTR a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -97,24 +97,24 @@ SetICMProfileA( int WINAPI EnumICMProfilesA( - HDC a0, - ICMENUMPROCA a1, - LPARAM a2 - ) + HDC a0, + ICMENUMPROCA a1, + LPARAM a2 +) { - /* - * FIXME - call NtGdiEnumICMProfiles with NULL for lpstrBuffer - * to find out how big a buffer we need. Then allocate that buffer - * and call NtGdiEnumICMProfiles again to have the buffer filled. - * - * Finally, step through the buffer ( MULTI-SZ recommended for format ), - * and convert each string to ANSI, calling the user's callback function - * until we run out of strings or the user returns FALSE - */ + /* + * FIXME - call NtGdiEnumICMProfiles with NULL for lpstrBuffer + * to find out how big a buffer we need. Then allocate that buffer + * and call NtGdiEnumICMProfiles again to have the buffer filled. + * + * Finally, step through the buffer ( MULTI-SZ recommended for format ), + * and convert each string to ANSI, calling the user's callback function + * until we run out of strings or the user returns FALSE + */ - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -124,15 +124,15 @@ EnumICMProfilesA( BOOL WINAPI UpdateICMRegKeyA( - DWORD a0, - LPSTR a1, - LPSTR a2, - UINT a3 - ) + DWORD a0, + LPSTR a1, + LPSTR a2, + UINT a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* diff --git a/reactos/dll/win32/gdi32/misc/stubsw.c b/reactos/dll/win32/gdi32/misc/stubsw.c index cebf72d63ef..29b7406ff7c 100644 --- a/reactos/dll/win32/gdi32/misc/stubsw.c +++ b/reactos/dll/win32/gdi32/misc/stubsw.c @@ -31,14 +31,14 @@ PolyTextOutW( HDC hdc, const POLYTEXTW *pptxt, INT cStrings ) BOOL WINAPI GetLogColorSpaceW( - HCOLORSPACE a0, - LPLOGCOLORSPACEW a1, - DWORD a2 - ) + HCOLORSPACE a0, + LPLOGCOLORSPACEW a1, + DWORD a2 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -48,16 +48,16 @@ GetLogColorSpaceW( BOOL WINAPI GetICMProfileW( - HDC hdc, - LPDWORD size, - LPWSTR filename - ) + HDC hdc, + LPDWORD size, + LPWSTR filename +) { if (!hdc || !size || !filename) return FALSE; - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -67,13 +67,13 @@ GetICMProfileW( BOOL WINAPI SetICMProfileW( - HDC a0, - LPWSTR a1 - ) + HDC a0, + LPWSTR a1 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -83,23 +83,23 @@ SetICMProfileW( int WINAPI EnumICMProfilesW( - HDC hDC, - ICMENUMPROCW lpEnumICMProfilesFunc, - LPARAM lParam - ) + HDC hDC, + ICMENUMPROCW lpEnumICMProfilesFunc, + LPARAM lParam +) { - /* - * FIXME - call NtGdiEnumICMProfiles with NULL for lpstrBuffer - * to find out how big a buffer we need. Then allocate that buffer - * and call NtGdiEnumICMProfiles again to have the buffer filled. - * - * Finally, step through the buffer ( MULTI-SZ recommended for format ), - * and call the user's callback function until we run out of strings or - * the user returns FALSE - */ - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + /* + * FIXME - call NtGdiEnumICMProfiles with NULL for lpstrBuffer + * to find out how big a buffer we need. Then allocate that buffer + * and call NtGdiEnumICMProfiles again to have the buffer filled. + * + * Finally, step through the buffer ( MULTI-SZ recommended for format ), + * and call the user's callback function until we run out of strings or + * the user returns FALSE + */ + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } @@ -109,15 +109,15 @@ EnumICMProfilesW( BOOL WINAPI UpdateICMRegKeyW( - DWORD a0, - LPWSTR a1, - LPWSTR a2, - UINT a3 - ) + DWORD a0, + LPWSTR a1, + LPWSTR a2, + UINT a3 +) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } @@ -134,9 +134,9 @@ BOOL WINAPI EudcLoadLinkW(LPCWSTR pBaseFaceName,LPCWSTR pEudcFontPath,INT iPriority,INT iFontLinkType) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -146,9 +146,9 @@ BOOL WINAPI EudcUnloadLinkW(LPCWSTR pBaseFaceName,LPCWSTR pEudcFontPath) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -194,9 +194,9 @@ BOOL WINAPI bInitSystemAndFontsDirectoriesW(LPWSTR *SystemDir,LPWSTR *FontsDir) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -206,9 +206,9 @@ BOOL WINAPI bMakePathNameW(LPWSTR lpBuffer,LPCWSTR lpFileName,LPWSTR *lpFilePart,DWORD unknown) { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return 0; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; } /* @@ -237,11 +237,11 @@ GetStringBitmapW(HDC hdc, BOOL WINAPI CreateScalableFontResourceW( - DWORD fdwHidden, - LPCWSTR lpszFontRes, - LPCWSTR lpszFontFile, - LPCWSTR lpszCurrentPath - ) + DWORD fdwHidden, + LPCWSTR lpszFontRes, + LPCWSTR lpszFontFile, + LPCWSTR lpszCurrentPath +) { HANDLE f; @@ -253,13 +253,14 @@ CreateScalableFontResourceW( */ /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */ - if ((f = CreateFileW(lpszFontRes, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) { + if ((f = CreateFileW(lpszFontRes, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) + { CloseHandle(f); SetLastError(ERROR_FILE_EXISTS); return FALSE; } return FALSE; /* create failed */ } - + /* EOF */ diff --git a/reactos/dll/win32/gdi32/misc/wingl.c b/reactos/dll/win32/gdi32/misc/wingl.c index b20ac7ee9d2..2a00f9bfc91 100644 --- a/reactos/dll/win32/gdi32/misc/wingl.c +++ b/reactos/dll/win32/gdi32/misc/wingl.c @@ -113,11 +113,11 @@ WINAPI ChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR * ppfd) { - if (glChoosePixelFormat == NULL) - if (OpenGLEnable() == FALSE) - return(0); + if (glChoosePixelFormat == NULL) + if (OpenGLEnable() == FALSE) + return(0); - return(glChoosePixelFormat(hdc, ppfd)); + return(glChoosePixelFormat(hdc, ppfd)); } @@ -132,11 +132,11 @@ DescribePixelFormat(HDC hdc, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd) { - if (glDescribePixelFormat == NULL) - if (OpenGLEnable() == FALSE) - return(0); + if (glDescribePixelFormat == NULL) + if (OpenGLEnable() == FALSE) + return(0); - return(glDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd)); + return(glDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd)); } @@ -148,11 +148,11 @@ INT WINAPI GetPixelFormat(HDC hdc) { - if (glGetPixelFormat == NULL) - if (OpenGLEnable() == FALSE) - return(0); + if (glGetPixelFormat == NULL) + if (OpenGLEnable() == FALSE) + return(0); - return(glGetPixelFormat(hdc)); + return(glGetPixelFormat(hdc)); } @@ -166,15 +166,15 @@ SetPixelFormat(HDC hdc, INT iPixelFormat, CONST PIXELFORMATDESCRIPTOR * ppfd) { - /* Can only be set once */ - INT current = GetPixelFormat(hdc); - if(current) return current == iPixelFormat ; - - if (glSetPixelFormat == NULL) - if (OpenGLEnable() == FALSE) - return(0); + /* Can only be set once */ + INT current = GetPixelFormat(hdc); + if(current) return current == iPixelFormat ; - return(glSetPixelFormat(hdc, iPixelFormat, ppfd)); + if (glSetPixelFormat == NULL) + if (OpenGLEnable() == FALSE) + return(0); + + return(glSetPixelFormat(hdc, iPixelFormat, ppfd)); } @@ -186,12 +186,12 @@ BOOL WINAPI SwapBuffers(HDC hdc) { - if (glSwapBuffers == NULL) - if (OpenGLEnable() == FALSE) - return(0); + if (glSwapBuffers == NULL) + if (OpenGLEnable() == FALSE) + return(0); - return(glSwapBuffers(hdc)); + return(glSwapBuffers(hdc)); } @@ -205,25 +205,25 @@ SwapBuffers(HDC hdc) UINT WINAPI GetEnhMetaFilePixelFormat( - HENHMETAFILE hemf, - UINT cbBuffer, - PIXELFORMATDESCRIPTOR *ppfd - ) + HENHMETAFILE hemf, + UINT cbBuffer, + PIXELFORMATDESCRIPTOR *ppfd +) { - ENHMETAHEADER pemh; + ENHMETAHEADER pemh; - if(GetEnhMetaFileHeader(hemf, sizeof(ENHMETAHEADER), &pemh)) - { - if(pemh.bOpenGL) - { - if(pemh.cbPixelFormat) - { - memcpy((void*)ppfd, UlongToPtr(pemh.offPixelFormat), cbBuffer ); - return(pemh.cbPixelFormat); - } - } - } - return(0); + if(GetEnhMetaFileHeader(hemf, sizeof(ENHMETAHEADER), &pemh)) + { + if(pemh.bOpenGL) + { + if(pemh.cbPixelFormat) + { + memcpy((void*)ppfd, UlongToPtr(pemh.offPixelFormat), cbBuffer ); + return(pemh.cbPixelFormat); + } + } + } + return(0); } /* EOF */ diff --git a/reactos/dll/win32/gdi32/objects/arc.c b/reactos/dll/win32/gdi32/objects/arc.c index ba5047c63ab..de2a291a98a 100644 --- a/reactos/dll/win32/gdi32/objects/arc.c +++ b/reactos/dll/win32/gdi32/objects/arc.c @@ -3,52 +3,52 @@ BOOL WINAPI Arc( - HDC hDC, - int nLeftRect, - int nTopRect, - int nRightRect, - int nBottomRect, - int nXStartArc, - int nYStartArc, - int nXEndArc, - int nYEndArc + HDC hDC, + int nLeftRect, + int nTopRect, + int nRightRect, + int nBottomRect, + int nXStartArc, + int nYStartArc, + int nXEndArc, + int nYEndArc ) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) -// Call Wine (rewrite of) MFDRV_MetaParam8 - return MFDRV_MetaParam8( hDC, META_ARC, a1, a2, a3, a4, a5, a6, a7, a8) - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) +// Call Wine (rewrite of) MFDRV_MetaParam8 + return MFDRV_MetaParam8( hDC, META_ARC, a1, a2, a3, a4, a5, a6, a7, a8) + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { // Call Wine (rewrite of) EMFDRV_ArcChordPie - BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_ARC); - return Ret; - } - return FALSE; + BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_ARC); + return Ret; + } + return FALSE; + } } - } #endif - return NtGdiArcInternal(GdiTypeArc, - hDC, - nLeftRect, - nTopRect, - nRightRect, - nBottomRect, - nXStartArc, - nYStartArc, - nXEndArc, - nYEndArc); + return NtGdiArcInternal(GdiTypeArc, + hDC, + nLeftRect, + nTopRect, + nRightRect, + nBottomRect, + nXStartArc, + nYStartArc, + nXEndArc, + nYEndArc); } @@ -64,131 +64,131 @@ AngleArc(HDC hDC, FLOAT StartAngle, FLOAT SweepAngle) { - gxf_long worker, worker1; + gxf_long worker, worker1; - worker.f = StartAngle; - worker1.f = SweepAngle; + worker.f = StartAngle; + worker1.f = SweepAngle; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; //No meta support for AngleArc - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - BOOL Ret = EMFDRV_AngleArc( hDC, X, Y, Radius, StartAngle, SweepAngle); - return Ret; - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; //No meta support for AngleArc + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + BOOL Ret = EMFDRV_AngleArc( hDC, X, Y, Radius, StartAngle, SweepAngle); + return Ret; + } + return FALSE; + } } - } #endif - return NtGdiAngleArc(hDC, X, Y, Radius, (DWORD)worker.l, (DWORD)worker1.l); + return NtGdiAngleArc(hDC, X, Y, Radius, (DWORD)worker.l, (DWORD)worker1.l); } BOOL WINAPI ArcTo( - HDC hDC, - int nLeftRect, - int nTopRect, - int nRightRect, - int nBottomRect, - int nXRadial1, - int nYRadial1, - int nXRadial2, - int nYRadial2) + HDC hDC, + int nLeftRect, + int nTopRect, + int nRightRect, + int nBottomRect, + int nXRadial1, + int nYRadial1, + int nXRadial2, + int nYRadial2) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; //No meta support for ArcTo - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_ARCTO); - return Ret; - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; //No meta support for ArcTo + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_ARCTO); + return Ret; + } + return FALSE; + } } - } #endif - return NtGdiArcInternal(GdiTypeArcTo, - hDC, - nLeftRect, - nTopRect, - nRightRect, - nBottomRect, - nXRadial1, - nYRadial1, - nXRadial2, - nYRadial2); + return NtGdiArcInternal(GdiTypeArcTo, + hDC, + nLeftRect, + nTopRect, + nRightRect, + nBottomRect, + nXRadial1, + nYRadial1, + nXRadial2, + nYRadial2); } BOOL WINAPI Chord( - HDC hDC, - int nLeftRect, - int nTopRect, - int nRightRect, - int nBottomRect, - int nXRadial1, - int nYRadial1, - int nXRadial2, - int nYRadial2) + HDC hDC, + int nLeftRect, + int nTopRect, + int nRightRect, + int nBottomRect, + int nXRadial1, + int nYRadial1, + int nXRadial2, + int nYRadial2) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam8( hDC, META_CHORD, a1, a2, a3, a4, a5, a6, a7, a8) - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_CHORD); - return Ret; - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam8( hDC, META_CHORD, a1, a2, a3, a4, a5, a6, a7, a8) + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_CHORD); + return Ret; + } + return FALSE; + } } - } #endif - return NtGdiArcInternal(GdiTypeChord, - hDC, - nLeftRect, - nTopRect, - nRightRect, - nBottomRect, - nXRadial1, - nYRadial1, - nXRadial2, - nYRadial2); + return NtGdiArcInternal(GdiTypeChord, + hDC, + nLeftRect, + nTopRect, + nRightRect, + nBottomRect, + nXRadial1, + nYRadial1, + nXRadial2, + nYRadial2); } @@ -198,41 +198,41 @@ Chord( BOOL WINAPI Pie( - HDC hDC, - int a1, - int a2, - int a3, - int a4, - int a5, - int a6, - int a7, - int a8 - ) + HDC hDC, + int a1, + int a2, + int a3, + int a4, + int a5, + int a6, + int a7, + int a8 +) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam8( hDC, META_PIE, a1, a2, a3, a4, a5, a6, a7, a8) - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_PIE); - return Ret; - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam8( hDC, META_PIE, a1, a2, a3, a4, a5, a6, a7, a8) + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + BOOL Ret = EMFDRV_ArcChordPie( hDC, a1, a2, a3, a4, a5, a6, a7, a8, EMR_PIE); + return Ret; + } + return FALSE; + } } - } #endif - return NtGdiArcInternal(GdiTypePie, hDC, a1, a2, a3, a4, a5, a6, a7, a8); + return NtGdiArcInternal(GdiTypePie, hDC, a1, a2, a3, a4, a5, a6, a7, a8); } diff --git a/reactos/dll/win32/gdi32/objects/bitmap.c b/reactos/dll/win32/gdi32/objects/bitmap.c index 18db05f2a61..969beb6ad44 100644 --- a/reactos/dll/win32/gdi32/objects/bitmap.c +++ b/reactos/dll/win32/gdi32/objects/bitmap.c @@ -19,7 +19,7 @@ INT FASTCALL DIB_BitmapInfoSize(const BITMAPINFO * info, WORD coloruse) const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info; colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0; return sizeof(BITMAPCOREHEADER) + colors * - ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD)); + ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD)); } else /* assume BITMAPINFOHEADER */ { @@ -48,15 +48,15 @@ DIB_BitmapMaxBitsSize( PBITMAPINFO Info, UINT ScanLines ) if (Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) { - PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info; - MaxBits = Core->bcBitCount * Core->bcPlanes * Core->bcWidth; + PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info; + MaxBits = Core->bcBitCount * Core->bcPlanes * Core->bcWidth; } else /* assume BITMAPINFOHEADER */ { - if ((Info->bmiHeader.biCompression) && (Info->bmiHeader.biCompression != BI_BITFIELDS)) - return Info->bmiHeader.biSizeImage; - // Planes are over looked by Yuan. I guess assumed always 1. - MaxBits = Info->bmiHeader.biBitCount * Info->bmiHeader.biPlanes * Info->bmiHeader.biWidth; + if ((Info->bmiHeader.biCompression) && (Info->bmiHeader.biCompression != BI_BITFIELDS)) + return Info->bmiHeader.biSizeImage; + // Planes are over looked by Yuan. I guess assumed always 1. + MaxBits = Info->bmiHeader.biBitCount * Info->bmiHeader.biPlanes * Info->bmiHeader.biWidth; } MaxBits = ((MaxBits + 31) & ~31 ) / 8; // From Yuan, ScanLineSize = (Width * bitcount + 31)/32 return (MaxBits * ScanLines); // ret the full Size. @@ -66,26 +66,26 @@ UINT FASTCALL DIB_BitmapBitsSize( CONST BITMAPINFO* Info ) { - UINT Ret; + UINT Ret; - if (!Info) return 0; + if (!Info) return 0; - if ( Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) - { - PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info; - Ret = Core->bcHeight * - ((Core->bcWidth * Core->bcPlanes * Core->bcBitCount + 31) & ~31 ) / 8; - } - else /* assume BITMAPINFOHEADER */ - { - if ((Info->bmiHeader.biCompression) && - (Info->bmiHeader.biCompression != BI_BITFIELDS)) - return Info->bmiHeader.biSizeImage; + if ( Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) + { + PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info; + Ret = Core->bcHeight * + ((Core->bcWidth * Core->bcPlanes * Core->bcBitCount + 31) & ~31 ) / 8; + } + else /* assume BITMAPINFOHEADER */ + { + if ((Info->bmiHeader.biCompression) && + (Info->bmiHeader.biCompression != BI_BITFIELDS)) + return Info->bmiHeader.biSizeImage; // Make Height positive always.... - Ret = abs(Info->bmiHeader.biHeight) * - ((Info->bmiHeader.biWidth * Info->bmiHeader.biPlanes * Info->bmiHeader.biBitCount + 31) & ~31 ) / 8; - } - return Ret; + Ret = abs(Info->bmiHeader.biHeight) * + ((Info->bmiHeader.biWidth * Info->bmiHeader.biPlanes * Info->bmiHeader.biBitCount + 31) & ~31 ) / 8; + } + return Ret; } @@ -104,54 +104,54 @@ DIB_GetBitmapInfo(const BITMAPINFOHEADER *header, PLONG compr, PLONG size ) { - if (header->biSize == sizeof(BITMAPCOREHEADER)) - { - BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header; - *width = core->bcWidth; - *height = core->bcHeight; - *planes = core->bcPlanes; - *bpp = core->bcBitCount; - *compr = 0; - *size = 0; - return 0; - } + if (header->biSize == sizeof(BITMAPCOREHEADER)) + { + BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header; + *width = core->bcWidth; + *height = core->bcHeight; + *planes = core->bcPlanes; + *bpp = core->bcBitCount; + *compr = 0; + *size = 0; + return 0; + } - if (header->biSize == sizeof(BITMAPINFOHEADER)) - { - *width = header->biWidth; - *height = header->biHeight; - *planes = header->biPlanes; - *bpp = header->biBitCount; - *compr = header->biCompression; - *size = header->biSizeImage; - return 1; - } + if (header->biSize == sizeof(BITMAPINFOHEADER)) + { + *width = header->biWidth; + *height = header->biHeight; + *planes = header->biPlanes; + *bpp = header->biBitCount; + *compr = header->biCompression; + *size = header->biSizeImage; + return 1; + } - if (header->biSize == sizeof(BITMAPV4HEADER)) - { - BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *)header; - *width = v4hdr->bV4Width; - *height = v4hdr->bV4Height; - *planes = v4hdr->bV4Planes; - *bpp = v4hdr->bV4BitCount; - *compr = v4hdr->bV4V4Compression; - *size = v4hdr->bV4SizeImage; - return 4; - } + if (header->biSize == sizeof(BITMAPV4HEADER)) + { + BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *)header; + *width = v4hdr->bV4Width; + *height = v4hdr->bV4Height; + *planes = v4hdr->bV4Planes; + *bpp = v4hdr->bV4BitCount; + *compr = v4hdr->bV4V4Compression; + *size = v4hdr->bV4SizeImage; + return 4; + } - if (header->biSize == sizeof(BITMAPV5HEADER)) - { - BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *)header; - *width = v5hdr->bV5Width; - *height = v5hdr->bV5Height; - *planes = v5hdr->bV5Planes; - *bpp = v5hdr->bV5BitCount; - *compr = v5hdr->bV5Compression; - *size = v5hdr->bV5SizeImage; - return 5; - } - DPRINT("(%ld): wrong size for header\n", header->biSize ); - return -1; + if (header->biSize == sizeof(BITMAPV5HEADER)) + { + BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *)header; + *width = v5hdr->bV5Width; + *height = v5hdr->bV5Height; + *planes = v5hdr->bV5Planes; + *bpp = v5hdr->bV5BitCount; + *compr = v5hdr->bV5Compression; + *size = v5hdr->bV5SizeImage; + return 5; + } + DPRINT("(%ld): wrong size for header\n", header->biSize ); + return -1; } /* @@ -173,13 +173,13 @@ GdiGetBitmapBitsSize(BITMAPINFO *lpbmi) else { if ( (lpbmi->bmiHeader.biCompression == BI_BITFIELDS) || - (lpbmi->bmiHeader.biCompression == BI_RGB)) + (lpbmi->bmiHeader.biCompression == BI_RGB)) { if (lpbmi->bmiHeader.biHeight >=0 ) { /* Calc the bits Size and align it*/ retSize = lpbmi->bmiHeader.biHeight * ((lpbmi->bmiHeader.biWidth * - lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8; + lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8; } else { @@ -201,53 +201,54 @@ GdiGetBitmapBitsSize(BITMAPINFO *lpbmi) */ HBITMAP WINAPI CreateDIBSection( - HDC hDC, - CONST BITMAPINFO *BitmapInfo, - UINT Usage, - VOID **Bits, - HANDLE hSection, - DWORD dwOffset) + HDC hDC, + CONST BITMAPINFO *BitmapInfo, + UINT Usage, + VOID **Bits, + HANDLE hSection, + DWORD dwOffset) { - PBITMAPINFO pConvertedInfo; - UINT ConvertedInfoSize; - HBITMAP hBitmap = NULL; - PVOID bmBits = NULL; + PBITMAPINFO pConvertedInfo; + UINT ConvertedInfoSize; + HBITMAP hBitmap = NULL; + PVOID bmBits = NULL; - pConvertedInfo = ConvertBitmapInfo(BitmapInfo, Usage, - &ConvertedInfoSize, FALSE); - if (pConvertedInfo) - { // Verify header due to converted may == info. - if ( pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) - { - if ( pConvertedInfo->bmiHeader.biCompression == BI_JPEG || - pConvertedInfo->bmiHeader.biCompression == BI_PNG ) - { - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } - } - bmBits = Bits; - hBitmap = NtGdiCreateDIBSection( hDC, - hSection, - dwOffset, - pConvertedInfo, - Usage, - 0, - 0, - 0, - &bmBits); - if (BitmapInfo != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + pConvertedInfo = ConvertBitmapInfo(BitmapInfo, Usage, + &ConvertedInfoSize, FALSE); + if (pConvertedInfo) + { + // Verify header due to converted may == info. + if ( pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) + { + if ( pConvertedInfo->bmiHeader.biCompression == BI_JPEG || + pConvertedInfo->bmiHeader.biCompression == BI_PNG ) + { + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } + } + bmBits = Bits; + hBitmap = NtGdiCreateDIBSection( hDC, + hSection, + dwOffset, + pConvertedInfo, + Usage, + 0, + 0, + 0, + &bmBits); + if (BitmapInfo != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - if (!hBitmap) - { - bmBits = NULL; - } - } + if (!hBitmap) + { + bmBits = NULL; + } + } - if (Bits) *Bits = bmBits; + if (Bits) *Bits = bmBits; - return hBitmap; + return hBitmap; } @@ -269,7 +270,7 @@ BitBlt(HDC hdcDest, /* handle to destination DC */ /* use patBlt for no source blt Like windows does */ if (!ROP_USES_SOURCE(dwRop)) { - return PatBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, dwRop); + return PatBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, dwRop); } return NtGdiBitBlt(hdcDest, @@ -290,28 +291,28 @@ BitBlt(HDC hdcDest, /* handle to destination DC */ */ BOOL WINAPI StretchBlt( - HDC hdcDest, /* handle to destination DC */ - int nXOriginDest, /* x-coord of destination upper-left corner */ - int nYOriginDest, /* y-coord of destination upper-left corner */ - int nWidthDest, /* width of destination rectangle */ - int nHeightDest, /* height of destination rectangle */ - HDC hdcSrc, /* handle to source DC */ - int nXOriginSrc, /* x-coord of source upper-left corner */ - int nYOriginSrc, /* y-coord of source upper-left corner */ - int nWidthSrc, /* width of source rectangle */ - int nHeightSrc, /* height of source rectangle */ - DWORD dwRop) /* raster operation code */ + HDC hdcDest, /* handle to destination DC */ + int nXOriginDest, /* x-coord of destination upper-left corner */ + int nYOriginDest, /* y-coord of destination upper-left corner */ + int nWidthDest, /* width of destination rectangle */ + int nHeightDest, /* height of destination rectangle */ + HDC hdcSrc, /* handle to source DC */ + int nXOriginSrc, /* x-coord of source upper-left corner */ + int nYOriginSrc, /* y-coord of source upper-left corner */ + int nWidthSrc, /* width of source rectangle */ + int nHeightSrc, /* height of source rectangle */ + DWORD dwRop) /* raster operation code */ { - if ((nWidthDest != nWidthSrc) || (nHeightDest != nHeightSrc)) - { - return NtGdiStretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, - nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, - nWidthSrc, nHeightSrc, dwRop, 0); - } + if ((nWidthDest != nWidthSrc) || (nHeightDest != nHeightSrc)) + { + return NtGdiStretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, + nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, + nWidthSrc, nHeightSrc, dwRop, 0); + } - return NtGdiBitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, - nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop, 0, 0); + return NtGdiBitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, + nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop, 0, 0); } /* @@ -342,71 +343,71 @@ CreateBitmap(INT Width, HBITMAP WINAPI CreateBitmapIndirect(const BITMAP *pbm) { - HBITMAP bitmap = NULL; + HBITMAP bitmap = NULL; - /* Note windows xp/2003 does not check if pbm is NULL or not */ - if ( (pbm->bmWidthBytes != 0) && - (!(pbm->bmWidthBytes & 1)) ) + /* Note windows xp/2003 does not check if pbm is NULL or not */ + if ( (pbm->bmWidthBytes != 0) && + (!(pbm->bmWidthBytes & 1)) ) - { + { - bitmap = CreateBitmap(pbm->bmWidth, - pbm->bmHeight, - pbm->bmPlanes, - pbm->bmBitsPixel, - pbm->bmBits); - } - else - { - SetLastError(ERROR_INVALID_PARAMETER); - } + bitmap = CreateBitmap(pbm->bmWidth, + pbm->bmHeight, + pbm->bmPlanes, + pbm->bmBitsPixel, + pbm->bmBits); + } + else + { + SetLastError(ERROR_INVALID_PARAMETER); + } - return bitmap; + return bitmap; } HBITMAP WINAPI CreateDiscardableBitmap( - HDC hDC, - INT Width, - INT Height) + HDC hDC, + INT Width, + INT Height) { - return CreateCompatibleBitmap(hDC, Width, Height); + return CreateCompatibleBitmap(hDC, Width, Height); } HBITMAP WINAPI CreateCompatibleBitmap( - HDC hDC, - INT Width, - INT Height) + HDC hDC, + INT Width, + INT Height) { - PDC_ATTR pDc_Attr; - HBITMAP hBmp = NULL; - DIBSECTION dibs; + PDC_ATTR pDc_Attr; + HBITMAP hBmp = NULL; + DIBSECTION dibs; - if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - return NULL; + if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) + return NULL; - if ( !Width || !Height ) - return GetStockObject(DEFAULT_BITMAP); + if ( !Width || !Height ) + return GetStockObject(DEFAULT_BITMAP); - if (!(pDc_Attr->ulDirty_ & DC_DIBSECTION)) - { - return NtGdiCreateCompatibleBitmap(hDC, Width, Height); - } + if (!(pDc_Attr->ulDirty_ & DC_DIBSECTION)) + { + return NtGdiCreateCompatibleBitmap(hDC, Width, Height); + } - hBmp = NtGdiGetDCObject(hDC, GDI_OBJECT_TYPE_BITMAP); + hBmp = NtGdiGetDCObject(hDC, GDI_OBJECT_TYPE_BITMAP); - if ( GetObjectA(hBmp, sizeof(DIBSECTION), &dibs) != sizeof(DIBSECTION) ) - return NULL; + if ( GetObjectA(hBmp, sizeof(DIBSECTION), &dibs) != sizeof(DIBSECTION) ) + return NULL; - if ( dibs.dsBm.bmBitsPixel <= 8 ) - GetDIBColorTable(hDC, 0, 256, (RGBQUAD *)&dibs.dsBitfields); + if ( dibs.dsBm.bmBitsPixel <= 8 ) + GetDIBColorTable(hDC, 0, 256, (RGBQUAD *)&dibs.dsBitfields); - dibs.dsBmih.biWidth = Width; - dibs.dsBmih.biHeight = Height; + dibs.dsBmih.biWidth = Width; + dibs.dsBmih.biHeight = Height; - return CreateDIBSection(hDC, (CONST BITMAPINFO *)&dibs.dsBmih, 0, NULL, NULL, 0); + return CreateDIBSection(hDC, (CONST BITMAPINFO *)&dibs.dsBmih, 0, NULL, NULL, 0); } @@ -438,7 +439,7 @@ GetDIBits( if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) { if ( lpbmi->bmiHeader.biCompression == BI_JPEG || - lpbmi->bmiHeader.biCompression == BI_PNG ) + lpbmi->bmiHeader.biCompression == BI_PNG ) { SetLastError(ERROR_INVALID_PARAMETER); return 0; @@ -446,15 +447,15 @@ GetDIBits( } } - return NtGdiGetDIBitsInternal(hDC, - hbmp, - uStartScan, - cScanLines, - lpvBits, - lpbmi, - uUsage, - cjBmpScanSize, - cjInfoSize); + return NtGdiGetDIBitsInternal(hDC, + hbmp, + uStartScan, + cScanLines, + lpvBits, + lpbmi, + uUsage, + cjBmpScanSize, + cjInfoSize); } /* @@ -469,65 +470,65 @@ CreateDIBitmap( HDC hDC, const BITMAPINFO *Data, UINT ColorUse) { - LONG width, height, compr, dibsize; - WORD planes, bpp; + LONG width, height, compr, dibsize; + WORD planes, bpp; // PDC_ATTR pDc_Attr; - UINT InfoSize = 0; - UINT cjBmpScanSize = 0; - HBITMAP hBmp; - NTSTATUS Status = STATUS_SUCCESS; + UINT InfoSize = 0; + UINT cjBmpScanSize = 0; + HBITMAP hBmp; + NTSTATUS Status = STATUS_SUCCESS; - if (!Header) return 0; + if (!Header) return 0; - if (DIB_GetBitmapInfo(Header, &width, &height, &planes, &bpp, &compr, &dibsize) == -1) - { - GdiSetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } + if (DIB_GetBitmapInfo(Header, &width, &height, &planes, &bpp, &compr, &dibsize) == -1) + { + GdiSetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } // For Icm support. // GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - if(Data) - { - _SEH2_TRY - { - cjBmpScanSize = DIB_BitmapBitsSize(Data); - CalculateColorTableSize(&Data->bmiHeader, &ColorUse, &InfoSize); - InfoSize += Data->bmiHeader.biSize; - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { + if(Data) + { + _SEH2_TRY + { + cjBmpScanSize = DIB_BitmapBitsSize(Data); + CalculateColorTableSize(&Data->bmiHeader, &ColorUse, &InfoSize); + InfoSize += Data->bmiHeader.biSize; + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { Status = _SEH2_GetExceptionCode(); - } - _SEH2_END - } + } + _SEH2_END + } - if(!NT_SUCCESS(Status)) - { - GdiSetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } + if(!NT_SUCCESS(Status)) + { + GdiSetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } - DPRINT("pBMI %x, Size bpp %d, dibsize %d, Conv %d, BSS %d\n", Data,bpp,dibsize,InfoSize,cjBmpScanSize); + DPRINT("pBMI %x, Size bpp %d, dibsize %d, Conv %d, BSS %d\n", Data,bpp,dibsize,InfoSize,cjBmpScanSize); - if ( !width || !height ) - hBmp = GetStockObject(DEFAULT_BITMAP); - else - { - hBmp = NtGdiCreateDIBitmapInternal(hDC, - width, - height, - Init, - (LPBYTE)Bits, - (LPBITMAPINFO)Data, - ColorUse, - InfoSize, - cjBmpScanSize, - 0, - 0); - } - return hBmp; + if ( !width || !height ) + hBmp = GetStockObject(DEFAULT_BITMAP); + else + { + hBmp = NtGdiCreateDIBitmapInternal(hDC, + width, + height, + Init, + (LPBYTE)Bits, + (LPBITMAPINFO)Data, + ColorUse, + InfoSize, + cjBmpScanSize, + 0, + 0); + } + return hBmp; } #if 0 // FIXME!!! This is a victim of the Win32k Initialization BUG!!!!! @@ -544,83 +545,83 @@ SetDIBits(HDC hDC, CONST BITMAPINFO *lpbmi, UINT fuColorUse) { - HDC hDCc, SavehDC, nhDC; - DWORD dwWidth, dwHeight; - HGDIOBJ hOldBitmap; - HPALETTE hPal = NULL; - INT LinesCopied = 0; - BOOL newDC = FALSE; + HDC hDCc, SavehDC, nhDC; + DWORD dwWidth, dwHeight; + HGDIOBJ hOldBitmap; + HPALETTE hPal = NULL; + INT LinesCopied = 0; + BOOL newDC = FALSE; - if ( !lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP) ) - return 0; - - if ( lpbmi ) - { - if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) - { - if ( lpbmi->bmiHeader.biCompression == BI_JPEG || lpbmi->bmiHeader.biCompression == BI_PNG ) - { - SetLastError(ERROR_INVALID_PARAMETER); + if ( !lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP) ) return 0; - } - } - } - hDCc = NtGdiGetDCforBitmap(hBitmap); - SavehDC = hDCc; - if ( !hDCc ) - { - nhDC = CreateCompatibleDC(hDC); - if ( !nhDC ) return 0; - newDC = TRUE; - SavehDC = nhDC; - } - else if ( !SaveDC(hDCc) ) - return 0; - - hOldBitmap = SelectObject(SavehDC, hBitmap); - - if ( hOldBitmap ) - { - if ( hDC ) - hPal = SelectPalette(SavehDC, (HPALETTE)GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE), FALSE); - - if ( lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER)) + if ( lpbmi ) { - PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi; - dwWidth = pbci->bmciHeader.bcWidth; - dwHeight = pbci->bmciHeader.bcHeight; + if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) + { + if ( lpbmi->bmiHeader.biCompression == BI_JPEG || lpbmi->bmiHeader.biCompression == BI_PNG ) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + } } + + hDCc = NtGdiGetDCforBitmap(hBitmap); + SavehDC = hDCc; + if ( !hDCc ) + { + nhDC = CreateCompatibleDC(hDC); + if ( !nhDC ) return 0; + newDC = TRUE; + SavehDC = nhDC; + } + else if ( !SaveDC(hDCc) ) + return 0; + + hOldBitmap = SelectObject(SavehDC, hBitmap); + + if ( hOldBitmap ) + { + if ( hDC ) + hPal = SelectPalette(SavehDC, (HPALETTE)GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE), FALSE); + + if ( lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER)) + { + PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi; + dwWidth = pbci->bmciHeader.bcWidth; + dwHeight = pbci->bmciHeader.bcHeight; + } + else + { + dwWidth = lpbmi->bmiHeader.biWidth; + dwHeight = abs(lpbmi->bmiHeader.biHeight); + } + + LinesCopied = SetDIBitsToDevice(SavehDC, + 0, + 0, + dwWidth, + dwHeight, + 0, + 0, + uStartScan, + cScanLines, + (void *)lpvBits, + (LPBITMAPINFO)lpbmi, + fuColorUse); + + if ( hDC ) SelectPalette(SavehDC, hPal, FALSE); + + SelectObject(SavehDC, hOldBitmap); + } + + if ( newDC ) + DeleteDC(SavehDC); else - { - dwWidth = lpbmi->bmiHeader.biWidth; - dwHeight = abs(lpbmi->bmiHeader.biHeight); - } + RestoreDC(SavehDC, -1); - LinesCopied = SetDIBitsToDevice(SavehDC, - 0, - 0, - dwWidth, - dwHeight, - 0, - 0, - uStartScan, - cScanLines, - (void *)lpvBits, - (LPBITMAPINFO)lpbmi, - fuColorUse); - - if ( hDC ) SelectPalette(SavehDC, hPal, FALSE); - - SelectObject(SavehDC, hOldBitmap); - } - - if ( newDC ) - DeleteDC(SavehDC); - else - RestoreDC(SavehDC, -1); - - return LinesCopied; + return LinesCopied; } #endif @@ -634,47 +635,47 @@ SetDIBits(HDC hdc, CONST BITMAPINFO *lpbmi, UINT fuColorUse) { - PBITMAPINFO pConvertedInfo; - UINT ConvertedInfoSize; - INT LinesCopied = 0; - UINT cjBmpScanSize = 0; - PVOID pvSafeBits = (PVOID)lpvBits; + PBITMAPINFO pConvertedInfo; + UINT ConvertedInfoSize; + INT LinesCopied = 0; + UINT cjBmpScanSize = 0; + PVOID pvSafeBits = (PVOID)lpvBits; // This needs to be almost the sames as SetDIBitsToDevice - if ( !cScanLines || !lpbmi || !lpvBits || (GDI_HANDLE_GET_TYPE(hbmp) != GDI_OBJECT_TYPE_BITMAP)) - return 0; + if ( !cScanLines || !lpbmi || !lpvBits || (GDI_HANDLE_GET_TYPE(hbmp) != GDI_OBJECT_TYPE_BITMAP)) + return 0; - if ( fuColorUse && fuColorUse != DIB_PAL_COLORS && fuColorUse != DIB_PAL_COLORS+1 ) - return 0; + if ( fuColorUse && fuColorUse != DIB_PAL_COLORS && fuColorUse != DIB_PAL_COLORS+1 ) + return 0; - pConvertedInfo = ConvertBitmapInfo(lpbmi, fuColorUse, - &ConvertedInfoSize, FALSE); - if (!pConvertedInfo) - return 0; + pConvertedInfo = ConvertBitmapInfo(lpbmi, fuColorUse, + &ConvertedInfoSize, FALSE); + if (!pConvertedInfo) + return 0; - cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, cScanLines); + cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, cScanLines); - if ( lpvBits ) - { - pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); - if (pvSafeBits) - RtlCopyMemory( pvSafeBits, lpvBits, cjBmpScanSize); - } + if ( lpvBits ) + { + pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); + if (pvSafeBits) + RtlCopyMemory( pvSafeBits, lpvBits, cjBmpScanSize); + } - LinesCopied = NtGdiSetDIBits( hdc, - hbmp, - uStartScan, - cScanLines, - pvSafeBits, - pConvertedInfo, - fuColorUse); + LinesCopied = NtGdiSetDIBits( hdc, + hbmp, + uStartScan, + cScanLines, + pvSafeBits, + pConvertedInfo, + fuColorUse); - if ( lpvBits != pvSafeBits) - RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); - if (lpbmi != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - return LinesCopied; + if ( lpvBits != pvSafeBits) + RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); + if (lpbmi != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + return LinesCopied; } /* @@ -697,111 +698,111 @@ SetDIBitsToDevice( CONST BITMAPINFO *lpbmi, UINT ColorUse) { - PDC_ATTR pDc_Attr; - PBITMAPINFO pConvertedInfo; - UINT ConvertedInfoSize; - INT LinesCopied = 0; - UINT cjBmpScanSize = 0; - PVOID pvSafeBits = (PVOID)Bits; + PDC_ATTR pDc_Attr; + PBITMAPINFO pConvertedInfo; + UINT ConvertedInfoSize; + INT LinesCopied = 0; + UINT cjBmpScanSize = 0; + PVOID pvSafeBits = (PVOID)Bits; - if ( !ScanLines || !lpbmi || !Bits ) - return 0; + if ( !ScanLines || !lpbmi || !Bits ) + return 0; - if ( ColorUse && ColorUse != DIB_PAL_COLORS && ColorUse != DIB_PAL_COLORS+1 ) - return 0; + if ( ColorUse && ColorUse != DIB_PAL_COLORS && ColorUse != DIB_PAL_COLORS+1 ) + return 0; - pConvertedInfo = ConvertBitmapInfo(lpbmi, ColorUse, - &ConvertedInfoSize, FALSE); - if (!pConvertedInfo) - return 0; + pConvertedInfo = ConvertBitmapInfo(lpbmi, ColorUse, + &ConvertedInfoSize, FALSE); + if (!pConvertedInfo) + return 0; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetDIBitsToDevice( hdc, - XDest, - YDest, - Width, - Height, - XSrc, - YSrc, - StartScan, - ScanLines, - Bits, - lpbmi, - ColorUse); - else - { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetDIBitsToDevice(hdc, - XDest, - YDest, - Width, - Height, - XSrc, - YSrc, - StartScan, - ScanLines, - Bits, - lpbmi, - ColorUse); - } - return 0; - } - } -#endif - cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, ScanLines); - - if ( Bits ) - { - pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); - if (pvSafeBits) - RtlCopyMemory( pvSafeBits, Bits, cjBmpScanSize); - } - - if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } -/* - if ( !pDc_Attr || - ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) && - (pConvertedInfo->bmiHeader.biCompression == BI_JPEG || - pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/ - { - LinesCopied = NtGdiSetDIBitsToDeviceInternal( hdc, + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetDIBitsToDevice( hdc, + XDest, + YDest, + Width, + Height, + XSrc, + YSrc, + StartScan, + ScanLines, + Bits, + lpbmi, + ColorUse); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetDIBitsToDevice(hdc, XDest, YDest, Width, - Height, - XSrc, - YSrc, - StartScan, - ScanLines, - (LPBYTE)pvSafeBits, - (LPBITMAPINFO)pConvertedInfo, - ColorUse, - cjBmpScanSize, - ConvertedInfoSize, - TRUE, - NULL); - } - if ( Bits != pvSafeBits) - RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); - if (lpbmi != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + Height, + XSrc, + YSrc, + StartScan, + ScanLines, + Bits, + lpbmi, + ColorUse); + } + return 0; + } + } +#endif + cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, ScanLines); - return LinesCopied; + if ( Bits ) + { + pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); + if (pvSafeBits) + RtlCopyMemory( pvSafeBits, Bits, cjBmpScanSize); + } + + if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + /* + if ( !pDc_Attr || + ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) && + (pConvertedInfo->bmiHeader.biCompression == BI_JPEG || + pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/ + { + LinesCopied = NtGdiSetDIBitsToDeviceInternal( hdc, + XDest, + YDest, + Width, + Height, + XSrc, + YSrc, + StartScan, + ScanLines, + (LPBYTE)pvSafeBits, + (LPBITMAPINFO)pConvertedInfo, + ColorUse, + cjBmpScanSize, + ConvertedInfoSize, + TRUE, + NULL); + } + if ( Bits != pvSafeBits) + RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); + if (lpbmi != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + + return LinesCopied; } @@ -825,128 +826,128 @@ StretchDIBits(HDC hdc, DWORD dwRop) { - PDC_ATTR pDc_Attr; - PBITMAPINFO pConvertedInfo = NULL; - UINT ConvertedInfoSize = 0; - INT LinesCopied = 0; - UINT cjBmpScanSize = 0; - PVOID pvSafeBits = NULL; - BOOL Hit = FALSE; + PDC_ATTR pDc_Attr; + PBITMAPINFO pConvertedInfo = NULL; + UINT ConvertedInfoSize = 0; + INT LinesCopied = 0; + UINT cjBmpScanSize = 0; + PVOID pvSafeBits = NULL; + BOOL Hit = FALSE; - DPRINT("StretchDIBits %x : %x : %d\n", lpBits, lpBitsInfo, iUsage); + DPRINT("StretchDIBits %x : %x : %d\n", lpBits, lpBitsInfo, iUsage); #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_StretchBlt( hdc, - XDest, - YDest, - nDestWidth, - nDestHeight, - XSrc, - YSrc, - nSrcWidth, - nSrcHeight, - lpBits, - lpBitsInfo, - iUsage, - dwRop); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_StretchBlt(hdc, - XDest, - YDest, - nDestWidth, - nDestHeight, - XSrc, - YSrc, - nSrcWidth, - nSrcHeight, - lpBits, - lpBitsInfo, - iUsage, - dwRop); - } - return 0; + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_StretchBlt( hdc, + XDest, + YDest, + nDestWidth, + nDestHeight, + XSrc, + YSrc, + nSrcWidth, + nSrcHeight, + lpBits, + lpBitsInfo, + iUsage, + dwRop); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_StretchBlt(hdc, + XDest, + YDest, + nDestWidth, + nDestHeight, + XSrc, + YSrc, + nSrcWidth, + nSrcHeight, + lpBits, + lpBitsInfo, + iUsage, + dwRop); + } + return 0; + } } - } #endif pConvertedInfo = ConvertBitmapInfo(lpBitsInfo, iUsage, - &ConvertedInfoSize, FALSE); + &ConvertedInfoSize, FALSE); if (!pConvertedInfo) { return 0; } - cjBmpScanSize = DIB_BitmapBitsSize((LPBITMAPINFO)pConvertedInfo); + cjBmpScanSize = DIB_BitmapBitsSize((LPBITMAPINFO)pConvertedInfo); - if ( lpBits ) - { - pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); - if (pvSafeBits) - { - _SEH2_TRY + if ( lpBits ) + { + pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize); + if (pvSafeBits) { - RtlCopyMemory( pvSafeBits, lpBits, cjBmpScanSize ); - } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - Hit = TRUE; - } - _SEH2_END + _SEH2_TRY + { + RtlCopyMemory( pvSafeBits, lpBits, cjBmpScanSize ); + } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + Hit = TRUE; + } + _SEH2_END - if (Hit) - { - // We don't die, we continue on with a allocated safe pointer to kernel - // space..... - DPRINT1("StretchDIBits fail to read BitMapInfo: %x or Bits: %x & Size: %d\n",pConvertedInfo,lpBits,cjBmpScanSize); + if (Hit) + { + // We don't die, we continue on with a allocated safe pointer to kernel + // space..... + DPRINT1("StretchDIBits fail to read BitMapInfo: %x or Bits: %x & Size: %d\n",pConvertedInfo,lpBits,cjBmpScanSize); + } + DPRINT("StretchDIBits Allocate Bits %d!!!\n", cjBmpScanSize); } - DPRINT("StretchDIBits Allocate Bits %d!!!\n", cjBmpScanSize); - } - } + } - if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } -/* - if ( !pDc_Attr || - ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) && - (pConvertedInfo->bmiHeader.biCompression == BI_JPEG || - pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/ - { - LinesCopied = NtGdiStretchDIBitsInternal( hdc, - XDest, - YDest, - nDestWidth, - nDestHeight, - XSrc, - YSrc, - nSrcWidth, - nSrcHeight, - pvSafeBits, - pConvertedInfo, - (DWORD)iUsage, - dwRop, - ConvertedInfoSize, - cjBmpScanSize, - NULL); - } - if ( pvSafeBits ) - RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); - if (lpBitsInfo != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + /* + if ( !pDc_Attr || + ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) && + (pConvertedInfo->bmiHeader.biCompression == BI_JPEG || + pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/ + { + LinesCopied = NtGdiStretchDIBitsInternal( hdc, + XDest, + YDest, + nDestWidth, + nDestHeight, + XSrc, + YSrc, + nSrcWidth, + nSrcHeight, + pvSafeBits, + pConvertedInfo, + (DWORD)iUsage, + dwRop, + ConvertedInfoSize, + cjBmpScanSize, + NULL); + } + if ( pvSafeBits ) + RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits); + if (lpBitsInfo != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - return LinesCopied; + return LinesCopied; } diff --git a/reactos/dll/win32/gdi32/objects/brush.c b/reactos/dll/win32/gdi32/objects/brush.c index dd4d305b0e8..185bed6c3fb 100644 --- a/reactos/dll/win32/gdi32/objects/brush.c +++ b/reactos/dll/win32/gdi32/objects/brush.c @@ -16,95 +16,95 @@ ExtCreatePen(DWORD dwPenStyle, DWORD dwStyleCount, CONST DWORD *lpStyle) { - PVOID lpPackedDIB = NULL; - HPEN hPen = NULL; - PBITMAPINFO pConvertedInfo = NULL; - UINT ConvertedInfoSize = 0, lbStyle; - BOOL Hit = FALSE; + PVOID lpPackedDIB = NULL; + HPEN hPen = NULL; + PBITMAPINFO pConvertedInfo = NULL; + UINT ConvertedInfoSize = 0, lbStyle; + BOOL Hit = FALSE; - if ((dwPenStyle & PS_STYLE_MASK) == PS_USERSTYLE) - { - if(!lpStyle) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - } // This is an enhancement and prevents a call to kernel space. - else if ((dwPenStyle & PS_STYLE_MASK) == PS_INSIDEFRAME && - (dwPenStyle & PS_TYPE_MASK) != PS_GEOMETRIC) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - else if ((dwPenStyle & PS_STYLE_MASK) == PS_ALTERNATE && - (dwPenStyle & PS_TYPE_MASK) != PS_COSMETIC) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - else - { - if (dwStyleCount || lpStyle) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - } + if ((dwPenStyle & PS_STYLE_MASK) == PS_USERSTYLE) + { + if(!lpStyle) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + } // This is an enhancement and prevents a call to kernel space. + else if ((dwPenStyle & PS_STYLE_MASK) == PS_INSIDEFRAME && + (dwPenStyle & PS_TYPE_MASK) != PS_GEOMETRIC) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + else if ((dwPenStyle & PS_STYLE_MASK) == PS_ALTERNATE && + (dwPenStyle & PS_TYPE_MASK) != PS_COSMETIC) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + else + { + if (dwStyleCount || lpStyle) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + } - lbStyle = lplb->lbStyle; + lbStyle = lplb->lbStyle; - if (lplb->lbStyle > BS_HATCHED) - { - if (lplb->lbStyle == BS_PATTERN) - { - pConvertedInfo = (PBITMAPINFO)lplb->lbHatch; - if (!pConvertedInfo) return 0; - } - else - { - if ((lplb->lbStyle == BS_DIBPATTERN) || (lplb->lbStyle == BS_DIBPATTERNPT)) - { - if (lplb->lbStyle == BS_DIBPATTERN) + if (lplb->lbStyle > BS_HATCHED) + { + if (lplb->lbStyle == BS_PATTERN) + { + pConvertedInfo = (PBITMAPINFO)lplb->lbHatch; + if (!pConvertedInfo) return 0; + } + else + { + if ((lplb->lbStyle == BS_DIBPATTERN) || (lplb->lbStyle == BS_DIBPATTERNPT)) { - lbStyle = BS_DIBPATTERNPT; - lpPackedDIB = GlobalLock((HGLOBAL)lplb->lbHatch); - if (lpPackedDIB == NULL) return 0; + if (lplb->lbStyle == BS_DIBPATTERN) + { + lbStyle = BS_DIBPATTERNPT; + lpPackedDIB = GlobalLock((HGLOBAL)lplb->lbHatch); + if (lpPackedDIB == NULL) return 0; + } + pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, + lplb->lbColor, + &ConvertedInfoSize, + TRUE); + Hit = TRUE; // We converted DIB. } - pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, - lplb->lbColor, - &ConvertedInfoSize, - TRUE); - Hit = TRUE; // We converted DIB. - } - else - pConvertedInfo = (PBITMAPINFO)lpStyle; - } - } - else - pConvertedInfo = (PBITMAPINFO)lplb->lbHatch; - - - hPen = NtGdiExtCreatePen(dwPenStyle, - dwWidth, - lbStyle, - lplb->lbColor, - lplb->lbHatch, - (ULONG_PTR)pConvertedInfo, - dwStyleCount, - (PULONG)lpStyle, - ConvertedInfoSize, - FALSE, - NULL); + else + pConvertedInfo = (PBITMAPINFO)lpStyle; + } + } + else + pConvertedInfo = (PBITMAPINFO)lplb->lbHatch; - if (lplb->lbStyle == BS_DIBPATTERN) GlobalUnlock((HGLOBAL)lplb->lbHatch); + hPen = NtGdiExtCreatePen(dwPenStyle, + dwWidth, + lbStyle, + lplb->lbColor, + lplb->lbHatch, + (ULONG_PTR)pConvertedInfo, + dwStyleCount, + (PULONG)lpStyle, + ConvertedInfoSize, + FALSE, + NULL); - if (Hit) - { - if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - } - return hPen; + + if (lplb->lbStyle == BS_DIBPATTERN) GlobalUnlock((HGLOBAL)lplb->lbHatch); + + if (Hit) + { + if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + } + return hPen; } /* @@ -112,31 +112,31 @@ ExtCreatePen(DWORD dwPenStyle, */ HBRUSH WINAPI CreateDIBPatternBrush( - HGLOBAL hglbDIBPacked, - UINT fuColorSpec) + HGLOBAL hglbDIBPacked, + UINT fuColorSpec) { - PVOID lpPackedDIB; - HBRUSH hBrush = NULL; - PBITMAPINFO pConvertedInfo; - UINT ConvertedInfoSize; + PVOID lpPackedDIB; + HBRUSH hBrush = NULL; + PBITMAPINFO pConvertedInfo; + UINT ConvertedInfoSize; - lpPackedDIB = GlobalLock(hglbDIBPacked); - if (lpPackedDIB == NULL) - return 0; + lpPackedDIB = GlobalLock(hglbDIBPacked); + if (lpPackedDIB == NULL) + return 0; - pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec, - &ConvertedInfoSize, TRUE); - if (pConvertedInfo) - { - hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec, - ConvertedInfoSize, FALSE, FALSE, lpPackedDIB); - if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - } + pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec, + &ConvertedInfoSize, TRUE); + if (pConvertedInfo) + { + hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec, + ConvertedInfoSize, FALSE, FALSE, lpPackedDIB); + if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + } - GlobalUnlock(hglbDIBPacked); + GlobalUnlock(hglbDIBPacked); - return hBrush; + return hBrush; } /* @@ -144,27 +144,27 @@ CreateDIBPatternBrush( */ HBRUSH WINAPI CreateDIBPatternBrushPt( - CONST VOID *lpPackedDIB, - UINT fuColorSpec) + CONST VOID *lpPackedDIB, + UINT fuColorSpec) { - HBRUSH hBrush = NULL; - PBITMAPINFO pConvertedInfo; - UINT ConvertedInfoSize; + HBRUSH hBrush = NULL; + PBITMAPINFO pConvertedInfo; + UINT ConvertedInfoSize; - if (lpPackedDIB == NULL) - return 0; + if (lpPackedDIB == NULL) + return 0; - pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec, - &ConvertedInfoSize, TRUE); - if (pConvertedInfo) - { - hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec, - ConvertedInfoSize, FALSE, FALSE, (PVOID)lpPackedDIB); - if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) - RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); - } + pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec, + &ConvertedInfoSize, TRUE); + if (pConvertedInfo) + { + hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec, + ConvertedInfoSize, FALSE, FALSE, (PVOID)lpPackedDIB); + if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo) + RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo); + } - return hBrush; + return hBrush; } /* @@ -204,56 +204,56 @@ CreateSolidBrush(IN COLORREF crColor) */ HBRUSH WINAPI CreateBrushIndirect( - CONST LOGBRUSH *LogBrush) + CONST LOGBRUSH *LogBrush) { - HBRUSH hBrush; + HBRUSH hBrush; - switch (LogBrush->lbStyle) - { - case BS_DIBPATTERN8X8: - case BS_DIBPATTERN: - hBrush = CreateDIBPatternBrush((HGLOBAL)LogBrush->lbHatch, - LogBrush->lbColor); - break; + switch (LogBrush->lbStyle) + { + case BS_DIBPATTERN8X8: + case BS_DIBPATTERN: + hBrush = CreateDIBPatternBrush((HGLOBAL)LogBrush->lbHatch, + LogBrush->lbColor); + break; - case BS_DIBPATTERNPT: - hBrush = CreateDIBPatternBrushPt((PVOID)LogBrush->lbHatch, - LogBrush->lbColor); - break; + case BS_DIBPATTERNPT: + hBrush = CreateDIBPatternBrushPt((PVOID)LogBrush->lbHatch, + LogBrush->lbColor); + break; - case BS_PATTERN: - hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch, - FALSE, - FALSE); - break; + case BS_PATTERN: + hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch, + FALSE, + FALSE); + break; - case BS_PATTERN8X8: - hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch, - FALSE, - TRUE); - break; + case BS_PATTERN8X8: + hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch, + FALSE, + TRUE); + break; - case BS_SOLID: - hBrush = NtGdiCreateSolidBrush(LogBrush->lbColor, 0); - break; + case BS_SOLID: + hBrush = NtGdiCreateSolidBrush(LogBrush->lbColor, 0); + break; - case BS_HATCHED: - hBrush = NtGdiCreateHatchBrushInternal(LogBrush->lbHatch, - LogBrush->lbColor, - FALSE); - break; + case BS_HATCHED: + hBrush = NtGdiCreateHatchBrushInternal(LogBrush->lbHatch, + LogBrush->lbColor, + FALSE); + break; - case BS_NULL: - hBrush = NtGdiGetStockObject(NULL_BRUSH); - break; + case BS_NULL: + hBrush = NtGdiGetStockObject(NULL_BRUSH); + break; - default: - SetLastError(ERROR_INVALID_PARAMETER); - hBrush = NULL; - break; - } + default: + SetLastError(ERROR_INVALID_PARAMETER); + hBrush = NULL; + break; + } - return hBrush; + return hBrush; } BOOL @@ -289,9 +289,9 @@ int WINAPI GetROP2(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->jROP2; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->jROP2; } /* @@ -302,46 +302,46 @@ WINAPI SetROP2(HDC hdc, int fnDrawMode) { - PDC_ATTR Dc_Attr; - INT Old_ROP2; - + PDC_ATTR Dc_Attr; + INT Old_ROP2; + #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetROP2( hdc, fnDrawMode); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetROP2(( hdc, fnDrawMode); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetROP2( hdc, fnDrawMode); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetROP2(( hdc, fnDrawMode); + } + return FALSE; + } } - } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) { - NtGdiFlush(); - Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + { + NtGdiFlush(); + Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + } } - } - Old_ROP2 = Dc_Attr->jROP2; - Dc_Attr->jROP2 = fnDrawMode; + Old_ROP2 = Dc_Attr->jROP2; + Dc_Attr->jROP2 = fnDrawMode; - return Old_ROP2; + return Old_ROP2; } /* @@ -352,15 +352,15 @@ BOOL WINAPI GetBrushOrgEx(HDC hdc,LPPOINT pt) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (pt) - { - pt->x = Dc_Attr->ptlBrushOrigin.x; - pt->y = Dc_Attr->ptlBrushOrigin.y; - } - return TRUE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (pt) + { + pt->x = Dc_Attr->ptlBrushOrigin.x; + pt->y = Dc_Attr->ptlBrushOrigin.y; + } + return TRUE; } /* @@ -373,62 +373,62 @@ SetBrushOrgEx(HDC hdc, int nYOrg, LPPOINT lppt) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - PLDC pLDC = GdiGetLDC(hdc); - if ( (pLDC == NULL) || (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)) + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; + PLDC pLDC = GdiGetLDC(hdc); + if ( (pLDC == NULL) || (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetBrushOrg(hdc, nXOrg, nYOrg); // ReactOS only. + } + return FALSE; } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetBrushOrg(hdc, nXOrg, nYOrg); // ReactOS only. - } - return FALSE; - } #endif - if (GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) - { - PTEB pTeb = NtCurrentTeb(); - if (lppt) + if (GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) { - lppt->x = Dc_Attr->ptlBrushOrigin.x; - lppt->y = Dc_Attr->ptlBrushOrigin.y; + PTEB pTeb = NtCurrentTeb(); + if (lppt) + { + lppt->x = Dc_Attr->ptlBrushOrigin.x; + lppt->y = Dc_Attr->ptlBrushOrigin.y; + } + if ((nXOrg == Dc_Attr->ptlBrushOrigin.x) && (nYOrg == Dc_Attr->ptlBrushOrigin.y)) + return TRUE; + + if(((pTeb->GdiTebBatch.HDC == NULL) || (pTeb->GdiTebBatch.HDC == hdc)) && + ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSSETBRHORG)) <= GDIBATCHBUFSIZE) && + (!(Dc_Attr->ulDirty_ & DC_DIBSECTION)) ) + { + PGDIBSSETBRHORG pgSBO = (PGDIBSSETBRHORG)(&pTeb->GdiTebBatch.Buffer[0] + + pTeb->GdiTebBatch.Offset); + + Dc_Attr->ptlBrushOrigin.x = nXOrg; + Dc_Attr->ptlBrushOrigin.y = nYOrg; + + pgSBO->gbHdr.Cmd = GdiBCSetBrushOrg; + pgSBO->gbHdr.Size = sizeof(GDIBSSETBRHORG); + pgSBO->ptlBrushOrigin = Dc_Attr->ptlBrushOrigin; + + pTeb->GdiTebBatch.Offset += sizeof(GDIBSSETBRHORG); + pTeb->GdiTebBatch.HDC = hdc; + pTeb->GdiBatchCount++; + DPRINT("Loading the Flush!! COUNT-> %d\n", pTeb->GdiBatchCount); + + if (pTeb->GdiBatchCount >= GDI_BatchLimit) + { + DPRINT("Call GdiFlush!!\n"); + NtGdiFlush(); + DPRINT("Exit GdiFlush!!\n"); + } + return TRUE; + } } - if ((nXOrg == Dc_Attr->ptlBrushOrigin.x) && (nYOrg == Dc_Attr->ptlBrushOrigin.y)) - return TRUE; - - if(((pTeb->GdiTebBatch.HDC == NULL) || (pTeb->GdiTebBatch.HDC == hdc)) && - ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSSETBRHORG)) <= GDIBATCHBUFSIZE) && - (!(Dc_Attr->ulDirty_ & DC_DIBSECTION)) ) - { - PGDIBSSETBRHORG pgSBO = (PGDIBSSETBRHORG)(&pTeb->GdiTebBatch.Buffer[0] + - pTeb->GdiTebBatch.Offset); - - Dc_Attr->ptlBrushOrigin.x = nXOrg; - Dc_Attr->ptlBrushOrigin.y = nYOrg; - - pgSBO->gbHdr.Cmd = GdiBCSetBrushOrg; - pgSBO->gbHdr.Size = sizeof(GDIBSSETBRHORG); - pgSBO->ptlBrushOrigin = Dc_Attr->ptlBrushOrigin; - - pTeb->GdiTebBatch.Offset += sizeof(GDIBSSETBRHORG); - pTeb->GdiTebBatch.HDC = hdc; - pTeb->GdiBatchCount++; - DPRINT("Loading the Flush!! COUNT-> %d\n", pTeb->GdiBatchCount); - - if (pTeb->GdiBatchCount >= GDI_BatchLimit) - { - DPRINT("Call GdiFlush!!\n"); - NtGdiFlush(); - DPRINT("Exit GdiFlush!!\n"); - } - return TRUE; - } - } - return NtGdiSetBrushOrg(hdc,nXOrg,nYOrg,lppt); + return NtGdiSetBrushOrg(hdc,nXOrg,nYOrg,lppt); } diff --git a/reactos/dll/win32/gdi32/objects/coord.c b/reactos/dll/win32/gdi32/objects/coord.c index 866108530b9..9f89ae1c89a 100644 --- a/reactos/dll/win32/gdi32/objects/coord.c +++ b/reactos/dll/win32/gdi32/objects/coord.c @@ -22,71 +22,71 @@ LONG FASTCALL EFtoF( EFLOAT_S * efp) { - long Mant, Exp, Sign = 0; + long Mant, Exp, Sign = 0; - if (!efp->lMant) return 0; + if (!efp->lMant) return 0; - Mant = efp->lMant; - Exp = efp->lExp; - Sign = SIGN(Mant); + Mant = efp->lMant; + Exp = efp->lExp; + Sign = SIGN(Mant); //// M$ storage emulation - if( Sign ) Mant = -Mant; - Mant = ((Mant & 0x3fffffff) >> 7); - Exp += (EXCESS-1); + if( Sign ) Mant = -Mant; + Mant = ((Mant & 0x3fffffff) >> 7); + Exp += (EXCESS-1); //// - Mant = MANT(Mant); - return PACK(Sign, Exp, Mant); + Mant = MANT(Mant); + return PACK(Sign, Exp, Mant); } VOID FASTCALL FtoEF( EFLOAT_S * efp, FLOATL f) { - long Mant, Exp, Sign = 0; - gxf_long worker; + long Mant, Exp, Sign = 0; + gxf_long worker; #ifdef _X86_ - worker.l = f; // It's a float stored in a long. + worker.l = f; // It's a float stored in a long. #else - worker.f = f; + worker.f = f; #endif - Exp = EXP(worker.l); - Mant = MANT(worker.l); - if (SIGN(worker.l)) Sign = -1; + Exp = EXP(worker.l); + Mant = MANT(worker.l); + if (SIGN(worker.l)) Sign = -1; //// M$ storage emulation - Mant = ((Mant << 7) | 0x40000000); - Mant ^= Sign; - Mant -= Sign; - Exp -= (EXCESS-1); + Mant = ((Mant << 7) | 0x40000000); + Mant ^= Sign; + Mant -= Sign; + Exp -= (EXCESS-1); //// - efp->lMant = Mant; - efp->lExp = Exp; + efp->lMant = Mant; + efp->lExp = Exp; } VOID FASTCALL CoordCnvP(MATRIX_S * mx, LPPOINT Point) { - FLOAT x, y; - gxf_long a, b, c; + FLOAT x, y; + gxf_long a, b, c; - x = (FLOAT)Point->x; - y = (FLOAT)Point->y; + x = (FLOAT)Point->x; + y = (FLOAT)Point->y; - a.l = EFtoF( &mx->efM11 ); - b.l = EFtoF( &mx->efM21 ); - c.l = EFtoF( &mx->efDx ); - x = x * a.f + y * b.f + c.f; + a.l = EFtoF( &mx->efM11 ); + b.l = EFtoF( &mx->efM21 ); + c.l = EFtoF( &mx->efDx ); + x = x * a.f + y * b.f + c.f; - a.l = EFtoF( &mx->efM12 ); - b.l = EFtoF( &mx->efM22 ); - c.l = EFtoF( &mx->efDy ); - y = x * a.f + y * b.f + c.f; + a.l = EFtoF( &mx->efM12 ); + b.l = EFtoF( &mx->efM22 ); + c.l = EFtoF( &mx->efDy ); + y = x * a.f + y * b.f + c.f; - FLOAT_TO_INT(x, Point->x ); - FLOAT_TO_INT(y, Point->y ); + FLOAT_TO_INT(x, Point->x ); + FLOAT_TO_INT(y, Point->y ); } @@ -95,24 +95,24 @@ WINAPI DPtoLP ( HDC hDC, LPPOINT Points, INT Count ) { #if 0 - INT i; - PDC_ATTR Dc_Attr; + INT i; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (Dc_Attr->flXform & ( DEVICE_TO_WORLD_INVALID | // Force a full recalibration! - PAGE_XLATE_CHANGED | // Changes or Updates have been made, - PAGE_EXTENTS_CHANGED | // do processing in kernel space. - WORLD_XFORM_CHANGED )) + if (Dc_Attr->flXform & ( DEVICE_TO_WORLD_INVALID | // Force a full recalibration! + PAGE_XLATE_CHANGED | // Changes or Updates have been made, + PAGE_EXTENTS_CHANGED | // do processing in kernel space. + WORLD_XFORM_CHANGED )) #endif - return NtGdiTransformPoints( hDC, Points, Points, Count, GdiDpToLp); // DPtoLP mode. + return NtGdiTransformPoints( hDC, Points, Points, Count, GdiDpToLp); // DPtoLP mode. #if 0 - else - { - for ( i = 0; i < Count; i++ ) - CoordCnvP ( &Dc_Attr->mxDeviceToWorld, &Points[i] ); - } - return TRUE; + else + { + for ( i = 0; i < Count; i++ ) + CoordCnvP ( &Dc_Attr->mxDeviceToWorld, &Points[i] ); + } + return TRUE; #endif } @@ -122,23 +122,23 @@ WINAPI LPtoDP ( HDC hDC, LPPOINT Points, INT Count ) { #if 0 - INT i; - PDC_ATTR Dc_Attr; + INT i; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (Dc_Attr->flXform & ( PAGE_XLATE_CHANGED | // Check for Changes and Updates - PAGE_EXTENTS_CHANGED | - WORLD_XFORM_CHANGED )) + if (Dc_Attr->flXform & ( PAGE_XLATE_CHANGED | // Check for Changes and Updates + PAGE_EXTENTS_CHANGED | + WORLD_XFORM_CHANGED )) #endif - return NtGdiTransformPoints( hDC, Points, Points, Count, GdiLpToDp); // LPtoDP mode + return NtGdiTransformPoints( hDC, Points, Points, Count, GdiLpToDp); // LPtoDP mode #if 0 - else - { - for ( i = 0; i < Count; i++ ) - CoordCnvP ( &Dc_Attr->mxWorldToDevice, &Points[i] ); - } - return TRUE; + else + { + for ( i = 0; i < Count; i++ ) + CoordCnvP ( &Dc_Attr->mxWorldToDevice, &Points[i] ); + } + return TRUE; #endif } @@ -151,33 +151,33 @@ WINAPI GetCurrentPositionEx(HDC hdc, LPPOINT lpPoint) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if ( lpPoint ) - { - if ( Dc_Attr->ulDirty_ & DIRTY_PTLCURRENT ) // have a hit! + if ( lpPoint ) { - lpPoint->x = Dc_Attr->ptfxCurrent.x; - lpPoint->y = Dc_Attr->ptfxCurrent.y; - DPtoLP ( hdc, lpPoint, 1); // reconvert back. - Dc_Attr->ptlCurrent.x = lpPoint->x; // save it - Dc_Attr->ptlCurrent.y = lpPoint->y; - Dc_Attr->ulDirty_ &= ~DIRTY_PTLCURRENT; // clear bit - } + if ( Dc_Attr->ulDirty_ & DIRTY_PTLCURRENT ) // have a hit! + { + lpPoint->x = Dc_Attr->ptfxCurrent.x; + lpPoint->y = Dc_Attr->ptfxCurrent.y; + DPtoLP ( hdc, lpPoint, 1); // reconvert back. + Dc_Attr->ptlCurrent.x = lpPoint->x; // save it + Dc_Attr->ptlCurrent.y = lpPoint->y; + Dc_Attr->ulDirty_ &= ~DIRTY_PTLCURRENT; // clear bit + } + else + { + lpPoint->x = Dc_Attr->ptlCurrent.x; + lpPoint->y = Dc_Attr->ptlCurrent.y; + } + } else { - lpPoint->x = Dc_Attr->ptlCurrent.x; - lpPoint->y = Dc_Attr->ptlCurrent.y; + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; } - } - else - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return TRUE; + return TRUE; } /* @@ -187,7 +187,7 @@ BOOL WINAPI GetWorldTransform( HDC hDC, LPXFORM lpXform ) { - return NtGdiGetTransform( hDC, GdiWorldSpaceToPageSpace, lpXform); + return NtGdiGetTransform( hDC, GdiWorldSpaceToPageSpace, lpXform); } @@ -195,126 +195,126 @@ BOOL WINAPI SetWorldTransform( HDC hDC, CONST XFORM *Xform ) { - /* FIXME shall we add undoc #define MWT_SETXFORM 4 ?? */ - return ModifyWorldTransform( hDC, Xform, MWT_MAX+1); + /* FIXME shall we add undoc #define MWT_SETXFORM 4 ?? */ + return ModifyWorldTransform( hDC, Xform, MWT_MAX+1); } BOOL WINAPI ModifyWorldTransform( - HDC hDC, - CONST XFORM *Xform, - DWORD iMode - ) + HDC hDC, + CONST XFORM *Xform, + DWORD iMode +) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - if (iMode == MWT_MAX+1) - if (!EMFDRV_SetWorldTransform( hDC, Xform) ) return FALSE; - return EMFDRV_ModifyWorldTransform( hDC, Xform, iMode); // Ported from wine. - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + if (iMode == MWT_MAX+1) + if (!EMFDRV_SetWorldTransform( hDC, Xform) ) return FALSE; + return EMFDRV_ModifyWorldTransform( hDC, Xform, iMode); // Ported from wine. + } + return FALSE; + } } - } #endif - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - /* Check that graphics mode is GM_ADVANCED */ - if ( Dc_Attr->iGraphicsMode != GM_ADVANCED ) return FALSE; + /* Check that graphics mode is GM_ADVANCED */ + if ( Dc_Attr->iGraphicsMode != GM_ADVANCED ) return FALSE; - return NtGdiModifyWorldTransform(hDC, (CONST LPXFORM) Xform, iMode); + return NtGdiModifyWorldTransform(hDC, (CONST LPXFORM) Xform, iMode); } BOOL WINAPI GetViewportExtEx( - HDC hdc, - LPSIZE lpSize - ) + HDC hdc, + LPSIZE lpSize +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if ((Dc_Attr->flXform & PAGE_EXTENTS_CHANGED) && (Dc_Attr->iMapMode == MM_ISOTROPIC)) - // Something was updated, go to kernel. - return NtGdiGetDCPoint( hdc, GdiGetViewPortExt, (PPOINTL) lpSize ); - else - { - lpSize->cx = Dc_Attr->szlViewportExt.cx; - lpSize->cy = Dc_Attr->szlViewportExt.cy; - } - return TRUE; + if ((Dc_Attr->flXform & PAGE_EXTENTS_CHANGED) && (Dc_Attr->iMapMode == MM_ISOTROPIC)) + // Something was updated, go to kernel. + return NtGdiGetDCPoint( hdc, GdiGetViewPortExt, (PPOINTL) lpSize ); + else + { + lpSize->cx = Dc_Attr->szlViewportExt.cx; + lpSize->cy = Dc_Attr->szlViewportExt.cy; + } + return TRUE; } BOOL WINAPI GetViewportOrgEx( - HDC hdc, - LPPOINT lpPoint - ) + HDC hdc, + LPPOINT lpPoint +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - lpPoint->x = Dc_Attr->ptlViewportOrg.x; - lpPoint->y = Dc_Attr->ptlViewportOrg.y; - if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; - return TRUE; - // return NtGdiGetDCPoint( hdc, GdiGetViewPortOrg, lpPoint ); + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + lpPoint->x = Dc_Attr->ptlViewportOrg.x; + lpPoint->y = Dc_Attr->ptlViewportOrg.y; + if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; + return TRUE; + // return NtGdiGetDCPoint( hdc, GdiGetViewPortOrg, lpPoint ); } BOOL WINAPI GetWindowExtEx( - HDC hdc, - LPSIZE lpSize - ) + HDC hdc, + LPSIZE lpSize +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - lpSize->cx = Dc_Attr->szlWindowExt.cx; - lpSize->cy = Dc_Attr->szlWindowExt.cy; - if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx; - return TRUE; - // return NtGdiGetDCPoint( hdc, GdiGetWindowExt, (LPPOINT) lpSize ); + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + lpSize->cx = Dc_Attr->szlWindowExt.cx; + lpSize->cy = Dc_Attr->szlWindowExt.cy; + if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx; + return TRUE; + // return NtGdiGetDCPoint( hdc, GdiGetWindowExt, (LPPOINT) lpSize ); } BOOL WINAPI GetWindowOrgEx( - HDC hdc, - LPPOINT lpPoint - ) + HDC hdc, + LPPOINT lpPoint +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - lpPoint->x = Dc_Attr->ptlWindowOrg.x; - lpPoint->y = Dc_Attr->ptlWindowOrg.y; - return TRUE; - //return NtGdiGetDCPoint( hdc, GdiGetWindowOrg, lpPoint ); + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + lpPoint->x = Dc_Attr->ptlWindowOrg.x; + lpPoint->y = Dc_Attr->ptlWindowOrg.y; + return TRUE; + //return NtGdiGetDCPoint( hdc, GdiGetWindowOrg, lpPoint ); } /* @@ -327,57 +327,57 @@ SetViewportExtEx(HDC hdc, int nYExtent, LPSIZE lpSize) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetViewportExtEx(); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetViewportExtEx(); - } - } - } -#endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) - { - return FALSE; - } - - if (lpSize) - { - lpSize->cx = Dc_Attr->szlViewportExt.cx; - lpSize->cy = Dc_Attr->szlViewportExt.cy; - } - - if ((Dc_Attr->szlViewportExt.cx == nXExtent) && (Dc_Attr->szlViewportExt.cy == nYExtent)) - return TRUE; - - if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC)) - { - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetViewportExtEx(); + else { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetViewportExtEx(); + } } - } - Dc_Attr->szlViewportExt.cx = nXExtent; - Dc_Attr->szlViewportExt.cy = nYExtent; - if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); - Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); - } - return TRUE; + } +#endif + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) + { + return FALSE; + } + + if (lpSize) + { + lpSize->cx = Dc_Attr->szlViewportExt.cx; + lpSize->cy = Dc_Attr->szlViewportExt.cy; + } + + if ((Dc_Attr->szlViewportExt.cx == nXExtent) && (Dc_Attr->szlViewportExt.cy == nYExtent)) + return TRUE; + + if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC)) + { + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + Dc_Attr->szlViewportExt.cx = nXExtent; + Dc_Attr->szlViewportExt.cy = nYExtent; + if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); + Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); + } + return TRUE; } /* @@ -391,55 +391,55 @@ SetWindowOrgEx(HDC hdc, LPPOINT lpPoint) { #if 0 - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetWindowOrgEx(); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetWindowOrgEx(); - } + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetWindowOrgEx(); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetWindowOrgEx(); + } + } } - } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (lpPoint) - { - lpPoint->x = Dc_Attr->ptlWindowOrg.x; - lpPoint->y = Dc_Attr->ptlWindowOrg.y; - } + if (lpPoint) + { + lpPoint->x = Dc_Attr->ptlWindowOrg.x; + lpPoint->y = Dc_Attr->ptlWindowOrg.y; + } - if ((Dc_Attr->ptlWindowOrg.x == X) && (Dc_Attr->ptlWindowOrg.y == Y)) - return TRUE; + if ((Dc_Attr->ptlWindowOrg.x == X) && (Dc_Attr->ptlWindowOrg.y == Y)) + return TRUE; - if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) - { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } - - Dc_Attr->ptlWindowOrg.x = X; - Dc_Attr->lWindowOrgx = X; - Dc_Attr->ptlWindowOrg.y = Y; - if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); - Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); - return TRUE; + if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + + Dc_Attr->ptlWindowOrg.x = X; + Dc_Attr->lWindowOrgx = X; + Dc_Attr->ptlWindowOrg.y = Y; + if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); + Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); + return TRUE; #endif - return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint); + return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint); } /* @@ -452,62 +452,62 @@ SetWindowExtEx(HDC hdc, int nYExtent, LPSIZE lpSize) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetWindowExtEx(); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetWindowExtEx(); - } - } - } -#endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - - if (lpSize) - { - lpSize->cx = Dc_Attr->szlWindowExt.cx; - lpSize->cy = Dc_Attr->szlWindowExt.cy; - if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx; - } - - if (Dc_Attr->dwLayout & LAYOUT_RTL) - { - NtGdiMirrorWindowOrg(hdc); - Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); - } - else if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC)) - { - if ((Dc_Attr->szlWindowExt.cx == nXExtent) && (Dc_Attr->szlWindowExt.cy == nYExtent)) - return TRUE; - - if ((!nXExtent) || (!nYExtent)) return FALSE; - - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetWindowExtEx(); + else { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetWindowExtEx(); + } } - } - Dc_Attr->szlWindowExt.cx = nXExtent; - Dc_Attr->szlWindowExt.cy = nYExtent; - if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); - Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); - } - return TRUE; // Return TRUE. + } +#endif + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + + if (lpSize) + { + lpSize->cx = Dc_Attr->szlWindowExt.cx; + lpSize->cy = Dc_Attr->szlWindowExt.cy; + if (Dc_Attr->dwLayout & LAYOUT_RTL) lpSize->cx = -lpSize->cx; + } + + if (Dc_Attr->dwLayout & LAYOUT_RTL) + { + NtGdiMirrorWindowOrg(hdc); + Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); + } + else if ((Dc_Attr->iMapMode == MM_ISOTROPIC) || (Dc_Attr->iMapMode == MM_ANISOTROPIC)) + { + if ((Dc_Attr->szlWindowExt.cx == nXExtent) && (Dc_Attr->szlWindowExt.cy == nYExtent)) + return TRUE; + + if ((!nXExtent) || (!nYExtent)) return FALSE; + + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + Dc_Attr->szlWindowExt.cx = nXExtent; + Dc_Attr->szlWindowExt.cy = nYExtent; + if (Dc_Attr->dwLayout & LAYOUT_RTL) NtGdiMirrorWindowOrg(hdc); + Dc_Attr->flXform |= (PAGE_EXTENTS_CHANGED|INVALIDATE_ATTRIBUTES|DEVICE_TO_WORLD_INVALID); + } + return TRUE; // Return TRUE. } /* @@ -521,42 +521,42 @@ SetViewportOrgEx(HDC hdc, LPPOINT lpPoint) { #if 0 - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetViewportOrgEx(); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetViewportOrgEx(); - } + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetViewportOrgEx(); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetViewportOrgEx(); + } + } } - } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (lpPoint) - { - lpPoint->x = Dc_Attr->ptlViewportOrg.x; - lpPoint->y = Dc_Attr->ptlViewportOrg.y; - if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; - } - Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); - if (Dc_Attr->dwLayout & LAYOUT_RTL) X = -X; - Dc_Attr->ptlViewportOrg.x = X; - Dc_Attr->ptlViewportOrg.y = Y; - return TRUE; + if (lpPoint) + { + lpPoint->x = Dc_Attr->ptlViewportOrg.x; + lpPoint->y = Dc_Attr->ptlViewportOrg.y; + if (Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; + } + Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); + if (Dc_Attr->dwLayout & LAYOUT_RTL) X = -X; + Dc_Attr->ptlViewportOrg.x = X; + Dc_Attr->ptlViewportOrg.y = Y; + return TRUE; #endif - return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint); + return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint); } /* @@ -565,38 +565,38 @@ SetViewportOrgEx(HDC hdc, BOOL WINAPI ScaleViewportExtEx( - HDC a0, - int a1, - int a2, - int a3, - int a4, - LPSIZE a5 - ) + HDC a0, + int a1, + int a2, + int a3, + int a4, + LPSIZE a5 +) { #if 0 - if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC) - return MFDRV_; - else + if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(a0); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_; - } + if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC) + return MFDRV_; + else + { + PLDC pLDC = GdiGetLDC(a0); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_; + } + } } - } #endif - if (!GdiIsHandleValid((HGDIOBJ) a0) || - (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE; + if (!GdiIsHandleValid((HGDIOBJ) a0) || + (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE; - return NtGdiScaleViewportExtEx(a0, a1, a2, a3, a4, a5); + return NtGdiScaleViewportExtEx(a0, a1, a2, a3, a4, a5); } /* @@ -605,38 +605,38 @@ ScaleViewportExtEx( BOOL WINAPI ScaleWindowExtEx( - HDC a0, - int a1, - int a2, - int a3, - int a4, - LPSIZE a5 - ) + HDC a0, + int a1, + int a2, + int a3, + int a4, + LPSIZE a5 +) { #if 0 - if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC) - return MFDRV_; - else + if (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(a0); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_; - } + if (GDI_HANDLE_GET_TYPE(a0) == GDI_OBJECT_TYPE_METADC) + return MFDRV_; + else + { + PLDC pLDC = GdiGetLDC(a0); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_; + } + } } - } #endif - if (!GdiIsHandleValid((HGDIOBJ) a0) || - (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE; + if (!GdiIsHandleValid((HGDIOBJ) a0) || + (GDI_HANDLE_GET_TYPE(a0) != GDI_OBJECT_TYPE_DC)) return FALSE; - return NtGdiScaleWindowExtEx(a0, a1, a2, a3, a4, a5); + return NtGdiScaleWindowExtEx(a0, a1, a2, a3, a4, a5); } /* @@ -645,11 +645,11 @@ ScaleWindowExtEx( DWORD WINAPI GetLayout(HDC hdc -) + ) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR; - return Dc_Attr->dwLayout; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR; + return Dc_Attr->dwLayout; } @@ -662,28 +662,28 @@ SetLayout(HDC hdc, DWORD dwLayout) { #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetLayout( hdc, dwLayout); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetLayout( hdc, dwLayout); - } + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetLayout( hdc, dwLayout); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetLayout( hdc, dwLayout); + } + } } - } #endif - if (!GdiIsHandleValid((HGDIOBJ) hdc) || - (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR; - return NtGdiSetLayout( hdc, -1, dwLayout); + if (!GdiIsHandleValid((HGDIOBJ) hdc) || + (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR; + return NtGdiSetLayout( hdc, -1, dwLayout); } /* @@ -693,9 +693,9 @@ DWORD WINAPI SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout) { - if (!GdiIsHandleValid((HGDIOBJ) hdc) || - (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR; - return NtGdiSetLayout( hdc, wox, dwLayout); + if (!GdiIsHandleValid((HGDIOBJ) hdc) || + (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return GDI_ERROR; + return NtGdiSetLayout( hdc, wox, dwLayout); } /* @@ -710,51 +710,51 @@ OffsetViewportOrgEx(HDC hdc, LPPOINT lpPoint) { #if 0 - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_OffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); - } - } - } -#endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - - if ( lpPoint ) - { - *lpPoint = (POINT)Dc_Attr->ptlViewportOrg; - if ( Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; - } - - if ( nXOffset || nYOffset != nXOffset ) - { - if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) - { - if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_OffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint); + else { - NtGdiFlush(); - Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); + } } - } - Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); - if ( Dc_Attr->dwLayout & LAYOUT_RTL) nXOffset = -nXOffset; - Dc_Attr->ptlViewportOrg.x += nXOffset; - Dc_Attr->ptlViewportOrg.y += nYOffset; - } - return TRUE; + } +#endif + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + + if ( lpPoint ) + { + *lpPoint = (POINT)Dc_Attr->ptlViewportOrg; + if ( Dc_Attr->dwLayout & LAYOUT_RTL) lpPoint->x = -lpPoint->x; + } + + if ( nXOffset || nYOffset != nXOffset ) + { + if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) + { + if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + { + NtGdiFlush(); + Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + } + } + Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); + if ( Dc_Attr->dwLayout & LAYOUT_RTL) nXOffset = -nXOffset; + Dc_Attr->ptlViewportOrg.x += nXOffset; + Dc_Attr->ptlViewportOrg.y += nYOffset; + } + return TRUE; #endif return NtGdiOffsetViewportOrgEx(hdc, nXOffset, nYOffset, lpPoint); } @@ -771,51 +771,51 @@ OffsetWindowOrgEx(HDC hdc, LPPOINT lpPoint) { #if 0 - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); - } - } - } -#endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - - if ( lpPoint ) - { - *lpPoint = (POINT)Dc_Attr->ptlWindowOrg; - lpPoint->x = Dc_Attr->lWindowOrgx; - } - - if ( nXOffset || nYOffset != nXOffset ) - { - if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) - { - if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); + else { - NtGdiFlush(); - Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_OffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); + } } - } - Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); - Dc_Attr->ptlWindowOrg.x += nXOffset; - Dc_Attr->ptlWindowOrg.y += nYOffset; - Dc_Attr->lWindowOrgx += nXOffset; - } - return TRUE; + } +#endif + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + + if ( lpPoint ) + { + *lpPoint = (POINT)Dc_Attr->ptlWindowOrg; + lpPoint->x = Dc_Attr->lWindowOrgx; + } + + if ( nXOffset || nYOffset != nXOffset ) + { + if (NtCurrentTeb()->GdiTebBatch.HDC == (ULONG)hdc) + { + if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + { + NtGdiFlush(); + Dc_Attr->ulDirty_ &= ~DC_MODE_DIRTY; + } + } + Dc_Attr->flXform |= (PAGE_XLATE_CHANGED|DEVICE_TO_WORLD_INVALID); + Dc_Attr->ptlWindowOrg.x += nXOffset; + Dc_Attr->ptlWindowOrg.y += nYOffset; + Dc_Attr->lWindowOrgx += nXOffset; + } + return TRUE; #endif return NtGdiOffsetWindowOrgEx(hdc, nXOffset, nYOffset, lpPoint); } diff --git a/reactos/dll/win32/gdi32/objects/dc.c b/reactos/dll/win32/gdi32/objects/dc.c index 7693dcc9592..af8a49cf0dd 100644 --- a/reactos/dll/win32/gdi32/objects/dc.c +++ b/reactos/dll/win32/gdi32/objects/dc.c @@ -13,79 +13,79 @@ IntCreateDICW ( LPCWSTR lpwszDriver, PDEVMODEW lpInitData, ULONG iType ) { - UNICODE_STRING Device, Output; - HDC hDC = NULL; - BOOL Display = FALSE, Default = FALSE; - ULONG UMdhpdev = 0; + UNICODE_STRING Device, Output; + HDC hDC = NULL; + BOOL Display = FALSE, Default = FALSE; + ULONG UMdhpdev = 0; - HANDLE hspool = NULL; + HANDLE hspool = NULL; - if ( !ghSpooler && !LoadTheSpoolerDrv()) - { - DPRINT1("WinSpooler.Drv Did not load!\n"); - } - else - { - DPRINT("WinSpooler.Drv Loaded! hMod -> 0x%x\n", ghSpooler); - } - - if ((!lpwszDevice) && (!lpwszDriver)) - { - Default = TRUE; // Ask Win32k to set Default device. - Display = TRUE; // Most likely to be DISPLAY. - } - else - { - if ((lpwszDevice) && (wcslen(lpwszDevice) != 0)) // First + if ( !ghSpooler && !LoadTheSpoolerDrv()) { - if (!_wcsnicmp(lpwszDevice, L"\\\\.\\DISPLAY",11)) Display = TRUE; - RtlInitUnicodeString(&Device, lpwszDevice); + DPRINT1("WinSpooler.Drv Did not load!\n"); } else { - if (lpwszDriver) // Second - { - if ((!_wcsnicmp(lpwszDriver, L"DISPLAY",7)) || - (!_wcsnicmp(lpwszDriver, L"\\\\.\\DISPLAY",11))) Display = TRUE; - RtlInitUnicodeString(&Device, lpwszDriver); - } + DPRINT("WinSpooler.Drv Loaded! hMod -> 0x%x\n", ghSpooler); } - } - if (lpwszOutput) RtlInitUnicodeString(&Output, lpwszOutput); + if ((!lpwszDevice) && (!lpwszDriver)) + { + Default = TRUE; // Ask Win32k to set Default device. + Display = TRUE; // Most likely to be DISPLAY. + } + else + { + if ((lpwszDevice) && (wcslen(lpwszDevice) != 0)) // First + { + if (!_wcsnicmp(lpwszDevice, L"\\\\.\\DISPLAY",11)) Display = TRUE; + RtlInitUnicodeString(&Device, lpwszDevice); + } + else + { + if (lpwszDriver) // Second + { + if ((!_wcsnicmp(lpwszDriver, L"DISPLAY",7)) || + (!_wcsnicmp(lpwszDriver, L"\\\\.\\DISPLAY",11))) Display = TRUE; + RtlInitUnicodeString(&Device, lpwszDriver); + } + } + } - if (!Display) - { - //Handle Print device or something else. - DPRINT1("Not a DISPLAY device! %wZ\n", &Device); - } + if (lpwszOutput) RtlInitUnicodeString(&Output, lpwszOutput); - hDC = NtGdiOpenDCW( (Default ? NULL : &Device), - (PDEVMODEW) lpInitData, - (lpwszOutput ? &Output : NULL), - iType, // DCW 0 and ICW 1. - Display, - hspool, - (PVOID) NULL, // NULL for now. - (PVOID) &UMdhpdev ); + if (!Display) + { + //Handle Print device or something else. + DPRINT1("Not a DISPLAY device! %wZ\n", &Device); + } + + hDC = NtGdiOpenDCW( (Default ? NULL : &Device), + (PDEVMODEW) lpInitData, + (lpwszOutput ? &Output : NULL), + iType, // DCW 0 and ICW 1. + Display, + hspool, + (PVOID) NULL, // NULL for now. + (PVOID) &UMdhpdev ); #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - PDC_ATTR Dc_Attr; - PLDC pLDC; + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) + { + PDC_ATTR Dc_Attr; + PLDC pLDC; - GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr); + GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr); - pLDC = LocalAlloc(LMEM_ZEROINIT, sizeof(LDC)); + pLDC = LocalAlloc(LMEM_ZEROINIT, sizeof(LDC)); - Dc_Attr->pvLDC = pLDC; - pLDC->hDC = hDC; - pLDC->iType = LDC_LDC; // 1 (init) local DC, 2 EMF LDC - DbgPrint("DC_ATTR Allocated -> 0x%x\n",Dc_Attr); - } + Dc_Attr->pvLDC = pLDC; + pLDC->hDC = hDC; + pLDC->iType = LDC_LDC; // 1 (init) local DC, 2 EMF LDC + DbgPrint("DC_ATTR Allocated -> 0x%x\n",Dc_Attr); + } #endif - return hDC; + return hDC; } @@ -96,20 +96,20 @@ HDC WINAPI CreateCompatibleDC ( HDC hdc) { - HDC rhDC; + HDC rhDC; // PDC_ATTR Dc_Attr; - rhDC = NtGdiCreateCompatibleDC(hdc); + rhDC = NtGdiCreateCompatibleDC(hdc); #if 0 - if ( hdc && rhDC) - { - if (GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) + if ( hdc && rhDC) { - if ( Dc_Attr->pvLIcm ) IcmCompatibleDC(rhDC, hdc, Dc_Attr); + if (GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) + { + if ( Dc_Attr->pvLIcm ) IcmCompatibleDC(rhDC, hdc, Dc_Attr); + } } - } #endif - return rhDC; + return rhDC; } /* @@ -118,61 +118,64 @@ CreateCompatibleDC ( HDC hdc) HDC WINAPI CreateDCA ( - LPCSTR lpszDriver, - LPCSTR lpszDevice, - LPCSTR lpszOutput, - CONST DEVMODEA * lpdvmInit - ) + LPCSTR lpszDriver, + LPCSTR lpszDevice, + LPCSTR lpszOutput, + CONST DEVMODEA * lpdvmInit +) { - ANSI_STRING DriverA, DeviceA, OutputA; - UNICODE_STRING DriverU, DeviceU, OutputU; - LPDEVMODEW dvmInitW = NULL; - HDC hDC; + ANSI_STRING DriverA, DeviceA, OutputA; + UNICODE_STRING DriverU, DeviceU, OutputU; + LPDEVMODEW dvmInitW = NULL; + HDC hDC; -/* - * If needed, convert to Unicode - * any string parameter. - */ + /* + * If needed, convert to Unicode + * any string parameter. + */ - if (NULL != lpszDriver) - { - RtlInitAnsiString(&DriverA, (LPSTR)lpszDriver); - RtlAnsiStringToUnicodeString(&DriverU, &DriverA, TRUE); - } else - DriverU.Buffer = NULL; - if (NULL != lpszDevice) - { - RtlInitAnsiString(&DeviceA, (LPSTR)lpszDevice); - RtlAnsiStringToUnicodeString(&DeviceU, &DeviceA, TRUE); - } else - DeviceU.Buffer = NULL; - if (NULL != lpszOutput) - { - RtlInitAnsiString(&OutputA, (LPSTR)lpszOutput); - RtlAnsiStringToUnicodeString(&OutputU, &OutputA, TRUE); - } else - OutputU.Buffer = NULL; + if (NULL != lpszDriver) + { + RtlInitAnsiString(&DriverA, (LPSTR)lpszDriver); + RtlAnsiStringToUnicodeString(&DriverU, &DriverA, TRUE); + } + else + DriverU.Buffer = NULL; + if (NULL != lpszDevice) + { + RtlInitAnsiString(&DeviceA, (LPSTR)lpszDevice); + RtlAnsiStringToUnicodeString(&DeviceU, &DeviceA, TRUE); + } + else + DeviceU.Buffer = NULL; + if (NULL != lpszOutput) + { + RtlInitAnsiString(&OutputA, (LPSTR)lpszOutput); + RtlAnsiStringToUnicodeString(&OutputU, &OutputA, TRUE); + } + else + OutputU.Buffer = NULL; - if ( lpdvmInit ) - dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit); + if ( lpdvmInit ) + dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit); - hDC = IntCreateDICW ( DriverU.Buffer, - DeviceU.Buffer, - OutputU.Buffer, - lpdvmInit ? dvmInitW : NULL, - 0 ); - HEAP_free (dvmInitW); -/* - * Free Unicode parameters. - */ - RtlFreeUnicodeString(&DriverU); - RtlFreeUnicodeString(&DeviceU); - RtlFreeUnicodeString(&OutputU); + hDC = IntCreateDICW ( DriverU.Buffer, + DeviceU.Buffer, + OutputU.Buffer, + lpdvmInit ? dvmInitW : NULL, + 0 ); + HEAP_free (dvmInitW); + /* + * Free Unicode parameters. + */ + RtlFreeUnicodeString(&DriverU); + RtlFreeUnicodeString(&DeviceU); + RtlFreeUnicodeString(&OutputU); -/* - * Return the possible DC handle. - */ - return hDC; + /* + * Return the possible DC handle. + */ + return hDC; } @@ -182,18 +185,18 @@ CreateDCA ( HDC WINAPI CreateDCW ( - LPCWSTR lpwszDriver, - LPCWSTR lpwszDevice, - LPCWSTR lpwszOutput, - CONST DEVMODEW *lpInitData - ) + LPCWSTR lpwszDriver, + LPCWSTR lpwszDevice, + LPCWSTR lpwszOutput, + CONST DEVMODEW *lpInitData +) { - return IntCreateDICW ( lpwszDriver, - lpwszDevice, - lpwszOutput, - (PDEVMODEW) lpInitData, - 0 ); + return IntCreateDICW ( lpwszDriver, + lpwszDevice, + lpwszOutput, + (PDEVMODEW) lpInitData, + 0 ); } @@ -203,17 +206,17 @@ CreateDCW ( HDC WINAPI CreateICW( - LPCWSTR lpszDriver, - LPCWSTR lpszDevice, - LPCWSTR lpszOutput, - CONST DEVMODEW *lpdvmInit - ) + LPCWSTR lpszDriver, + LPCWSTR lpszDevice, + LPCWSTR lpszOutput, + CONST DEVMODEW *lpdvmInit +) { - return IntCreateDICW ( lpszDriver, - lpszDevice, - lpszOutput, - (PDEVMODEW) lpdvmInit, - 1 ); + return IntCreateDICW ( lpszDriver, + lpszDevice, + lpszOutput, + (PDEVMODEW) lpdvmInit, + 1 ); } @@ -223,48 +226,48 @@ CreateICW( HDC WINAPI CreateICA( - LPCSTR lpszDriver, - LPCSTR lpszDevice, - LPCSTR lpszOutput, - CONST DEVMODEA *lpdvmInit - ) + LPCSTR lpszDriver, + LPCSTR lpszDevice, + LPCSTR lpszOutput, + CONST DEVMODEA *lpdvmInit +) { - NTSTATUS Status; - LPWSTR lpszDriverW, lpszDeviceW, lpszOutputW; - LPDEVMODEW dvmInitW = NULL; - HDC rc = 0; + NTSTATUS Status; + LPWSTR lpszDriverW, lpszDeviceW, lpszOutputW; + LPDEVMODEW dvmInitW = NULL; + HDC rc = 0; - Status = HEAP_strdupA2W ( &lpszDriverW, lpszDriver ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else - { - Status = HEAP_strdupA2W ( &lpszDeviceW, lpszDevice ); + Status = HEAP_strdupA2W ( &lpszDriverW, lpszDriver ); if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); + SetLastError (RtlNtStatusToDosError(Status)); else - { - Status = HEAP_strdupA2W ( &lpszOutputW, lpszOutput ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else - { - if ( lpdvmInit ) - dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit); + { + Status = HEAP_strdupA2W ( &lpszDeviceW, lpszDevice ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else + { + Status = HEAP_strdupA2W ( &lpszOutputW, lpszOutput ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else + { + if ( lpdvmInit ) + dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit); - rc = IntCreateDICW ( lpszDriverW, - lpszDeviceW, - lpszOutputW, - lpdvmInit ? dvmInitW : NULL, - 1 ); - HEAP_free (dvmInitW); - HEAP_free ( lpszOutputW ); - } - HEAP_free ( lpszDeviceW ); - } - HEAP_free ( lpszDriverW ); - } - return rc; + rc = IntCreateDICW ( lpszDriverW, + lpszDeviceW, + lpszOutputW, + lpdvmInit ? dvmInitW : NULL, + 1 ); + HEAP_free (dvmInitW); + HEAP_free ( lpszOutputW ); + } + HEAP_free ( lpszDeviceW ); + } + HEAP_free ( lpszDriverW ); + } + return rc; } @@ -275,39 +278,39 @@ BOOL WINAPI DeleteDC(HDC hDC) { - BOOL Ret = TRUE; - PLDC pLDC = NULL; - HANDLE hPrinter = NULL; - ULONG hType = GDI_HANDLE_GET_TYPE(hDC); + BOOL Ret = TRUE; + PLDC pLDC = NULL; + HANDLE hPrinter = NULL; + ULONG hType = GDI_HANDLE_GET_TYPE(hDC); - pLDC = GdiGetLDC(hDC); + pLDC = GdiGetLDC(hDC); - if (hType != GDILoObjType_LO_DC_TYPE) - { + if (hType != GDILoObjType_LO_DC_TYPE) + { - if ( !pLDC || hType == GDILoObjType_LO_METADC16_TYPE) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->Flags & LDC_INIT_DOCUMENT) AbortDoc(hDC); - if (pLDC->hPrinter) - { - DocumentEventEx(NULL, pLDC->hPrinter, hDC, DOCUMENTEVENT_DELETEDC, 0, NULL, 0, NULL); - hPrinter = pLDC->hPrinter; - pLDC->hPrinter = NULL; - } - } + if ( !pLDC || hType == GDILoObjType_LO_METADC16_TYPE) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->Flags & LDC_INIT_DOCUMENT) AbortDoc(hDC); + if (pLDC->hPrinter) + { + DocumentEventEx(NULL, pLDC->hPrinter, hDC, DOCUMENTEVENT_DELETEDC, 0, NULL, 0, NULL); + hPrinter = pLDC->hPrinter; + pLDC->hPrinter = NULL; + } + } - Ret = NtGdiDeleteObjectApp(hDC); + Ret = NtGdiDeleteObjectApp(hDC); - if (Ret && pLDC ) - { - DPRINT1("Delete the Local DC structure\n"); - LocalFree( pLDC ); - } - if (hPrinter) fpClosePrinter(hPrinter); - return Ret; + if (Ret && pLDC ) + { + DPRINT1("Delete the Local DC structure\n"); + LocalFree( pLDC ); + } + if (hPrinter) fpClosePrinter(hPrinter); + return Ret; } /* @@ -317,87 +320,88 @@ BOOL WINAPI DeleteObject(HGDIOBJ hObject) { - UINT Type = 0; + UINT Type = 0; - /* From Wine: DeleteObject does not SetLastError() on a null object */ - if(!hObject) return FALSE; + /* From Wine: DeleteObject does not SetLastError() on a null object */ + if(!hObject) return FALSE; - if (0 != ((DWORD) hObject & GDI_HANDLE_STOCK_MASK)) - { // Relax! This is a normal return! - DPRINT("Trying to delete system object 0x%x\n", hObject); - return TRUE; - } - // If you dont own it?! Get OUT! - if(!GdiIsHandleValid(hObject)) return FALSE; + if (0 != ((DWORD) hObject & GDI_HANDLE_STOCK_MASK)) + { + // Relax! This is a normal return! + DPRINT("Trying to delete system object 0x%x\n", hObject); + return TRUE; + } + // If you dont own it?! Get OUT! + if(!GdiIsHandleValid(hObject)) return FALSE; - Type = GDI_HANDLE_GET_TYPE(hObject); + Type = GDI_HANDLE_GET_TYPE(hObject); - if ((Type == GDI_OBJECT_TYPE_METAFILE) || - (Type == GDI_OBJECT_TYPE_ENHMETAFILE)) - return FALSE; + if ((Type == GDI_OBJECT_TYPE_METAFILE) || + (Type == GDI_OBJECT_TYPE_ENHMETAFILE)) + return FALSE; - switch (Type) - { - case GDI_OBJECT_TYPE_DC: - return DeleteDC((HDC) hObject); - case GDI_OBJECT_TYPE_COLORSPACE: - return NtGdiDeleteColorSpace((HCOLORSPACE) hObject); - case GDI_OBJECT_TYPE_REGION: - return DeleteRegion((HRGN) hObject); + switch (Type) + { + case GDI_OBJECT_TYPE_DC: + return DeleteDC((HDC) hObject); + case GDI_OBJECT_TYPE_COLORSPACE: + return NtGdiDeleteColorSpace((HCOLORSPACE) hObject); + case GDI_OBJECT_TYPE_REGION: + return DeleteRegion((HRGN) hObject); #if 0 - case GDI_OBJECT_TYPE_METADC: - return MFDRV_DeleteObject( hObject ); - case GDI_OBJECT_TYPE_EMF: - { - PLDC pLDC = GdiGetLDC(hObject); - if ( !pLDC ) return FALSE; - return EMFDRV_DeleteObject( hObject ); - } + case GDI_OBJECT_TYPE_METADC: + return MFDRV_DeleteObject( hObject ); + case GDI_OBJECT_TYPE_EMF: + { + PLDC pLDC = GdiGetLDC(hObject); + if ( !pLDC ) return FALSE; + return EMFDRV_DeleteObject( hObject ); + } #endif - case GDI_OBJECT_TYPE_FONT: - break; + case GDI_OBJECT_TYPE_FONT: + break; - case GDI_OBJECT_TYPE_BRUSH: - case GDI_OBJECT_TYPE_EXTPEN: - case GDI_OBJECT_TYPE_PEN: - { - PBRUSH_ATTR Brh_Attr; - PTEB pTeb; + case GDI_OBJECT_TYPE_BRUSH: + case GDI_OBJECT_TYPE_EXTPEN: + case GDI_OBJECT_TYPE_PEN: + { + PBRUSH_ATTR Brh_Attr; + PTEB pTeb; - if ((!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &Brh_Attr)) || - (Brh_Attr == NULL) ) break; + if ((!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &Brh_Attr)) || + (Brh_Attr == NULL) ) break; - pTeb = NtCurrentTeb(); + pTeb = NtCurrentTeb(); - if (pTeb->Win32ThreadInfo == NULL) break; + if (pTeb->Win32ThreadInfo == NULL) break; - if ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSOBJECT)) <= GDIBATCHBUFSIZE) - { - PGDIBSOBJECT pgO = (PGDIBSOBJECT)(&pTeb->GdiTebBatch.Buffer[0] + - pTeb->GdiTebBatch.Offset); - pgO->gbHdr.Cmd = GdiBCDelObj; - pgO->gbHdr.Size = sizeof(GDIBSOBJECT); - pgO->hgdiobj = hObject; + if ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSOBJECT)) <= GDIBATCHBUFSIZE) + { + PGDIBSOBJECT pgO = (PGDIBSOBJECT)(&pTeb->GdiTebBatch.Buffer[0] + + pTeb->GdiTebBatch.Offset); + pgO->gbHdr.Cmd = GdiBCDelObj; + pgO->gbHdr.Size = sizeof(GDIBSOBJECT); + pgO->hgdiobj = hObject; - pTeb->GdiTebBatch.Offset += sizeof(GDIBSOBJECT); - pTeb->GdiBatchCount++; - if (pTeb->GdiBatchCount >= GDI_BatchLimit) NtGdiFlush(); - return TRUE; - } - break; - } - case GDI_OBJECT_TYPE_BITMAP: - default: - break; - } - return NtGdiDeleteObjectApp(hObject); + pTeb->GdiTebBatch.Offset += sizeof(GDIBSOBJECT); + pTeb->GdiBatchCount++; + if (pTeb->GdiBatchCount >= GDI_BatchLimit) NtGdiFlush(); + return TRUE; + } + break; + } + case GDI_OBJECT_TYPE_BITMAP: + default: + break; + } + return NtGdiDeleteObjectApp(hObject); } INT WINAPI GetArcDirection( HDC hdc ) { - return GetDCDWord( hdc, GdiGetArcDirection, 0); + return GetDCDWord( hdc, GdiGetArcDirection, 0); } @@ -405,7 +409,7 @@ INT WINAPI SetArcDirection( HDC hdc, INT nDirection ) { - return GetAndSetDCDWord( hdc, GdiGetSetArcDirection, nDirection, 0, 0, 0 ); + return GetAndSetDCDWord( hdc, GdiGetSetArcDirection, nDirection, 0, 0, 0 ); } @@ -413,36 +417,36 @@ HGDIOBJ WINAPI GetDCObject( HDC hDC, INT iType) { - if((iType == GDI_OBJECT_TYPE_BRUSH) || - (iType == GDI_OBJECT_TYPE_EXTPEN)|| - (iType == GDI_OBJECT_TYPE_PEN) || - (iType == GDI_OBJECT_TYPE_COLORSPACE)) - { - HGDIOBJ hGO = NULL; - PDC_ATTR Dc_Attr; + if((iType == GDI_OBJECT_TYPE_BRUSH) || + (iType == GDI_OBJECT_TYPE_EXTPEN)|| + (iType == GDI_OBJECT_TYPE_PEN) || + (iType == GDI_OBJECT_TYPE_COLORSPACE)) + { + HGDIOBJ hGO = NULL; + PDC_ATTR Dc_Attr; - if (!hDC) return hGO; + if (!hDC) return hGO; - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return NULL; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return NULL; - switch (iType) - { - case GDI_OBJECT_TYPE_BRUSH: - hGO = Dc_Attr->hbrush; - break; + switch (iType) + { + case GDI_OBJECT_TYPE_BRUSH: + hGO = Dc_Attr->hbrush; + break; - case GDI_OBJECT_TYPE_EXTPEN: - case GDI_OBJECT_TYPE_PEN: - hGO = Dc_Attr->hpen; - break; + case GDI_OBJECT_TYPE_EXTPEN: + case GDI_OBJECT_TYPE_PEN: + hGO = Dc_Attr->hpen; + break; - case GDI_OBJECT_TYPE_COLORSPACE: - hGO = Dc_Attr->hColorSpace; - break; - } - return hGO; - } - return NtGdiGetDCObject( hDC, iType ); + case GDI_OBJECT_TYPE_COLORSPACE: + hGO = Dc_Attr->hColorSpace; + break; + } + return hGO; + } + return NtGdiGetDCObject( hDC, iType ); } @@ -457,30 +461,30 @@ GetCurrentObject(HDC hdc, { switch(uObjectType) { - case OBJ_EXTPEN: - case OBJ_PEN: + case OBJ_EXTPEN: + case OBJ_PEN: uObjectType = GDI_OBJECT_TYPE_PEN; break; - case OBJ_BRUSH: + case OBJ_BRUSH: uObjectType = GDI_OBJECT_TYPE_BRUSH; break; - case OBJ_PAL: + case OBJ_PAL: uObjectType = GDI_OBJECT_TYPE_PALETTE; break; - case OBJ_FONT: + case OBJ_FONT: uObjectType = GDI_OBJECT_TYPE_FONT; break; - case OBJ_BITMAP: + case OBJ_BITMAP: uObjectType = GDI_OBJECT_TYPE_BITMAP; break; - case OBJ_COLORSPACE: + case OBJ_COLORSPACE: uObjectType = GDI_OBJECT_TYPE_COLORSPACE; break; - /* tests show that OBJ_REGION is explicitly ignored */ - case OBJ_REGION: + /* tests show that OBJ_REGION is explicitly ignored */ + case OBJ_REGION: return NULL; - /* the SDK only mentions those above */ - default: + /* the SDK only mentions those above */ + default: SetLastError(ERROR_INVALID_PARAMETER); return NULL; } @@ -496,164 +500,164 @@ WINAPI GetDeviceCaps(HDC hDC, int i) { - PDC_ATTR Dc_Attr; - PLDC pLDC; - PDEVCAPS pDevCaps = GdiDevCaps; // Primary display device capabilities. - DPRINT("Device CAPS1\n"); + PDC_ATTR Dc_Attr; + PLDC pLDC; + PDEVCAPS pDevCaps = GdiDevCaps; // Primary display device capabilities. + DPRINT("Device CAPS1\n"); - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - { - if ( i == TECHNOLOGY) return DT_METAFILE; - return 0; - } - else - { - pLDC = GdiGetLDC(hDC); - if ( !pLDC ) + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) { - SetLastError(ERROR_INVALID_HANDLE); - return 0; + if ( i == TECHNOLOGY) return DT_METAFILE; + return 0; } - if (!(pLDC->Flags & LDC_DEVCAPS)) + else { - if (!NtGdiGetDeviceCapsAll(hDC, &pLDC->DevCaps)) - SetLastError(ERROR_INVALID_PARAMETER); - pLDC->Flags |= LDC_DEVCAPS; + pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (!(pLDC->Flags & LDC_DEVCAPS)) + { + if (!NtGdiGetDeviceCapsAll(hDC, &pLDC->DevCaps)) + SetLastError(ERROR_INVALID_PARAMETER); + pLDC->Flags |= LDC_DEVCAPS; + } + pDevCaps = &pLDC->DevCaps; } - pDevCaps = &pLDC->DevCaps; - } - } - else - { - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) - return 0; - if (!(Dc_Attr->ulDirty_ & DC_PRIMARY_DISPLAY) ) - return NtGdiGetDeviceCaps(hDC,i); - } - DPRINT("Device CAPS2\n"); + } + else + { + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) + return 0; + if (!(Dc_Attr->ulDirty_ & DC_PRIMARY_DISPLAY) ) + return NtGdiGetDeviceCaps(hDC,i); + } + DPRINT("Device CAPS2\n"); - switch (i) - { + switch (i) + { case DRIVERVERSION: - return pDevCaps->ulVersion; + return pDevCaps->ulVersion; case TECHNOLOGY: - return pDevCaps->ulTechnology; + return pDevCaps->ulTechnology; case HORZSIZE: - return pDevCaps->ulHorzSize; + return pDevCaps->ulHorzSize; case VERTSIZE: - return pDevCaps->ulVertSize; + return pDevCaps->ulVertSize; case HORZRES: - return pDevCaps->ulHorzRes; + return pDevCaps->ulHorzRes; case VERTRES: - return pDevCaps->ulVertRes; + return pDevCaps->ulVertRes; case LOGPIXELSX: - return pDevCaps->ulLogPixelsX; + return pDevCaps->ulLogPixelsX; case LOGPIXELSY: - return pDevCaps->ulLogPixelsY; + return pDevCaps->ulLogPixelsY; case BITSPIXEL: - return pDevCaps->ulBitsPixel; + return pDevCaps->ulBitsPixel; case PLANES: - return pDevCaps->ulPlanes; + return pDevCaps->ulPlanes; case NUMBRUSHES: - return -1; + return -1; case NUMPENS: - return pDevCaps->ulNumPens; + return pDevCaps->ulNumPens; case NUMFONTS: - return pDevCaps->ulNumFonts; + return pDevCaps->ulNumFonts; case NUMCOLORS: - return pDevCaps->ulNumColors; + return pDevCaps->ulNumColors; case ASPECTX: - return pDevCaps->ulAspectX; + return pDevCaps->ulAspectX; case ASPECTY: - return pDevCaps->ulAspectY; + return pDevCaps->ulAspectY; case ASPECTXY: - return pDevCaps->ulAspectXY; + return pDevCaps->ulAspectXY; case CLIPCAPS: - return CP_RECTANGLE; + return CP_RECTANGLE; case SIZEPALETTE: - return pDevCaps->ulSizePalette; + return pDevCaps->ulSizePalette; case NUMRESERVED: - return 20; + return 20; case COLORRES: - return pDevCaps->ulColorRes; + return pDevCaps->ulColorRes; case DESKTOPVERTRES: - return pDevCaps->ulVertRes; + return pDevCaps->ulVertRes; case DESKTOPHORZRES: - return pDevCaps->ulHorzRes; + return pDevCaps->ulHorzRes; case BLTALIGNMENT: - return pDevCaps->ulBltAlignment; + return pDevCaps->ulBltAlignment; case SHADEBLENDCAPS: - return pDevCaps->ulShadeBlend; + return pDevCaps->ulShadeBlend; case COLORMGMTCAPS: - return pDevCaps->ulColorMgmtCaps; + return pDevCaps->ulColorMgmtCaps; case PHYSICALWIDTH: - return pDevCaps->ulPhysicalWidth; + return pDevCaps->ulPhysicalWidth; case PHYSICALHEIGHT: - return pDevCaps->ulPhysicalHeight; + return pDevCaps->ulPhysicalHeight; case PHYSICALOFFSETX: - return pDevCaps->ulPhysicalOffsetX; + return pDevCaps->ulPhysicalOffsetX; case PHYSICALOFFSETY: - return pDevCaps->ulPhysicalOffsetY; + return pDevCaps->ulPhysicalOffsetY; case VREFRESH: - return pDevCaps->ulVRefresh; + return pDevCaps->ulVRefresh; case RASTERCAPS: - return pDevCaps->ulRasterCaps; + return pDevCaps->ulRasterCaps; case CURVECAPS: - return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE | - CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT); + return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE | + CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT); case LINECAPS: - return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE | - LC_STYLED | LC_WIDESTYLED | LC_INTERIORS); + return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE | + LC_STYLED | LC_WIDESTYLED | LC_INTERIORS); case POLYGONALCAPS: - return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE | - PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS); + return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE | + PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS); case TEXTCAPS: - return pDevCaps->ulTextCaps; + return pDevCaps->ulTextCaps; case PDEVICESIZE: case SCALINGFACTORX: case SCALINGFACTORY: default: - return 0; - } - return 0; + return 0; + } + return 0; } /* @@ -662,11 +666,11 @@ GetDeviceCaps(HDC hDC, DWORD WINAPI GetRelAbs( - HDC hdc, - DWORD dwIgnore - ) + HDC hdc, + DWORD dwIgnore +) { - return GetDCDWord( hdc, GdiGetRelAbs, 0); + return GetDCDWord( hdc, GdiGetRelAbs, 0); } @@ -676,11 +680,11 @@ GetRelAbs( INT WINAPI SetRelAbs( - HDC hdc, - INT Mode - ) + HDC hdc, + INT Mode +) { - return GetAndSetDCDWord( hdc, GdiGetSetRelAbs, Mode, 0, 0, 0 ); + return GetAndSetDCDWord( hdc, GdiGetSetRelAbs, Mode, 0, 0, 0 ); } @@ -691,35 +695,35 @@ DWORD WINAPI GetAndSetDCDWord( HDC hDC, INT u, DWORD dwIn, DWORD Unk1, DWORD Unk2, DWORD Unk3 ) { - BOOL Ret = TRUE; + BOOL Ret = TRUE; // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return 0; //call MFDRV - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - Ret = TRUE; //call EMFDRV - if (Ret) - return u; - return 0; - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return 0; //call MFDRV + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + Ret = TRUE; //call EMFDRV + if (Ret) + return u; + return 0; + } + } } - } - Ret = NtGdiGetAndSetDCDword( hDC, u, dwIn, (DWORD*) &u ); - if (Ret) - return u; - else - SetLastError(ERROR_INVALID_HANDLE); - return 0; + Ret = NtGdiGetAndSetDCDword( hDC, u, dwIn, (DWORD*) &u ); + if (Ret) + return u; + else + SetLastError(ERROR_INVALID_HANDLE); + return 0; } @@ -730,9 +734,9 @@ DWORD WINAPI GetDCDWord( HDC hDC, INT u, DWORD Result ) { - BOOL Ret = NtGdiGetDCDword( hDC, u, (DWORD*) &u ); - if (!Ret) return Result; - else return u; + BOOL Ret = NtGdiGetDCDword( hDC, u, (DWORD*) &u ); + if (!Ret) return Result; + else return u; } @@ -742,11 +746,11 @@ GetDCDWord( HDC hDC, INT u, DWORD Result ) BOOL WINAPI GetAspectRatioFilterEx( - HDC hdc, - LPSIZE lpAspectRatio - ) + HDC hdc, + LPSIZE lpAspectRatio +) { - return NtGdiGetDCPoint( hdc, GdiGetAspectRatioFilter, (PPOINTL) lpAspectRatio ); + return NtGdiGetDCPoint( hdc, GdiGetAspectRatioFilter, (PPOINTL) lpAspectRatio ); } @@ -758,9 +762,9 @@ WINAPI GetDCOrgEx( HDC hdc, LPPOINT lpPoint - ) +) { - return NtGdiGetDCPoint( hdc, GdiGetDCOrg, (PPOINTL)lpPoint ); + return NtGdiGetDCPoint( hdc, GdiGetDCOrg, (PPOINTL)lpPoint ); } @@ -771,58 +775,58 @@ LONG WINAPI GetDCOrg( HDC hdc - ) +) { - // Officially obsolete by Microsoft - POINT Pt; - if (!GetDCOrgEx(hdc, &Pt)) - return 0; - return(MAKELONG(Pt.x, Pt.y)); + // Officially obsolete by Microsoft + POINT Pt; + if (!GetDCOrgEx(hdc, &Pt)) + return 0; + return(MAKELONG(Pt.x, Pt.y)); } int GetNonFontObject(HGDIOBJ hGdiObj, int cbSize, LPVOID lpBuffer) { - INT dwType; + INT dwType; - hGdiObj = (HANDLE)GdiFixUpHandle(hGdiObj); - dwType = GDI_HANDLE_GET_TYPE(hGdiObj); + hGdiObj = (HANDLE)GdiFixUpHandle(hGdiObj); + dwType = GDI_HANDLE_GET_TYPE(hGdiObj); + + if (!lpBuffer) // Should pass it all to Win32k and let god sort it out. ;^) + { + switch(dwType) + { + case GDI_OBJECT_TYPE_PEN: + return sizeof(LOGPEN); + case GDI_OBJECT_TYPE_BRUSH: + return sizeof(LOGBRUSH); + case GDI_OBJECT_TYPE_BITMAP: + return sizeof(BITMAP); + case GDI_OBJECT_TYPE_PALETTE: + return sizeof(WORD); + case GDI_OBJECT_TYPE_EXTPEN: /* we don't know the size, ask win32k */ + break; + } + } - if (!lpBuffer) // Should pass it all to Win32k and let god sort it out. ;^) - { switch(dwType) { - case GDI_OBJECT_TYPE_PEN: - return sizeof(LOGPEN); - case GDI_OBJECT_TYPE_BRUSH: - return sizeof(LOGBRUSH); - case GDI_OBJECT_TYPE_BITMAP: - return sizeof(BITMAP); - case GDI_OBJECT_TYPE_PALETTE: - return sizeof(WORD); - case GDI_OBJECT_TYPE_EXTPEN: /* we don't know the size, ask win32k */ - break; - } - } - - switch(dwType) - { case GDI_OBJECT_TYPE_PEN: //Check the structures and see if A & W are the same. case GDI_OBJECT_TYPE_EXTPEN: case GDI_OBJECT_TYPE_BRUSH: // Mixing Apples and Oranges? case GDI_OBJECT_TYPE_BITMAP: case GDI_OBJECT_TYPE_PALETTE: - return NtGdiExtGetObjectW(hGdiObj, cbSize, lpBuffer); + return NtGdiExtGetObjectW(hGdiObj, cbSize, lpBuffer); case GDI_OBJECT_TYPE_DC: case GDI_OBJECT_TYPE_REGION: case GDI_OBJECT_TYPE_METAFILE: case GDI_OBJECT_TYPE_ENHMETAFILE: case GDI_OBJECT_TYPE_EMF: - SetLastError(ERROR_INVALID_HANDLE); - } - return 0; + SetLastError(ERROR_INVALID_HANDLE); + } + return 0; } @@ -833,62 +837,62 @@ int WINAPI GetObjectA(HGDIOBJ hGdiObj, int cbSize, LPVOID lpBuffer) { - ENUMLOGFONTEXDVW LogFont; - DWORD dwType; - INT Result = 0; + ENUMLOGFONTEXDVW LogFont; + DWORD dwType; + INT Result = 0; - dwType = GDI_HANDLE_GET_TYPE(hGdiObj); + dwType = GDI_HANDLE_GET_TYPE(hGdiObj); - if(dwType == GDI_OBJECT_TYPE_COLORSPACE) //Stays here, processes struct A - { - SetLastError(ERROR_NOT_SUPPORTED); - return 0; - } - - if (dwType == GDI_OBJECT_TYPE_FONT) - { - if (!lpBuffer) + if(dwType == GDI_OBJECT_TYPE_COLORSPACE) //Stays here, processes struct A { - return sizeof(LOGFONTA); - } - if (cbSize == 0) - { - /* Windows does not SetLastError() */ - return 0; - } - // ENUMLOGFONTEXDVW is the default size and should be the structure for - // Entry->KernelData for Font objects. - Result = NtGdiExtGetObjectW(hGdiObj, sizeof(ENUMLOGFONTEXDVW), &LogFont); - - if (0 == Result) - { - return 0; + SetLastError(ERROR_NOT_SUPPORTED); + return 0; } - switch (cbSize) - { - case sizeof(ENUMLOGFONTEXDVA): - // need to move more here. - case sizeof(ENUMLOGFONTEXA): + if (dwType == GDI_OBJECT_TYPE_FONT) + { + if (!lpBuffer) + { + return sizeof(LOGFONTA); + } + if (cbSize == 0) + { + /* Windows does not SetLastError() */ + return 0; + } + // ENUMLOGFONTEXDVW is the default size and should be the structure for + // Entry->KernelData for Font objects. + Result = NtGdiExtGetObjectW(hGdiObj, sizeof(ENUMLOGFONTEXDVW), &LogFont); + + if (0 == Result) + { + return 0; + } + + switch (cbSize) + { + case sizeof(ENUMLOGFONTEXDVA): + // need to move more here. + case sizeof(ENUMLOGFONTEXA): EnumLogFontExW2A( (LPENUMLOGFONTEXA) lpBuffer, &LogFont.elfEnumLogfontEx ); break; - case sizeof(ENUMLOGFONTA): - // Same here, maybe? Check the structures. - case sizeof(EXTLOGFONTA): - // Same here - case sizeof(LOGFONTA): + case sizeof(ENUMLOGFONTA): + // Same here, maybe? Check the structures. + case sizeof(EXTLOGFONTA): + // Same here + case sizeof(LOGFONTA): LogFontW2A((LPLOGFONTA) lpBuffer, &LogFont.elfEnumLogfontEx.elfLogFont); break; - default: + default: SetLastError(ERROR_BUFFER_OVERFLOW); return 0; - } - return cbSize; - } + } + return cbSize; + } - return GetNonFontObject(hGdiObj, cbSize, lpBuffer); + return GetNonFontObject(hGdiObj, cbSize, lpBuffer); } @@ -899,47 +903,47 @@ int WINAPI GetObjectW(HGDIOBJ hGdiObj, int cbSize, LPVOID lpBuffer) { - DWORD dwType = GDI_HANDLE_GET_TYPE(hGdiObj); - INT Result = 0; + DWORD dwType = GDI_HANDLE_GET_TYPE(hGdiObj); + INT Result = 0; -/* - Check List: - MSDN, "This can be a handle to one of the following: logical bitmap, a brush, - a font, a palette, a pen, or a device independent bitmap created by calling - the CreateDIBSection function." - */ - if(dwType == GDI_OBJECT_TYPE_COLORSPACE) //Stays here, processes struct W - { - SetLastError(ERROR_NOT_SUPPORTED); // Not supported yet. - return 0; - } - - if (dwType == GDI_OBJECT_TYPE_FONT) - { - if (!lpBuffer) + /* + Check List: + MSDN, "This can be a handle to one of the following: logical bitmap, a brush, + a font, a palette, a pen, or a device independent bitmap created by calling + the CreateDIBSection function." + */ + if(dwType == GDI_OBJECT_TYPE_COLORSPACE) //Stays here, processes struct W { - return sizeof(LOGFONTW); + SetLastError(ERROR_NOT_SUPPORTED); // Not supported yet. + return 0; } - if (cbSize == 0) + if (dwType == GDI_OBJECT_TYPE_FONT) { - /* Windows does not SetLastError() */ - return 0; + if (!lpBuffer) + { + return sizeof(LOGFONTW); + } + + if (cbSize == 0) + { + /* Windows does not SetLastError() */ + return 0; + } + // Poorly written apps are not ReactOS problem! + // We fix it here if the size is larger than the default size. + if( cbSize > (int)sizeof(ENUMLOGFONTEXDVW) ) cbSize = sizeof(ENUMLOGFONTEXDVW); + + Result = NtGdiExtGetObjectW(hGdiObj, cbSize, lpBuffer); // Should handle the copy. + + if (0 == Result) + { + return 0; + } + return cbSize; } - // Poorly written apps are not ReactOS problem! - // We fix it here if the size is larger than the default size. - if( cbSize > (int)sizeof(ENUMLOGFONTEXDVW) ) cbSize = sizeof(ENUMLOGFONTEXDVW); - Result = NtGdiExtGetObjectW(hGdiObj, cbSize, lpBuffer); // Should handle the copy. - - if (0 == Result) - { - return 0; - } - return cbSize; - } - - return GetNonFontObject(hGdiObj, cbSize, lpBuffer); + return GetNonFontObject(hGdiObj, cbSize, lpBuffer); } @@ -949,13 +953,13 @@ GetObjectW(HGDIOBJ hGdiObj, int cbSize, LPVOID lpBuffer) COLORREF WINAPI GetDCBrushColor( - HDC hdc + HDC hdc ) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return CLR_INVALID; - return (COLORREF) Dc_Attr->ulBrushClr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return CLR_INVALID; + return (COLORREF) Dc_Attr->ulBrushClr; } /* @@ -964,13 +968,13 @@ GetDCBrushColor( COLORREF WINAPI GetDCPenColor( - HDC hdc + HDC hdc ) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return CLR_INVALID; - return (COLORREF) Dc_Attr->ulPenClr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return CLR_INVALID; + return (COLORREF) Dc_Attr->ulPenClr; } /* @@ -979,26 +983,26 @@ GetDCPenColor( COLORREF WINAPI SetDCBrushColor( - HDC hdc, - COLORREF crColor + HDC hdc, + COLORREF crColor ) { - PDC_ATTR Dc_Attr; - COLORREF OldColor = CLR_INVALID; + PDC_ATTR Dc_Attr; + COLORREF OldColor = CLR_INVALID; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; - else - { - OldColor = (COLORREF) Dc_Attr->ulBrushClr; - Dc_Attr->ulBrushClr = (ULONG) crColor; - - if ( Dc_Attr->crBrushClr != crColor ) // if same, don't force a copy. + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; + else { - Dc_Attr->ulDirty_ |= DIRTY_FILL; - Dc_Attr->crBrushClr = crColor; + OldColor = (COLORREF) Dc_Attr->ulBrushClr; + Dc_Attr->ulBrushClr = (ULONG) crColor; + + if ( Dc_Attr->crBrushClr != crColor ) // if same, don't force a copy. + { + Dc_Attr->ulDirty_ |= DIRTY_FILL; + Dc_Attr->crBrushClr = crColor; + } } - } - return OldColor; + return OldColor; } /* @@ -1007,26 +1011,26 @@ SetDCBrushColor( COLORREF WINAPI SetDCPenColor( - HDC hdc, - COLORREF crColor + HDC hdc, + COLORREF crColor ) { - PDC_ATTR Dc_Attr; - COLORREF OldColor = CLR_INVALID; + PDC_ATTR Dc_Attr; + COLORREF OldColor = CLR_INVALID; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; - else - { - OldColor = (COLORREF) Dc_Attr->ulPenClr; - Dc_Attr->ulPenClr = (ULONG) crColor; - - if ( Dc_Attr->crPenClr != crColor ) + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; + else { - Dc_Attr->ulDirty_ |= DIRTY_LINE; - Dc_Attr->crPenClr = crColor; + OldColor = (COLORREF) Dc_Attr->ulPenClr; + Dc_Attr->ulPenClr = (ULONG) crColor; + + if ( Dc_Attr->crPenClr != crColor ) + { + Dc_Attr->ulDirty_ |= DIRTY_LINE; + Dc_Attr->crPenClr = crColor; + } } - } - return OldColor; + return OldColor; } /* @@ -1037,9 +1041,9 @@ COLORREF WINAPI GetBkColor(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->ulBackgroundClr; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->ulBackgroundClr; } /* @@ -1048,43 +1052,43 @@ GetBkColor(HDC hdc) COLORREF WINAPI SetBkColor( - HDC hdc, - COLORREF crColor + HDC hdc, + COLORREF crColor ) { - PDC_ATTR Dc_Attr; - COLORREF OldColor = CLR_INVALID; + PDC_ATTR Dc_Attr; + COLORREF OldColor = CLR_INVALID; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetBkColor( hDC, crColor ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetBkColor( hDC, crColor ); - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetBkColor( hDC, crColor ); + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetBkColor( hDC, crColor ); + } + } } - } #endif - OldColor = (COLORREF) Dc_Attr->ulBackgroundClr; - Dc_Attr->ulBackgroundClr = (ULONG) crColor; + OldColor = (COLORREF) Dc_Attr->ulBackgroundClr; + Dc_Attr->ulBackgroundClr = (ULONG) crColor; - if ( Dc_Attr->crBackgroundClr != crColor ) - { - Dc_Attr->ulDirty_ |= (DIRTY_BACKGROUND|DIRTY_LINE|DIRTY_FILL); - Dc_Attr->crBackgroundClr = crColor; - } - return OldColor; + if ( Dc_Attr->crBackgroundClr != crColor ) + { + Dc_Attr->ulDirty_ |= (DIRTY_BACKGROUND|DIRTY_LINE|DIRTY_FILL); + Dc_Attr->crBackgroundClr = crColor; + } + return OldColor; } /* @@ -1095,9 +1099,9 @@ int WINAPI GetBkMode(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->lBkMode; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->lBkMode; } /* @@ -1107,36 +1111,36 @@ GetBkMode(HDC hdc) int WINAPI SetBkMode(HDC hdc, - int iBkMode) + int iBkMode) { - PDC_ATTR Dc_Attr; - INT OldMode = 0; + PDC_ATTR Dc_Attr; + INT OldMode = 0; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldMode; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldMode; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetBkMode( hdc, iBkMode ) - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetBkMode( hdc, iBkMode ) - } - } - } + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetBkMode( hdc, iBkMode ) + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetBkMode( hdc, iBkMode ) + } + } + } #endif - OldMode = Dc_Attr->lBkMode; - Dc_Attr->jBkMode = iBkMode; // Processed - Dc_Attr->lBkMode = iBkMode; // Raw - return OldMode; + OldMode = Dc_Attr->lBkMode; + Dc_Attr->jBkMode = iBkMode; // Processed + Dc_Attr->lBkMode = iBkMode; // Raw + return OldMode; } /* @@ -1147,9 +1151,9 @@ int WINAPI GetPolyFillMode(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->lFillMode; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->lFillMode; } /* @@ -1160,43 +1164,43 @@ WINAPI SetPolyFillMode(HDC hdc, int iPolyFillMode) { - INT fmode; - PDC_ATTR Dc_Attr; + INT fmode; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetPolyFillMode( hdc, iPolyFillMode ) - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetPolyFillMode( hdc, iPolyFillMode ) - } - } - } + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetPolyFillMode( hdc, iPolyFillMode ) + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetPolyFillMode( hdc, iPolyFillMode ) + } + } + } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) - { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) + { + if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } - fmode = Dc_Attr->lFillMode; - Dc_Attr->lFillMode = iPolyFillMode; + fmode = Dc_Attr->lFillMode; + Dc_Attr->lFillMode = iPolyFillMode; - return fmode; + return fmode; } /* @@ -1207,9 +1211,9 @@ int WINAPI GetGraphicsMode(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->iGraphicsMode; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->iGraphicsMode; } /* @@ -1220,34 +1224,34 @@ WINAPI SetGraphicsMode(HDC hdc, int iMode) { - INT oMode; - PDC_ATTR Dc_Attr; - if ((iMode < GM_COMPATIBLE) || (iMode > GM_ADVANCED)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + INT oMode; + PDC_ATTR Dc_Attr; + if ((iMode < GM_COMPATIBLE) || (iMode > GM_ADVANCED)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - if (iMode == Dc_Attr->iGraphicsMode) return iMode; + if (iMode == Dc_Attr->iGraphicsMode) return iMode; - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) - { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } -/* One would think that setting the graphics mode to GM_COMPATIBLE - * would also reset the world transformation matrix to the unity - * matrix. However, in Windows, this is not the case. This doesn't - * make a lot of sense to me, but that's the way it is. - */ - oMode = Dc_Attr->iGraphicsMode; - Dc_Attr->iGraphicsMode = iMode; + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) + { + if (Dc_Attr->ulDirty_ & DC_MODE_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + /* One would think that setting the graphics mode to GM_COMPATIBLE + * would also reset the world transformation matrix to the unity + * matrix. However, in Windows, this is not the case. This doesn't + * make a lot of sense to me, but that's the way it is. + */ + oMode = Dc_Attr->iGraphicsMode; + Dc_Attr->iGraphicsMode = iMode; - return oMode; + return oMode; } /* @@ -1256,12 +1260,12 @@ SetGraphicsMode(HDC hdc, HDC WINAPI ResetDCW( - HDC hdc, - CONST DEVMODEW *lpInitData - ) + HDC hdc, + CONST DEVMODEW *lpInitData +) { - NtGdiResetDC ( hdc, (PDEVMODEW)lpInitData, NULL, NULL, NULL); - return hdc; + NtGdiResetDC ( hdc, (PDEVMODEW)lpInitData, NULL, NULL, NULL); + return hdc; } @@ -1271,17 +1275,17 @@ ResetDCW( HDC WINAPI ResetDCA( - HDC hdc, - CONST DEVMODEA *lpInitData - ) + HDC hdc, + CONST DEVMODEA *lpInitData +) { - LPDEVMODEW InitDataW; + LPDEVMODEW InitDataW; - InitDataW = GdiConvertToDevmodeW((LPDEVMODEA)lpInitData); + InitDataW = GdiConvertToDevmodeW((LPDEVMODEA)lpInitData); - NtGdiResetDC ( hdc, InitDataW, NULL, NULL, NULL); - HEAP_free(InitDataW); - return hdc; + NtGdiResetDC ( hdc, InitDataW, NULL, NULL, NULL); + HEAP_free(InitDataW); + return hdc; } @@ -1291,67 +1295,67 @@ ResetDCA( DWORD WINAPI GetObjectType( - HGDIOBJ h - ) + HGDIOBJ h +) { - DWORD Ret = 0; + DWORD Ret = 0; - if(GdiIsHandleValid(h)) - { - LONG Type = GDI_HANDLE_GET_TYPE(h); - switch(Type) + if(GdiIsHandleValid(h)) { - case GDI_OBJECT_TYPE_PEN: - Ret = OBJ_PEN; - break; - case GDI_OBJECT_TYPE_BRUSH: - Ret = OBJ_BRUSH; - break; - case GDI_OBJECT_TYPE_BITMAP: - Ret = OBJ_BITMAP; - break; - case GDI_OBJECT_TYPE_FONT: - Ret = OBJ_FONT; - break; - case GDI_OBJECT_TYPE_PALETTE: - Ret = OBJ_PAL; - break; - case GDI_OBJECT_TYPE_REGION: - Ret = OBJ_REGION; - break; - case GDI_OBJECT_TYPE_DC: - if ( GetDCDWord( h, GdiGetIsMemDc, 0)) + LONG Type = GDI_HANDLE_GET_TYPE(h); + switch(Type) { - Ret = OBJ_MEMDC; - } - else - Ret = OBJ_DC; - break; - case GDI_OBJECT_TYPE_COLORSPACE: - Ret = OBJ_COLORSPACE; - break; - case GDI_OBJECT_TYPE_METAFILE: - Ret = OBJ_METAFILE; - break; - case GDI_OBJECT_TYPE_ENHMETAFILE: - Ret = OBJ_ENHMETAFILE; - break; - case GDI_OBJECT_TYPE_METADC: - Ret = OBJ_METADC; - break; - case GDI_OBJECT_TYPE_EXTPEN: - Ret = OBJ_EXTPEN; - break; + case GDI_OBJECT_TYPE_PEN: + Ret = OBJ_PEN; + break; + case GDI_OBJECT_TYPE_BRUSH: + Ret = OBJ_BRUSH; + break; + case GDI_OBJECT_TYPE_BITMAP: + Ret = OBJ_BITMAP; + break; + case GDI_OBJECT_TYPE_FONT: + Ret = OBJ_FONT; + break; + case GDI_OBJECT_TYPE_PALETTE: + Ret = OBJ_PAL; + break; + case GDI_OBJECT_TYPE_REGION: + Ret = OBJ_REGION; + break; + case GDI_OBJECT_TYPE_DC: + if ( GetDCDWord( h, GdiGetIsMemDc, 0)) + { + Ret = OBJ_MEMDC; + } + else + Ret = OBJ_DC; + break; + case GDI_OBJECT_TYPE_COLORSPACE: + Ret = OBJ_COLORSPACE; + break; + case GDI_OBJECT_TYPE_METAFILE: + Ret = OBJ_METAFILE; + break; + case GDI_OBJECT_TYPE_ENHMETAFILE: + Ret = OBJ_ENHMETAFILE; + break; + case GDI_OBJECT_TYPE_METADC: + Ret = OBJ_METADC; + break; + case GDI_OBJECT_TYPE_EXTPEN: + Ret = OBJ_EXTPEN; + break; - default: - DPRINT1("GetObjectType: Magic 0x%08x not implemented\n", Type); - break; + default: + DPRINT1("GetObjectType: Magic 0x%08x not implemented\n", Type); + break; + } } - } - else - /* From Wine: GetObjectType does SetLastError() on a null object */ - SetLastError(ERROR_INVALID_HANDLE); - return Ret; + else + /* From Wine: GetObjectType does SetLastError() on a null object */ + SetLastError(ERROR_INVALID_HANDLE); + return Ret; } @@ -1361,29 +1365,29 @@ GetObjectType( HGDIOBJ WINAPI GetStockObject( - INT h - ) + INT h +) { - HGDIOBJ Ret = NULL; - if ((h < 0) || (h >= NB_STOCK_OBJECTS)) return Ret; - Ret = stock_objects[h]; - if (!Ret) - { - HGDIOBJ Obj = NtGdiGetStockObject( h ); + HGDIOBJ Ret = NULL; + if ((h < 0) || (h >= NB_STOCK_OBJECTS)) return Ret; + Ret = stock_objects[h]; + if (!Ret) + { + HGDIOBJ Obj = NtGdiGetStockObject( h ); - if (GdiIsHandleValid(Obj)) - { - stock_objects[h] = Obj; - return Obj; - }// Returns Null anyway. - } - return Ret; + if (GdiIsHandleValid(Obj)) + { + stock_objects[h] = Obj; + return Obj; + }// Returns Null anyway. + } + return Ret; } /* FIXME: include correct header */ HPALETTE WINAPI NtUserSelectPalette(HDC hDC, - HPALETTE hpal, - BOOL ForceBackground); + HPALETTE hpal, + BOOL ForceBackground); HPALETTE WINAPI @@ -1393,24 +1397,24 @@ SelectPalette( BOOL bForceBackground) { #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SelectPalette( hDC, hPal, bForceBackground); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return NULL; - } - if (pLDC->iType == LDC_EMFLDC) - { - if return EMFDRV_SelectPalette( hDC, hPal, bForceBackground); - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SelectPalette( hDC, hPal, bForceBackground); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + if (pLDC->iType == LDC_EMFLDC) + { + if return EMFDRV_SelectPalette( hDC, hPal, bForceBackground); + } + } } - } #endif return NtUserSelectPalette(hDC, hPal, bForceBackground); } @@ -1423,9 +1427,9 @@ int WINAPI GetMapMode(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->iMapMode; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->iMapMode; } /* @@ -1434,129 +1438,129 @@ GetMapMode(HDC hdc) INT WINAPI SetMapMode( - HDC hdc, - INT Mode - ) + HDC hdc, + INT Mode +) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetMapMode(hdc, Mode); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetMapMode(hdc, Mode); + else + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } #endif - // Force change if Isotropic is set for recompute. - if ((Mode != Dc_Attr->iMapMode) || (Mode == MM_ISOTROPIC)) - { - Dc_Attr->ulDirty_ &= ~SLOW_WIDTHS; - return GetAndSetDCDWord( hdc, GdiGetSetMapMode, Mode, 0, 0, 0 ); - } - return Dc_Attr->iMapMode; -} + // Force change if Isotropic is set for recompute. + if ((Mode != Dc_Attr->iMapMode) || (Mode == MM_ISOTROPIC)) + { + Dc_Attr->ulDirty_ &= ~SLOW_WIDTHS; + return GetAndSetDCDWord( hdc, GdiGetSetMapMode, Mode, 0, 0, 0 ); + } + return Dc_Attr->iMapMode; + } -/* - * @implemented - * - */ -int -WINAPI -GetStretchBltMode(HDC hdc) -{ - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->lStretchBltMode; -} + /* + * @implemented + * + */ + int + WINAPI + GetStretchBltMode(HDC hdc) + { + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->lStretchBltMode; + } -/* - * @implemented - */ -int -WINAPI -SetStretchBltMode(HDC hdc, int iStretchMode) -{ - INT oSMode; - PDC_ATTR Dc_Attr; + /* + * @implemented + */ + int + WINAPI + SetStretchBltMode(HDC hdc, int iStretchMode) + { + INT oSMode; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetStretchBltMode( hdc, iStretchMode); - else - { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetStretchBltMode( hdc, iStretchMode); - } - } - } + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetStretchBltMode( hdc, iStretchMode); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetStretchBltMode( hdc, iStretchMode); + } + } + } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - oSMode = Dc_Attr->lStretchBltMode; - Dc_Attr->lStretchBltMode = iStretchMode; + oSMode = Dc_Attr->lStretchBltMode; + Dc_Attr->lStretchBltMode = iStretchMode; - // Wine returns an error here. We set the default. - if ((iStretchMode <= 0) || (iStretchMode > MAXSTRETCHBLTMODE)) iStretchMode = WHITEONBLACK; + // Wine returns an error here. We set the default. + if ((iStretchMode <= 0) || (iStretchMode > MAXSTRETCHBLTMODE)) iStretchMode = WHITEONBLACK; - Dc_Attr->jStretchBltMode = iStretchMode; + Dc_Attr->jStretchBltMode = iStretchMode; - return oSMode; -} - -/* - * @implemented - */ -HFONT -WINAPI -GetHFONT(HDC hdc) -{ - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return NULL; - return Dc_Attr->hlfntNew; -} - - -/* - * @implemented - * - */ -HGDIOBJ -WINAPI -SelectObject(HDC hDC, - HGDIOBJ hGdiObj) -{ - PDC_ATTR pDc_Attr; - HGDIOBJ hOldObj = NULL; - UINT uType; - - if(!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - { - SetLastError(ERROR_INVALID_HANDLE); - return NULL; + return oSMode; } - hGdiObj = GdiFixUpHandle(hGdiObj); - if (!GdiIsHandleValid(hGdiObj)) + /* + * @implemented + */ + HFONT + WINAPI + GetHFONT(HDC hdc) { - return NULL; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return NULL; + return Dc_Attr->hlfntNew; } - uType = GDI_HANDLE_GET_TYPE(hGdiObj); - switch (uType) + /* + * @implemented + * + */ + HGDIOBJ + WINAPI + SelectObject(HDC hDC, + HGDIOBJ hGdiObj) { + PDC_ATTR pDc_Attr; + HGDIOBJ hOldObj = NULL; + UINT uType; + + if(!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) + { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + + hGdiObj = GdiFixUpHandle(hGdiObj); + if (!GdiIsHandleValid(hGdiObj)) + { + return NULL; + } + + uType = GDI_HANDLE_GET_TYPE(hGdiObj); + + switch (uType) + { case GDI_OBJECT_TYPE_REGION: return (HGDIOBJ)ExtSelectClipRgn(hDC, hGdiObj, RGN_COPY); @@ -1617,7 +1621,7 @@ SelectObject(HDC hDC, default: SetLastError(ERROR_INVALID_FUNCTION); return NULL; - } + } - return NULL; -} + return NULL; + } diff --git a/reactos/dll/win32/gdi32/objects/eng.c b/reactos/dll/win32/gdi32/objects/eng.c index d29adf08a08..51144b233a0 100644 --- a/reactos/dll/win32/gdi32/objects/eng.c +++ b/reactos/dll/win32/gdi32/objects/eng.c @@ -156,16 +156,16 @@ EngGetCurrentCodePage( OUT PUSHORT OemCodePage, LPWSTR WINAPI EngGetDriverName(HDEV hdev) { - // DHPDEV from NtGdiGetDhpdev must be from print driver. - PUMPDEV pPDev = (PUMPDEV)NtGdiGetDhpdev(hdev); + // DHPDEV from NtGdiGetDhpdev must be from print driver. + PUMPDEV pPDev = (PUMPDEV)NtGdiGetDhpdev(hdev); - if (!pPDev) return NULL; - - if (pPDev->Sig != PDEV_UMPD_ID) - { - pPDev = (PUMPDEV)pPDev->Sig; - } - return pPDev->pdi5Info->pDriverPath; + if (!pPDev) return NULL; + + if (pPDev->Sig != PDEV_UMPD_ID) + { + pPDev = (PUMPDEV)pPDev->Sig; + } + return pPDev->pdi5Info->pDriverPath; } /* @@ -174,15 +174,15 @@ EngGetDriverName(HDEV hdev) LPWSTR WINAPI EngGetPrinterDataFileName(HDEV hdev) { - PUMPDEV pPDev = (PUMPDEV)NtGdiGetDhpdev(hdev); + PUMPDEV pPDev = (PUMPDEV)NtGdiGetDhpdev(hdev); - if (!pPDev) return NULL; + if (!pPDev) return NULL; - if (pPDev->Sig != PDEV_UMPD_ID) - { - pPDev = (PUMPDEV)pPDev->Sig; - } - return pPDev->pdi5Info->pDataFile; + if (pPDev->Sig != PDEV_UMPD_ID) + { + pPDev = (PUMPDEV)pPDev->Sig; + } + return pPDev->pdi5Info->pDataFile; } /* @@ -191,7 +191,7 @@ EngGetPrinterDataFileName(HDEV hdev) HANDLE WINAPI EngLoadModule(LPWSTR pwsz) { - return LoadLibraryExW ( pwsz, NULL, LOAD_LIBRARY_AS_DATAFILE); + return LoadLibraryExW ( pwsz, NULL, LOAD_LIBRARY_AS_DATAFILE); } /* @@ -204,7 +204,7 @@ EngMultiByteToWideChar(UINT CodePage, LPSTR MultiByteString, INT BytesInMultiByteString) { - return MultiByteToWideChar(CodePage,0,MultiByteString,BytesInMultiByteString,WideCharString,BytesInWideCharString / sizeof(WCHAR)); + return MultiByteToWideChar(CodePage,0,MultiByteString,BytesInMultiByteString,WideCharString,BytesInWideCharString / sizeof(WCHAR)); } /* @@ -213,16 +213,16 @@ EngMultiByteToWideChar(UINT CodePage, VOID WINAPI EngQueryLocalTime(PENG_TIME_FIELDS etf) { - SYSTEMTIME SystemTime; - GetLocalTime( &SystemTime ); - etf->usYear = SystemTime.wYear; - etf->usMonth = SystemTime.wMonth; - etf->usWeekday = SystemTime.wDayOfWeek; - etf->usDay = SystemTime.wDay; - etf->usHour = SystemTime.wHour; - etf->usMinute = SystemTime.wMinute; - etf->usSecond = SystemTime.wSecond; - etf->usMilliseconds = SystemTime.wMilliseconds; + SYSTEMTIME SystemTime; + GetLocalTime( &SystemTime ); + etf->usYear = SystemTime.wYear; + etf->usMonth = SystemTime.wMonth; + etf->usWeekday = SystemTime.wDayOfWeek; + etf->usDay = SystemTime.wDay; + etf->usHour = SystemTime.wHour; + etf->usMinute = SystemTime.wMinute; + etf->usSecond = SystemTime.wSecond; + etf->usMilliseconds = SystemTime.wMilliseconds; } /* @@ -232,7 +232,7 @@ VOID WINAPI EngReleaseSemaphore ( IN HSEMAPHORE hsem ) { - RtlLeaveCriticalSection( (PRTL_CRITICAL_SECTION) hsem); + RtlLeaveCriticalSection( (PRTL_CRITICAL_SECTION) hsem); } @@ -249,6 +249,6 @@ EngWideCharToMultiByte( UINT CodePage, LPSTR MultiByteString, INT BytesInMultiByteString) { - return WideCharToMultiByte(CodePage, 0, WideCharString, (BytesInWideCharString/sizeof(WCHAR)), - MultiByteString, BytesInMultiByteString, NULL, NULL); + return WideCharToMultiByte(CodePage, 0, WideCharString, (BytesInWideCharString/sizeof(WCHAR)), + MultiByteString, BytesInMultiByteString, NULL, NULL); } diff --git a/reactos/dll/win32/gdi32/objects/enhmfile.c b/reactos/dll/win32/gdi32/objects/enhmfile.c index 43d1f1f7d19..ec68f24c63a 100644 --- a/reactos/dll/win32/gdi32/objects/enhmfile.c +++ b/reactos/dll/win32/gdi32/objects/enhmfile.c @@ -6,15 +6,15 @@ /* - * @unimplemented + * @unimplemented */ HENHMETAFILE WINAPI CloseEnhMetaFile( - HDC hdc) + HDC hdc) { - UNIMPLEMENTED; - return 0; + UNIMPLEMENTED; + return 0; } @@ -26,7 +26,7 @@ CreateEnhMetaFileW( LPCWSTR filename, /* [in] optional filename for disk metafiles */ const RECT* rect, /* [in] optional bounding rectangle */ LPCWSTR description /* [in] optional description */ - ) +) { HDC mDC; PDC_ATTR Dc_Attr; @@ -40,8 +40,8 @@ CreateEnhMetaFileW( if ( !GdiGetHandleUserData((HGDIOBJ) mDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) { - SetLastError (ERROR_INVALID_PARAMETER); - return NULL; // need to delete the handle? + SetLastError (ERROR_INVALID_PARAMETER); + return NULL; // need to delete the handle? } pLDC = LocalAlloc(LMEM_ZEROINIT, sizeof(LDC)); @@ -51,8 +51,9 @@ CreateEnhMetaFileW( pLDC->iType = LDC_EMFDC - if (description) - { /* App name\0Title\0\0 */ + if (description) + { + /* App name\0Title\0\0 */ length = lstrlenW(description); length += lstrlenW(description + length + 1); length += 3; @@ -96,7 +97,8 @@ CreateEnhMetaFileW( EmfDC->emf->rclFrame.bottom = rect->bottom; } else - { /* Set this to {0,0 - -1,-1} and update it at the end */ + { + /* Set this to {0,0 - -1,-1} and update it at the end */ EmfDC->emf->rclFrame.left = EmfDC->emf->rclFrame.top = 0; EmfDC->emf->rclFrame.right = EmfDC->emf->rclFrame.bottom = -1; } @@ -131,7 +133,7 @@ CreateEnhMetaFileW( if (filename) /* disk based metafile */ { if ((hFile = CreateFileW(filename, GENERIC_WRITE | GENERIC_READ, 0, - NULL, CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) + NULL, CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) { EMFDRV_DeleteDC( EmfDC ); return NULL; @@ -140,9 +142,9 @@ CreateEnhMetaFileW( { EMFDRV_DeleteDC( EmfDC ); return NULL; - } - EmfDC.hFile = hFile; - EmfDC.iType = METAFILE_DISK; + } + EmfDC.hFile = hFile; + EmfDC.iType = METAFILE_DISK; } else EmfDC.iType = METAFILE_MEMORY; @@ -158,23 +160,23 @@ CreateEnhMetaFileW( HENHMETAFILE WINAPI CopyEnhMetaFileA( - HENHMETAFILE hemfSrc, - LPCSTR lpszFile) + HENHMETAFILE hemfSrc, + LPCSTR lpszFile) { - NTSTATUS Status; - LPWSTR lpszFileW; - HENHMETAFILE rc = 0; + NTSTATUS Status; + LPWSTR lpszFileW; + HENHMETAFILE rc = 0; - Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else + Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else { - rc = NULL; + rc = NULL; - HEAP_free ( lpszFileW ); + HEAP_free ( lpszFileW ); } - return rc; + return rc; } @@ -184,44 +186,44 @@ CopyEnhMetaFileA( HDC WINAPI CreateEnhMetaFileA( - HDC hdcRef, - LPCSTR lpFileName, - CONST RECT *lpRect, - LPCSTR lpDescription) + HDC hdcRef, + LPCSTR lpFileName, + CONST RECT *lpRect, + LPCSTR lpDescription) { - NTSTATUS Status; - LPWSTR lpFileNameW, lpDescriptionW; - HDC rc = 0; + NTSTATUS Status; + LPWSTR lpFileNameW, lpDescriptionW; + HDC rc = 0; - lpFileNameW = NULL; - if (lpFileName != NULL) - { - Status = HEAP_strdupA2W ( &lpFileNameW, lpFileName ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); + lpFileNameW = NULL; + if (lpFileName != NULL) + { + Status = HEAP_strdupA2W ( &lpFileNameW, lpFileName ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); - return rc; - } + return rc; + } - lpDescriptionW = NULL; - if (lpDescription != NULL) - { - Status = HEAP_strdupA2W ( &lpDescriptionW, lpDescription ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); + lpDescriptionW = NULL; + if (lpDescription != NULL) + { + Status = HEAP_strdupA2W ( &lpDescriptionW, lpDescription ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); - return rc; - } + return rc; + } - rc = NULL; + rc = NULL; - if (lpDescriptionW != NULL) - HEAP_free ( lpDescriptionW ); + if (lpDescriptionW != NULL) + HEAP_free ( lpDescriptionW ); - if (lpFileNameW != NULL) - HEAP_free ( lpFileNameW ); + if (lpFileNameW != NULL) + HEAP_free ( lpFileNameW ); - return rc; + return rc; } #if 0 @@ -229,201 +231,201 @@ CreateEnhMetaFileA( HDC WINAPI NtGdiCreateEnhMetaFile(HDC hDCRef, - LPCWSTR File, - CONST LPRECT Rect, - LPCWSTR Description) + LPCWSTR File, + CONST LPRECT Rect, + LPCWSTR Description) { - PDC Dc; - HDC ret = NULL; - DWORD length = 0; - HDC tempHDC; - DWORD MemSize; - DWORD dwDesiredAccess; + PDC Dc; + HDC ret = NULL; + DWORD length = 0; + HDC tempHDC; + DWORD MemSize; + DWORD dwDesiredAccess; - tempHDC = hDCRef; - if (hDCRef == NULL) - { - /* FIXME ?? - * Shall we create hdc NtGdiHdcCompatible hdc ?? - */ - UNICODE_STRING DriverName; - RtlInitUnicodeString(&DriverName, L"DISPLAY"); - //IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE); - tempHDC = NtGdiOpenDCW( &DriverName, - NULL, - NULL, - 0, // DCW 0 and ICW 1. - NULL, - (PVOID) NULL, - (PVOID) NULL ); - } + tempHDC = hDCRef; + if (hDCRef == NULL) + { + /* FIXME ?? + * Shall we create hdc NtGdiHdcCompatible hdc ?? + */ + UNICODE_STRING DriverName; + RtlInitUnicodeString(&DriverName, L"DISPLAY"); + //IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE); + tempHDC = NtGdiOpenDCW( &DriverName, + NULL, + NULL, + 0, // DCW 0 and ICW 1. + NULL, + (PVOID) NULL, + (PVOID) NULL ); + } - GDIOBJ_SetOwnership(GdiHandleTable, tempHDC, PsGetCurrentProcess()); - DC_SetOwnership(tempHDC, PsGetCurrentProcess()); + GDIOBJ_SetOwnership(GdiHandleTable, tempHDC, PsGetCurrentProcess()); + DC_SetOwnership(tempHDC, PsGetCurrentProcess()); - Dc = DC_LockDc(tempHDC); - if (Dc == NULL) - { - if (hDCRef == NULL) - { - NtGdiDeleteObjectApp(tempHDC); - } - SetLastWin32Error(ERROR_INVALID_HANDLE); - return NULL; - } + Dc = DC_LockDc(tempHDC); + if (Dc == NULL) + { + if (hDCRef == NULL) + { + NtGdiDeleteObjectApp(tempHDC); + } + SetLastWin32Error(ERROR_INVALID_HANDLE); + return NULL; + } - if(Description) - { - length = wcslen(Description); - length += wcslen(Description + length + 1); - length += 3; - length *= 2; - } + if(Description) + { + length = wcslen(Description); + length += wcslen(Description + length + 1); + length += 3; + length *= 2; + } - MemSize = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4; + MemSize = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4; - if (!(Dc->emh = EngAllocMem(FL_ZERO_MEMORY, MemSize, 0))) - { - DC_UnlockDc(Dc); - if (hDCRef == NULL) - { - NtGdiDeleteObjectApp(tempHDC); - } - SetLastWin32Error(ERROR_INVALID_HANDLE); - return NULL; - } + if (!(Dc->emh = EngAllocMem(FL_ZERO_MEMORY, MemSize, 0))) + { + DC_UnlockDc(Dc); + if (hDCRef == NULL) + { + NtGdiDeleteObjectApp(tempHDC); + } + SetLastWin32Error(ERROR_INVALID_HANDLE); + return NULL; + } - Dc->emh->iType = EMR_HEADER; - Dc->emh->nSize = MemSize; + Dc->emh->iType = EMR_HEADER; + Dc->emh->nSize = MemSize; - Dc->emh->rclBounds.left = Dc->emh->rclBounds.top = 0; - Dc->emh->rclBounds.right = Dc->emh->rclBounds.bottom = -1; + Dc->emh->rclBounds.left = Dc->emh->rclBounds.top = 0; + Dc->emh->rclBounds.right = Dc->emh->rclBounds.bottom = -1; - if(Rect) - { - Dc->emh->rclFrame.left = Rect->left; - Dc->emh->rclFrame.top = Rect->top; - Dc->emh->rclFrame.right = Rect->right; - Dc->emh->rclFrame.bottom = Rect->bottom; - } - else - { - /* Set this to {0,0 - -1,-1} and update it at the end */ - Dc->emh->rclFrame.left = Dc->emh->rclFrame.top = 0; - Dc->emh->rclFrame.right = Dc->emh->rclFrame.bottom = -1; - } - - Dc->emh->dSignature = ENHMETA_SIGNATURE; - Dc->emh->nVersion = 0x10000; - Dc->emh->nBytes = Dc->emh->nSize; - Dc->emh->nRecords = 1; - Dc->emh->nHandles = 1; - - Dc->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */ - Dc->emh->nDescription = length / 2; - - Dc->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0; - - Dc->emh->nPalEntries = 0; /* I guess this should start at 0 */ - - /* Size in pixels */ - Dc->emh->szlDevice.cx = NtGdiGetDeviceCaps(tempHDC, HORZRES); - Dc->emh->szlDevice.cy = NtGdiGetDeviceCaps(tempHDC, VERTRES); - - /* Size in millimeters */ - Dc->emh->szlMillimeters.cx = NtGdiGetDeviceCaps(tempHDC, HORZSIZE); - Dc->emh->szlMillimeters.cy = NtGdiGetDeviceCaps(tempHDC, VERTSIZE); - - /* Size in micrometers */ - Dc->emh->szlMicrometers.cx = Dc->emh->szlMillimeters.cx * 1000; - Dc->emh->szlMicrometers.cy = Dc->emh->szlMillimeters.cy * 1000; - - if(Description) - { - memcpy((char *)Dc->emh + sizeof(ENHMETAHEADER), Description, length); - } - - ret = tempHDC; - if (File) - { - OBJECT_ATTRIBUTES ObjectAttributes; - IO_STATUS_BLOCK IoStatusBlock; - IO_STATUS_BLOCK Iosb; - UNICODE_STRING NtPathU; - NTSTATUS Status; - ULONG FileAttributes = (FILE_ATTRIBUTE_VALID_FLAGS & ~FILE_ATTRIBUTE_DIRECTORY); - - DPRINT1("Trying Create EnhMetaFile\n"); - - /* disk based metafile */ - dwDesiredAccess = GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES; - - if (!RtlDosPathNameToNtPathName_U (File, &NtPathU, NULL, NULL)) - { - DC_UnlockDc(Dc); - if (hDCRef == NULL) - { - NtGdiDeleteObjectApp(tempHDC); - } - DPRINT1("Can not Create EnhMetaFile\n"); - SetLastWin32Error(ERROR_PATH_NOT_FOUND); - return NULL; - } - - InitializeObjectAttributes(&ObjectAttributes, &NtPathU, 0, NULL, NULL); - - Status = NtCreateFile (&Dc->hFile, dwDesiredAccess, &ObjectAttributes, &IoStatusBlock, - NULL, FileAttributes, 0, FILE_OVERWRITE_IF, FILE_NON_DIRECTORY_FILE, - NULL, 0); - - RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathU.Buffer); - - if (!NT_SUCCESS(Status)) - { - Dc->hFile = NULL; - DC_UnlockDc(Dc); - if (hDCRef == NULL) - { - NtGdiDeleteObjectApp(tempHDC); - } - DPRINT1("Create EnhMetaFile fail\n"); - SetLastWin32Error(ERROR_INVALID_HANDLE); - return NULL; - } - - SetLastWin32Error(IoStatusBlock.Information == FILE_OVERWRITTEN ? ERROR_ALREADY_EXISTS : 0); - - Status = NtWriteFile(Dc->hFile, NULL, NULL, NULL, &Iosb, (PVOID)&Dc->emh, Dc->emh->nSize, NULL, NULL); - if (Status == STATUS_PENDING) - { - Status = NtWaitForSingleObject(Dc->hFile,FALSE,NULL); - if (NT_SUCCESS(Status)) - { - Status = Iosb.Status; - } - } - - if (NT_SUCCESS(Status)) - { - ret = tempHDC; - DC_UnlockDc(Dc); - } - else - { - Dc->hFile = NULL; - DPRINT1("Write to EnhMetaFile fail\n"); - SetLastWin32Error(ERROR_CAN_NOT_COMPLETE); - ret = NULL; - DC_UnlockDc(Dc); - if (hDCRef == NULL) - { - NtGdiDeleteObjectApp(tempHDC); - } - } + if(Rect) + { + Dc->emh->rclFrame.left = Rect->left; + Dc->emh->rclFrame.top = Rect->top; + Dc->emh->rclFrame.right = Rect->right; + Dc->emh->rclFrame.bottom = Rect->bottom; } else { - DC_UnlockDc(Dc); + /* Set this to {0,0 - -1,-1} and update it at the end */ + Dc->emh->rclFrame.left = Dc->emh->rclFrame.top = 0; + Dc->emh->rclFrame.right = Dc->emh->rclFrame.bottom = -1; + } + + Dc->emh->dSignature = ENHMETA_SIGNATURE; + Dc->emh->nVersion = 0x10000; + Dc->emh->nBytes = Dc->emh->nSize; + Dc->emh->nRecords = 1; + Dc->emh->nHandles = 1; + + Dc->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */ + Dc->emh->nDescription = length / 2; + + Dc->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0; + + Dc->emh->nPalEntries = 0; /* I guess this should start at 0 */ + + /* Size in pixels */ + Dc->emh->szlDevice.cx = NtGdiGetDeviceCaps(tempHDC, HORZRES); + Dc->emh->szlDevice.cy = NtGdiGetDeviceCaps(tempHDC, VERTRES); + + /* Size in millimeters */ + Dc->emh->szlMillimeters.cx = NtGdiGetDeviceCaps(tempHDC, HORZSIZE); + Dc->emh->szlMillimeters.cy = NtGdiGetDeviceCaps(tempHDC, VERTSIZE); + + /* Size in micrometers */ + Dc->emh->szlMicrometers.cx = Dc->emh->szlMillimeters.cx * 1000; + Dc->emh->szlMicrometers.cy = Dc->emh->szlMillimeters.cy * 1000; + + if(Description) + { + memcpy((char *)Dc->emh + sizeof(ENHMETAHEADER), Description, length); + } + + ret = tempHDC; + if (File) + { + OBJECT_ATTRIBUTES ObjectAttributes; + IO_STATUS_BLOCK IoStatusBlock; + IO_STATUS_BLOCK Iosb; + UNICODE_STRING NtPathU; + NTSTATUS Status; + ULONG FileAttributes = (FILE_ATTRIBUTE_VALID_FLAGS & ~FILE_ATTRIBUTE_DIRECTORY); + + DPRINT1("Trying Create EnhMetaFile\n"); + + /* disk based metafile */ + dwDesiredAccess = GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES; + + if (!RtlDosPathNameToNtPathName_U (File, &NtPathU, NULL, NULL)) + { + DC_UnlockDc(Dc); + if (hDCRef == NULL) + { + NtGdiDeleteObjectApp(tempHDC); + } + DPRINT1("Can not Create EnhMetaFile\n"); + SetLastWin32Error(ERROR_PATH_NOT_FOUND); + return NULL; + } + + InitializeObjectAttributes(&ObjectAttributes, &NtPathU, 0, NULL, NULL); + + Status = NtCreateFile (&Dc->hFile, dwDesiredAccess, &ObjectAttributes, &IoStatusBlock, + NULL, FileAttributes, 0, FILE_OVERWRITE_IF, FILE_NON_DIRECTORY_FILE, + NULL, 0); + + RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathU.Buffer); + + if (!NT_SUCCESS(Status)) + { + Dc->hFile = NULL; + DC_UnlockDc(Dc); + if (hDCRef == NULL) + { + NtGdiDeleteObjectApp(tempHDC); + } + DPRINT1("Create EnhMetaFile fail\n"); + SetLastWin32Error(ERROR_INVALID_HANDLE); + return NULL; + } + + SetLastWin32Error(IoStatusBlock.Information == FILE_OVERWRITTEN ? ERROR_ALREADY_EXISTS : 0); + + Status = NtWriteFile(Dc->hFile, NULL, NULL, NULL, &Iosb, (PVOID)&Dc->emh, Dc->emh->nSize, NULL, NULL); + if (Status == STATUS_PENDING) + { + Status = NtWaitForSingleObject(Dc->hFile,FALSE,NULL); + if (NT_SUCCESS(Status)) + { + Status = Iosb.Status; + } + } + + if (NT_SUCCESS(Status)) + { + ret = tempHDC; + DC_UnlockDc(Dc); + } + else + { + Dc->hFile = NULL; + DPRINT1("Write to EnhMetaFile fail\n"); + SetLastWin32Error(ERROR_CAN_NOT_COMPLETE); + ret = NULL; + DC_UnlockDc(Dc); + if (hDCRef == NULL) + { + NtGdiDeleteObjectApp(tempHDC); + } + } + } + else + { + DC_UnlockDc(Dc); } return ret; @@ -438,23 +440,23 @@ NtGdiCreateEnhMetaFile(HDC hDCRef, HENHMETAFILE WINAPI GetEnhMetaFileA( - LPCSTR lpszMetaFile) + LPCSTR lpszMetaFile) { - NTSTATUS Status; - LPWSTR lpszMetaFileW; - HENHMETAFILE rc = 0; + NTSTATUS Status; + LPWSTR lpszMetaFileW; + HENHMETAFILE rc = 0; - Status = HEAP_strdupA2W ( &lpszMetaFileW, lpszMetaFile ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else - { - rc = NULL; + Status = HEAP_strdupA2W ( &lpszMetaFileW, lpszMetaFile ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else + { + rc = NULL; - HEAP_free ( lpszMetaFileW ); - } + HEAP_free ( lpszMetaFileW ); + } - return rc; + return rc; } @@ -464,41 +466,41 @@ GetEnhMetaFileA( UINT WINAPI GetEnhMetaFileDescriptionA( - HENHMETAFILE hemf, - UINT cchBuffer, - LPSTR lpszDescription) + HENHMETAFILE hemf, + UINT cchBuffer, + LPSTR lpszDescription) { - NTSTATUS Status; - LPWSTR lpszDescriptionW; + NTSTATUS Status; + LPWSTR lpszDescriptionW; - if ( lpszDescription && cchBuffer ) + if ( lpszDescription && cchBuffer ) { - lpszDescriptionW = (LPWSTR)HEAP_alloc ( cchBuffer*sizeof(WCHAR) ); - if ( !lpszDescriptionW ) - { - SetLastError (RtlNtStatusToDosError(STATUS_NO_MEMORY)); - return 0; - } + lpszDescriptionW = (LPWSTR)HEAP_alloc ( cchBuffer*sizeof(WCHAR) ); + if ( !lpszDescriptionW ) + { + SetLastError (RtlNtStatusToDosError(STATUS_NO_MEMORY)); + return 0; + } } - else - lpszDescriptionW = NULL; + else + lpszDescriptionW = NULL; - if ( lpszDescription && cchBuffer ) + if ( lpszDescription && cchBuffer ) { - Status = RtlUnicodeToMultiByteN ( lpszDescription, - cchBuffer, - NULL, - lpszDescriptionW, - cchBuffer ); - HEAP_free ( lpszDescriptionW ); - if ( !NT_SUCCESS(Status) ) - { - SetLastError (RtlNtStatusToDosError(Status)); - return 0; - } + Status = RtlUnicodeToMultiByteN ( lpszDescription, + cchBuffer, + NULL, + lpszDescriptionW, + cchBuffer ); + HEAP_free ( lpszDescriptionW ); + if ( !NT_SUCCESS(Status) ) + { + SetLastError (RtlNtStatusToDosError(Status)); + return 0; + } } - return 0; + return 0; } @@ -508,44 +510,44 @@ GetEnhMetaFileDescriptionA( HENHMETAFILE WINAPI CopyEnhMetaFileW( - HENHMETAFILE hemfSrc, - LPCWSTR lpszFile) + HENHMETAFILE hemfSrc, + LPCWSTR lpszFile) { - UNIMPLEMENTED; - return 0; + UNIMPLEMENTED; + return 0; } HENHMETAFILE WINAPI GetEnhMetaFileW( - LPCWSTR lpszMetaFile) + LPCWSTR lpszMetaFile) { - UNIMPLEMENTED; - return 0; + UNIMPLEMENTED; + return 0; } UINT WINAPI GetEnhMetaFileDescriptionW( - HENHMETAFILE hemf, - UINT cchBuffer, - LPWSTR lpszDescription) + HENHMETAFILE hemf, + UINT cchBuffer, + LPWSTR lpszDescription) { - UNIMPLEMENTED; - return 0; + UNIMPLEMENTED; + return 0; } HDC WINAPI CreateEnhMetaFileW( - HDC hdcRef, - LPCWSTR lpFileName, - LPCRECT lpRect, - LPCWSTR lpDescription) + HDC hdcRef, + LPCWSTR lpFileName, + LPCRECT lpRect, + LPCWSTR lpDescription) { - UNIMPLEMENTED; - return 0; + UNIMPLEMENTED; + return 0; } diff --git a/reactos/dll/win32/gdi32/objects/font.c b/reactos/dll/win32/gdi32/objects/font.c index 2090b9ad1a8..d8e54607be1 100644 --- a/reactos/dll/win32/gdi32/objects/font.c +++ b/reactos/dll/win32/gdi32/objects/font.c @@ -16,44 +16,45 @@ * For TranslateCharsetInfo */ #define MAXTCIINDEX 32 -static const CHARSETINFO FONT_tci[MAXTCIINDEX] = { - /* ANSI */ - { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} }, - { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} }, - { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} }, - { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} }, - { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} }, - { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} }, - { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} }, - { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} }, - { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} }, - /* reserved by ANSI */ - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - /* ANSI and OEM */ - { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} }, - { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} }, - { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} }, - { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} }, - { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} }, - { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} }, - /* reserved for alternate ANSI and OEM */ - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - /* reserved for system */ - { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, - { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} } +static const CHARSETINFO FONT_tci[MAXTCIINDEX] = +{ + /* ANSI */ + { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} }, + { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} }, + { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} }, + { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} }, + { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} }, + { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} }, + { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} }, + { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} }, + { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} }, + /* reserved by ANSI */ + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + /* ANSI and OEM */ + { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} }, + { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} }, + { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} }, + { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} }, + { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} }, + { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} }, + /* reserved for alternate ANSI and OEM */ + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + /* reserved for system */ + { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} }, + { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} } }; #define INITIAL_FAMILY_COUNT 64 @@ -129,41 +130,41 @@ static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP) VOID FASTCALL NewTextMetricW2A(NEWTEXTMETRICA *tma, NEWTEXTMETRICW *tmw) { - FONT_TextMetricWToA((TEXTMETRICW *) tmw, (TEXTMETRICA *) tma); - tma->ntmFlags = tmw->ntmFlags; - tma->ntmSizeEM = tmw->ntmSizeEM; - tma->ntmCellHeight = tmw->ntmCellHeight; - tma->ntmAvgWidth = tmw->ntmAvgWidth; + FONT_TextMetricWToA((TEXTMETRICW *) tmw, (TEXTMETRICA *) tma); + tma->ntmFlags = tmw->ntmFlags; + tma->ntmSizeEM = tmw->ntmSizeEM; + tma->ntmCellHeight = tmw->ntmCellHeight; + tma->ntmAvgWidth = tmw->ntmAvgWidth; } VOID FASTCALL NewTextMetricExW2A(NEWTEXTMETRICEXA *tma, NEWTEXTMETRICEXW *tmw) { - NewTextMetricW2A(&tma->ntmTm, &tmw->ntmTm); - tma->ntmFontSig = tmw->ntmFontSig; + NewTextMetricW2A(&tma->ntmTm, &tmw->ntmTm); + tma->ntmFontSig = tmw->ntmFontSig; } static int FASTCALL IntEnumFontFamilies(HDC Dc, LPLOGFONTW LogFont, PVOID EnumProc, LPARAM lParam, BOOL Unicode) { - int FontFamilyCount; - int FontFamilySize; - PFONTFAMILYINFO Info; - int Ret = 0; - int i; - ENUMLOGFONTEXA EnumLogFontExA; - NEWTEXTMETRICEXA NewTextMetricExA; - LOGFONTW lfW; + int FontFamilyCount; + int FontFamilySize; + PFONTFAMILYINFO Info; + int Ret = 0; + int i; + ENUMLOGFONTEXA EnumLogFontExA; + NEWTEXTMETRICEXA NewTextMetricExA; + LOGFONTW lfW; - Info = RtlAllocateHeap(GetProcessHeap(), 0, - INITIAL_FAMILY_COUNT * sizeof(FONTFAMILYINFO)); - if (NULL == Info) + Info = RtlAllocateHeap(GetProcessHeap(), 0, + INITIAL_FAMILY_COUNT * sizeof(FONTFAMILYINFO)); + if (NULL == Info) { - return 0; + return 0; } - if (!LogFont) + if (!LogFont) { lfW.lfCharSet = DEFAULT_CHARSET; lfW.lfPitchAndFamily = 0; @@ -171,60 +172,61 @@ IntEnumFontFamilies(HDC Dc, LPLOGFONTW LogFont, PVOID EnumProc, LPARAM lParam, LogFont = &lfW; } - FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, LogFont, Info, INITIAL_FAMILY_COUNT); - if (FontFamilyCount < 0) + FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, LogFont, Info, INITIAL_FAMILY_COUNT); + if (FontFamilyCount < 0) { - RtlFreeHeap(GetProcessHeap(), 0, Info); - return 0; + RtlFreeHeap(GetProcessHeap(), 0, Info); + return 0; } - if (INITIAL_FAMILY_COUNT < FontFamilyCount) + if (INITIAL_FAMILY_COUNT < FontFamilyCount) { - FontFamilySize = FontFamilyCount; - RtlFreeHeap(GetProcessHeap(), 0, Info); - Info = RtlAllocateHeap(GetProcessHeap(), 0, - FontFamilyCount * sizeof(FONTFAMILYINFO)); - if (NULL == Info) + FontFamilySize = FontFamilyCount; + RtlFreeHeap(GetProcessHeap(), 0, Info); + Info = RtlAllocateHeap(GetProcessHeap(), 0, + FontFamilyCount * sizeof(FONTFAMILYINFO)); + if (NULL == Info) { - return 0; + return 0; } - FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, LogFont, Info, FontFamilySize); - if (FontFamilyCount < 0 || FontFamilySize < FontFamilyCount) + FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, LogFont, Info, FontFamilySize); + if (FontFamilyCount < 0 || FontFamilySize < FontFamilyCount) { - RtlFreeHeap(GetProcessHeap(), 0, Info); - return 0; + RtlFreeHeap(GetProcessHeap(), 0, Info); + return 0; } } - for (i = 0; i < FontFamilyCount; i++) + for (i = 0; i < FontFamilyCount; i++) { - if (Unicode) + if (Unicode) { - Ret = ((FONTENUMPROCW) EnumProc)( - (VOID*)&Info[i].EnumLogFontEx, - (VOID*)&Info[i].NewTextMetricEx, - Info[i].FontType, lParam); + Ret = ((FONTENUMPROCW) EnumProc)( + (VOID*)&Info[i].EnumLogFontEx, + (VOID*)&Info[i].NewTextMetricEx, + Info[i].FontType, lParam); } - else - { // Could use EnumLogFontExW2A here? - LogFontW2A(&EnumLogFontExA.elfLogFont, &Info[i].EnumLogFontEx.elfLogFont); - WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfFullName, -1, - (LPSTR)EnumLogFontExA.elfFullName, LF_FULLFACESIZE, NULL, NULL); - WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfStyle, -1, - (LPSTR)EnumLogFontExA.elfStyle, LF_FACESIZE, NULL, NULL); - WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfScript, -1, - (LPSTR)EnumLogFontExA.elfScript, LF_FACESIZE, NULL, NULL); - NewTextMetricExW2A(&NewTextMetricExA, - &Info[i].NewTextMetricEx); - Ret = ((FONTENUMPROCA) EnumProc)( - (VOID*)&EnumLogFontExA, - (VOID*)&NewTextMetricExA, - Info[i].FontType, lParam); + else + { + // Could use EnumLogFontExW2A here? + LogFontW2A(&EnumLogFontExA.elfLogFont, &Info[i].EnumLogFontEx.elfLogFont); + WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfFullName, -1, + (LPSTR)EnumLogFontExA.elfFullName, LF_FULLFACESIZE, NULL, NULL); + WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfStyle, -1, + (LPSTR)EnumLogFontExA.elfStyle, LF_FACESIZE, NULL, NULL); + WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfScript, -1, + (LPSTR)EnumLogFontExA.elfScript, LF_FACESIZE, NULL, NULL); + NewTextMetricExW2A(&NewTextMetricExA, + &Info[i].NewTextMetricEx); + Ret = ((FONTENUMPROCA) EnumProc)( + (VOID*)&EnumLogFontExA, + (VOID*)&NewTextMetricExA, + Info[i].FontType, lParam); } } - RtlFreeHeap(GetProcessHeap(), 0, Info); + RtlFreeHeap(GetProcessHeap(), 0, Info); - return Ret; + return Ret; } /* @@ -234,7 +236,7 @@ int WINAPI EnumFontFamiliesExW(HDC hdc, LPLOGFONTW lpLogfont, FONTENUMPROCW lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags) { - return IntEnumFontFamilies(hdc, lpLogfont, lpEnumFontFamExProc, lParam, TRUE); + return IntEnumFontFamilies(hdc, lpLogfont, lpEnumFontFamExProc, lParam, TRUE); } @@ -245,17 +247,17 @@ int WINAPI EnumFontFamiliesW(HDC hdc, LPCWSTR lpszFamily, FONTENUMPROCW lpEnumFontFamProc, LPARAM lParam) { - LOGFONTW LogFont; + LOGFONTW LogFont; - ZeroMemory(&LogFont, sizeof(LOGFONTW)); - LogFont.lfCharSet = DEFAULT_CHARSET; - if (NULL != lpszFamily) + ZeroMemory(&LogFont, sizeof(LOGFONTW)); + LogFont.lfCharSet = DEFAULT_CHARSET; + if (NULL != lpszFamily) { - if (!*lpszFamily) return 1; - lstrcpynW(LogFont.lfFaceName, lpszFamily, LF_FACESIZE); + if (!*lpszFamily) return 1; + lstrcpynW(LogFont.lfFaceName, lpszFamily, LF_FACESIZE); } - return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, TRUE); + return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, TRUE); } @@ -266,17 +268,17 @@ int WINAPI EnumFontFamiliesExA (HDC hdc, LPLOGFONTA lpLogfont, FONTENUMPROCA lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags) { - LOGFONTW LogFontW, *pLogFontW; + LOGFONTW LogFontW, *pLogFontW; - if (lpLogfont) - { - LogFontA2W(&LogFontW,lpLogfont); - pLogFontW = &LogFontW; - } - else pLogFontW = NULL; + if (lpLogfont) + { + LogFontA2W(&LogFontW,lpLogfont); + pLogFontW = &LogFontW; + } + else pLogFontW = NULL; - /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */ - return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, FALSE); + /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */ + return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, FALSE); } @@ -287,17 +289,17 @@ int WINAPI EnumFontFamiliesA(HDC hdc, LPCSTR lpszFamily, FONTENUMPROCA lpEnumFontFamProc, LPARAM lParam) { - LOGFONTW LogFont; + LOGFONTW LogFont; - ZeroMemory(&LogFont, sizeof(LOGFONTW)); - LogFont.lfCharSet = DEFAULT_CHARSET; - if (NULL != lpszFamily) + ZeroMemory(&LogFont, sizeof(LOGFONTW)); + LogFont.lfCharSet = DEFAULT_CHARSET; + if (NULL != lpszFamily) { - if (!*lpszFamily) return 1; - MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE); + if (!*lpszFamily) return 1; + MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE); } - return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, FALSE); + return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, FALSE); } @@ -307,12 +309,12 @@ EnumFontFamiliesA(HDC hdc, LPCSTR lpszFamily, FONTENUMPROCA lpEnumFontFamProc, DWORD WINAPI GetCharacterPlacementA( - HDC hdc, - LPCSTR lpString, - INT uCount, - INT nMaxExtent, - GCP_RESULTSA *lpResults, - DWORD dwFlags) + HDC hdc, + LPCSTR lpString, + INT uCount, + INT nMaxExtent, + GCP_RESULTSA *lpResults, + DWORD dwFlags) { WCHAR *lpStringW; INT uCountW; @@ -322,12 +324,12 @@ GetCharacterPlacementA( if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) ) { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; + SetLastError(ERROR_INVALID_PARAMETER); + return 0; } -/* TRACE("%s, %d, %d, 0x%08x\n", - debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags); -*/ + /* TRACE("%s, %d, %d, 0x%08x\n", + debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags); + */ /* both structs are equal in size */ memcpy(&resultsW, lpResults, sizeof(resultsW)); @@ -351,7 +353,8 @@ GetCharacterPlacementA( lpResults->nGlyphs = resultsW.nGlyphs; lpResults->nMaxFit = resultsW.nMaxFit; - if(lpResults->lpOutString) { + if(lpResults->lpOutString) + { WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW, lpResults->lpOutString, uCount, NULL, NULL ); } @@ -369,121 +372,121 @@ GetCharacterPlacementA( DWORD WINAPI GetCharacterPlacementW( - HDC hdc, - LPCWSTR lpString, - INT uCount, - INT nMaxExtent, - GCP_RESULTSW *lpResults, - DWORD dwFlags - ) + HDC hdc, + LPCWSTR lpString, + INT uCount, + INT nMaxExtent, + GCP_RESULTSW *lpResults, + DWORD dwFlags +) { - DWORD ret=0; - SIZE size; - UINT i, nSet; - DPRINT("GetCharacterPlacementW\n"); + DWORD ret=0; + SIZE size; + UINT i, nSet; + DPRINT("GetCharacterPlacementW\n"); - if(dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags); - if(lpResults->lpClass) DPRINT("classes not implemented\n"); - if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER)) - DPRINT("Caret positions for complex scripts not implemented\n"); + if(dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags); + if(lpResults->lpClass) DPRINT("classes not implemented\n"); + if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER)) + DPRINT("Caret positions for complex scripts not implemented\n"); - nSet = (UINT)uCount; - if(nSet > lpResults->nGlyphs) - nSet = lpResults->nGlyphs; + nSet = (UINT)uCount; + if(nSet > lpResults->nGlyphs) + nSet = lpResults->nGlyphs; - /* return number of initialized fields */ - lpResults->nGlyphs = nSet; + /* return number of initialized fields */ + lpResults->nGlyphs = nSet; -/*if((dwFlags&GCP_REORDER)==0 || !BidiAvail) - {*/ + /*if((dwFlags&GCP_REORDER)==0 || !BidiAvail) + {*/ /* Treat the case where no special handling was requested in a fastpath way */ /* copy will do if the GCP_REORDER flag is not set */ if(lpResults->lpOutString) - lstrcpynW( lpResults->lpOutString, lpString, nSet ); + lstrcpynW( lpResults->lpOutString, lpString, nSet ); if(lpResults->lpGlyphs) - lstrcpynW( lpResults->lpGlyphs, lpString, nSet ); + lstrcpynW( lpResults->lpGlyphs, lpString, nSet ); if(lpResults->lpOrder) { - for(i = 0; i < nSet; i++) - lpResults->lpOrder[i] = i; + for(i = 0; i < nSet; i++) + lpResults->lpOrder[i] = i; } -/*} else - { - BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString, - nSet, lpResults->lpOrder ); - }*/ + /*} else + { + BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString, + nSet, lpResults->lpOrder ); + }*/ - /* FIXME: Will use the placement chars */ - if (lpResults->lpDx) - { - int c; - for (i = 0; i < nSet; i++) + /* FIXME: Will use the placement chars */ + if (lpResults->lpDx) { - if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c)) - lpResults->lpDx[i]= c; + int c; + for (i = 0; i < nSet; i++) + { + if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c)) + lpResults->lpDx[i]= c; + } } - } - if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER)) - { - int pos = 0; + if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER)) + { + int pos = 0; - lpResults->lpCaretPos[0] = 0; - for (i = 1; i < nSet; i++) - if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size)) - lpResults->lpCaretPos[i] = (pos += size.cx); - } + lpResults->lpCaretPos[0] = 0; + for (i = 1; i < nSet; i++) + if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size)) + lpResults->lpCaretPos[i] = (pos += size.cx); + } - /*if(lpResults->lpGlyphs) - NtGdiGetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);*/ + /*if(lpResults->lpGlyphs) + NtGdiGetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);*/ - if (GetTextExtentPoint32W(hdc, lpString, uCount, &size)) - ret = MAKELONG(size.cx, size.cy); + if (GetTextExtentPoint32W(hdc, lpString, uCount, &size)) + ret = MAKELONG(size.cx, size.cy); - return ret; + return ret; } DWORD WINAPI NewGetCharacterPlacementW( - HDC hdc, - LPCWSTR lpString, - INT uCount, - INT nMaxExtent, - GCP_RESULTSW *lpResults, - DWORD dwFlags - ) + HDC hdc, + LPCWSTR lpString, + INT uCount, + INT nMaxExtent, + GCP_RESULTSW *lpResults, + DWORD dwFlags +) { - INT nSet; - SIZE Size = {0,0}; + INT nSet; + SIZE Size = {0,0}; - if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) ) - { - SetLastError(ERROR_INVALID_PARAMETER); - return 0; - } + if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) ) + { + SetLastError(ERROR_INVALID_PARAMETER); + return 0; + } - if ( !lpResults ) - { - if ( GetTextExtentPointW(hdc, lpString, uCount, &Size) ) - { - return MAKELONG(Size.cx, Size.cy); - } - return 0; - } + if ( !lpResults ) + { + if ( GetTextExtentPointW(hdc, lpString, uCount, &Size) ) + { + return MAKELONG(Size.cx, Size.cy); + } + return 0; + } - nSet = uCount; - if ( nSet > lpResults->nGlyphs ) - nSet = lpResults->nGlyphs; + nSet = uCount; + if ( nSet > lpResults->nGlyphs ) + nSet = lpResults->nGlyphs; - return NtGdiGetCharacterPlacementW( hdc, - (LPWSTR)lpString, - nSet, - nMaxExtent, - lpResults, - dwFlags); + return NtGdiGetCharacterPlacementW( hdc, + (LPWSTR)lpString, + nSet, + nMaxExtent, + lpResults, + dwFlags); } /* @@ -497,18 +500,18 @@ GetCharABCWidthsFloatW(HDC hdc, UINT LastChar, LPABCFLOAT abcF) { - DPRINT("GetCharABCWidthsFloatW\n"); - if ((!abcF) || (FirstChar > LastChar)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return NtGdiGetCharABCWidthsW( hdc, - FirstChar, - (ULONG)(LastChar - FirstChar + 1), - (PWCHAR) NULL, - 0, - (PVOID)abcF); + DPRINT("GetCharABCWidthsFloatW\n"); + if ((!abcF) || (FirstChar > LastChar)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return NtGdiGetCharABCWidthsW( hdc, + FirstChar, + (ULONG)(LastChar - FirstChar + 1), + (PWCHAR) NULL, + 0, + (PVOID)abcF); } /* @@ -522,18 +525,18 @@ GetCharWidthFloatW(HDC hdc, UINT iLastChar, PFLOAT pxBuffer) { - DPRINT("GetCharWidthsFloatW\n"); - if ((!pxBuffer) || (iFirstChar > iLastChar)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return NtGdiGetCharWidthW( hdc, - iFirstChar, - (ULONG)(iLastChar - iFirstChar + 1), - (PWCHAR) NULL, - 0, - (PVOID) pxBuffer); + DPRINT("GetCharWidthsFloatW\n"); + if ((!pxBuffer) || (iFirstChar > iLastChar)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return NtGdiGetCharWidthW( hdc, + iFirstChar, + (ULONG)(iLastChar - iFirstChar + 1), + (PWCHAR) NULL, + 0, + (PVOID) pxBuffer); } /* @@ -547,18 +550,18 @@ GetCharWidthW(HDC hdc, UINT iLastChar, LPINT lpBuffer) { - DPRINT("GetCharWidthsW\n"); - if ((!lpBuffer) || (iFirstChar > iLastChar)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return NtGdiGetCharWidthW( hdc, - iFirstChar, - (ULONG)(iLastChar - iFirstChar + 1), - (PWCHAR) NULL, - GCW_NOFLOAT, - (PVOID) lpBuffer); + DPRINT("GetCharWidthsW\n"); + if ((!lpBuffer) || (iFirstChar > iLastChar)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return NtGdiGetCharWidthW( hdc, + iFirstChar, + (ULONG)(iLastChar - iFirstChar + 1), + (PWCHAR) NULL, + GCW_NOFLOAT, + (PVOID) lpBuffer); } /* @@ -568,22 +571,22 @@ GetCharWidthW(HDC hdc, BOOL WINAPI GetCharWidth32W(HDC hdc, - UINT iFirstChar, - UINT iLastChar, - LPINT lpBuffer) + UINT iFirstChar, + UINT iLastChar, + LPINT lpBuffer) { - DPRINT("GetCharWidths32W\n"); - if ((!lpBuffer) || (iFirstChar > iLastChar)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return NtGdiGetCharWidthW( hdc, - iFirstChar, - (ULONG)(iLastChar - iFirstChar + 1), - (PWCHAR) NULL, - GCW_NOFLOAT|GCW_WIN32, - (PVOID) lpBuffer); + DPRINT("GetCharWidths32W\n"); + if ((!lpBuffer) || (iFirstChar > iLastChar)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return NtGdiGetCharWidthW( hdc, + iFirstChar, + (ULONG)(iLastChar - iFirstChar + 1), + (PWCHAR) NULL, + GCW_NOFLOAT|GCW_WIN32, + (PVOID) lpBuffer); } @@ -598,18 +601,18 @@ GetCharABCWidthsW(HDC hdc, UINT LastChar, LPABC lpabc) { - DPRINT("GetCharABCWidthsW\n"); - if ((!lpabc) || (FirstChar > LastChar)) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - return NtGdiGetCharABCWidthsW( hdc, - FirstChar, - (ULONG)(LastChar - FirstChar + 1), - (PWCHAR) NULL, - GCABCW_NOFLOAT, - (PVOID)lpabc); + DPRINT("GetCharABCWidthsW\n"); + if ((!lpabc) || (FirstChar > LastChar)) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return NtGdiGetCharABCWidthsW( hdc, + FirstChar, + (ULONG)(LastChar - FirstChar + 1), + (PWCHAR) NULL, + GCABCW_NOFLOAT, + (PVOID)lpabc); } /* @@ -618,11 +621,11 @@ GetCharABCWidthsW(HDC hdc, BOOL WINAPI GetCharWidthA( - HDC hdc, - UINT iFirstChar, - UINT iLastChar, - LPINT lpBuffer - ) + HDC hdc, + UINT iFirstChar, + UINT iLastChar, + LPINT lpBuffer +) { INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1); LPSTR str; @@ -648,11 +651,11 @@ GetCharWidthA( } ret = NtGdiGetCharWidthW( hdc, - wstr[0], - (ULONG) count, - (PWCHAR) wstr, - GCW_NOFLOAT, - (PVOID) lpBuffer); + wstr[0], + (ULONG) count, + (PWCHAR) wstr, + GCW_NOFLOAT, + (PVOID) lpBuffer); HeapFree(GetProcessHeap(), 0, str); HeapFree(GetProcessHeap(), 0, wstr); @@ -666,11 +669,11 @@ GetCharWidthA( BOOL WINAPI GetCharWidth32A( - HDC hdc, - UINT iFirstChar, - UINT iLastChar, - LPINT lpBuffer - ) + HDC hdc, + UINT iFirstChar, + UINT iLastChar, + LPINT lpBuffer +) { INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1); LPSTR str; @@ -695,11 +698,11 @@ GetCharWidth32A( } ret = NtGdiGetCharWidthW( hdc, - wstr[0], - (ULONG) count, - (PWCHAR) wstr, - GCW_NOFLOAT|GCW_WIN32, - (PVOID) lpBuffer); + wstr[0], + (ULONG) count, + (PWCHAR) wstr, + GCW_NOFLOAT|GCW_WIN32, + (PVOID) lpBuffer); HeapFree(GetProcessHeap(), 0, str); HeapFree(GetProcessHeap(), 0, wstr); @@ -713,11 +716,11 @@ GetCharWidth32A( BOOL APIENTRY GetCharWidthFloatA( - HDC hdc, - UINT iFirstChar, - UINT iLastChar, - PFLOAT pxBuffer - ) + HDC hdc, + UINT iFirstChar, + UINT iLastChar, + PFLOAT pxBuffer +) { INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1); LPSTR str; @@ -754,11 +757,11 @@ GetCharWidthFloatA( BOOL APIENTRY GetCharABCWidthsA( - HDC hdc, - UINT uFirstChar, - UINT uLastChar, - LPABC lpabc - ) + HDC hdc, + UINT uFirstChar, + UINT uLastChar, + LPABC lpabc +) { INT i, wlen, count = (INT)(uLastChar - uFirstChar + 1); LPSTR str; @@ -783,11 +786,11 @@ GetCharABCWidthsA( } ret = NtGdiGetCharABCWidthsW( hdc, - wstr[0], - (ULONG)count, - (PWCHAR)wstr, - GCABCW_NOFLOAT, - (PVOID)lpabc); + wstr[0], + (ULONG)count, + (PWCHAR)wstr, + GCABCW_NOFLOAT, + (PVOID)lpabc); HeapFree(GetProcessHeap(), 0, str); HeapFree(GetProcessHeap(), 0, wstr); @@ -801,11 +804,11 @@ GetCharABCWidthsA( BOOL APIENTRY GetCharABCWidthsFloatA( - HDC hdc, - UINT iFirstChar, - UINT iLastChar, - LPABCFLOAT lpABCF - ) + HDC hdc, + UINT iFirstChar, + UINT iLastChar, + LPABCFLOAT lpABCF +) { INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1); LPSTR str; @@ -848,13 +851,13 @@ GetCharABCWidthsI(HDC hdc, LPWORD pgi, LPABC lpabc) { - DPRINT("GetCharABCWidthsI\n"); - return NtGdiGetCharABCWidthsW( hdc, - giFirst, - (ULONG) cgi, - (PWCHAR) pgi, - GCABCW_NOFLOAT|GCABCW_INDICES, - (PVOID)lpabc); + DPRINT("GetCharABCWidthsI\n"); + return NtGdiGetCharABCWidthsW( hdc, + giFirst, + (ULONG) cgi, + (PWCHAR) pgi, + GCABCW_NOFLOAT|GCABCW_INDICES, + (PVOID)lpabc); } /* @@ -867,21 +870,21 @@ GetCharWidthI(HDC hdc, UINT cgi, LPWORD pgi, LPINT lpBuffer -) + ) { - DPRINT("GetCharWidthsI\n"); - if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max. - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - if (!cgi) return TRUE; - return NtGdiGetCharWidthW( hdc, - giFirst, - cgi, - (PWCHAR) pgi, - GCW_INDICES|GCW_NOFLOAT|GCW_WIN32, - (PVOID) lpBuffer ); + DPRINT("GetCharWidthsI\n"); + if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max. + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + if (!cgi) return TRUE; + return NtGdiGetCharWidthW( hdc, + giFirst, + cgi, + (PWCHAR) pgi, + GCW_INDICES|GCW_NOFLOAT|GCW_WIN32, + (PVOID) lpBuffer ); } /* @@ -890,22 +893,22 @@ GetCharWidthI(HDC hdc, DWORD WINAPI GetFontLanguageInfo( - HDC hDc - ) + HDC hDc +) { - DWORD Gcp = 0, Ret = 0; - if (gbLpk) - { - Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0); - if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET)) - Ret = (GCP_KASHIDA|GCP_DIACRITIC|GCP_LIGATE|GCP_GLYPHSHAPE|GCP_REORDER); - } - Gcp = GetDCDWord(hDc, GdiGetFontLanguageInfo, GCP_ERROR); - if ( Gcp == GCP_ERROR) - return Gcp; - else - Ret = Gcp | Ret; - return Ret; + DWORD Gcp = 0, Ret = 0; + if (gbLpk) + { + Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0); + if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET)) + Ret = (GCP_KASHIDA|GCP_DIACRITIC|GCP_LIGATE|GCP_GLYPHSHAPE|GCP_REORDER); + } + Gcp = GetDCDWord(hDc, GdiGetFontLanguageInfo, GCP_ERROR); + if ( Gcp == GCP_ERROR) + return Gcp; + else + Ret = Gcp | Ret; + return Ret; } /* @@ -914,12 +917,12 @@ GetFontLanguageInfo( DWORD WINAPI GetGlyphIndicesA( - HDC hdc, - LPCSTR lpstr, - INT count, - LPWORD pgi, - DWORD flags - ) + HDC hdc, + LPCSTR lpstr, + INT count, + LPWORD pgi, + DWORD flags +) { DWORD Ret; WCHAR *lpstrW; @@ -941,14 +944,14 @@ GetGlyphIndicesA( DWORD WINAPI GetGlyphOutlineA( - HDC hdc, - UINT uChar, - UINT uFormat, - LPGLYPHMETRICS lpgm, - DWORD cbBuffer, - LPVOID lpvBuffer, - CONST MAT2 *lpmat2 - ) + HDC hdc, + UINT uChar, + UINT uFormat, + LPGLYPHMETRICS lpgm, + DWORD cbBuffer, + LPVOID lpvBuffer, + CONST MAT2 *lpmat2 +) { LPWSTR p = NULL; @@ -956,20 +959,25 @@ GetGlyphOutlineA( UINT c; DPRINT("GetGlyphOutlineA uChar %x\n", uChar); if (!lpgm || !lpmat2) return GDI_ERROR; - if(!(uFormat & GGO_GLYPH_INDEX)) { + if(!(uFormat & GGO_GLYPH_INDEX)) + { int len; char mbchs[2]; - if(uChar > 0xff) { /* but, 2 bytes character only */ + if(uChar > 0xff) /* but, 2 bytes character only */ + { len = 2; mbchs[0] = (uChar & 0xff00) >> 8; mbchs[1] = (uChar & 0xff); - } else { + } + else + { len = 1; mbchs[0] = (uChar & 0xff); } p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL); c = p[0]; - } else + } + else c = uChar; ret = NtGdiGetGlyphOutline(hdc, c, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE); HeapFree(GetProcessHeap(), 0, p); @@ -983,19 +991,19 @@ GetGlyphOutlineA( DWORD WINAPI GetGlyphOutlineW( - HDC hdc, - UINT uChar, - UINT uFormat, - LPGLYPHMETRICS lpgm, - DWORD cbBuffer, - LPVOID lpvBuffer, - CONST MAT2 *lpmat2 - ) + HDC hdc, + UINT uChar, + UINT uFormat, + LPGLYPHMETRICS lpgm, + DWORD cbBuffer, + LPVOID lpvBuffer, + CONST MAT2 *lpmat2 +) { - DPRINT("GetGlyphOutlineW uChar %x\n", uChar); - if (!lpgm || !lpmat2) return GDI_ERROR; - if (!lpvBuffer) cbBuffer = 0; - return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE); + DPRINT("GetGlyphOutlineW uChar %x\n", uChar); + if (!lpgm || !lpmat2) return GDI_ERROR; + if (!lpvBuffer) cbBuffer = 0; + return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE); } @@ -1005,10 +1013,10 @@ GetGlyphOutlineW( UINT APIENTRY GetOutlineTextMetricsA( - HDC hdc, - UINT cbData, - LPOUTLINETEXTMETRICA lpOTM - ) + HDC hdc, + UINT cbData, + LPOUTLINETEXTMETRICA lpOTM +) { char buf[512], *ptr; UINT ret, needed; @@ -1031,24 +1039,25 @@ GetOutlineTextMetricsA( needed = sizeof(OUTLINETEXTMETRICA); if(lpOTMW->otmpFamilyName) needed += WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFamilyName), -1, - NULL, 0, NULL, NULL); + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFamilyName), -1, + NULL, 0, NULL, NULL); if(lpOTMW->otmpFaceName) needed += WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFaceName), -1, - NULL, 0, NULL, NULL); + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFaceName), -1, + NULL, 0, NULL, NULL); if(lpOTMW->otmpStyleName) needed += WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpStyleName), -1, - NULL, 0, NULL, NULL); + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpStyleName), -1, + NULL, 0, NULL, NULL); if(lpOTMW->otmpFullName) needed += WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFullName), -1, - NULL, 0, NULL, NULL); + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFullName), -1, + NULL, 0, NULL, NULL); - if(!lpOTM) { + if(!lpOTM) + { ret = needed; - goto end; + goto end; } DPRINT("needed = %d\n", needed); @@ -1097,48 +1106,57 @@ GetOutlineTextMetricsA( ptr = (char*)(output + 1); left = needed - sizeof(*output); - if(lpOTMW->otmpFamilyName) { + if(lpOTMW->otmpFamilyName) + { output->otmpFamilyName = (LPSTR)(ptr - (char*)output); - len = WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFamilyName), -1, - ptr, left, NULL, NULL); - left -= len; - ptr += len; - } else + len = WideCharToMultiByte(CP_ACP, 0, + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFamilyName), -1, + ptr, left, NULL, NULL); + left -= len; + ptr += len; + } + else output->otmpFamilyName = 0; - if(lpOTMW->otmpFaceName) { + if(lpOTMW->otmpFaceName) + { output->otmpFaceName = (LPSTR)(ptr - (char*)output); - len = WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFaceName), -1, - ptr, left, NULL, NULL); - left -= len; - ptr += len; - } else + len = WideCharToMultiByte(CP_ACP, 0, + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFaceName), -1, + ptr, left, NULL, NULL); + left -= len; + ptr += len; + } + else output->otmpFaceName = 0; - if(lpOTMW->otmpStyleName) { + if(lpOTMW->otmpStyleName) + { output->otmpStyleName = (LPSTR)(ptr - (char*)output); - len = WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpStyleName), -1, - ptr, left, NULL, NULL); - left -= len; - ptr += len; - } else + len = WideCharToMultiByte(CP_ACP, 0, + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpStyleName), -1, + ptr, left, NULL, NULL); + left -= len; + ptr += len; + } + else output->otmpStyleName = 0; - if(lpOTMW->otmpFullName) { + if(lpOTMW->otmpFullName) + { output->otmpFullName = (LPSTR)(ptr - (char*)output); - len = WideCharToMultiByte(CP_ACP, 0, - (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFullName), -1, - ptr, left, NULL, NULL); - left -= len; - } else + len = WideCharToMultiByte(CP_ACP, 0, + (WCHAR*)((char*)lpOTMW + (int)lpOTMW->otmpFullName), -1, + ptr, left, NULL, NULL); + left -= len; + } + else output->otmpFullName = 0; assert(left == 0); - if(output != lpOTM) { + if(output != lpOTM) + { memcpy(lpOTM, output, cbData); HeapFree(GetProcessHeap(), 0, output); @@ -1171,14 +1189,14 @@ end: UINT APIENTRY GetOutlineTextMetricsW( - HDC hdc, - UINT cbData, - LPOUTLINETEXTMETRICW lpOTM - ) + HDC hdc, + UINT cbData, + LPOUTLINETEXTMETRICW lpOTM +) { - TMDIFF Tmd; // Should not be zero. + TMDIFF Tmd; // Should not be zero. - return NtGdiGetOutlineTextMetricsInternalW(hdc, cbData, lpOTM, &Tmd); + return NtGdiGetOutlineTextMetricsInternalW(hdc, cbData, lpOTM, &Tmd); } /* @@ -1207,8 +1225,8 @@ GetKerningPairsW(HDC hdc, DWORD WINAPI GetKerningPairsA( HDC hDC, - DWORD cPairs, - LPKERNINGPAIR kern_pairA ) + DWORD cPairs, + LPKERNINGPAIR kern_pairA ) { INT charset; CHARSETINFO csi; @@ -1290,20 +1308,20 @@ HFONT WINAPI CreateFontIndirectExA(const ENUMLOGFONTEXDVA *elfexd) { - if (elfexd) - { - ENUMLOGFONTEXDVW Logfont; + if (elfexd) + { + ENUMLOGFONTEXDVW Logfont; - EnumLogFontExW2A( (LPENUMLOGFONTEXA) elfexd, - &Logfont.elfEnumLogfontEx ); + EnumLogFontExW2A( (LPENUMLOGFONTEXA) elfexd, + &Logfont.elfEnumLogfontEx ); - RtlCopyMemory( &Logfont.elfDesignVector, - (PVOID) &elfexd->elfDesignVector, - sizeof(DESIGNVECTOR)); + RtlCopyMemory( &Logfont.elfDesignVector, + (PVOID) &elfexd->elfDesignVector, + sizeof(DESIGNVECTOR)); - return NtGdiHfontCreate( &Logfont, 0, 0, 0, NULL); - } - else return NULL; + return NtGdiHfontCreate( &Logfont, 0, 0, 0, NULL); + } + else return NULL; } @@ -1314,14 +1332,14 @@ HFONT WINAPI CreateFontIndirectExW(const ENUMLOGFONTEXDVW *elfexd) { - /* Msdn: Note, this function ignores the elfDesignVector member in - ENUMLOGFONTEXDV. - */ - if ( elfexd ) - { - return NtGdiHfontCreate((PENUMLOGFONTEXDVW) elfexd, 0, 0, 0, NULL ); - } - else return NULL; + /* Msdn: Note, this function ignores the elfDesignVector member in + ENUMLOGFONTEXDV. + */ + if ( elfexd ) + { + return NtGdiHfontCreate((PENUMLOGFONTEXDVW) elfexd, 0, 0, 0, NULL ); + } + else return NULL; } @@ -1331,17 +1349,17 @@ CreateFontIndirectExW(const ENUMLOGFONTEXDVW *elfexd) HFONT WINAPI CreateFontIndirectA( - CONST LOGFONTA *lplf - ) + CONST LOGFONTA *lplf +) { - if (lplf) + if (lplf) { - LOGFONTW tlf; + LOGFONTW tlf; - LogFontA2W(&tlf, lplf); - return CreateFontIndirectW(&tlf); + LogFontA2W(&tlf, lplf); + return CreateFontIndirectW(&tlf); } - else return NULL; + else return NULL; } @@ -1351,30 +1369,30 @@ CreateFontIndirectA( HFONT WINAPI CreateFontIndirectW( - CONST LOGFONTW *lplf - ) + CONST LOGFONTW *lplf +) { - if (lplf) - { - ENUMLOGFONTEXDVW Logfont; + if (lplf) + { + ENUMLOGFONTEXDVW Logfont; - RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW)); - // Need something other than just cleaning memory here. - // Guess? Use caller data to determine the rest. - RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfFullName, - sizeof(Logfont.elfEnumLogfontEx.elfFullName)); - RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfStyle, - sizeof(Logfont.elfEnumLogfontEx.elfStyle)); - RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript, - sizeof(Logfont.elfEnumLogfontEx.elfScript)); + RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW)); + // Need something other than just cleaning memory here. + // Guess? Use caller data to determine the rest. + RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfFullName, + sizeof(Logfont.elfEnumLogfontEx.elfFullName)); + RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfStyle, + sizeof(Logfont.elfEnumLogfontEx.elfStyle)); + RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript, + sizeof(Logfont.elfEnumLogfontEx.elfScript)); - Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES + Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES - RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR)); + RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR)); - return CreateFontIndirectExW(&Logfont); - } - else return NULL; + return CreateFontIndirectExW(&Logfont); + } + else return NULL; } @@ -1384,47 +1402,47 @@ CreateFontIndirectW( HFONT WINAPI CreateFontA( - int nHeight, - int nWidth, - int nEscapement, - int nOrientation, - int fnWeight, - DWORD fdwItalic, - DWORD fdwUnderline, - DWORD fdwStrikeOut, - DWORD fdwCharSet, - DWORD fdwOutputPrecision, - DWORD fdwClipPrecision, - DWORD fdwQuality, - DWORD fdwPitchAndFamily, - LPCSTR lpszFace - ) + int nHeight, + int nWidth, + int nEscapement, + int nOrientation, + int fnWeight, + DWORD fdwItalic, + DWORD fdwUnderline, + DWORD fdwStrikeOut, + DWORD fdwCharSet, + DWORD fdwOutputPrecision, + DWORD fdwClipPrecision, + DWORD fdwQuality, + DWORD fdwPitchAndFamily, + LPCSTR lpszFace +) { - ANSI_STRING StringA; - UNICODE_STRING StringU; - HFONT ret; + ANSI_STRING StringA; + UNICODE_STRING StringU; + HFONT ret; - RtlInitAnsiString(&StringA, (LPSTR)lpszFace); - RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); + RtlInitAnsiString(&StringA, (LPSTR)lpszFace); + RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); - ret = CreateFontW(nHeight, - nWidth, + ret = CreateFontW(nHeight, + nWidth, nEscapement, - nOrientation, - fnWeight, - fdwItalic, - fdwUnderline, - fdwStrikeOut, - fdwCharSet, - fdwOutputPrecision, - fdwClipPrecision, - fdwQuality, - fdwPitchAndFamily, - StringU.Buffer); + nOrientation, + fnWeight, + fdwItalic, + fdwUnderline, + fdwStrikeOut, + fdwCharSet, + fdwOutputPrecision, + fdwClipPrecision, + fdwQuality, + fdwPitchAndFamily, + StringU.Buffer); - RtlFreeUnicodeString(&StringU); + RtlFreeUnicodeString(&StringU); - return ret; + return ret; } @@ -1434,51 +1452,51 @@ CreateFontA( HFONT WINAPI CreateFontW( - int nHeight, - int nWidth, - int nEscapement, - int nOrientation, - int nWeight, - DWORD fnItalic, - DWORD fdwUnderline, - DWORD fdwStrikeOut, - DWORD fdwCharSet, - DWORD fdwOutputPrecision, - DWORD fdwClipPrecision, - DWORD fdwQuality, - DWORD fdwPitchAndFamily, - LPCWSTR lpszFace - ) + int nHeight, + int nWidth, + int nEscapement, + int nOrientation, + int nWeight, + DWORD fnItalic, + DWORD fdwUnderline, + DWORD fdwStrikeOut, + DWORD fdwCharSet, + DWORD fdwOutputPrecision, + DWORD fdwClipPrecision, + DWORD fdwQuality, + DWORD fdwPitchAndFamily, + LPCWSTR lpszFace +) { - LOGFONTW logfont; + LOGFONTW logfont; - logfont.lfHeight = nHeight; - logfont.lfWidth = nWidth; - logfont.lfEscapement = nEscapement; - logfont.lfOrientation = nOrientation; - logfont.lfWeight = nWeight; - logfont.lfItalic = fnItalic; - logfont.lfUnderline = fdwUnderline; - logfont.lfStrikeOut = fdwStrikeOut; - logfont.lfCharSet = fdwCharSet; - logfont.lfOutPrecision = fdwOutputPrecision; - logfont.lfClipPrecision = fdwClipPrecision; - logfont.lfQuality = fdwQuality; - logfont.lfPitchAndFamily = fdwPitchAndFamily; + logfont.lfHeight = nHeight; + logfont.lfWidth = nWidth; + logfont.lfEscapement = nEscapement; + logfont.lfOrientation = nOrientation; + logfont.lfWeight = nWeight; + logfont.lfItalic = fnItalic; + logfont.lfUnderline = fdwUnderline; + logfont.lfStrikeOut = fdwStrikeOut; + logfont.lfCharSet = fdwCharSet; + logfont.lfOutPrecision = fdwOutputPrecision; + logfont.lfClipPrecision = fdwClipPrecision; + logfont.lfQuality = fdwQuality; + logfont.lfPitchAndFamily = fdwPitchAndFamily; - if (NULL != lpszFace) - { - int Size = sizeof(logfont.lfFaceName) / sizeof(WCHAR); - wcsncpy((wchar_t *)logfont.lfFaceName, lpszFace, Size - 1); - /* Be 101% sure to have '\0' at end of string */ - logfont.lfFaceName[Size - 1] = '\0'; - } - else - { - logfont.lfFaceName[0] = L'\0'; - } + if (NULL != lpszFace) + { + int Size = sizeof(logfont.lfFaceName) / sizeof(WCHAR); + wcsncpy((wchar_t *)logfont.lfFaceName, lpszFace, Size - 1); + /* Be 101% sure to have '\0' at end of string */ + logfont.lfFaceName[Size - 1] = '\0'; + } + else + { + logfont.lfFaceName[0] = L'\0'; + } - return CreateFontIndirectW(&logfont); + return CreateFontIndirectW(&logfont); } @@ -1488,13 +1506,13 @@ CreateFontW( BOOL WINAPI CreateScalableFontResourceA( - DWORD fdwHidden, - LPCSTR lpszFontRes, - LPCSTR lpszFontFile, - LPCSTR lpszCurrentPath - ) + DWORD fdwHidden, + LPCSTR lpszFontRes, + LPCSTR lpszFontFile, + LPCSTR lpszCurrentPath +) { - return FALSE; + return FALSE; } @@ -1563,9 +1581,9 @@ AddFontResourceA ( LPCSTR lpszFilename ) } else { - rc = GdiAddFontResourceW ( FilenameW, 0, 0); + rc = GdiAddFontResourceW ( FilenameW, 0, 0); - HEAP_free ( FilenameW ); + HEAP_free ( FilenameW ); } return rc; } @@ -1611,7 +1629,7 @@ WINAPI RemoveFontResourceExA(LPCSTR lpFileName, DWORD fl, PVOID pdv -) + ) { NTSTATUS Status; LPWSTR lpFileNameW; @@ -1622,14 +1640,14 @@ RemoveFontResourceExA(LPCSTR lpFileName, Status = HEAP_strdupA2W ( &lpFileNameW, lpFileName ); if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); + SetLastError (RtlNtStatusToDosError(Status)); else { HEAP_free ( lpFileNameW ); } - return 0; + return 0; } /* @@ -1687,10 +1705,12 @@ GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height) { SIZE sz; TEXTMETRICW tm; - static const WCHAR alphabet[] = { + static const WCHAR alphabet[] = + { 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q', 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H', - 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0}; + 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0 + }; if(!GetTextMetricsW(hdc, &tm)) return 0; @@ -1723,27 +1743,28 @@ GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height) BOOL WINAPI TranslateCharsetInfo( - LPDWORD lpSrc, /* [in] + LPDWORD lpSrc, /* [in] if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE if flags == TCI_SRCCHARSET: a character set value if flags == TCI_SRCCODEPAGE: a code page value */ - LPCHARSETINFO lpCs, /* [out] structure to receive charset information */ - DWORD flags /* [in] determines interpretation of lpSrc */) + LPCHARSETINFO lpCs, /* [out] structure to receive charset information */ + DWORD flags /* [in] determines interpretation of lpSrc */) { int index = 0; - switch (flags) { + switch (flags) + { case TCI_SRCFONTSIG: - while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++; - break; + while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++; + break; case TCI_SRCCODEPAGE: - while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++; - break; + while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++; + break; case TCI_SRCCHARSET: - while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++; - break; + while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++; + break; default: - return FALSE; + return FALSE; } if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE; memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO)); @@ -1757,51 +1778,51 @@ TranslateCharsetInfo( DWORD WINAPI SetMapperFlags( - HDC hDC, - DWORD flags - ) + HDC hDC, + DWORD flags +) { - DWORD Ret = GDI_ERROR; - PDC_ATTR Dc_Attr; + DWORD Ret = GDI_ERROR; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetMapperFlags( hDC, flags); + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) + { + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetMapperFlags( hDC, flags); + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return GDI_ERROR; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetMapperFlags( hDC, flags); + } + } + } +#endif + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR; + + if (NtCurrentTeb()->GdiTebBatch.HDC == hDC) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + + if ( flags & ~1 ) + SetLastError(ERROR_INVALID_PARAMETER); else { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return GDI_ERROR; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetMapperFlags( hDC, flags); - } + Ret = Dc_Attr->flFontMapper; + Dc_Attr->flFontMapper = flags; } - } -#endif - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR; - - if (NtCurrentTeb()->GdiTebBatch.HDC == hDC) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) - { - NtGdiFlush(); - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } - - if ( flags & ~1 ) - SetLastError(ERROR_INVALID_PARAMETER); - else - { - Ret = Dc_Attr->flFontMapper; - Dc_Attr->flFontMapper = flags; - } - return Ret; + return Ret; } @@ -1811,16 +1832,16 @@ SetMapperFlags( int WINAPI EnumFontsW( - HDC hDC, - LPCWSTR lpFaceName, - FONTENUMPROCW FontFunc, - LPARAM lParam - ) + HDC hDC, + LPCWSTR lpFaceName, + FONTENUMPROCW FontFunc, + LPARAM lParam +) { #if 0 - return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam ); + return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam ); #else - return EnumFontFamiliesW( hDC, lpFaceName, FontFunc, lParam ); + return EnumFontFamiliesW( hDC, lpFaceName, FontFunc, lParam ); #endif } @@ -1830,29 +1851,29 @@ EnumFontsW( int WINAPI EnumFontsA ( - HDC hDC, - LPCSTR lpFaceName, - FONTENUMPROCA FontFunc, - LPARAM lParam - ) + HDC hDC, + LPCSTR lpFaceName, + FONTENUMPROCA FontFunc, + LPARAM lParam +) { #if 0 - NTSTATUS Status; - LPWSTR lpFaceNameW; - int rc = 0; + NTSTATUS Status; + LPWSTR lpFaceNameW; + int rc = 0; - Status = HEAP_strdupA2W ( &lpFaceNameW, lpFaceName ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else + Status = HEAP_strdupA2W ( &lpFaceNameW, lpFaceName ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else { - rc = NtGdiEnumFonts ( hDC, lpFaceNameW, FontFunc, lParam ); + rc = NtGdiEnumFonts ( hDC, lpFaceNameW, FontFunc, lParam ); - HEAP_free ( lpFaceNameW ); + HEAP_free ( lpFaceNameW ); } - return rc; + return rc; #else - return EnumFontFamiliesA( hDC, lpFaceName, FontFunc, lParam ); + return EnumFontFamiliesA( hDC, lpFaceName, FontFunc, lParam ); #endif } @@ -1867,50 +1888,50 @@ NewEnumFontFamiliesExW( LPARAM lParam, DWORD dwFlags) { - ULONG_PTR idEnum, cbDataSize, cbRetSize; - PENUMFONTDATAW pEfdw; - PBYTE pBuffer; - PBYTE pMax; - INT ret = 1; + ULONG_PTR idEnum, cbDataSize, cbRetSize; + PENUMFONTDATAW pEfdw; + PBYTE pBuffer; + PBYTE pMax; + INT ret = 1; - /* Open enumeration handle and find out how much memory we need */ - idEnum = NtGdiEnumFontOpen(hDC, - EfdFontFamilies, - 0, - LF_FACESIZE, - (lpLogfont && lpLogfont->lfFaceName[0])? lpLogfont->lfFaceName : NULL, - lpLogfont? lpLogfont->lfCharSet : DEFAULT_CHARSET, - &cbDataSize); - if (idEnum == 0) - { - return 0; - } - if (cbDataSize == 0) - { - NtGdiEnumFontClose(idEnum); - return 0; - } + /* Open enumeration handle and find out how much memory we need */ + idEnum = NtGdiEnumFontOpen(hDC, + EfdFontFamilies, + 0, + LF_FACESIZE, + (lpLogfont && lpLogfont->lfFaceName[0])? lpLogfont->lfFaceName : NULL, + lpLogfont? lpLogfont->lfCharSet : DEFAULT_CHARSET, + &cbDataSize); + if (idEnum == 0) + { + return 0; + } + if (cbDataSize == 0) + { + NtGdiEnumFontClose(idEnum); + return 0; + } - /* Allocate memory */ - pBuffer = HeapAlloc(GetProcessHeap(), 0, cbDataSize); - if (pBuffer == NULL) - { - SetLastError(ERROR_NOT_ENOUGH_MEMORY); - NtGdiEnumFontClose(idEnum); - return 0; - } + /* Allocate memory */ + pBuffer = HeapAlloc(GetProcessHeap(), 0, cbDataSize); + if (pBuffer == NULL) + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + NtGdiEnumFontClose(idEnum); + return 0; + } - /* Do the enumeration */ - if (!NtGdiEnumFontChunk(hDC, idEnum, cbDataSize, &cbRetSize, (PVOID)pBuffer)) - { - HeapFree(GetProcessHeap(), 0, pBuffer); - NtGdiEnumFontClose(idEnum); - return 0; - } + /* Do the enumeration */ + if (!NtGdiEnumFontChunk(hDC, idEnum, cbDataSize, &cbRetSize, (PVOID)pBuffer)) + { + HeapFree(GetProcessHeap(), 0, pBuffer); + NtGdiEnumFontClose(idEnum); + return 0; + } /* Get start and end address */ pEfdw = (PENUMFONTDATAW)pBuffer; - pMax = pBuffer + cbDataSize; + pMax = pBuffer + cbDataSize; /* Iterate through the structures */ while ((PBYTE)pEfdw < pMax && ret) @@ -1923,11 +1944,11 @@ NewEnumFontFamiliesExW( lParam); pEfdw = (PENUMFONTDATAW)((ULONG_PTR)pEfdw + pEfdw->cbSize); - } + } - /* Release the memory and close handle */ - HeapFree(GetProcessHeap(), 0, pBuffer); - NtGdiEnumFontClose(idEnum); + /* Release the memory and close handle */ + HeapFree(GetProcessHeap(), 0, pBuffer); + NtGdiEnumFontClose(idEnum); - return ret; + return ret; } diff --git a/reactos/dll/win32/gdi32/objects/icm.c b/reactos/dll/win32/gdi32/objects/icm.c index acbc4b476a4..02e05cb5db7 100644 --- a/reactos/dll/win32/gdi32/objects/icm.c +++ b/reactos/dll/win32/gdi32/objects/icm.c @@ -7,22 +7,22 @@ HCOLORSPACE FASTCALL IntCreateColorSpaceW( - LPLOGCOLORSPACEW lplcpw, - BOOL Ascii - ) + LPLOGCOLORSPACEW lplcpw, + BOOL Ascii +) { - LOGCOLORSPACEEXW lcpeexw; + LOGCOLORSPACEEXW lcpeexw; - if ((lplcpw->lcsSignature != LCS_SIGNATURE) || - (lplcpw->lcsVersion != 0x400) || - (lplcpw->lcsSize != sizeof(LOGCOLORSPACEW))) - { - SetLastError(ERROR_INVALID_COLORSPACE); - return NULL; - } - RtlCopyMemory(&lcpeexw.lcsColorSpace, lplcpw, sizeof(LOGCOLORSPACEW)); - - return NtGdiCreateColorSpace(&lcpeexw); + if ((lplcpw->lcsSignature != LCS_SIGNATURE) || + (lplcpw->lcsVersion != 0x400) || + (lplcpw->lcsSize != sizeof(LOGCOLORSPACEW))) + { + SetLastError(ERROR_INVALID_COLORSPACE); + return NULL; + } + RtlCopyMemory(&lcpeexw.lcsColorSpace, lplcpw, sizeof(LOGCOLORSPACEW)); + + return NtGdiCreateColorSpace(&lcpeexw); } /* @@ -31,10 +31,10 @@ IntCreateColorSpaceW( HCOLORSPACE WINAPI CreateColorSpaceW( - LPLOGCOLORSPACEW lplcpw - ) + LPLOGCOLORSPACEW lplcpw +) { - return IntCreateColorSpaceW(lplcpw, FALSE); + return IntCreateColorSpaceW(lplcpw, FALSE); } @@ -44,36 +44,36 @@ CreateColorSpaceW( HCOLORSPACE WINAPI CreateColorSpaceA( - LPLOGCOLORSPACEA lplcpa - ) + LPLOGCOLORSPACEA lplcpa +) { - LOGCOLORSPACEW lcpw; + LOGCOLORSPACEW lcpw; - if ((lplcpa->lcsSignature != LCS_SIGNATURE) || - (lplcpa->lcsVersion != 0x400) || - (lplcpa->lcsSize != sizeof(LOGCOLORSPACEA))) - { - SetLastError(ERROR_INVALID_COLORSPACE); - return NULL; - } + if ((lplcpa->lcsSignature != LCS_SIGNATURE) || + (lplcpa->lcsVersion != 0x400) || + (lplcpa->lcsSize != sizeof(LOGCOLORSPACEA))) + { + SetLastError(ERROR_INVALID_COLORSPACE); + return NULL; + } - lcpw.lcsSignature = lplcpa->lcsSignature; - lcpw.lcsVersion = lplcpa->lcsVersion; - lcpw.lcsSize = sizeof(LOGCOLORSPACEW); - lcpw.lcsCSType = lplcpa->lcsCSType; - lcpw.lcsIntent = lplcpa->lcsIntent; - lcpw.lcsEndpoints = lplcpa->lcsEndpoints; - lcpw.lcsGammaRed = lplcpa->lcsGammaRed; - lcpw.lcsGammaGreen = lplcpa->lcsGammaGreen; - lcpw.lcsGammaBlue = lplcpa->lcsGammaBlue; + lcpw.lcsSignature = lplcpa->lcsSignature; + lcpw.lcsVersion = lplcpa->lcsVersion; + lcpw.lcsSize = sizeof(LOGCOLORSPACEW); + lcpw.lcsCSType = lplcpa->lcsCSType; + lcpw.lcsIntent = lplcpa->lcsIntent; + lcpw.lcsEndpoints = lplcpa->lcsEndpoints; + lcpw.lcsGammaRed = lplcpa->lcsGammaRed; + lcpw.lcsGammaGreen = lplcpa->lcsGammaGreen; + lcpw.lcsGammaBlue = lplcpa->lcsGammaBlue; - RtlMultiByteToUnicodeN( lcpw.lcsFilename, - MAX_PATH, - NULL, - lplcpa->lcsFilename, - strlen(lplcpa->lcsFilename) + 1); + RtlMultiByteToUnicodeN( lcpw.lcsFilename, + MAX_PATH, + NULL, + lplcpa->lcsFilename, + strlen(lplcpa->lcsFilename) + 1); - return IntCreateColorSpaceW(&lcpw, FALSE); + return IntCreateColorSpaceW(&lcpw, FALSE); } /* @@ -83,14 +83,14 @@ HCOLORSPACE WINAPI GetColorSpace(HDC hDC) { - PDC_ATTR pDc_Attr; + PDC_ATTR pDc_Attr; - if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) - { - SetLastError(ERROR_INVALID_HANDLE); - return NULL; - } - return pDc_Attr->hColorSpace; + if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr)) + { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + return pDc_Attr->hColorSpace; } @@ -100,31 +100,31 @@ GetColorSpace(HDC hDC) HCOLORSPACE WINAPI SetColorSpace( - HDC hDC, - HCOLORSPACE hCS - ) + HDC hDC, + HCOLORSPACE hCS +) { - HCOLORSPACE rhCS = GetColorSpace(hDC); + HCOLORSPACE rhCS = GetColorSpace(hDC); - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) - { - if (NtGdiSetColorSpace(hDC, hCS)) return rhCS; - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) + { + if (NtGdiSetColorSpace(hDC, hCS)) return rhCS; + } #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC) - { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return NULL; - } - if (pLDC->iType == LDC_EMFLDC) - { - return NULL; - } - } + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC) + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } + if (pLDC->iType == LDC_EMFLDC) + { + return NULL; + } + } #endif - return NULL; + return NULL; } diff --git a/reactos/dll/win32/gdi32/objects/linedda.c b/reactos/dll/win32/gdi32/objects/linedda.c index f6312bbdff7..9e6997206be 100644 --- a/reactos/dll/win32/gdi32/objects/linedda.c +++ b/reactos/dll/win32/gdi32/objects/linedda.c @@ -58,8 +58,9 @@ BOOL WINAPI LineDDA(INT nXStart, INT nYStart, INT nXEnd, INT nYEnd, } if (dx > dy) /* line is "more horizontal" */ { - err = 2*dy - dx; erradd = 2*dy - 2*dx; - for(cnt = 0;cnt < dx; cnt++) + err = 2*dy - dx; + erradd = 2*dy - 2*dx; + for(cnt = 0; cnt < dx; cnt++) { callback(nXStart,nYStart,lParam); if (err > 0) @@ -73,8 +74,9 @@ BOOL WINAPI LineDDA(INT nXStart, INT nYStart, INT nXEnd, INT nYEnd, } else /* line is "more vertical" */ { - err = 2*dx - dy; erradd = 2*dx - 2*dy; - for(cnt = 0;cnt < dy; cnt++) + err = 2*dx - dy; + erradd = 2*dx - 2*dy; + for(cnt = 0; cnt < dy; cnt++) { callback(nXStart,nYStart,lParam); if (err > 0) diff --git a/reactos/dll/win32/gdi32/objects/metafile.c b/reactos/dll/win32/gdi32/objects/metafile.c index 61ded65dd7e..cf4e51759eb 100644 --- a/reactos/dll/win32/gdi32/objects/metafile.c +++ b/reactos/dll/win32/gdi32/objects/metafile.c @@ -14,66 +14,66 @@ BOOL MF_CreateMFDC ( HGDIOBJ hMDC, PMETAFILEDC pmfDC ) { - PMF_ENTRY pMFME; + PMF_ENTRY pMFME; - pMFME = LocalAlloc(LMEM_ZEROINIT, sizeof(MF_ENTRY)); - if (!pMFME) - { - return FALSE; - } + pMFME = LocalAlloc(LMEM_ZEROINIT, sizeof(MF_ENTRY)); + if (!pMFME) + { + return FALSE; + } - if (hMF_List == NULL) - { - hMF_List = pMFME; - InitializeListHead(&hMF_List->List); - } - else - InsertTailList(&hMF_List->List, &pMFME->List); + if (hMF_List == NULL) + { + hMF_List = pMFME; + InitializeListHead(&hMF_List->List); + } + else + InsertTailList(&hMF_List->List, &pMFME->List); - pMFME->hmDC = hMDC; - pMFME->pmfDC = pmfDC; + pMFME->hmDC = hMDC; + pMFME->pmfDC = pmfDC; - hMFCount++; - return TRUE; + hMFCount++; + return TRUE; } PMETAFILEDC MF_GetMFDC ( HGDIOBJ hMDC ) { - PMF_ENTRY pMFME = hMF_List; + PMF_ENTRY pMFME = hMF_List; - do - { - if ( pMFME->hmDC == hMDC ) return pMFME->pmfDC; - pMFME = (PMF_ENTRY) pMFME->List.Flink; - } - while ( pMFME != hMF_List ); + do + { + if ( pMFME->hmDC == hMDC ) return pMFME->pmfDC; + pMFME = (PMF_ENTRY) pMFME->List.Flink; + } + while ( pMFME != hMF_List ); - return NULL; + return NULL; } BOOL MF_DeleteMFDC ( HGDIOBJ hMDC ) { - PMF_ENTRY pMFME = hMF_List; + PMF_ENTRY pMFME = hMF_List; - do - { - if ( pMFME->hmDC == hMDC) + do { - RemoveEntryList(&pMFME->List); - LocalFree ( pMFME ); - hMFCount--; - if (!hMFCount) hMF_List = NULL; - return TRUE; + if ( pMFME->hmDC == hMDC) + { + RemoveEntryList(&pMFME->List); + LocalFree ( pMFME ); + hMFCount--; + if (!hMFCount) hMF_List = NULL; + return TRUE; + } + pMFME = (PMF_ENTRY) pMFME->List.Flink; } - pMFME = (PMF_ENTRY) pMFME->List.Flink; - } - while ( pMFME != hMF_List ); + while ( pMFME != hMF_List ); - return FALSE; + return FALSE; } /* FUNCTIONS *****************************************************************/ @@ -84,10 +84,10 @@ MF_DeleteMFDC ( HGDIOBJ hMDC ) HMETAFILE WINAPI CloseMetaFile( - HDC a0 - ) + HDC a0 +) { - return 0; + return 0; } @@ -97,11 +97,11 @@ CloseMetaFile( HMETAFILE WINAPI CopyMetaFileW( - HMETAFILE hmfSrc, - LPCWSTR lpszFile - ) + HMETAFILE hmfSrc, + LPCWSTR lpszFile +) { - return NULL; + return NULL; } @@ -111,24 +111,24 @@ CopyMetaFileW( HMETAFILE WINAPI CopyMetaFileA( - HMETAFILE hmfSrc, - LPCSTR lpszFile - ) + HMETAFILE hmfSrc, + LPCSTR lpszFile +) { - NTSTATUS Status; - PWSTR lpszFileW; - HMETAFILE rc = 0; + NTSTATUS Status; + PWSTR lpszFileW; + HMETAFILE rc = 0; - Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else - { - rc = CopyMetaFileW( hmfSrc, lpszFileW ); - HEAP_free ( lpszFileW ); - } + Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else + { + rc = CopyMetaFileW( hmfSrc, lpszFileW ); + HEAP_free ( lpszFileW ); + } - return rc; + return rc; } @@ -138,59 +138,59 @@ CopyMetaFileA( HDC WINAPI CreateMetaFileW( - LPCWSTR lpszFile - ) + LPCWSTR lpszFile +) { - HANDLE hFile; - HDC hmDC; - PMETAFILEDC pmfDC = LocalAlloc(LMEM_ZEROINIT, sizeof(METAFILEDC)); - if (!pmfDC) return NULL; + HANDLE hFile; + HDC hmDC; + PMETAFILEDC pmfDC = LocalAlloc(LMEM_ZEROINIT, sizeof(METAFILEDC)); + if (!pmfDC) return NULL; - pmfDC->mh.mtHeaderSize = sizeof(METAHEADER) / sizeof(WORD); - pmfDC->mh.mtVersion = 0x0300; - pmfDC->mh.mtSize = pmfDC->mh.mtHeaderSize; + pmfDC->mh.mtHeaderSize = sizeof(METAHEADER) / sizeof(WORD); + pmfDC->mh.mtVersion = 0x0300; + pmfDC->mh.mtSize = pmfDC->mh.mtHeaderSize; - pmfDC->hPen = GetStockObject(BLACK_PEN); - pmfDC->hBrush = GetStockObject(WHITE_BRUSH); - pmfDC->hFont = GetStockObject(DEVICE_DEFAULT_FONT); - pmfDC->hBitmap = GetStockObject(DEFAULT_BITMAP); - pmfDC->hPalette = GetStockObject(DEFAULT_PALETTE); + pmfDC->hPen = GetStockObject(BLACK_PEN); + pmfDC->hBrush = GetStockObject(WHITE_BRUSH); + pmfDC->hFont = GetStockObject(DEVICE_DEFAULT_FONT); + pmfDC->hBitmap = GetStockObject(DEFAULT_BITMAP); + pmfDC->hPalette = GetStockObject(DEFAULT_PALETTE); - if (lpszFile) /* disk based metafile */ - { - pmfDC->mh.mtType = METAFILE_DISK; - - if(!GetFullPathName( lpszFile, - MAX_PATH, - (LPTSTR) &pmfDC->Filename, - (LPTSTR*) &lpszFile)) + if (lpszFile) /* disk based metafile */ { - LocalFree(pmfDC); - return NULL; + pmfDC->mh.mtType = METAFILE_DISK; + + if(!GetFullPathName( lpszFile, + MAX_PATH, + (LPTSTR) &pmfDC->Filename, + (LPTSTR*) &lpszFile)) + { + LocalFree(pmfDC); + return NULL; + } + + if ((hFile = CreateFileW(pmfDC->Filename, GENERIC_WRITE, 0, NULL, + CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) + { + LocalFree(pmfDC); + return NULL; + } + + if (!WriteFile( hFile, &pmfDC->mh, sizeof(pmfDC->mh), &pmfDC->dwWritten, NULL )) + { + LocalFree(pmfDC); + return NULL; + } + pmfDC->hFile = hFile; } + else /* memory based metafile */ + pmfDC->mh.mtType = METAFILE_MEMORY; - if ((hFile = CreateFileW(pmfDC->Filename, GENERIC_WRITE, 0, NULL, - CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) - { - LocalFree(pmfDC); - return NULL; - } + hmDC = NtGdiCreateClientObj ( GDI_OBJECT_TYPE_METADC ); - if (!WriteFile( hFile, &pmfDC->mh, sizeof(pmfDC->mh), &pmfDC->dwWritten, NULL )) - { - LocalFree(pmfDC); - return NULL; - } - pmfDC->hFile = hFile; - } - else /* memory based metafile */ - pmfDC->mh.mtType = METAFILE_MEMORY; + MF_CreateMFDC ( hmDC, pmfDC ); - hmDC = NtGdiCreateClientObj ( GDI_OBJECT_TYPE_METADC ); - - MF_CreateMFDC ( hmDC, pmfDC ); - - return hmDC; + return hmDC; } @@ -200,22 +200,22 @@ CreateMetaFileW( HDC WINAPI CreateMetaFileA( - LPCSTR lpszFile - ) + LPCSTR lpszFile +) { - NTSTATUS Status; - PWSTR lpszFileW; - HDC rc = 0; + NTSTATUS Status; + PWSTR lpszFileW; + HDC rc = 0; - Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else + Status = HEAP_strdupA2W ( &lpszFileW, lpszFile ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else { - rc = CreateMetaFileW( lpszFileW ); - HEAP_free ( lpszFileW ); + rc = CreateMetaFileW( lpszFileW ); + HEAP_free ( lpszFileW ); } - return rc; + return rc; } @@ -225,10 +225,10 @@ CreateMetaFileA( BOOL WINAPI DeleteMetaFile( - HMETAFILE a0 - ) + HMETAFILE a0 +) { - return FALSE; + return FALSE; } @@ -238,10 +238,10 @@ DeleteMetaFile( HMETAFILE WINAPI GetMetaFileW( - LPCWSTR lpszMetaFile - ) + LPCWSTR lpszMetaFile +) { - return NULL; + return NULL; } @@ -251,23 +251,23 @@ GetMetaFileW( HMETAFILE WINAPI GetMetaFileA( - LPCSTR lpszMetaFile - ) + LPCSTR lpszMetaFile +) { - NTSTATUS Status; - LPWSTR lpszMetaFileW; - HMETAFILE rc = 0; + NTSTATUS Status; + LPWSTR lpszMetaFileW; + HMETAFILE rc = 0; - Status = HEAP_strdupA2W ( &lpszMetaFileW, lpszMetaFile ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else + Status = HEAP_strdupA2W ( &lpszMetaFileW, lpszMetaFile ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else { - rc = GetMetaFileW( lpszMetaFileW ); - HEAP_free ( lpszMetaFileW ); + rc = GetMetaFileW( lpszMetaFileW ); + HEAP_free ( lpszMetaFileW ); } - return rc; + return rc; } diff --git a/reactos/dll/win32/gdi32/objects/painting.c b/reactos/dll/win32/gdi32/objects/painting.c index a1bbcbb1abf..c6f3d849a98 100644 --- a/reactos/dll/win32/gdi32/objects/painting.c +++ b/reactos/dll/win32/gdi32/objects/painting.c @@ -10,27 +10,27 @@ LineTo( HDC hDC, INT x, INT y ) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam2( hDC, META_LINETO, x, y); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return MFDRV_LineTo( hDC, x, y ) - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam2( hDC, META_LINETO, x, y); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return MFDRV_LineTo( hDC, x, y ) + } + return FALSE; + } } - } #endif - return NtGdiLineTo( hDC, x, y); + return NtGdiLineTo( hDC, x, y); } @@ -38,50 +38,50 @@ BOOL WINAPI MoveToEx( HDC hDC, INT x, INT y, LPPOINT Point ) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam2( hDC, META_MOVETO, x, y); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - if (!EMFDRV_MoveTo( hDC, x, y)) return FALSE; - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam2( hDC, META_MOVETO, x, y); + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + if (!EMFDRV_MoveTo( hDC, x, y)) return FALSE; + } + } } - } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if ( Point ) - { - if ( Dc_Attr->ulDirty_ & DIRTY_PTLCURRENT ) // Double hit! + if ( Point ) { - Point->x = Dc_Attr->ptfxCurrent.x; // ret prev before change. - Point->y = Dc_Attr->ptfxCurrent.y; - DPtoLP ( hDC, Point, 1); // reconvert back. + if ( Dc_Attr->ulDirty_ & DIRTY_PTLCURRENT ) // Double hit! + { + Point->x = Dc_Attr->ptfxCurrent.x; // ret prev before change. + Point->y = Dc_Attr->ptfxCurrent.y; + DPtoLP ( hDC, Point, 1); // reconvert back. + } + else + { + Point->x = Dc_Attr->ptlCurrent.x; + Point->y = Dc_Attr->ptlCurrent.y; + } } - else - { - Point->x = Dc_Attr->ptlCurrent.x; - Point->y = Dc_Attr->ptlCurrent.y; - } - } - Dc_Attr->ptlCurrent.x = x; - Dc_Attr->ptlCurrent.y = y; + Dc_Attr->ptlCurrent.x = x; + Dc_Attr->ptlCurrent.y = y; - Dc_Attr->ulDirty_ &= ~DIRTY_PTLCURRENT; - Dc_Attr->ulDirty_ |= ( DIRTY_PTFXCURRENT|DIRTY_STYLESTATE); // Set dirty - return TRUE; + Dc_Attr->ulDirty_ &= ~DIRTY_PTLCURRENT; + Dc_Attr->ulDirty_ |= ( DIRTY_PTFXCURRENT|DIRTY_STYLESTATE); // Set dirty + return TRUE; } @@ -94,27 +94,27 @@ Ellipse(HDC hDC, INT Left, INT Top, INT Right, INT Bottom) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam4(hDC, META_ELLIPSE, Left, Top, Right, Bottom ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_Ellipse( hDC, Left, Top, Right, Bottom ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam4(hDC, META_ELLIPSE, Left, Top, Right, Bottom ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_Ellipse( hDC, Left, Top, Right, Bottom ); + } + return FALSE; + } } - } #endif - return NtGdiEllipse( hDC, Left, Top, Right, Bottom); + return NtGdiEllipse( hDC, Left, Top, Right, Bottom); } @@ -127,27 +127,27 @@ Rectangle(HDC hDC, INT Left, INT Top, INT Right, INT Bottom) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam4(hDC, META_RECTANGLE, Left, Top, Right, Bottom ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_Rectangle( hDC, Left, Top, Right, Bottom ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam4(hDC, META_RECTANGLE, Left, Top, Right, Bottom ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_Rectangle( hDC, Left, Top, Right, Bottom ); + } + return FALSE; + } } - } #endif - return NtGdiRectangle( hDC, Left, Top, Right, Bottom); + return NtGdiRectangle( hDC, Left, Top, Right, Bottom); } @@ -157,33 +157,33 @@ Rectangle(HDC hDC, INT Left, INT Top, INT Right, INT Bottom) BOOL WINAPI RoundRect(HDC hDC, INT Left, INT Top, INT Right, INT Bottom, - INT ell_Width, INT ell_Height) + INT ell_Width, INT ell_Height) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam6( hDC, META_ROUNDRECT, Left, Top, Right, Bottom, - ell_Width, ell_Height ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_RoundRect( hDC, Left, Top, Right, Bottom, - ell_Width, ell_Height ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam6( hDC, META_ROUNDRECT, Left, Top, Right, Bottom, + ell_Width, ell_Height ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_RoundRect( hDC, Left, Top, Right, Bottom, + ell_Width, ell_Height ); + } + return FALSE; + } } - } #endif - return NtGdiRoundRect( hDC, Left, Top, Right, Bottom, ell_Width, ell_Height); + return NtGdiRoundRect( hDC, Left, Top, Right, Bottom, ell_Width, ell_Height); } @@ -194,9 +194,9 @@ COLORREF WINAPI GetPixel( HDC hDC, INT x, INT y ) { - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) return CLR_INVALID; - if (!GdiIsHandleValid((HGDIOBJ) hDC)) return CLR_INVALID; - return NtGdiGetPixel( hDC, x, y); + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) return CLR_INVALID; + if (!GdiIsHandleValid((HGDIOBJ) hDC)) return CLR_INVALID; + return NtGdiGetPixel( hDC, x, y); } @@ -209,28 +209,28 @@ SetPixel( HDC hDC, INT x, INT y, COLORREF Color ) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_MetaParam4(hDC, META_SETPIXEL, x, y, HIWORD(Color), - LOWORD(Color)); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return 0; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_SetPixel( hDC, x, y, Color ); - } - return 0; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_MetaParam4(hDC, META_SETPIXEL, x, y, HIWORD(Color), + LOWORD(Color)); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return 0; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_SetPixel( hDC, x, y, Color ); + } + return 0; + } } - } #endif - return NtGdiSetPixel( hDC, x, y, Color); + return NtGdiSetPixel( hDC, x, y, Color); } @@ -241,9 +241,9 @@ BOOL WINAPI SetPixelV( HDC hDC, INT x, INT y, COLORREF Color ) { - COLORREF Cr = SetPixel( hDC, x, y, Color ); - if (Cr != CLR_INVALID) return TRUE; - return FALSE; + COLORREF Cr = SetPixel( hDC, x, y, Color ); + if (Cr != CLR_INVALID) return TRUE; + return FALSE; } @@ -255,30 +255,30 @@ WINAPI FillRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush ) { - if ( (!hRgn) || (!hBrush) ) return FALSE; + if ( (!hRgn) || (!hBrush) ) return FALSE; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_FillRgn( hDC, hRgn, hBrush); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_FillRgn(( hDC, hRgn, hBrush); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_FillRgn( hDC, hRgn, hBrush); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_FillRgn(( hDC, hRgn, hBrush); + } + return FALSE; + } } - } #endif - return NtGdiFillRgn( hDC, hRgn, hBrush); + return NtGdiFillRgn( hDC, hRgn, hBrush); } @@ -290,30 +290,30 @@ WINAPI FrameRgn( HDC hDC, HRGN hRgn, HBRUSH hBrush, INT nWidth, INT nHeight ) { - if ( (!hRgn) || (!hBrush) ) return FALSE; + if ( (!hRgn) || (!hBrush) ) return FALSE; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_FrameRgn( hDC, hRgn, hBrush, nWidth, nHeight ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_FrameRgn( hDC, hRgn, hBrush, nWidth, nHeight ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_FrameRgn( hDC, hRgn, hBrush, nWidth, nHeight ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_FrameRgn( hDC, hRgn, hBrush, nWidth, nHeight ); + } + return FALSE; + } } - } #endif - return NtGdiFrameRgn( hDC, hRgn, hBrush, nWidth, nHeight); + return NtGdiFrameRgn( hDC, hRgn, hBrush, nWidth, nHeight); } @@ -325,30 +325,30 @@ WINAPI InvertRgn( HDC hDC, HRGN hRgn ) { - if ( !hRgn ) return FALSE; + if ( !hRgn ) return FALSE; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_InvertRgn( hDC, HRGN hRgn ); // Use this instead of MFDRV_MetaParam. - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_PaintInvertRgn( hDC, hRgn, EMR_INVERTRGN ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_InvertRgn( hDC, HRGN hRgn ); // Use this instead of MFDRV_MetaParam. + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_PaintInvertRgn( hDC, hRgn, EMR_INVERTRGN ); + } + return FALSE; + } } - } #endif - return NtGdiInvertRgn( hDC, hRgn); + return NtGdiInvertRgn( hDC, hRgn); } @@ -361,30 +361,30 @@ PaintRgn( HDC hDC, HRGN hRgn ) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_PaintRgn( hDC, HRGN hRgn ); // Use this instead of MFDRV_MetaParam. - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_PaintInvertRgn( hDC, hRgn, EMR_PAINTRGN ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_PaintRgn( hDC, HRGN hRgn ); // Use this instead of MFDRV_MetaParam. + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_PaintInvertRgn( hDC, hRgn, EMR_PAINTRGN ); + } + return FALSE; + } } - } #endif - // Could just use Dc_Attr->hbrush? No. - HBRUSH hBrush = (HBRUSH) GetDCObject( hDC, GDI_OBJECT_TYPE_BRUSH); +// Could just use Dc_Attr->hbrush? No. + HBRUSH hBrush = (HBRUSH) GetDCObject( hDC, GDI_OBJECT_TYPE_BRUSH); - return NtGdiFillRgn( hDC, hRgn, hBrush); + return NtGdiFillRgn( hDC, hRgn, hBrush); } @@ -397,31 +397,31 @@ PolyBezier(HDC hDC ,const POINT* Point, DWORD cPoints) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - /* - * Since MetaFiles don't record Beziers and they don't even record - * approximations to them using lines. - */ - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return FALSE; // Not supported yet. - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + /* + * Since MetaFiles don't record Beziers and they don't even record + * approximations to them using lines. + */ + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return FALSE; // Not supported yet. + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC ,(PPOINT) Point, &cPoints, 1, GdiPolyBezier ); + return NtGdiPolyPolyDraw( hDC ,(PPOINT) Point, &cPoints, 1, GdiPolyBezier ); } @@ -434,27 +434,27 @@ PolyBezierTo(HDC hDC, const POINT* Point ,DWORD cPoints) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return FALSE; // Not supported yet. - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return FALSE; // Not supported yet. + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, &cPoints, 1, GdiPolyBezierTo ); + return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, &cPoints, 1, GdiPolyBezierTo ); } @@ -467,27 +467,27 @@ PolyDraw(HDC hDC, const POINT* Point, const BYTE *lpbTypes, int cCount ) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return FALSE; // Not supported yet. - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return FALSE; // Not supported yet. + } + return FALSE; + } } - } #endif - return NtGdiPolyDraw( hDC , (PPOINT) Point, (PBYTE)lpbTypes, cCount ); + return NtGdiPolyDraw( hDC , (PPOINT) Point, (PBYTE)lpbTypes, cCount ); } @@ -500,27 +500,27 @@ Polygon(HDC hDC, const POINT *Point, int Count) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_Polygon( hDC, Point, Count ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_Polygon( hDC, Point, Count ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_Polygon( hDC, Point, Count ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_Polygon( hDC, Point, Count ); + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, (PULONG)&Count, 1, GdiPolyPolygon ); + return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, (PULONG)&Count, 1, GdiPolyPolygon ); } @@ -533,27 +533,27 @@ Polyline(HDC hDC, const POINT *Point, int Count) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_Polyline( hDC, Point, Count ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_Polyline( hDC, Point, Count ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_Polyline( hDC, Point, Count ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_Polyline( hDC, Point, Count ); + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, (PULONG)&Count, 1, GdiPolyPolyLine ); + return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, (PULONG)&Count, 1, GdiPolyPolyLine ); } @@ -566,27 +566,27 @@ PolylineTo(HDC hDC, const POINT* Point, DWORD Count) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return FALSE; // Not supported yet. - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return FALSE; // Not supported yet. + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, &Count, 1, GdiPolyLineTo ); + return NtGdiPolyPolyDraw( hDC , (PPOINT) Point, &Count, 1, GdiPolyLineTo ); } @@ -599,27 +599,27 @@ PolyPolygon(HDC hDC, const POINT* Point, const INT* Count, int Polys) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_PolyPolygon( hDC, Point, Count, Polys); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_PolyPolygon( hDC, Point, Count, Polys ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_PolyPolygon( hDC, Point, Count, Polys); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_PolyPolygon( hDC, Point, Count, Polys ); + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT)Point, (PULONG)Count, Polys, GdiPolyPolygon ); + return NtGdiPolyPolyDraw( hDC , (PPOINT)Point, (PULONG)Count, Polys, GdiPolyPolygon ); } @@ -632,27 +632,27 @@ PolyPolyline(HDC hDC, const POINT* Point, const DWORD* Counts, DWORD Polys) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return FALSE; - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_PolyPolyline(hDC, Point, Counts, Polys); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return FALSE; + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_PolyPolyline(hDC, Point, Counts, Polys); + } + return FALSE; + } } - } #endif - return NtGdiPolyPolyDraw( hDC , (PPOINT)Point, (PULONG)Counts, Polys, GdiPolyPolyLine ); + return NtGdiPolyPolyDraw( hDC , (PPOINT)Point, (PULONG)Counts, Polys, GdiPolyPolyLine ); } @@ -662,34 +662,34 @@ PolyPolyline(HDC hDC, const POINT* Point, const DWORD* Counts, DWORD Polys) BOOL WINAPI ExtFloodFill( - HDC hDC, - int nXStart, - int nYStart, - COLORREF crFill, - UINT fuFillType - ) + HDC hDC, + int nXStart, + int nYStart, + COLORREF crFill, + UINT fuFillType +) { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_ExtFloodFill( hDC, nXStart, nYStart, crFill, fuFillType ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hDC); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - return EMFDRV_ExtFloodFill( hDC, nXStart, nYStart, crFill, fuFillType ); - } - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_ExtFloodFill( hDC, nXStart, nYStart, crFill, fuFillType ); + else + { + PLDC pLDC = GdiGetLDC(hDC); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + return EMFDRV_ExtFloodFill( hDC, nXStart, nYStart, crFill, fuFillType ); + } + return FALSE; + } } - } #endif return NtGdiExtFloodFill(hDC, nXStart, nYStart, crFill, fuFillType); } @@ -715,32 +715,32 @@ FloodFill( */ BOOL WINAPI MaskBlt( - HDC hdcDest, - INT nXDest, - INT nYDest, - INT nWidth, - INT nHeight, - HDC hdcSrc, - INT nXSrc, - INT nYSrc, - HBITMAP hbmMask, - INT xMask, - INT yMask, - DWORD dwRop) + HDC hdcDest, + INT nXDest, + INT nYDest, + INT nWidth, + INT nHeight, + HDC hdcSrc, + INT nXSrc, + INT nYSrc, + HBITMAP hbmMask, + INT xMask, + INT yMask, + DWORD dwRop) { - return NtGdiMaskBlt(hdcDest, - nXDest, - nYDest, - nWidth, - nHeight, - hdcSrc, - nXSrc, - nYSrc, - hbmMask, - xMask, - yMask, - dwRop, - GetBkColor(hdcSrc)); + return NtGdiMaskBlt(hdcDest, + nXDest, + nYDest, + nWidth, + nHeight, + hdcSrc, + nXSrc, + nYSrc, + hbmMask, + xMask, + yMask, + dwRop, + GetBkColor(hdcSrc)); } @@ -750,26 +750,26 @@ MaskBlt( BOOL WINAPI PlgBlt( - HDC hdcDest, - const POINT *lpPoint, - HDC hdcSrc, - INT nXSrc, - INT nYSrc, - INT nWidth, - INT nHeight, - HBITMAP hbmMask, - INT xMask, - INT yMask) + HDC hdcDest, + const POINT *lpPoint, + HDC hdcSrc, + INT nXSrc, + INT nYSrc, + INT nWidth, + INT nHeight, + HBITMAP hbmMask, + INT xMask, + INT yMask) { - return NtGdiPlgBlt(hdcDest, - (LPPOINT)lpPoint, - hdcSrc, - nXSrc, - nYSrc, - nWidth, - nHeight, - hbmMask, - xMask, - yMask, - GetBkColor(hdcSrc)); + return NtGdiPlgBlt(hdcDest, + (LPPOINT)lpPoint, + hdcSrc, + nXSrc, + nYSrc, + nWidth, + nHeight, + hbmMask, + xMask, + yMask, + GetBkColor(hdcSrc)); } diff --git a/reactos/dll/win32/gdi32/objects/palette.c b/reactos/dll/win32/gdi32/objects/palette.c index 4301ac605ea..9c7b471b82c 100644 --- a/reactos/dll/win32/gdi32/objects/palette.c +++ b/reactos/dll/win32/gdi32/objects/palette.c @@ -104,10 +104,10 @@ GetSystemPaletteEntries(HDC hDC, RtlCopyMemory(ippe, sys_pal_template, 10 * sizeof(PALETTEENTRY)); RtlCopyMemory(&ippe[246], &sys_pal_template[10], 10 * sizeof(PALETTEENTRY)); RtlZeroMemory(&ippe[10], sizeof(ippe) - 20 * sizeof(PALETTEENTRY)); - + if (iStartIndex < 256) { - RtlCopyMemory(ppe, + RtlCopyMemory(ppe, &ippe[iStartIndex], min(256 - iStartIndex, cEntries) * sizeof(PALETTEENTRY)); @@ -125,9 +125,9 @@ GetDIBColorTable(HDC hDC, UINT cEntries, RGBQUAD *pColors) { - if (cEntries) - return NtGdiDoPalette(hDC, iStartIndex, cEntries, pColors, GdiPalGetColorTable, FALSE); - return 0; + if (cEntries) + return NtGdiDoPalette(hDC, iStartIndex, cEntries, pColors, GdiPalGetColorTable, FALSE); + return 0; } /* @@ -139,21 +139,21 @@ RealizePalette(HDC hDC) /* [in] Handle of device context */ { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_(hDC); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - HPALETTE Pal = GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE); - PLDC pLDC = GdiGetLDC((HDC) Pal); - if ( !pLDC ) return FALSE; - if (pLDC->iType == LDC_EMFLDC) return EMFDRV_(Pal); - return FALSE; + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_(hDC); + else + { + HPALETTE Pal = GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE); + PLDC pLDC = GdiGetLDC((HDC) Pal); + if ( !pLDC ) return FALSE; + if (pLDC->iType == LDC_EMFLDC) return EMFDRV_(Pal); + return FALSE; + } } - } #endif - return UserRealizePalette(hDC); + return UserRealizePalette(hDC); } /* @@ -162,11 +162,11 @@ RealizePalette(HDC hDC) /* [in] Handle of device context */ BOOL WINAPI ResizePalette( - HPALETTE hPalette, - UINT nEntries - ) + HPALETTE hPalette, + UINT nEntries +) { - return NtGdiResizePalette(hPalette, nEntries); + return NtGdiResizePalette(hPalette, nEntries); } /* @@ -195,11 +195,11 @@ SetDIBColorTable(HDC hDC, BOOL WINAPI UpdateColors( - HDC hdc - ) + HDC hdc +) { - ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; - return NtGdiUpdateColors(hdc); + ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + return NtGdiUpdateColors(hdc); } /* EOF */ diff --git a/reactos/dll/win32/gdi32/objects/path.c b/reactos/dll/win32/gdi32/objects/path.c index e3ea862a3f8..8a35a0e1e9f 100644 --- a/reactos/dll/win32/gdi32/objects/path.c +++ b/reactos/dll/win32/gdi32/objects/path.c @@ -17,10 +17,10 @@ BOOL WINAPI AbortPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiAbortPath( hdc ); + return NtGdiAbortPath( hdc ); } @@ -30,10 +30,10 @@ AbortPath( BOOL WINAPI BeginPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiBeginPath( hdc ); + return NtGdiBeginPath( hdc ); } /* @@ -42,10 +42,10 @@ BeginPath( BOOL WINAPI CloseFigure( - HDC hdc - ) + HDC hdc +) { - return NtGdiCloseFigure ( hdc ); + return NtGdiCloseFigure ( hdc ); } @@ -55,10 +55,10 @@ CloseFigure( BOOL WINAPI EndPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiEndPath( hdc ); + return NtGdiEndPath( hdc ); } @@ -68,10 +68,10 @@ EndPath( BOOL WINAPI FillPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiFillPath( hdc ); + return NtGdiFillPath( hdc ); } @@ -81,10 +81,10 @@ FillPath( BOOL WINAPI FlattenPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiFlattenPath ( hdc ); + return NtGdiFlattenPath ( hdc ); } @@ -119,10 +119,10 @@ GetPath(HDC hdc, HRGN WINAPI PathToRegion( - HDC hdc - ) + HDC hdc +) { - return NtGdiPathToRegion ( hdc ); + return NtGdiPathToRegion ( hdc ); } /* @@ -131,18 +131,18 @@ PathToRegion( BOOL WINAPI SetMiterLimit( - HDC hdc, - FLOAT a1, - PFLOAT a2 - ) + HDC hdc, + FLOAT a1, + PFLOAT a2 +) { - BOOL Ret; - gxf_long worker, worker1; + BOOL Ret; + gxf_long worker, worker1; - worker.f = a1; - Ret = NtGdiSetMiterLimit ( hdc, worker.l, a2 ? &worker1.l : NULL ); - if (a2 && Ret) *a2 = worker1.f; - return Ret; + worker.f = a1; + Ret = NtGdiSetMiterLimit ( hdc, worker.l, a2 ? &worker1.l : NULL ); + if (a2 && Ret) *a2 = worker1.f; + return Ret; } @@ -152,10 +152,10 @@ SetMiterLimit( BOOL WINAPI StrokeAndFillPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiStrokeAndFillPath ( hdc ); + return NtGdiStrokeAndFillPath ( hdc ); } @@ -165,10 +165,10 @@ StrokeAndFillPath( BOOL WINAPI StrokePath( - HDC hdc - ) + HDC hdc +) { - return NtGdiStrokePath ( hdc ); + return NtGdiStrokePath ( hdc ); } @@ -178,10 +178,10 @@ StrokePath( BOOL WINAPI WidenPath( - HDC hdc - ) + HDC hdc +) { - return NtGdiWidenPath ( hdc ); + return NtGdiWidenPath ( hdc ); } /* @@ -190,9 +190,9 @@ WidenPath( BOOL WINAPI SelectClipPath( - HDC hdc, - int Mode - ) + HDC hdc, + int Mode +) { - return NtGdiSelectClipPath ( hdc, Mode ); + return NtGdiSelectClipPath ( hdc, Mode ); } diff --git a/reactos/dll/win32/gdi32/objects/pen.c b/reactos/dll/win32/gdi32/objects/pen.c index 32ed648f0d5..0a431c20049 100644 --- a/reactos/dll/win32/gdi32/objects/pen.c +++ b/reactos/dll/win32/gdi32/objects/pen.c @@ -26,8 +26,8 @@ CreatePen( /* FIXME Some part need be done in user mode */ if (nPenStyle > PS_DASHDOTDOT) { - if (nPenStyle == PS_NULL) return GetStockObject(NULL_PEN); - if (nPenStyle != PS_INSIDEFRAME) nPenStyle = PS_SOLID; + if (nPenStyle == PS_NULL) return GetStockObject(NULL_PEN); + if (nPenStyle != PS_INSIDEFRAME) nPenStyle = PS_SOLID; } return NtGdiCreatePen(nPenStyle, nWidth, crColor, NULL); } diff --git a/reactos/dll/win32/gdi32/objects/printdrv.c b/reactos/dll/win32/gdi32/objects/printdrv.c index 379b85e96bb..3c6d0e89917 100644 --- a/reactos/dll/win32/gdi32/objects/printdrv.c +++ b/reactos/dll/win32/gdi32/objects/printdrv.c @@ -71,68 +71,68 @@ static int FASTCALL IntEndPage( - HDC hdc, - BOOL Form - ) + HDC hdc, + BOOL Form +) { - PLDC pldc; - int Ret = SP_ERROR; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + int Ret = SP_ERROR; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - pldc = GdiGetLDC(hdc); - if ( !pldc ) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + pldc = GdiGetLDC(hdc); + if ( !pldc ) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - if (pldc->Flags & LDC_ATENDPAGE) return 1; + if (pldc->Flags & LDC_ATENDPAGE) return 1; - if (pldc->Flags & LDC_META_PRINT) - { - if ( Form ) - { - // Do MF EndPageForm - } - else - { - // Do MF EndPage - } - return Ret; - } + if (pldc->Flags & LDC_META_PRINT) + { + if ( Form ) + { + // Do MF EndPageForm + } + else + { + // Do MF EndPage + } + return Ret; + } - if (pldc->Flags & LDC_KILL_DOCUMENT || pldc->Flags & LDC_INIT_PAGE) - { - SetLastError(ERROR_INVALID_PARAMETER); - return SP_ERROR; - } + if (pldc->Flags & LDC_KILL_DOCUMENT || pldc->Flags & LDC_INIT_PAGE) + { + SetLastError(ERROR_INVALID_PARAMETER); + return SP_ERROR; + } - if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc); + if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc); - pldc->Flags &= ~LDC_INIT_PAGE; + pldc->Flags &= ~LDC_INIT_PAGE; - DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDPAGE, 0, NULL, 0, NULL); + DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDPAGE, 0, NULL, 0, NULL); - ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; - if ( NtGdiEndPage(hdc) ) - { - BOOL Good; + if ( NtGdiEndPage(hdc) ) + { + BOOL Good; // if (pldc->pUMPDev) - Good = EndPagePrinterEx(NULL,pldc->hPrinter); + Good = EndPagePrinterEx(NULL,pldc->hPrinter); - if (Good) pldc->Flags |= LDC_STARTPAGE; - Ret = 1; - } - else - SetLastError(ERROR_INVALID_PARAMETER); - return Ret; + if (Good) pldc->Flags |= LDC_STARTPAGE; + Ret = 1; + } + else + SetLastError(ERROR_INVALID_PARAMETER); + return Ret; } /* FUNCTIONS *****************************************************************/ @@ -140,9 +140,9 @@ IntEndPage( BOOL FASTCALL AbortPrinterEx( - PVOID pvUMPDev, - HANDLE hPrinter - ) + PVOID pvUMPDev, + HANDLE hPrinter +) { return fpAbortPrinter(hPrinter); } @@ -150,15 +150,15 @@ AbortPrinterEx( int FASTCALL DocumentEventEx( - PVOID pvUMPDev, - HANDLE hPrinter, - HDC hdc, - int iEsc, - ULONG cbIn, - PVOID pvIn, - ULONG cbOut, - PVOID pvOut - ) + PVOID pvUMPDev, + HANDLE hPrinter, + HDC hdc, + int iEsc, + ULONG cbIn, + PVOID pvIn, + ULONG cbOut, + PVOID pvOut +) { return fpDocumentEvent(hPrinter,hdc,iEsc,cbIn,pvIn,cbOut,pvOut); } @@ -166,9 +166,9 @@ DocumentEventEx( BOOL FASTCALL EndDocPrinterEx( - PVOID pvUMPDev, - HANDLE hPrinter - ) + PVOID pvUMPDev, + HANDLE hPrinter +) { return fpEndDocPrinter(hPrinter); } @@ -176,91 +176,91 @@ EndDocPrinterEx( BOOL FASTCALL EndPagePrinterEx( - PVOID pvUMPDev, - HANDLE hPrinter - ) + PVOID pvUMPDev, + HANDLE hPrinter +) { return fpEndPagePrinter(hPrinter); } - + BOOL FASTCALL LoadTheSpoolerDrv(VOID) { - HMODULE hModWinSpoolDrv; + HMODULE hModWinSpoolDrv; - if ( !ghSpooler ) - { - RtlEnterCriticalSection(&semLocal); + if ( !ghSpooler ) + { + RtlEnterCriticalSection(&semLocal); - hModWinSpoolDrv = LoadLibraryW(L"WINSPOOL.DRV"); + hModWinSpoolDrv = LoadLibraryW(L"WINSPOOL.DRV"); - if (hModWinSpoolDrv) - { - fpAbortPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "AbortPrinter"); - fpClosePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "ClosePrinter"); - fpCloseSpoolFileHandle = (PVOID)GetProcAddress(hModWinSpoolDrv, "CloseSpoolFileHandle"); - fpCommitSpoolData = (PVOID)GetProcAddress(hModWinSpoolDrv, "CommitSpoolData"); - // fpConnectToLd64In32Server = (PVOID)GetProcAddress(hModWinSpoolDrv, (LPCSTR)224); - fpDocumentEvent = (PVOID)GetProcAddress(hModWinSpoolDrv,"DocumentEvent"); - fpDocumentPropertiesW = (PVOID)GetProcAddress(hModWinSpoolDrv, "DocumentPropertiesW"); - fpEndDocPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "EndDocPrinter"); - fpEndPagePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "EndPagePrinter"); - fpGetPrinterW = (PVOID)GetProcAddress( hModWinSpoolDrv,"GetPrinterW"); - fpGetPrinterDriverW = (PVOID)GetProcAddress(hModWinSpoolDrv,"GetPrinterDriverW"); - fpGetSpoolFileHandle = (PVOID)GetProcAddress(hModWinSpoolDrv, "GetSpoolFileHandle"); - fpIsValidDevmodeW = (PVOID)GetProcAddress(hModWinSpoolDrv, "IsValidDevmodeW"); - fpOpenPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "OpenPrinterW"); - fpQueryColorProfile = (PVOID)GetProcAddress(hModWinSpoolDrv,"QueryColorProfile"); - fpQueryRemoteFonts = (PVOID)GetProcAddress(hModWinSpoolDrv, "QueryRemoteFonts"); - fpQuerySpoolMode = (PVOID)GetProcAddress(hModWinSpoolDrv, "QuerySpoolMode"); - fpReadPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "ReadPrinter"); - fpResetPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "ResetPrinterW"); - fpSeekPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "SeekPrinter"); - fpSplDriverUnloadComplete = (PVOID)GetProcAddress(hModWinSpoolDrv, "SplDriverUnloadComplete"); - fpSplReadPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, (LPCSTR)205); - fpStartDocDlgW = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartDocDlgW"); - fpStartDocPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartDocPrinterW"); - fpStartPagePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartPagePrinter"); - - if ( !fpAbortPrinter || - !fpClosePrinter || - !fpCloseSpoolFileHandle || - !fpCommitSpoolData || - !fpDocumentEvent || - !fpDocumentPropertiesW || - !fpEndDocPrinter || - !fpEndPagePrinter || - !fpGetPrinterW || - !fpGetPrinterDriverW || - !fpGetSpoolFileHandle || - !fpIsValidDevmodeW || - !fpOpenPrinterW || - !fpQueryColorProfile || - !fpQueryRemoteFonts || - !fpQuerySpoolMode || - !fpReadPrinter || - !fpResetPrinterW || - !fpSeekPrinter || - !fpSplDriverUnloadComplete || - !fpSplReadPrinter || - !fpStartDocDlgW || - !fpStartDocPrinterW || - !fpStartPagePrinter ) + if (hModWinSpoolDrv) { - FreeLibrary(hModWinSpoolDrv); - hModWinSpoolDrv = NULL; + fpAbortPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "AbortPrinter"); + fpClosePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "ClosePrinter"); + fpCloseSpoolFileHandle = (PVOID)GetProcAddress(hModWinSpoolDrv, "CloseSpoolFileHandle"); + fpCommitSpoolData = (PVOID)GetProcAddress(hModWinSpoolDrv, "CommitSpoolData"); + // fpConnectToLd64In32Server = (PVOID)GetProcAddress(hModWinSpoolDrv, (LPCSTR)224); + fpDocumentEvent = (PVOID)GetProcAddress(hModWinSpoolDrv,"DocumentEvent"); + fpDocumentPropertiesW = (PVOID)GetProcAddress(hModWinSpoolDrv, "DocumentPropertiesW"); + fpEndDocPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "EndDocPrinter"); + fpEndPagePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "EndPagePrinter"); + fpGetPrinterW = (PVOID)GetProcAddress( hModWinSpoolDrv,"GetPrinterW"); + fpGetPrinterDriverW = (PVOID)GetProcAddress(hModWinSpoolDrv,"GetPrinterDriverW"); + fpGetSpoolFileHandle = (PVOID)GetProcAddress(hModWinSpoolDrv, "GetSpoolFileHandle"); + fpIsValidDevmodeW = (PVOID)GetProcAddress(hModWinSpoolDrv, "IsValidDevmodeW"); + fpOpenPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "OpenPrinterW"); + fpQueryColorProfile = (PVOID)GetProcAddress(hModWinSpoolDrv,"QueryColorProfile"); + fpQueryRemoteFonts = (PVOID)GetProcAddress(hModWinSpoolDrv, "QueryRemoteFonts"); + fpQuerySpoolMode = (PVOID)GetProcAddress(hModWinSpoolDrv, "QuerySpoolMode"); + fpReadPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "ReadPrinter"); + fpResetPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "ResetPrinterW"); + fpSeekPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "SeekPrinter"); + fpSplDriverUnloadComplete = (PVOID)GetProcAddress(hModWinSpoolDrv, "SplDriverUnloadComplete"); + fpSplReadPrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, (LPCSTR)205); + fpStartDocDlgW = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartDocDlgW"); + fpStartDocPrinterW = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartDocPrinterW"); + fpStartPagePrinter = (PVOID)GetProcAddress(hModWinSpoolDrv, "StartPagePrinter"); + + if ( !fpAbortPrinter || + !fpClosePrinter || + !fpCloseSpoolFileHandle || + !fpCommitSpoolData || + !fpDocumentEvent || + !fpDocumentPropertiesW || + !fpEndDocPrinter || + !fpEndPagePrinter || + !fpGetPrinterW || + !fpGetPrinterDriverW || + !fpGetSpoolFileHandle || + !fpIsValidDevmodeW || + !fpOpenPrinterW || + !fpQueryColorProfile || + !fpQueryRemoteFonts || + !fpQuerySpoolMode || + !fpReadPrinter || + !fpResetPrinterW || + !fpSeekPrinter || + !fpSplDriverUnloadComplete || + !fpSplReadPrinter || + !fpStartDocDlgW || + !fpStartDocPrinterW || + !fpStartPagePrinter ) + { + FreeLibrary(hModWinSpoolDrv); + hModWinSpoolDrv = NULL; + } + ghSpooler = hModWinSpoolDrv; } - ghSpooler = hModWinSpoolDrv; - } - RtlLeaveCriticalSection(&semLocal); - } - else - return TRUE; + RtlLeaveCriticalSection(&semLocal); + } + else + return TRUE; - if ( !ghSpooler ) SetLastError(ERROR_NOT_ENOUGH_MEMORY); + if ( !ghSpooler ) SetLastError(ERROR_NOT_ENOUGH_MEMORY); - return (ghSpooler != NULL); + return (ghSpooler != NULL); } /* @@ -274,16 +274,16 @@ LoadTheSpoolerDrv(VOID) 4. To end each page, call EndPagePrinter. 5. Repeat 2, 3, and 4 for as many pages as necessary. 6. To end the print job, call EndDocPrinter. - + */ DWORD FASTCALL StartDocPrinterWEx( - PVOID pvUMPDev, - HANDLE hPrinter, - DWORD Level, - LPBYTE pDocInfo - ) + PVOID pvUMPDev, + HANDLE hPrinter, + DWORD Level, + LPBYTE pDocInfo +) { return fpStartDocPrinterW(hPrinter,Level,pDocInfo); } @@ -291,9 +291,9 @@ StartDocPrinterWEx( BOOL FASTCALL StartPagePrinterEx( - PVOID pvUMPDev, - HANDLE hPrinter - ) + PVOID pvUMPDev, + HANDLE hPrinter +) { return fpStartPagePrinter(hPrinter); } @@ -306,49 +306,49 @@ StartPagePrinterEx( int WINAPI AbortDoc( - HDC hdc - ) + HDC hdc +) { - PLDC pldc; - int Ret = SP_ERROR; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + int Ret = SP_ERROR; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - pldc = GdiGetLDC(hdc); - if ( !pldc ) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + pldc = GdiGetLDC(hdc); + if ( !pldc ) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - if ( !(pldc->Flags & LDC_INIT_DOCUMENT) ) return 1; + if ( !(pldc->Flags & LDC_INIT_DOCUMENT) ) return 1; - DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ABORTDOC, 0, NULL, 0, NULL); - - ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ABORTDOC, 0, NULL, 0, NULL); - if ( pldc->Flags & LDC_META_PRINT) - { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return Ret; - } + ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; - if (NtGdiAbortDoc(hdc)) - { - if (fpAbortPrinter(pldc->hPrinter)) Ret = 1; - } - else - Ret = SP_ERROR; + if ( pldc->Flags & LDC_META_PRINT) + { + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return Ret; + } - pldc->Flags &= ~(LDC_ATENDPAGE|LDC_META_PRINT|LDC_STARTPAGE|LDC_INIT_PAGE|LDC_INIT_DOCUMENT|LDC_SAPCALLBACK); + if (NtGdiAbortDoc(hdc)) + { + if (fpAbortPrinter(pldc->hPrinter)) Ret = 1; + } + else + Ret = SP_ERROR; - return Ret; + pldc->Flags &= ~(LDC_ATENDPAGE|LDC_META_PRINT|LDC_STARTPAGE|LDC_INIT_PAGE|LDC_INIT_DOCUMENT|LDC_SAPCALLBACK); + + return Ret; } /* @@ -357,55 +357,55 @@ AbortDoc( int WINAPI EndDoc( - HDC hdc - ) + HDC hdc +) { - PLDC pldc; - int Ret = SP_ERROR; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + int Ret = SP_ERROR; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - pldc = GdiGetLDC(hdc); - if ( !pldc ) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + pldc = GdiGetLDC(hdc); + if ( !pldc ) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - if (pldc->Flags & LDC_META_PRINT) - { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return Ret; - } + if (pldc->Flags & LDC_META_PRINT) + { + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return Ret; + } - if (pldc->Flags & LDC_INIT_DOCUMENT) - { - BOOL Good; - if (pldc->Flags & LDC_INIT_PAGE) EndPage(hdc); + if (pldc->Flags & LDC_INIT_DOCUMENT) + { + BOOL Good; + if (pldc->Flags & LDC_INIT_PAGE) EndPage(hdc); - DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDDOC, 0, NULL, 0, NULL); - - ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDDOC, 0, NULL, 0, NULL); - Good = NtGdiEndDoc(hdc); + ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + + Good = NtGdiEndDoc(hdc); // if (pldc->pUMPDev) - Good = EndDocPrinterEx(NULL,pldc->hPrinter); + Good = EndDocPrinterEx(NULL,pldc->hPrinter); - if (Good) - { - DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDDOCPOST, 0, NULL, 0, NULL); - Ret = 1; - } - pldc->Flags &= ~(LDC_ATENDPAGE|LDC_STARTPAGE|LDC_INIT_DOCUMENT|LDC_SAPCALLBACK); - } - return Ret; + if (Good) + { + DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_ENDDOCPOST, 0, NULL, 0, NULL); + Ret = 1; + } + pldc->Flags &= ~(LDC_ATENDPAGE|LDC_STARTPAGE|LDC_INIT_DOCUMENT|LDC_SAPCALLBACK); + } + return Ret; } /* @@ -415,7 +415,7 @@ int WINAPI EndFormPage(HDC hdc) { - return IntEndPage(hdc,TRUE); + return IntEndPage(hdc,TRUE); } /* @@ -425,7 +425,7 @@ int WINAPI EndPage(HDC hdc ) { - return IntEndPage(hdc,FALSE); + return IntEndPage(hdc,FALSE); } /* @@ -472,121 +472,121 @@ GdiGetPageCount(HANDLE SpoolFileHandle) int WINAPI StartDocW( - HDC hdc, - CONST DOCINFOW *lpdi - ) + HDC hdc, + CONST DOCINFOW *lpdi +) { - PLDC pldc; - DOCINFOW diW; - DOC_INFO_1W di1W; - LPWSTR lpwstrRet = NULL; - BOOL Banding; - int PrnJobNo, Ret = SP_ERROR; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + DOCINFOW diW; + DOC_INFO_1W di1W; + LPWSTR lpwstrRet = NULL; + BOOL Banding; + int PrnJobNo, Ret = SP_ERROR; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - return SP_ERROR; + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + return SP_ERROR; - pldc = GdiGetLDC(hdc); - if ( !pldc || pldc->Flags & LDC_ATENDPAGE) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + pldc = GdiGetLDC(hdc); + if ( !pldc || pldc->Flags & LDC_ATENDPAGE) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - if (!pldc->hPrinter) return SP_ERROR; + if (!pldc->hPrinter) return SP_ERROR; - pldc->Flags &= ~LDC_KILL_DOCUMENT; + pldc->Flags &= ~LDC_KILL_DOCUMENT; - if (lpdi) - RtlCopyMemory(&diW, lpdi, sizeof(DOCINFOW)); - else - { - diW.cbSize = sizeof(DOCINFOW); - diW.lpszDocName = NULL; - diW.lpszOutput = NULL; - diW.lpszDatatype = NULL; - diW.fwType = 0; - } + if (lpdi) + RtlCopyMemory(&diW, lpdi, sizeof(DOCINFOW)); + else + { + diW.cbSize = sizeof(DOCINFOW); + diW.lpszDocName = NULL; + diW.lpszOutput = NULL; + diW.lpszDatatype = NULL; + diW.fwType = 0; + } - if (!diW.lpszOutput) - if (pldc->pwszPort) diW.lpszOutput = pldc->pwszPort; + if (!diW.lpszOutput) + if (pldc->pwszPort) diW.lpszOutput = pldc->pwszPort; - lpwstrRet = fpStartDocDlgW(pldc->hPrinter, &diW); - if (lpwstrRet == (LPWSTR)SP_APPABORT) - { - pldc->Flags |= LDC_KILL_DOCUMENT; - return SP_ERROR; - } - if (lpwstrRet == (LPWSTR)SP_ERROR) return SP_ERROR; + lpwstrRet = fpStartDocDlgW(pldc->hPrinter, &diW); + if (lpwstrRet == (LPWSTR)SP_APPABORT) + { + pldc->Flags |= LDC_KILL_DOCUMENT; + return SP_ERROR; + } + if (lpwstrRet == (LPWSTR)SP_ERROR) return SP_ERROR; - if (lpwstrRet != 0) diW.lpszOutput = lpwstrRet; + if (lpwstrRet != 0) diW.lpszOutput = lpwstrRet; - Ret = DocumentEventEx( NULL, - pldc->hPrinter, - hdc, - DOCUMENTEVENT_STARTDOC, - sizeof(ULONG), - &diW, - 0, - NULL); + Ret = DocumentEventEx( NULL, + pldc->hPrinter, + hdc, + DOCUMENTEVENT_STARTDOC, + sizeof(ULONG), + &diW, + 0, + NULL); - if (Ret == SP_APPABORT) - { - pldc->Flags |= LDC_KILL_DOCUMENT; - Ret = SP_ERROR; - } - if (Ret == SP_ERROR) - { - if (lpwstrRet) LocalFree(lpwstrRet); - return Ret; - } + if (Ret == SP_APPABORT) + { + pldc->Flags |= LDC_KILL_DOCUMENT; + Ret = SP_ERROR; + } + if (Ret == SP_ERROR) + { + if (lpwstrRet) LocalFree(lpwstrRet); + return Ret; + } - di1W.pDocName = (LPWSTR)diW.lpszDocName; - di1W.pOutputFile = (LPWSTR)diW.lpszOutput; - di1W.pDatatype = (LPWSTR)diW.lpszDatatype; + di1W.pDocName = (LPWSTR)diW.lpszDocName; + di1W.pOutputFile = (LPWSTR)diW.lpszOutput; + di1W.pDatatype = (LPWSTR)diW.lpszDatatype; - Ret = SP_ERROR; + Ret = SP_ERROR; - PrnJobNo = StartDocPrinterWEx(NULL, pldc->hPrinter, 1, (LPBYTE)&di1W); - if (PrnJobNo <= 0) - { - Ret = NtGdiStartDoc( hdc, &diW, &Banding, PrnJobNo); - if (Ret) - { - if (pldc->pAbortProc) - { - GdiSAPCallback(pldc); - pldc->Flags |= LDC_SAPCALLBACK; - pldc->CallBackTick = GetTickCount(); - } - pldc->Flags |= LDC_INIT_DOCUMENT; - if (!Banding) pldc->Flags |= LDC_STARTPAGE; - } - } - if (Ret == SP_ERROR) - { - //if ( pldc->pUMPDev ) - AbortPrinterEx(NULL, pldc->hPrinter); - DPRINT1("StartDoc Died!!!\n"); - } - else - { - if ( DocumentEventEx( NULL, - pldc->hPrinter, - hdc, - DOCUMENTEVENT_STARTDOCPOST, - sizeof(ULONG), - &Ret, - 0, - NULL) == SP_ERROR) - { - AbortDoc(hdc); - Ret = SP_ERROR; - } - } - if (lpwstrRet) LocalFree(lpwstrRet); - return Ret; + PrnJobNo = StartDocPrinterWEx(NULL, pldc->hPrinter, 1, (LPBYTE)&di1W); + if (PrnJobNo <= 0) + { + Ret = NtGdiStartDoc( hdc, &diW, &Banding, PrnJobNo); + if (Ret) + { + if (pldc->pAbortProc) + { + GdiSAPCallback(pldc); + pldc->Flags |= LDC_SAPCALLBACK; + pldc->CallBackTick = GetTickCount(); + } + pldc->Flags |= LDC_INIT_DOCUMENT; + if (!Banding) pldc->Flags |= LDC_STARTPAGE; + } + } + if (Ret == SP_ERROR) + { + //if ( pldc->pUMPDev ) + AbortPrinterEx(NULL, pldc->hPrinter); + DPRINT1("StartDoc Died!!!\n"); + } + else + { + if ( DocumentEventEx( NULL, + pldc->hPrinter, + hdc, + DOCUMENTEVENT_STARTDOCPOST, + sizeof(ULONG), + &Ret, + 0, + NULL) == SP_ERROR) + { + AbortDoc(hdc); + Ret = SP_ERROR; + } + } + if (lpwstrRet) LocalFree(lpwstrRet); + return Ret; } /* @@ -595,9 +595,9 @@ StartDocW( int WINAPI StartDocA( - HDC hdc, - CONST DOCINFOA *lpdi - ) + HDC hdc, + CONST DOCINFOA *lpdi +) { LPWSTR szDocName = NULL, szOutput = NULL, szDatatype = NULL; DOCINFOW docW; @@ -643,52 +643,52 @@ StartDocA( int WINAPI StartPage( - HDC hdc - ) + HDC hdc +) { - PLDC pldc; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - pldc = GdiGetLDC(hdc); - if ( !pldc ) - { - SetLastError(ERROR_INVALID_HANDLE); - return SP_ERROR; - } + pldc = GdiGetLDC(hdc); + if ( !pldc ) + { + SetLastError(ERROR_INVALID_HANDLE); + return SP_ERROR; + } - if (pldc->Flags & LDC_META_PRINT) - { - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return SP_ERROR; - } + if (pldc->Flags & LDC_META_PRINT) + { + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return SP_ERROR; + } - pldc->Flags &= ~(LDC_ATENDPAGE|LDC_STARTPAGE); + pldc->Flags &= ~(LDC_ATENDPAGE|LDC_STARTPAGE); - if (pldc->Flags & LDC_INIT_PAGE) return 1; + if (pldc->Flags & LDC_INIT_PAGE) return 1; - if (DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_STARTPAGE, 0, NULL, 0, NULL) != SP_ERROR) - { - pldc->Flags |= LDC_INIT_PAGE; + if (DocumentEventEx(NULL, pldc->hPrinter, hdc, DOCUMENTEVENT_STARTPAGE, 0, NULL, 0, NULL) != SP_ERROR) + { + pldc->Flags |= LDC_INIT_PAGE; - ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; + ((PW32CLIENTINFO)NtCurrentTeb()->Win32ClientInfo)->cSpins = 0; - if (StartPagePrinterEx(NULL, pldc->hPrinter)) - { - if (NtGdiStartPage(hdc)) return 1; - } + if (StartPagePrinterEx(NULL, pldc->hPrinter)) + { + if (NtGdiStartPage(hdc)) return 1; + } - pldc->Flags &= ~(LDC_INIT_PAGE); - EndDoc(hdc); - SetLastError(ERROR_INVALID_HANDLE); - } - return SP_ERROR; + pldc->Flags &= ~(LDC_INIT_PAGE); + EndDoc(hdc); + SetLastError(ERROR_INVALID_HANDLE); + } + return SP_ERROR; } /* @@ -697,37 +697,37 @@ StartPage( int WINAPI SetAbortProc( - HDC hdc, - ABORTPROC lpAbortProc) + HDC hdc, + ABORTPROC lpAbortProc) { - PLDC pldc; - ULONG hType = GDI_HANDLE_GET_TYPE(hdc); + PLDC pldc; + ULONG hType = GDI_HANDLE_GET_TYPE(hdc); - if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) - return SP_ERROR; + if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE) + return SP_ERROR; - pldc = GdiGetLDC(hdc); - if ( pldc ) - { - if ( lpAbortProc ) - { - if ( pldc->Flags & LDC_INIT_DOCUMENT ) - { - pldc->Flags |= LDC_SAPCALLBACK; - pldc->CallBackTick = GetTickCount(); - } - } - else - { - pldc->Flags &= ~LDC_SAPCALLBACK; - } - pldc->pAbortProc = lpAbortProc; - return 1; - } - else - { - SetLastError(ERROR_INVALID_HANDLE); - } - return SP_ERROR; + pldc = GdiGetLDC(hdc); + if ( pldc ) + { + if ( lpAbortProc ) + { + if ( pldc->Flags & LDC_INIT_DOCUMENT ) + { + pldc->Flags |= LDC_SAPCALLBACK; + pldc->CallBackTick = GetTickCount(); + } + } + else + { + pldc->Flags &= ~LDC_SAPCALLBACK; + } + pldc->pAbortProc = lpAbortProc; + return 1; + } + else + { + SetLastError(ERROR_INVALID_HANDLE); + } + return SP_ERROR; } diff --git a/reactos/dll/win32/gdi32/objects/region.c b/reactos/dll/win32/gdi32/objects/region.c index eb6395363e4..54140ed071d 100644 --- a/reactos/dll/win32/gdi32/objects/region.c +++ b/reactos/dll/win32/gdi32/objects/region.c @@ -26,38 +26,38 @@ INT FASTCALL ComplexityFromRects( PRECTL prc1, PRECTL prc2) { - if ( prc2->left >= prc1->left ) - { - if ( ( prc1->right >= prc2->right) && - ( prc1->top <= prc2->top ) && - ( prc1->bottom >= prc2->bottom ) ) - return SAME_RGN; + if ( prc2->left >= prc1->left ) + { + if ( ( prc1->right >= prc2->right) && + ( prc1->top <= prc2->top ) && + ( prc1->bottom >= prc2->bottom ) ) + return SAME_RGN; - if ( prc2->left > prc1->left ) - { + if ( prc2->left > prc1->left ) + { + if ( ( prc1->left >= prc2->right ) || + ( prc1->right <= prc2->left ) || + ( prc1->top >= prc2->bottom ) || + ( prc1->bottom <= prc2->top ) ) + return DIFF_RGN; + } + } + + if ( ( prc2->right < prc1->right ) || + ( prc2->top > prc1->top ) || + ( prc2->bottom < prc1->bottom ) ) + { if ( ( prc1->left >= prc2->right ) || - ( prc1->right <= prc2->left ) || - ( prc1->top >= prc2->bottom ) || - ( prc1->bottom <= prc2->top ) ) - return DIFF_RGN; - } - } - - if ( ( prc2->right < prc1->right ) || - ( prc2->top > prc1->top ) || - ( prc2->bottom < prc1->bottom ) ) - { - if ( ( prc1->left >= prc2->right ) || - ( prc1->right <= prc2->left ) || - ( prc1->top >= prc2->bottom ) || - ( prc1->bottom <= prc2->top ) ) - return DIFF_RGN; - } - else - { - return INVERTED_RGN; - } - return OVERLAPPING_RGN; + ( prc1->right <= prc2->left ) || + ( prc1->top >= prc2->bottom ) || + ( prc1->bottom <= prc2->top ) ) + return DIFF_RGN; + } + else + { + return INVERTED_RGN; + } + return OVERLAPPING_RGN; } static @@ -65,36 +65,38 @@ VOID FASTCALL SortRects(PRECT pRect, INT nCount) { - INT i = 0, a = 0, b = 0, c, s; - RECT sRect; + INT i = 0, a = 0, b = 0, c, s; + RECT sRect; - if (nCount > 0) - { - i = 1; // set index point - c = nCount; // set inverse count - do - { - s = i; // set sort count - if ( i < nCount ) + if (nCount > 0) + { + i = 1; // set index point + c = nCount; // set inverse count + do { - a = i - 1; - b = i; - do - { - if(pRect[b].top != pRect[i].bottom) break; - if(pRect[b].left < pRect[a].left) - { - sRect = pRect[a]; - pRect[a] = pRect[b]; - pRect[b] = sRect; - } - ++s; - ++b; - } while ( s < nCount ); + s = i; // set sort count + if ( i < nCount ) + { + a = i - 1; + b = i; + do + { + if(pRect[b].top != pRect[i].bottom) break; + if(pRect[b].left < pRect[a].left) + { + sRect = pRect[a]; + pRect[a] = pRect[b]; + pRect[b] = sRect; + } + ++s; + ++b; + } + while ( s < nCount ); + } + ++i; } - ++i; - } while ( c-- != 1 ); - } + while ( c-- != 1 ); + } } /* @@ -105,82 +107,82 @@ FASTCALL DeleteRegion( HRGN hRgn ) { #if 0 - PRGN_ATTR Rgn_Attr; + PRGN_ATTR Rgn_Attr; - if ((GdiGetHandleUserData((HGDIOBJ) hRgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) && - ( Rgn_Attr != NULL )) - { - PGDIBSOBJECT pgO; - - pgO = GdiAllocBatchCommand(NULL, GdiBCDelRgn); - if (pgO) - { - pgO->hgdiobj = (HGDIOBJ)hRgn; - return TRUE; - } - } + if ((GdiGetHandleUserData((HGDIOBJ) hRgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) && + ( Rgn_Attr != NULL )) + { + PGDIBSOBJECT pgO; + + pgO = GdiAllocBatchCommand(NULL, GdiBCDelRgn); + if (pgO) + { + pgO->hgdiobj = (HGDIOBJ)hRgn; + return TRUE; + } + } #endif - return NtGdiDeleteObjectApp((HGDIOBJ) hRgn); + return NtGdiDeleteObjectApp((HGDIOBJ) hRgn); } INT FASTCALL MirrorRgnByWidth(HRGN hRgn, INT Width, HRGN *phRgn) { - INT cRgnDSize, Ret = 0; - PRGNDATA pRgnData; - - cRgnDSize = NtGdiGetRegionData(hRgn, 0, NULL); + INT cRgnDSize, Ret = 0; + PRGNDATA pRgnData; - if (cRgnDSize) - { - pRgnData = LocalAlloc(LMEM_FIXED, cRgnDSize * sizeof(LONG)); - if (pRgnData) - { - if ( GetRegionData(hRgn, cRgnDSize, pRgnData) ) + cRgnDSize = NtGdiGetRegionData(hRgn, 0, NULL); + + if (cRgnDSize) + { + pRgnData = LocalAlloc(LMEM_FIXED, cRgnDSize * sizeof(LONG)); + if (pRgnData) { - HRGN hRgnex; - UINT i; - INT SaveL = pRgnData->rdh.rcBound.left; - pRgnData->rdh.rcBound.left = Width - pRgnData->rdh.rcBound.right; - pRgnData->rdh.rcBound.right = Width - SaveL; - if (pRgnData->rdh.nCount > 0) - { - PRECT pRect = (PRECT)&pRgnData->Buffer; - for (i = 0; i < pRgnData->rdh.nCount; i++) - { - SaveL = pRect[i].left; - pRect[i].left = Width - pRect[i].right; - pRect[i].right = Width - SaveL; - } - } - SortRects((PRECT)&pRgnData->Buffer, pRgnData->rdh.nCount); - hRgnex = ExtCreateRegion(NULL, cRgnDSize , pRgnData); - if (hRgnex) - { - if (phRgn) phRgn = (HRGN *)hRgnex; - else - { - CombineRgn(hRgn, hRgnex, 0, RGN_COPY); - DeleteObject(hRgnex); - } - Ret = 1; - } + if ( GetRegionData(hRgn, cRgnDSize, pRgnData) ) + { + HRGN hRgnex; + UINT i; + INT SaveL = pRgnData->rdh.rcBound.left; + pRgnData->rdh.rcBound.left = Width - pRgnData->rdh.rcBound.right; + pRgnData->rdh.rcBound.right = Width - SaveL; + if (pRgnData->rdh.nCount > 0) + { + PRECT pRect = (PRECT)&pRgnData->Buffer; + for (i = 0; i < pRgnData->rdh.nCount; i++) + { + SaveL = pRect[i].left; + pRect[i].left = Width - pRect[i].right; + pRect[i].right = Width - SaveL; + } + } + SortRects((PRECT)&pRgnData->Buffer, pRgnData->rdh.nCount); + hRgnex = ExtCreateRegion(NULL, cRgnDSize , pRgnData); + if (hRgnex) + { + if (phRgn) phRgn = (HRGN *)hRgnex; + else + { + CombineRgn(hRgn, hRgnex, 0, RGN_COPY); + DeleteObject(hRgnex); + } + Ret = 1; + } + } + LocalFree(pRgnData); } - LocalFree(pRgnData); - } - } - return Ret; + } + return Ret; } INT WINAPI MirrorRgnDC(HDC hdc, HRGN hRgn, HRGN *phRgn) { - if (!GdiIsHandleValid((HGDIOBJ) hdc) || - (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return 0; + if (!GdiIsHandleValid((HGDIOBJ) hdc) || + (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)) return 0; - return MirrorRgnByWidth(hRgn, NtGdiGetDeviceWidth(hdc), phRgn); + return MirrorRgnByWidth(hRgn, NtGdiGetDeviceWidth(hdc), phRgn); } /* FUNCTIONS *****************************************************************/ @@ -195,202 +197,204 @@ CombineRgn(HRGN hDest, HRGN hSrc2, INT CombineMode) { - PRGN_ATTR pRgn_Attr_Dest = NULL; - PRGN_ATTR pRgn_Attr_Src1 = NULL; - PRGN_ATTR pRgn_Attr_Src2 = NULL; - INT Complexity; - BOOL Ret; + PRGN_ATTR pRgn_Attr_Dest = NULL; + PRGN_ATTR pRgn_Attr_Src1 = NULL; + PRGN_ATTR pRgn_Attr_Src2 = NULL; + INT Complexity; + BOOL Ret; // HACK -return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - Ret = GdiGetHandleUserData((HGDIOBJ) hDest, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Dest); - Ret = GdiGetHandleUserData((HGDIOBJ) hSrc1, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Src1); + Ret = GdiGetHandleUserData((HGDIOBJ) hDest, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Dest); + Ret = GdiGetHandleUserData((HGDIOBJ) hSrc1, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Src1); - if ( !Ret || - !pRgn_Attr_Dest || - !pRgn_Attr_Src1 || - pRgn_Attr_Src1->Flags > SIMPLEREGION ) - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + if ( !Ret || + !pRgn_Attr_Dest || + !pRgn_Attr_Src1 || + pRgn_Attr_Src1->Flags > SIMPLEREGION ) + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - /* Handle COPY and use only src1. */ - if ( CombineMode == RGN_COPY ) - { - switch (pRgn_Attr_Src1->Flags) - { + /* Handle COPY and use only src1. */ + if ( CombineMode == RGN_COPY ) + { + switch (pRgn_Attr_Src1->Flags) + { case NULLREGION: - Ret = SetRectRgn( hDest, 0, 0, 0, 0); - if (Ret) + Ret = SetRectRgn( hDest, 0, 0, 0, 0); + if (Ret) return NULLREGION; - goto ERROR_Exit; + goto ERROR_Exit; case SIMPLEREGION: - Ret = SetRectRgn( hDest, - pRgn_Attr_Src1->Rect.left, - pRgn_Attr_Src1->Rect.top, - pRgn_Attr_Src1->Rect.right, - pRgn_Attr_Src1->Rect.bottom ); - if (Ret) + Ret = SetRectRgn( hDest, + pRgn_Attr_Src1->Rect.left, + pRgn_Attr_Src1->Rect.top, + pRgn_Attr_Src1->Rect.right, + pRgn_Attr_Src1->Rect.bottom ); + if (Ret) return SIMPLEREGION; - goto ERROR_Exit; + goto ERROR_Exit; case COMPLEXREGION: default: return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - } - } + } + } - Ret = GdiGetHandleUserData((HGDIOBJ) hSrc2, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Src2); - if ( !Ret || - !pRgn_Attr_Src2 || - pRgn_Attr_Src2->Flags > SIMPLEREGION ) - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - - /* All but AND. */ - if ( CombineMode != RGN_AND) - { - if ( CombineMode <= RGN_AND) - { - /* - There might be some type of junk in the call, so go K. - If this becomes a problem, need to setup parameter check at the top. - */ - DPRINT1("Might be junk! CombineMode %d\n",CombineMode); + Ret = GdiGetHandleUserData((HGDIOBJ) hSrc2, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr_Src2); + if ( !Ret || + !pRgn_Attr_Src2 || + pRgn_Attr_Src2->Flags > SIMPLEREGION ) return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - } - if ( CombineMode > RGN_XOR) /* Handle DIFF. */ - { - if ( CombineMode != RGN_DIFF) - { /* Filter check! Well, must be junk?, so go K. */ - DPRINT1("RGN_COPY was handled! CombineMode %d\n",CombineMode); - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - } - /* Now handle DIFF. */ - if ( pRgn_Attr_Src1->Flags == NULLREGION ) + /* All but AND. */ + if ( CombineMode != RGN_AND) + { + if ( CombineMode <= RGN_AND) { - if (SetRectRgn( hDest, 0, 0, 0, 0)) - return NULLREGION; - goto ERROR_Exit; + /* + There might be some type of junk in the call, so go K. + If this becomes a problem, need to setup parameter check at the top. + */ + DPRINT1("Might be junk! CombineMode %d\n",CombineMode); + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); } - if ( pRgn_Attr_Src2->Flags != NULLREGION ) + if ( CombineMode > RGN_XOR) /* Handle DIFF. */ { - Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); + if ( CombineMode != RGN_DIFF) + { + /* Filter check! Well, must be junk?, so go K. */ + DPRINT1("RGN_COPY was handled! CombineMode %d\n",CombineMode); + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + } + /* Now handle DIFF. */ + if ( pRgn_Attr_Src1->Flags == NULLREGION ) + { + if (SetRectRgn( hDest, 0, 0, 0, 0)) + return NULLREGION; + goto ERROR_Exit; + } - if ( Complexity != DIFF_RGN ) - { - if ( Complexity != INVERTED_RGN) - /* If same or overlapping and norm just go K. */ - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + if ( pRgn_Attr_Src2->Flags != NULLREGION ) + { + Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); - if (SetRectRgn( hDest, 0, 0, 0, 0)) - return NULLREGION; - goto ERROR_Exit; - } + if ( Complexity != DIFF_RGN ) + { + if ( Complexity != INVERTED_RGN) + /* If same or overlapping and norm just go K. */ + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + + if (SetRectRgn( hDest, 0, 0, 0, 0)) + return NULLREGION; + goto ERROR_Exit; + } + } } - } - else /* Handle OR or XOR. */ - { - if ( pRgn_Attr_Src1->Flags == NULLREGION ) + else /* Handle OR or XOR. */ { - if ( pRgn_Attr_Src2->Flags != NULLREGION ) - { /* Src1 null and not NULL, set from src2. */ - Ret = SetRectRgn( hDest, - pRgn_Attr_Src2->Rect.left, - pRgn_Attr_Src2->Rect.top, - pRgn_Attr_Src2->Rect.right, - pRgn_Attr_Src2->Rect.bottom ); - if (Ret) - return SIMPLEREGION; - goto ERROR_Exit; - } - /* Both are NULL. */ - if (SetRectRgn( hDest, 0, 0, 0, 0)) - return NULLREGION; - goto ERROR_Exit; + if ( pRgn_Attr_Src1->Flags == NULLREGION ) + { + if ( pRgn_Attr_Src2->Flags != NULLREGION ) + { + /* Src1 null and not NULL, set from src2. */ + Ret = SetRectRgn( hDest, + pRgn_Attr_Src2->Rect.left, + pRgn_Attr_Src2->Rect.top, + pRgn_Attr_Src2->Rect.right, + pRgn_Attr_Src2->Rect.bottom ); + if (Ret) + return SIMPLEREGION; + goto ERROR_Exit; + } + /* Both are NULL. */ + if (SetRectRgn( hDest, 0, 0, 0, 0)) + return NULLREGION; + goto ERROR_Exit; + } + /* Src1 is not NULL. */ + if ( pRgn_Attr_Src2->Flags != NULLREGION ) + { + if ( CombineMode != RGN_OR ) /* Filter XOR, so go K. */ + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + + Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); + /* If inverted use Src2. */ + if ( Complexity == INVERTED_RGN) + { + Ret = SetRectRgn( hDest, + pRgn_Attr_Src2->Rect.left, + pRgn_Attr_Src2->Rect.top, + pRgn_Attr_Src2->Rect.right, + pRgn_Attr_Src2->Rect.bottom ); + if (Ret) + return SIMPLEREGION; + goto ERROR_Exit; + } + /* Not NULL or overlapping or differentiated, go to K. */ + if ( Complexity != SAME_RGN) + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + /* If same, just fall through. */ + } } - /* Src1 is not NULL. */ - if ( pRgn_Attr_Src2->Flags != NULLREGION ) - { - if ( CombineMode != RGN_OR ) /* Filter XOR, so go K. */ - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - - Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); - /* If inverted use Src2. */ - if ( Complexity == INVERTED_RGN) - { - Ret = SetRectRgn( hDest, - pRgn_Attr_Src2->Rect.left, - pRgn_Attr_Src2->Rect.top, - pRgn_Attr_Src2->Rect.right, - pRgn_Attr_Src2->Rect.bottom ); - if (Ret) - return SIMPLEREGION; - goto ERROR_Exit; - } - /* Not NULL or overlapping or differentiated, go to K. */ - if ( Complexity != SAME_RGN) - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - /* If same, just fall through. */ - } - } - Ret = SetRectRgn( hDest, - pRgn_Attr_Src1->Rect.left, - pRgn_Attr_Src1->Rect.top, - pRgn_Attr_Src1->Rect.right, - pRgn_Attr_Src1->Rect.bottom ); - if (Ret) - return SIMPLEREGION; - goto ERROR_Exit; - } - - /* Handle AND. */ - if ( pRgn_Attr_Src1->Flags != NULLREGION && - pRgn_Attr_Src2->Flags != NULLREGION ) - { - Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); - - if ( Complexity == DIFF_RGN ) /* Differentiated in anyway just NULL rgn. */ - { - if (SetRectRgn( hDest, 0, 0, 0, 0)) - return NULLREGION; - goto ERROR_Exit; - } - - if ( Complexity != INVERTED_RGN) /* Not inverted and overlapping. */ - { - if ( Complexity != SAME_RGN) /* Must be norm and overlapping. */ - return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); - /* Merge from src2. */ Ret = SetRectRgn( hDest, - pRgn_Attr_Src2->Rect.left, - pRgn_Attr_Src2->Rect.top, - pRgn_Attr_Src2->Rect.right, - pRgn_Attr_Src2->Rect.bottom ); + pRgn_Attr_Src1->Rect.left, + pRgn_Attr_Src1->Rect.top, + pRgn_Attr_Src1->Rect.right, + pRgn_Attr_Src1->Rect.bottom ); if (Ret) - return SIMPLEREGION; + return SIMPLEREGION; goto ERROR_Exit; - } - /* Inverted so merge from src1. */ - Ret = SetRectRgn( hDest, - pRgn_Attr_Src1->Rect.left, - pRgn_Attr_Src1->Rect.top, - pRgn_Attr_Src1->Rect.right, - pRgn_Attr_Src1->Rect.bottom ); - if (Ret) - return SIMPLEREGION; - goto ERROR_Exit; - } + } - /* It's all NULL! */ - if (SetRectRgn( hDest, 0, 0, 0, 0)) - return NULLREGION; + /* Handle AND. */ + if ( pRgn_Attr_Src1->Flags != NULLREGION && + pRgn_Attr_Src2->Flags != NULLREGION ) + { + Complexity = ComplexityFromRects( &pRgn_Attr_Src1->Rect, &pRgn_Attr_Src2->Rect); + + if ( Complexity == DIFF_RGN ) /* Differentiated in anyway just NULL rgn. */ + { + if (SetRectRgn( hDest, 0, 0, 0, 0)) + return NULLREGION; + goto ERROR_Exit; + } + + if ( Complexity != INVERTED_RGN) /* Not inverted and overlapping. */ + { + if ( Complexity != SAME_RGN) /* Must be norm and overlapping. */ + return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode); + /* Merge from src2. */ + Ret = SetRectRgn( hDest, + pRgn_Attr_Src2->Rect.left, + pRgn_Attr_Src2->Rect.top, + pRgn_Attr_Src2->Rect.right, + pRgn_Attr_Src2->Rect.bottom ); + if (Ret) + return SIMPLEREGION; + goto ERROR_Exit; + } + /* Inverted so merge from src1. */ + Ret = SetRectRgn( hDest, + pRgn_Attr_Src1->Rect.left, + pRgn_Attr_Src1->Rect.top, + pRgn_Attr_Src1->Rect.right, + pRgn_Attr_Src1->Rect.bottom ); + if (Ret) + return SIMPLEREGION; + goto ERROR_Exit; + } + + /* It's all NULL! */ + if (SetRectRgn( hDest, 0, 0, 0, 0)) + return NULLREGION; ERROR_Exit: - /* Even on error the flag is set dirty and force server side to redraw. */ - pRgn_Attr_Dest->AttrFlags |= ATTR_RGN_DIRTY; - return ERROR; + /* Even on error the flag is set dirty and force server side to redraw. */ + pRgn_Attr_Dest->AttrFlags |= ATTR_RGN_DIRTY; + return ERROR; } /* @@ -399,7 +403,7 @@ ERROR_Exit: HRGN WINAPI CreateEllipticRgnIndirect( - const RECT *prc + const RECT *prc ) { /* Notes if prc is NULL it will crash on All Windows NT I checked 2000/XP/VISTA */ @@ -437,72 +441,72 @@ HRGN WINAPI CreateRectRgn(int x1, int y1, int x2, int y2) { - PRGN_ATTR pRgn_Attr; - HRGN hrgn; - int tmp; + PRGN_ATTR pRgn_Attr; + HRGN hrgn; + int tmp; /// <- //// Remove when Brush/Pen/Rgn Attr is ready! - return NtGdiCreateRectRgn(x1,y1,x2,y2); + return NtGdiCreateRectRgn(x1,y1,x2,y2); //// - /* Normalize points */ - tmp = x1; - if ( x1 > x2 ) - { - x1 = x2; - x2 = tmp; - } + /* Normalize points */ + tmp = x1; + if ( x1 > x2 ) + { + x1 = x2; + x2 = tmp; + } - tmp = y1; - if ( y1 > y2 ) - { - y1 = y2; - y2 = tmp; - } - /* Check outside 24 bit limit for universal set. Chp 9 Areas, pg 560.*/ - if ( x1 < -(1<<27) || - y1 < -(1<<27) || - x2 > (1<<27)-1 || - y2 > (1<<27)-1 ) - { - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } + tmp = y1; + if ( y1 > y2 ) + { + y1 = y2; + y2 = tmp; + } + /* Check outside 24 bit limit for universal set. Chp 9 Areas, pg 560.*/ + if ( x1 < -(1<<27) || + y1 < -(1<<27) || + x2 > (1<<27)-1 || + y2 > (1<<27)-1 ) + { + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } - hrgn = hGetPEBHandle(hctRegionHandle, 0); + hrgn = hGetPEBHandle(hctRegionHandle, 0); - if (!hrgn) - hrgn = NtGdiCreateRectRgn(0, 0, 1, 1); + if (!hrgn) + hrgn = NtGdiCreateRectRgn(0, 0, 1, 1); - if (!hrgn) - return hrgn; + if (!hrgn) + return hrgn; - if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) - { - DPRINT1("No Attr for Region handle!!!\n"); - DeleteRegion(hrgn); - return NULL; - } + if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) + { + DPRINT1("No Attr for Region handle!!!\n"); + DeleteRegion(hrgn); + return NULL; + } - if (( x1 == x2) || (y1 == y2)) - { - pRgn_Attr->Flags = NULLREGION; - pRgn_Attr->Rect.left = pRgn_Attr->Rect.top = - pRgn_Attr->Rect.right = pRgn_Attr->Rect.bottom = 0; - } - else - { - pRgn_Attr->Flags = SIMPLEREGION; - pRgn_Attr->Rect.left = x1; - pRgn_Attr->Rect.top = y1; - pRgn_Attr->Rect.right = x2; - pRgn_Attr->Rect.bottom = y2; - } + if (( x1 == x2) || (y1 == y2)) + { + pRgn_Attr->Flags = NULLREGION; + pRgn_Attr->Rect.left = pRgn_Attr->Rect.top = + pRgn_Attr->Rect.right = pRgn_Attr->Rect.bottom = 0; + } + else + { + pRgn_Attr->Flags = SIMPLEREGION; + pRgn_Attr->Rect.left = x1; + pRgn_Attr->Rect.top = y1; + pRgn_Attr->Rect.right = x2; + pRgn_Attr->Rect.bottom = y2; + } - pRgn_Attr->AttrFlags = (ATTR_RGN_DIRTY|ATTR_RGN_VALID); + pRgn_Attr->AttrFlags = (ATTR_RGN_DIRTY|ATTR_RGN_VALID); - return hrgn; + return hrgn; } /* @@ -528,23 +532,23 @@ ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBo { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( pLDC ) - { - if (pLDC->iType != LDC_EMFLDC || EMFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom)) - return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom); - } - else - SetLastError(ERROR_INVALID_HANDLE); - return ERROR; + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( pLDC ) + { + if (pLDC->iType != LDC_EMFLDC || EMFDRV_ExcludeClipRect( hdc, xLeft, yTop, xRight, yBottom)) + return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom); + } + else + SetLastError(ERROR_INVALID_HANDLE); + return ERROR; + } } - } #endif return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom); } @@ -555,22 +559,22 @@ ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBo HRGN WINAPI ExtCreateRegion( - CONST XFORM * lpXform, - DWORD nCount, - CONST RGNDATA * lpRgnData - ) + CONST XFORM * lpXform, + DWORD nCount, + CONST RGNDATA * lpRgnData +) { - if (lpRgnData) - { - if ((!lpXform) && (lpRgnData->rdh.nCount == 1)) - { - PRECT pRect = (PRECT)&lpRgnData->Buffer[0]; - return CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom); - } - return NtGdiExtCreateRegion((LPXFORM) lpXform, nCount,(LPRGNDATA) lpRgnData); - } - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; + if (lpRgnData) + { + if ((!lpXform) && (lpRgnData->rdh.nCount == 1)) + { + PRECT pRect = (PRECT)&lpRgnData->Buffer[0]; + return CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom); + } + return NtGdiExtCreateRegion((LPXFORM) lpXform, nCount,(LPRGNDATA) lpRgnData); + } + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; } /* @@ -580,110 +584,110 @@ INT WINAPI ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode) { - INT Ret; - HRGN NewRgn = NULL; + INT Ret; + HRGN NewRgn = NULL; #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_ExtSelectClipRgn( hdc, ); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( pLDC ) - { - if (pLDC->iType != LDC_EMFLDC || EMFDRV_ExtSelectClipRgn( hdc, )) - return NtGdiExtSelectClipRgn(hdc, ); -} - else - SetLastError(ERROR_INVALID_HANDLE); - return ERROR; + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_ExtSelectClipRgn( hdc, ); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( pLDC ) + { + if (pLDC->iType != LDC_EMFLDC || EMFDRV_ExtSelectClipRgn( hdc, )) + return NtGdiExtSelectClipRgn(hdc, ); + } + else + SetLastError(ERROR_INVALID_HANDLE); + return ERROR; + } } - } #endif #if 0 - if ( hrgn ) - { - if ( GetLayout(hdc) & LAYOUT_RTL ) - { - if ( MirrorRgnDC(hdc, hrgn, &NewRgn) ) + if ( hrgn ) + { + if ( GetLayout(hdc) & LAYOUT_RTL ) { - if ( NewRgn ) hrgn = NewRgn; + if ( MirrorRgnDC(hdc, hrgn, &NewRgn) ) + { + if ( NewRgn ) hrgn = NewRgn; + } } - } - } + } #endif - /* Batch handles RGN_COPY only! */ - if (iMode == RGN_COPY) - { + /* Batch handles RGN_COPY only! */ + if (iMode == RGN_COPY) + { #if 0 - PDC_ATTR pDc_Attr; - PRGN_ATTR pRgn_Attr = NULL; + PDC_ATTR pDc_Attr; + PRGN_ATTR pRgn_Attr = NULL; - /* hrgn can be NULL unless the RGN_COPY mode is specified. */ - if (hrgn) - GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr); + /* hrgn can be NULL unless the RGN_COPY mode is specified. */ + if (hrgn) + GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr); - if ( GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &pDc_Attr) && - pDc_Attr ) - { - PGDI_TABLE_ENTRY pEntry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hdc); - PTEB pTeb = NtCurrentTeb(); - - if ( pTeb->Win32ThreadInfo != NULL && - pTeb->GdiTebBatch.HDC == hdc && - !(pDc_Attr->ulDirty_ & DC_DIBSECTION) && - !(pEntry->Flags & GDI_ENTRY_VALIDATE_VIS) ) + if ( GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &pDc_Attr) && + pDc_Attr ) { - if (!hrgn || - (hrgn && pRgn_Attr && pRgn_Attr->Flags <= SIMPLEREGION) ) - { - if ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSEXTSELCLPRGN)) <= GDIBATCHBUFSIZE) - { - PGDIBSEXTSELCLPRGN pgO = (PGDIBSEXTSELCLPRGN)(&pTeb->GdiTebBatch.Buffer[0] + - pTeb->GdiTebBatch.Offset); - pgO->gbHdr.Cmd = GdiBCExtSelClipRgn; - pgO->gbHdr.Size = sizeof(GDIBSEXTSELCLPRGN); - pgO->fnMode = iMode; + PGDI_TABLE_ENTRY pEntry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hdc); + PTEB pTeb = NtCurrentTeb(); - if ( hrgn && pRgn_Attr ) - { - Ret = pRgn_Attr->Flags; + if ( pTeb->Win32ThreadInfo != NULL && + pTeb->GdiTebBatch.HDC == hdc && + !(pDc_Attr->ulDirty_ & DC_DIBSECTION) && + !(pEntry->Flags & GDI_ENTRY_VALIDATE_VIS) ) + { + if (!hrgn || + (hrgn && pRgn_Attr && pRgn_Attr->Flags <= SIMPLEREGION) ) + { + if ((pTeb->GdiTebBatch.Offset + sizeof(GDIBSEXTSELCLPRGN)) <= GDIBATCHBUFSIZE) + { + PGDIBSEXTSELCLPRGN pgO = (PGDIBSEXTSELCLPRGN)(&pTeb->GdiTebBatch.Buffer[0] + + pTeb->GdiTebBatch.Offset); + pgO->gbHdr.Cmd = GdiBCExtSelClipRgn; + pgO->gbHdr.Size = sizeof(GDIBSEXTSELCLPRGN); + pgO->fnMode = iMode; - if ( pDc_Attr->VisRectRegion.Rect.left >= pRgn_Attr->Rect.right || - pDc_Attr->VisRectRegion.Rect.top >= pRgn_Attr->Rect.bottom || - pDc_Attr->VisRectRegion.Rect.right <= pRgn_Attr->Rect.left || - pDc_Attr->VisRectRegion.Rect.bottom <= pRgn_Attr->Rect.top ) - Ret = NULLREGION; + if ( hrgn && pRgn_Attr ) + { + Ret = pRgn_Attr->Flags; - pgO->left = pRgn_Attr->Rect.left; - pgO->top = pRgn_Attr->Rect.top; - pgO->right = pRgn_Attr->Rect.right; - pgO->bottom = pRgn_Attr->Rect.bottom; - } - else - { - Ret = pDc_Attr->VisRectRegion.Flags; - pgO->fnMode |= 0x80000000; // Set no hrgn mode. - } - pTeb->GdiTebBatch.Offset += sizeof(GDIBSEXTSELCLPRGN); - pTeb->GdiBatchCount++; - if (pTeb->GdiBatchCount >= GDI_BatchLimit) NtGdiFlush(); - if ( NewRgn ) DeleteObject(NewRgn); - return Ret; - } - } + if ( pDc_Attr->VisRectRegion.Rect.left >= pRgn_Attr->Rect.right || + pDc_Attr->VisRectRegion.Rect.top >= pRgn_Attr->Rect.bottom || + pDc_Attr->VisRectRegion.Rect.right <= pRgn_Attr->Rect.left || + pDc_Attr->VisRectRegion.Rect.bottom <= pRgn_Attr->Rect.top ) + Ret = NULLREGION; + + pgO->left = pRgn_Attr->Rect.left; + pgO->top = pRgn_Attr->Rect.top; + pgO->right = pRgn_Attr->Rect.right; + pgO->bottom = pRgn_Attr->Rect.bottom; + } + else + { + Ret = pDc_Attr->VisRectRegion.Flags; + pgO->fnMode |= 0x80000000; // Set no hrgn mode. + } + pTeb->GdiTebBatch.Offset += sizeof(GDIBSEXTSELCLPRGN); + pTeb->GdiBatchCount++; + if (pTeb->GdiBatchCount >= GDI_BatchLimit) NtGdiFlush(); + if ( NewRgn ) DeleteObject(NewRgn); + return Ret; + } + } + } } - } #endif - } - Ret = NtGdiExtSelectClipRgn(hdc, hrgn, iMode); + } + Ret = NtGdiExtSelectClipRgn(hdc, hrgn, iMode); - if ( NewRgn ) DeleteObject(NewRgn); + if ( NewRgn ) DeleteObject(NewRgn); - return Ret; + return Ret; } /* @@ -692,16 +696,16 @@ ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode) int WINAPI GetClipRgn( - HDC hdc, - HRGN hrgn - ) + HDC hdc, + HRGN hrgn +) { - INT Ret = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN); + INT Ret = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN); // if (Ret) // { // if(GetLayout(hdc) & LAYOUT_RTL) MirrorRgnDC(hdc,(HRGN)Ret, NULL); // } - return Ret; + return Ret; } /* @@ -742,26 +746,26 @@ WINAPI GetRgnBox(HRGN hrgn, LPRECT prcOut) { - PRGN_ATTR Rgn_Attr; + PRGN_ATTR Rgn_Attr; - //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) - return NtGdiGetRgnBox(hrgn, prcOut); + //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) + return NtGdiGetRgnBox(hrgn, prcOut); - if (Rgn_Attr->Flags == NULLREGION) - { - prcOut->left = 0; - prcOut->top = 0; - prcOut->right = 0; - prcOut->bottom = 0; - } - else - { - if (Rgn_Attr->Flags != SIMPLEREGION) - return NtGdiGetRgnBox(hrgn, prcOut); - /* WARNING! prcOut is never checked newbies! */ - RtlCopyMemory( prcOut, &Rgn_Attr->Rect, sizeof(RECT)); - } - return Rgn_Attr->Flags; + if (Rgn_Attr->Flags == NULLREGION) + { + prcOut->left = 0; + prcOut->top = 0; + prcOut->right = 0; + prcOut->bottom = 0; + } + else + { + if (Rgn_Attr->Flags != SIMPLEREGION) + return NtGdiGetRgnBox(hrgn, prcOut); + /* WARNING! prcOut is never checked newbies! */ + RtlCopyMemory( prcOut, &Rgn_Attr->Rect, sizeof(RECT)); + } + return Rgn_Attr->Flags; } /* @@ -777,23 +781,23 @@ IntersectClipRect(HDC hdc, { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( pLDC ) - { - if (pLDC->iType != LDC_EMFLDC || EMFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect)) - return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); - } - else - SetLastError(ERROR_INVALID_HANDLE); - return ERROR; + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( pLDC ) + { + if (pLDC->iType != LDC_EMFLDC || EMFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect)) + return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); + } + else + SetLastError(ERROR_INVALID_HANDLE); + return ERROR; + } } - } #endif return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect); } @@ -805,9 +809,9 @@ BOOL WINAPI MirrorRgn(HWND hwnd, HRGN hrgn) { - RECT Rect; - GetWindowRect(hwnd, &Rect); - return MirrorRgnByWidth(hrgn, Rect.right - Rect.left, NULL); + RECT Rect; + GetWindowRect(hwnd, &Rect); + return MirrorRgnByWidth(hrgn, Rect.right - Rect.left, NULL); } /* @@ -821,25 +825,25 @@ OffsetClipRgn(HDC hdc, { #if 0 // Handle something other than a normal dc object. - if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) - return MFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset ); - else + if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = GdiGetLDC(hdc); - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return ERROR; - } - if (pLDC->iType == LDC_EMFLDC && !EMFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset )) - return ERROR; - return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset); + if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC) + return MFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset ); + else + { + PLDC pLDC = GdiGetLDC(hdc); + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return ERROR; + } + if (pLDC->iType == LDC_EMFLDC && !EMFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset )) + return ERROR; + return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset); + } } - } #endif - return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset); + return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset); } /* @@ -849,53 +853,53 @@ OffsetClipRgn(HDC hdc, INT WINAPI OffsetRgn( HRGN hrgn, - int nXOffset, - int nYOffset) + int nXOffset, + int nYOffset) { - PRGN_ATTR pRgn_Attr; - int nLeftRect, nTopRect, nRightRect, nBottomRect; + PRGN_ATTR pRgn_Attr; + int nLeftRect, nTopRect, nRightRect, nBottomRect; // HACKFIX // if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) - return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset); + return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset); - if ( pRgn_Attr->Flags == NULLREGION) - return pRgn_Attr->Flags; + if ( pRgn_Attr->Flags == NULLREGION) + return pRgn_Attr->Flags; - if ( pRgn_Attr->Flags != SIMPLEREGION) - return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset); + if ( pRgn_Attr->Flags != SIMPLEREGION) + return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset); - nLeftRect = pRgn_Attr->Rect.left; - nTopRect = pRgn_Attr->Rect.top; - nRightRect = pRgn_Attr->Rect.right; - nBottomRect = pRgn_Attr->Rect.bottom; + nLeftRect = pRgn_Attr->Rect.left; + nTopRect = pRgn_Attr->Rect.top; + nRightRect = pRgn_Attr->Rect.right; + nBottomRect = pRgn_Attr->Rect.bottom; - if (nLeftRect < nRightRect) - { - if (nTopRect < nBottomRect) - { - nLeftRect = nXOffset + nLeftRect; - nTopRect = nYOffset + nTopRect; - nRightRect = nXOffset + nRightRect; - nBottomRect = nYOffset + nBottomRect; - - /* Check 28 bit limit. Chp 9 Areas, pg 560. */ - if ( nLeftRect < -(1<<27) || - nTopRect < -(1<<27) || - nRightRect > (1<<27)-1 || - nBottomRect > (1<<27)-1 ) + if (nLeftRect < nRightRect) + { + if (nTopRect < nBottomRect) { - return ERROR; - } + nLeftRect = nXOffset + nLeftRect; + nTopRect = nYOffset + nTopRect; + nRightRect = nXOffset + nRightRect; + nBottomRect = nYOffset + nBottomRect; - pRgn_Attr->Rect.top = nTopRect; - pRgn_Attr->Rect.left = nLeftRect; - pRgn_Attr->Rect.right = nRightRect; - pRgn_Attr->Rect.bottom = nBottomRect; - pRgn_Attr->AttrFlags |= ATTR_RGN_DIRTY; - } - } - return pRgn_Attr->Flags; + /* Check 28 bit limit. Chp 9 Areas, pg 560. */ + if ( nLeftRect < -(1<<27) || + nTopRect < -(1<<27) || + nRightRect > (1<<27)-1 || + nBottomRect > (1<<27)-1 ) + { + return ERROR; + } + + pRgn_Attr->Rect.top = nTopRect; + pRgn_Attr->Rect.left = nLeftRect; + pRgn_Attr->Rect.right = nRightRect; + pRgn_Attr->Rect.bottom = nBottomRect; + pRgn_Attr->AttrFlags |= ATTR_RGN_DIRTY; + } + } + return pRgn_Attr->Flags; } /* @@ -907,19 +911,19 @@ PtInRegion(IN HRGN hrgn, int x, int y) { - PRGN_ATTR pRgn_Attr; + PRGN_ATTR pRgn_Attr; - // HACKFIX - //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) - return NtGdiPtInRegion(hrgn,x,y); + // HACKFIX + //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) + return NtGdiPtInRegion(hrgn,x,y); - if ( pRgn_Attr->Flags == NULLREGION) - return FALSE; + if ( pRgn_Attr->Flags == NULLREGION) + return FALSE; - if ( pRgn_Attr->Flags != SIMPLEREGION) - return NtGdiPtInRegion(hrgn,x,y); + if ( pRgn_Attr->Flags != SIMPLEREGION) + return NtGdiPtInRegion(hrgn,x,y); - return INRECT( pRgn_Attr->Rect, x, y); + return INRECT( pRgn_Attr->Rect, x, y); } /* @@ -930,46 +934,46 @@ WINAPI RectInRegion(HRGN hrgn, LPCRECT prcl) { - PRGN_ATTR pRgn_Attr; - RECTL rc; + PRGN_ATTR pRgn_Attr; + RECTL rc; - // HACKFIX - //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) - return NtGdiRectInRegion(hrgn, (LPRECT) prcl); + // HACKFIX + //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &pRgn_Attr)) + return NtGdiRectInRegion(hrgn, (LPRECT) prcl); - if ( pRgn_Attr->Flags == NULLREGION) - return FALSE; + if ( pRgn_Attr->Flags == NULLREGION) + return FALSE; - if ( pRgn_Attr->Flags != SIMPLEREGION) - return NtGdiRectInRegion(hrgn, (LPRECT) prcl); + if ( pRgn_Attr->Flags != SIMPLEREGION) + return NtGdiRectInRegion(hrgn, (LPRECT) prcl); - /* swap the coordinates to make right >= left and bottom >= top */ - /* (region building rectangles are normalized the same way) */ - if ( prcl->top > prcl->bottom) - { - rc.top = prcl->bottom; - rc.bottom = prcl->top; - } - else - { - rc.top = prcl->top; - rc.bottom = prcl->bottom; - } - if ( prcl->right < prcl->left) - { - rc.right = prcl->left; - rc.left = prcl->right; - } - else - { - rc.right = prcl->right; - rc.left = prcl->left; - } + /* swap the coordinates to make right >= left and bottom >= top */ + /* (region building rectangles are normalized the same way) */ + if ( prcl->top > prcl->bottom) + { + rc.top = prcl->bottom; + rc.bottom = prcl->top; + } + else + { + rc.top = prcl->top; + rc.bottom = prcl->bottom; + } + if ( prcl->right < prcl->left) + { + rc.right = prcl->left; + rc.left = prcl->right; + } + else + { + rc.right = prcl->right; + rc.left = prcl->left; + } - if ( ComplexityFromRects( &pRgn_Attr->Rect, &rc) != DIFF_RGN ) - return TRUE; + if ( ComplexityFromRects( &pRgn_Attr->Rect, &rc) != DIFF_RGN ) + return TRUE; - return FALSE; + return FALSE; } /* @@ -977,8 +981,8 @@ RectInRegion(HRGN hrgn, */ int WINAPI SelectClipRgn( - HDC hdc, - HRGN hrgn + HDC hdc, + HRGN hrgn ) { return ExtSelectClipRgn(hdc, hrgn, RGN_COPY); @@ -995,39 +999,39 @@ SetRectRgn(HRGN hrgn, int nRightRect, int nBottomRect) { - PRGN_ATTR Rgn_Attr; + PRGN_ATTR Rgn_Attr; - //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) - return NtGdiSetRectRgn(hrgn, nLeftRect, nTopRect, nRightRect, nBottomRect); + //if (!GdiGetHandleUserData((HGDIOBJ) hrgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr)) + return NtGdiSetRectRgn(hrgn, nLeftRect, nTopRect, nRightRect, nBottomRect); - if ((nLeftRect == nRightRect) || (nTopRect == nBottomRect)) - { - Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY; - Rgn_Attr->Flags = NULLREGION; - Rgn_Attr->Rect.left = Rgn_Attr->Rect.top = - Rgn_Attr->Rect.right = Rgn_Attr->Rect.bottom = 0; - return TRUE; - } + if ((nLeftRect == nRightRect) || (nTopRect == nBottomRect)) + { + Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY; + Rgn_Attr->Flags = NULLREGION; + Rgn_Attr->Rect.left = Rgn_Attr->Rect.top = + Rgn_Attr->Rect.right = Rgn_Attr->Rect.bottom = 0; + return TRUE; + } - Rgn_Attr->Rect.left = nLeftRect; - Rgn_Attr->Rect.top = nTopRect; - Rgn_Attr->Rect.right = nRightRect; - Rgn_Attr->Rect.bottom = nBottomRect; + Rgn_Attr->Rect.left = nLeftRect; + Rgn_Attr->Rect.top = nTopRect; + Rgn_Attr->Rect.right = nRightRect; + Rgn_Attr->Rect.bottom = nBottomRect; - if(nLeftRect > nRightRect) - { - Rgn_Attr->Rect.left = nRightRect; - Rgn_Attr->Rect.right = nLeftRect; - } - if(nTopRect > nBottomRect) - { - Rgn_Attr->Rect.top = nBottomRect; - Rgn_Attr->Rect.bottom = nTopRect; - } + if(nLeftRect > nRightRect) + { + Rgn_Attr->Rect.left = nRightRect; + Rgn_Attr->Rect.right = nLeftRect; + } + if(nTopRect > nBottomRect) + { + Rgn_Attr->Rect.top = nBottomRect; + Rgn_Attr->Rect.bottom = nTopRect; + } - Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY ; - Rgn_Attr->Flags = SIMPLEREGION; - return TRUE; + Rgn_Attr->AttrFlags |= ATTR_RGN_DIRTY ; + Rgn_Attr->Flags = SIMPLEREGION; + return TRUE; } /* @@ -1037,20 +1041,20 @@ int WINAPI SetMetaRgn( HDC hDC ) { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) - return NtGdiSetMetaRgn(hDC); + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC) + return NtGdiSetMetaRgn(hDC); #if 0 - PLDC pLDC = GdiGetLDC(hDC); - if ( pLDC && GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC ) - { - if (pLDC->iType == LDC_EMFLDC || EMFDRV_SetMetaRgn(hDC)) + PLDC pLDC = GdiGetLDC(hDC); + if ( pLDC && GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC ) { - return NtGdiSetMetaRgn(hDC); + if (pLDC->iType == LDC_EMFLDC || EMFDRV_SetMetaRgn(hDC)) + { + return NtGdiSetMetaRgn(hDC); + } + else + SetLastError(ERROR_INVALID_HANDLE); } - else - SetLastError(ERROR_INVALID_HANDLE); - } #endif - return ERROR; + return ERROR; } diff --git a/reactos/dll/win32/gdi32/objects/text.c b/reactos/dll/win32/gdi32/objects/text.c index b84e948abad..75b79c30b8a 100644 --- a/reactos/dll/win32/gdi32/objects/text.c +++ b/reactos/dll/win32/gdi32/objects/text.c @@ -7,26 +7,27 @@ BOOL WINAPI TextOutA( - HDC hdc, - int nXStart, - int nYStart, - LPCSTR lpString, - int cchString) + HDC hdc, + int nXStart, + int nYStart, + LPCSTR lpString, + int cchString) { - ANSI_STRING StringA; - UNICODE_STRING StringU; - BOOL ret; + ANSI_STRING StringA; + UNICODE_STRING StringU; + BOOL ret; - if (NULL != lpString) - { - RtlInitAnsiString(&StringA, (LPSTR)lpString); - RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); - } else - StringU.Buffer = NULL; + if (NULL != lpString) + { + RtlInitAnsiString(&StringA, (LPSTR)lpString); + RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); + } + else + StringU.Buffer = NULL; - ret = TextOutW(hdc, nXStart, nYStart, StringU.Buffer, cchString); - RtlFreeUnicodeString(&StringU); - return ret; + ret = TextOutW(hdc, nXStart, nYStart, StringU.Buffer, cchString); + RtlFreeUnicodeString(&StringU); + return ret; } @@ -36,13 +37,13 @@ TextOutA( BOOL WINAPI TextOutW( - HDC hdc, - int nXStart, - int nYStart, - LPCWSTR lpString, - int cchString) + HDC hdc, + int nXStart, + int nYStart, + LPCWSTR lpString, + int cchString) { - return NtGdiExtTextOutW(hdc, nXStart, nYStart, 0, NULL, (LPWSTR)lpString, cchString, NULL, 0); + return NtGdiExtTextOutW(hdc, nXStart, nYStart, 0, NULL, (LPWSTR)lpString, cchString, NULL, 0); } @@ -53,10 +54,10 @@ DWORD WINAPI GdiGetCodePage(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - if (Dc_Attr->ulDirty_ & DIRTY_CHARSET) return LOWORD(NtGdiGetCharSet(hdc)); - return LOWORD(Dc_Attr->iCS_CP); + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + if (Dc_Attr->ulDirty_ & DIRTY_CHARSET) return LOWORD(NtGdiGetCharSet(hdc)); + return LOWORD(Dc_Attr->iCS_CP); } @@ -66,13 +67,13 @@ GdiGetCodePage(HDC hdc) int WINAPI GetTextCharacterExtra( - HDC hDc - ) + HDC hDc +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hDc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->lTextExtra; + if (!GdiGetHandleUserData((HGDIOBJ) hDc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->lTextExtra; // return GetDCDWord( hDc, GdiGetTextCharExtra, 0); } @@ -96,19 +97,19 @@ GetTextCharset(HDC hdc) BOOL WINAPI GetTextMetricsA( - HDC hdc, - LPTEXTMETRICA lptm - ) + HDC hdc, + LPTEXTMETRICA lptm +) { - TMW_INTERNAL tmwi; + TMW_INTERNAL tmwi; - if (! NtGdiGetTextMetricsW(hdc, &tmwi, sizeof(TMW_INTERNAL))) - { - return FALSE; - } + if (! NtGdiGetTextMetricsW(hdc, &tmwi, sizeof(TMW_INTERNAL))) + { + return FALSE; + } - FONT_TextMetricWToA(&tmwi.TextMetric, lptm); - return TRUE; + FONT_TextMetricWToA(&tmwi.TextMetric, lptm); + return TRUE; } @@ -118,19 +119,19 @@ GetTextMetricsA( BOOL WINAPI GetTextMetricsW( - HDC hdc, - LPTEXTMETRICW lptm - ) + HDC hdc, + LPTEXTMETRICW lptm +) { - TMW_INTERNAL tmwi; + TMW_INTERNAL tmwi; - if (! NtGdiGetTextMetricsW(hdc, &tmwi, sizeof(TMW_INTERNAL))) - { - return FALSE; - } + if (! NtGdiGetTextMetricsW(hdc, &tmwi, sizeof(TMW_INTERNAL))) + { + return FALSE; + } - *lptm = tmwi.TextMetric; - return TRUE; + *lptm = tmwi.TextMetric; + return TRUE; } @@ -140,24 +141,24 @@ GetTextMetricsW( BOOL APIENTRY GetTextExtentPointA( - HDC hdc, - LPCSTR lpString, - int cchString, - LPSIZE lpSize - ) + HDC hdc, + LPCSTR lpString, + int cchString, + LPSIZE lpSize +) { - ANSI_STRING StringA; - UNICODE_STRING StringU; - BOOL ret; + ANSI_STRING StringA; + UNICODE_STRING StringU; + BOOL ret; - RtlInitAnsiString(&StringA, (LPSTR)lpString); - RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); + RtlInitAnsiString(&StringA, (LPSTR)lpString); + RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); - ret = GetTextExtentPointW(hdc, StringU.Buffer, cchString, lpSize); + ret = GetTextExtentPointW(hdc, StringU.Buffer, cchString, lpSize); - RtlFreeUnicodeString(&StringU); + RtlFreeUnicodeString(&StringU); - return ret; + return ret; } @@ -167,13 +168,13 @@ GetTextExtentPointA( BOOL APIENTRY GetTextExtentPointW( - HDC hdc, - LPCWSTR lpString, - int cchString, - LPSIZE lpSize - ) + HDC hdc, + LPCWSTR lpString, + int cchString, + LPSIZE lpSize +) { - return NtGdiGetTextExtent(hdc, (LPWSTR)lpString, cchString, lpSize, 0); + return NtGdiGetTextExtent(hdc, (LPWSTR)lpString, cchString, lpSize, 0); } @@ -183,24 +184,24 @@ GetTextExtentPointW( BOOL APIENTRY GetTextExtentExPointW( - HDC hdc, - LPCWSTR lpszStr, - int cchString, - int nMaxExtent, - LPINT lpnFit, - LPINT alpDx, - LPSIZE lpSize - ) + HDC hdc, + LPCWSTR lpszStr, + int cchString, + int nMaxExtent, + LPINT lpnFit, + LPINT alpDx, + LPSIZE lpSize +) { - if(nMaxExtent < -1) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } + if(nMaxExtent < -1) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } - return NtGdiGetTextExtentExW ( - hdc, (LPWSTR)lpszStr, cchString, nMaxExtent, (PULONG)lpnFit, (PULONG)alpDx, lpSize, 0 ); + return NtGdiGetTextExtentExW ( + hdc, (LPWSTR)lpszStr, cchString, nMaxExtent, (PULONG)lpnFit, (PULONG)alpDx, lpSize, 0 ); } @@ -210,37 +211,37 @@ GetTextExtentExPointW( BOOL APIENTRY GetTextExtentExPointA( - HDC hdc, - LPCSTR lpszStr, - int cchString, - int nMaxExtent, - LPINT lpnFit, - LPINT alpDx, - LPSIZE lpSize - ) + HDC hdc, + LPCSTR lpszStr, + int cchString, + int nMaxExtent, + LPINT lpnFit, + LPINT alpDx, + LPSIZE lpSize +) { - NTSTATUS Status; - LPWSTR lpszStrW; - BOOL rc = 0; + NTSTATUS Status; + LPWSTR lpszStrW; + BOOL rc = 0; - if(nMaxExtent < -1) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } + if(nMaxExtent < -1) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } - Status = HEAP_strdupA2W ( &lpszStrW, lpszStr ); - if (!NT_SUCCESS (Status)) - SetLastError (RtlNtStatusToDosError(Status)); - else - { - rc = NtGdiGetTextExtentExW ( - hdc, lpszStrW, cchString, nMaxExtent, (PULONG)lpnFit, (PULONG)alpDx, lpSize, 0 ); + Status = HEAP_strdupA2W ( &lpszStrW, lpszStr ); + if (!NT_SUCCESS (Status)) + SetLastError (RtlNtStatusToDosError(Status)); + else + { + rc = NtGdiGetTextExtentExW ( + hdc, lpszStrW, cchString, nMaxExtent, (PULONG)lpnFit, (PULONG)alpDx, lpSize, 0 ); - HEAP_free ( lpszStrW ); - } + HEAP_free ( lpszStrW ); + } - return rc; + return rc; } @@ -250,24 +251,24 @@ GetTextExtentExPointA( BOOL APIENTRY GetTextExtentPoint32A( - HDC hdc, - LPCSTR lpString, - int cchString, - LPSIZE lpSize - ) + HDC hdc, + LPCSTR lpString, + int cchString, + LPSIZE lpSize +) { - ANSI_STRING StringA; - UNICODE_STRING StringU; - BOOL ret; + ANSI_STRING StringA; + UNICODE_STRING StringU; + BOOL ret; - RtlInitAnsiString(&StringA, (LPSTR)lpString); - RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); + RtlInitAnsiString(&StringA, (LPSTR)lpString); + RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); - ret = GetTextExtentPoint32W(hdc, StringU.Buffer, cchString, lpSize); + ret = GetTextExtentPoint32W(hdc, StringU.Buffer, cchString, lpSize); - RtlFreeUnicodeString(&StringU); + RtlFreeUnicodeString(&StringU); - return ret; + return ret; } @@ -277,13 +278,13 @@ GetTextExtentPoint32A( BOOL APIENTRY GetTextExtentPoint32W( - HDC hdc, - LPCWSTR lpString, - int cchString, - LPSIZE lpSize - ) + HDC hdc, + LPCWSTR lpString, + int cchString, + LPSIZE lpSize +) { - return NtGdiGetTextExtent(hdc, (LPWSTR)lpString, cchString, lpSize, 0); + return NtGdiGetTextExtent(hdc, (LPWSTR)lpString, cchString, lpSize, 0); } /* @@ -321,28 +322,28 @@ GetTextExtentPointI(HDC hdc, BOOL WINAPI ExtTextOutA( - HDC hdc, - int X, - int Y, - UINT fuOptions, - CONST RECT *lprc, - LPCSTR lpString, - UINT cchString, - CONST INT *lpDx - ) + HDC hdc, + int X, + int Y, + UINT fuOptions, + CONST RECT *lprc, + LPCSTR lpString, + UINT cchString, + CONST INT *lpDx +) { - ANSI_STRING StringA; - UNICODE_STRING StringU; - BOOL ret; + ANSI_STRING StringA; + UNICODE_STRING StringU; + BOOL ret; - RtlInitAnsiString(&StringA, (LPSTR)lpString); - RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); + RtlInitAnsiString(&StringA, (LPSTR)lpString); + RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE); - ret = ExtTextOutW(hdc, X, Y, fuOptions, lprc, StringU.Buffer, cchString, lpDx); + ret = ExtTextOutW(hdc, X, Y, fuOptions, lprc, StringU.Buffer, cchString, lpDx); - RtlFreeUnicodeString(&StringU); + RtlFreeUnicodeString(&StringU); - return ret; + return ret; } @@ -352,17 +353,17 @@ ExtTextOutA( BOOL WINAPI ExtTextOutW( - HDC hdc, - int X, - int Y, - UINT fuOptions, - CONST RECT *lprc, - LPCWSTR lpString, - UINT cchString, - CONST INT *lpDx - ) + HDC hdc, + int X, + int Y, + UINT fuOptions, + CONST RECT *lprc, + LPCWSTR lpString, + UINT cchString, + CONST INT *lpDx +) { - return NtGdiExtTextOutW(hdc, X, Y, fuOptions, (LPRECT)lprc, (LPWSTR)lpString, cchString, (LPINT)lpDx, 0); + return NtGdiExtTextOutW(hdc, X, Y, fuOptions, (LPRECT)lprc, (LPWSTR)lpString, cchString, (LPINT)lpDx, 0); } @@ -436,12 +437,12 @@ GetTextFaceAliasW(HDC hdc, int cChar, LPWSTR pszOut) { - if ( pszOut && !cChar ) - { - GdiSetLastError(ERROR_INVALID_PARAMETER); - return 0; - } - return NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE); + if ( pszOut && !cChar ) + { + GdiSetLastError(ERROR_INVALID_PARAMETER); + return 0; + } + return NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE); } @@ -452,7 +453,7 @@ GetFontResourceInfoW( DWORD *pdwBufSize, void* lpBuffer, DWORD dwType - ) +) { BOOL bRet; UNICODE_STRING NtFileName; @@ -473,13 +474,13 @@ GetFontResourceInfoW( } bRet = NtGdiGetFontResourceInfoInternalW( - NtFileName.Buffer, - (NtFileName.Length / sizeof(WCHAR)) + 1, - 1, - *pdwBufSize, - pdwBufSize, - lpBuffer, - dwType); + NtFileName.Buffer, + (NtFileName.Length / sizeof(WCHAR)) + 1, + 1, + *pdwBufSize, + pdwBufSize, + lpBuffer, + dwType); RtlFreeHeap(RtlGetProcessHeap(), 0, NtFileName.Buffer); @@ -498,37 +499,37 @@ GetFontResourceInfoW( int WINAPI SetTextCharacterExtra( - HDC hDC, - int CharExtra - ) + HDC hDC, + int CharExtra +) { - INT cExtra = 0x80000000; - PDC_ATTR Dc_Attr; + INT cExtra = 0x80000000; + PDC_ATTR Dc_Attr; - if (CharExtra == cExtra) - { - SetLastError(ERROR_INVALID_PARAMETER); - return cExtra; - } + if (CharExtra == cExtra) + { + SetLastError(ERROR_INVALID_PARAMETER); + return cExtra; + } #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - { - return MFDRV_SetTextCharacterExtra( hDC, CharExtra ); // Wine port. - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + { + return MFDRV_SetTextCharacterExtra( hDC, CharExtra ); // Wine port. + } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return cExtra; + if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return cExtra; - if (NtCurrentTeb()->GdiTebBatch.HDC == hDC) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) - { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } - cExtra = Dc_Attr->lTextExtra; - Dc_Attr->lTextExtra = CharExtra; - return cExtra; + if (NtCurrentTeb()->GdiTebBatch.HDC == hDC) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + cExtra = Dc_Attr->lTextExtra; + Dc_Attr->lTextExtra = CharExtra; + return cExtra; // return GetAndSetDCDWord( hDC, GdiGetSetTextCharExtra, CharExtra, 0, 0, 0 ); } @@ -540,9 +541,9 @@ UINT WINAPI GetTextAlign(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->lTextAlign; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->lTextAlign; } @@ -554,9 +555,9 @@ COLORREF WINAPI GetTextColor(HDC hdc) { - PDC_ATTR Dc_Attr; - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; - return Dc_Attr->ulForegroundClr; + PDC_ATTR Dc_Attr; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return 0; + return Dc_Attr->ulForegroundClr; } @@ -569,38 +570,38 @@ WINAPI SetTextAlign(HDC hdc, UINT fMode) { - PDC_ATTR Dc_Attr; - INT OldMode = 0; + PDC_ATTR Dc_Attr; + INT OldMode = 0; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetTextAlign( hdc, fMode ) - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - if return EMFDRV_SetTextAlign( hdc, fMode ) - } - } - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetTextAlign( hdc, fMode ) + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + if return EMFDRV_SetTextAlign( hdc, fMode ) + } + } + } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldMode; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldMode; - OldMode = Dc_Attr->lTextAlign; - Dc_Attr->lTextAlign = fMode; // Raw - if (Dc_Attr->dwLayout & LAYOUT_RTL) - { - if(!(fMode & TA_CENTER)) fMode |= TA_RIGHT; - } - Dc_Attr->flTextAlign = fMode & (TA_BASELINE|TA_UPDATECP|TA_CENTER); - return OldMode; + OldMode = Dc_Attr->lTextAlign; + Dc_Attr->lTextAlign = fMode; // Raw + if (Dc_Attr->dwLayout & LAYOUT_RTL) + { + if(!(fMode & TA_CENTER)) fMode |= TA_RIGHT; + } + Dc_Attr->flTextAlign = fMode & (TA_BASELINE|TA_UPDATECP|TA_CENTER); + return OldMode; } @@ -611,43 +612,43 @@ SetTextAlign(HDC hdc, COLORREF WINAPI SetTextColor( - HDC hdc, - COLORREF crColor + HDC hdc, + COLORREF crColor ) { - PDC_ATTR Dc_Attr; - COLORREF OldColor = CLR_INVALID; + PDC_ATTR Dc_Attr; + COLORREF OldColor = CLR_INVALID; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetTextColor( hDC, crColor ); - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - PLDC pLDC = Dc_Attr->pvLDC; - if ( !pLDC ) - { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } - if (pLDC->iType == LDC_EMFLDC) - { - if return EMFDRV_SetTextColor( hDC, crColor ); - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetTextColor( hDC, crColor ); + else + { + PLDC pLDC = Dc_Attr->pvLDC; + if ( !pLDC ) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + if (pLDC->iType == LDC_EMFLDC) + { + if return EMFDRV_SetTextColor( hDC, crColor ); + } + } } - } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return OldColor; - OldColor = (COLORREF) Dc_Attr->ulForegroundClr; - Dc_Attr->ulForegroundClr = (ULONG) crColor; + OldColor = (COLORREF) Dc_Attr->ulForegroundClr; + Dc_Attr->ulForegroundClr = (ULONG) crColor; - if ( Dc_Attr->crForegroundClr != crColor ) - { - Dc_Attr->ulDirty_ |= (DIRTY_TEXT|DIRTY_LINE|DIRTY_FILL); - Dc_Attr->crForegroundClr = crColor; - } - return OldColor; + if ( Dc_Attr->crForegroundClr != crColor ) + { + Dc_Attr->ulDirty_ |= (DIRTY_TEXT|DIRTY_LINE|DIRTY_FILL); + Dc_Attr->crForegroundClr = crColor; + } + return OldColor; } /* @@ -656,34 +657,34 @@ SetTextColor( BOOL WINAPI SetTextJustification( - HDC hdc, - int extra, - int breaks - ) + HDC hdc, + int extra, + int breaks +) { - PDC_ATTR Dc_Attr; + PDC_ATTR Dc_Attr; #if 0 - if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) - { - if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) - return MFDRV_SetTextJustification( hdc, extra, breaks ) - else + if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC) { - SetLastError(ERROR_INVALID_HANDLE); - return FALSE; - } + if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC) + return MFDRV_SetTextJustification( hdc, extra, breaks ) + else + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } #endif - if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; + if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE; - if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) - { - if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) - { - NtGdiFlush(); // Sync up Dc_Attr from Kernel space. - Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); - } - } - Dc_Attr->cBreak = breaks; - Dc_Attr->lBreakExtra = extra; - return TRUE; -} + if (NtCurrentTeb()->GdiTebBatch.HDC == hdc) + { + if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY) + { + NtGdiFlush(); // Sync up Dc_Attr from Kernel space. + Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY); + } + } + Dc_Attr->cBreak = breaks; + Dc_Attr->lBreakExtra = extra; + return TRUE; + } diff --git a/reactos/dll/win32/gdi32/objects/utils.c b/reactos/dll/win32/gdi32/objects/utils.c index fb99ed85491..734d5df54c6 100644 --- a/reactos/dll/win32/gdi32/objects/utils.c +++ b/reactos/dll/win32/gdi32/objects/utils.c @@ -24,107 +24,107 @@ BOOL WINAPI CalculateColorTableSize( - CONST BITMAPINFOHEADER *BitmapInfoHeader, - UINT *ColorSpec, - UINT *ColorTableSize) + CONST BITMAPINFOHEADER *BitmapInfoHeader, + UINT *ColorSpec, + UINT *ColorTableSize) { - WORD BitCount; - DWORD ClrUsed; - DWORD Compression; + WORD BitCount; + DWORD ClrUsed; + DWORD Compression; - /* - * At first get some basic parameters from the passed BitmapInfoHeader - * structure. It can have one of the following formats: - * - BITMAPCOREHEADER (the oldest one with totally different layout - * from the others) - * - BITMAPINFOHEADER (the standard and most common header) - * - BITMAPV4HEADER (extension of BITMAPINFOHEADER) - * - BITMAPV5HEADER (extension of BITMAPV4HEADER) - */ + /* + * At first get some basic parameters from the passed BitmapInfoHeader + * structure. It can have one of the following formats: + * - BITMAPCOREHEADER (the oldest one with totally different layout + * from the others) + * - BITMAPINFOHEADER (the standard and most common header) + * - BITMAPV4HEADER (extension of BITMAPINFOHEADER) + * - BITMAPV5HEADER (extension of BITMAPV4HEADER) + */ - if (BitmapInfoHeader->biSize == sizeof(BITMAPCOREHEADER)) - { - BitCount = ((LPBITMAPCOREHEADER)BitmapInfoHeader)->bcBitCount; - ClrUsed = 0; - Compression = BI_RGB; - } - else - { - BitCount = BitmapInfoHeader->biBitCount; - ClrUsed = BitmapInfoHeader->biClrUsed; - Compression = BitmapInfoHeader->biCompression; - } + if (BitmapInfoHeader->biSize == sizeof(BITMAPCOREHEADER)) + { + BitCount = ((LPBITMAPCOREHEADER)BitmapInfoHeader)->bcBitCount; + ClrUsed = 0; + Compression = BI_RGB; + } + else + { + BitCount = BitmapInfoHeader->biBitCount; + ClrUsed = BitmapInfoHeader->biClrUsed; + Compression = BitmapInfoHeader->biCompression; + } - switch (Compression) - { - case BI_BITFIELDS: - if (*ColorSpec == DIB_PAL_COLORS) + switch (Compression) + { + case BI_BITFIELDS: + if (*ColorSpec == DIB_PAL_COLORS) *ColorSpec = DIB_RGB_COLORS; - if (BitCount != 16 && BitCount != 32) + if (BitCount != 16 && BitCount != 32) return FALSE; - /* - * For BITMAPV4HEADER/BITMAPV5HEADER the masks are included in - * the structure itself (bV4RedMask, bV4GreenMask, and bV4BlueMask). - * For BITMAPINFOHEADER the color masks are stored in the palette. - */ + /* + * For BITMAPV4HEADER/BITMAPV5HEADER the masks are included in + * the structure itself (bV4RedMask, bV4GreenMask, and bV4BlueMask). + * For BITMAPINFOHEADER the color masks are stored in the palette. + */ - if (BitmapInfoHeader->biSize > sizeof(BITMAPINFOHEADER)) + if (BitmapInfoHeader->biSize > sizeof(BITMAPINFOHEADER)) *ColorTableSize = 0; - else + else *ColorTableSize = 3; - return TRUE; + return TRUE; - case BI_RGB: - switch (BitCount) - { - case 1: - *ColorTableSize = ClrUsed ? min(ClrUsed, 2) : 2; - return TRUE; + case BI_RGB: + switch (BitCount) + { + case 1: + *ColorTableSize = ClrUsed ? min(ClrUsed, 2) : 2; + return TRUE; - case 4: - *ColorTableSize = ClrUsed ? min(ClrUsed, 16) : 16; - return TRUE; - - case 8: - *ColorTableSize = ClrUsed ? min(ClrUsed, 256) : 256; - return TRUE; - - default: - if (*ColorSpec == DIB_PAL_COLORS) - *ColorSpec = DIB_RGB_COLORS; - if (BitCount != 16 && BitCount != 24 && BitCount != 32) - return FALSE; - *ColorTableSize = ClrUsed; - return TRUE; - } - - case BI_RLE4: - if (BitCount == 4) - { + case 4: *ColorTableSize = ClrUsed ? min(ClrUsed, 16) : 16; return TRUE; - } - return FALSE; - case BI_RLE8: - if (BitCount == 8) - { + case 8: *ColorTableSize = ClrUsed ? min(ClrUsed, 256) : 256; return TRUE; - } - return FALSE; - case BI_JPEG: - case BI_PNG: - *ColorTableSize = ClrUsed; - return TRUE; + default: + if (*ColorSpec == DIB_PAL_COLORS) + *ColorSpec = DIB_RGB_COLORS; + if (BitCount != 16 && BitCount != 24 && BitCount != 32) + return FALSE; + *ColorTableSize = ClrUsed; + return TRUE; + } - default: - return FALSE; - } + case BI_RLE4: + if (BitCount == 4) + { + *ColorTableSize = ClrUsed ? min(ClrUsed, 16) : 16; + return TRUE; + } + return FALSE; + + case BI_RLE8: + if (BitCount == 8) + { + *ColorTableSize = ClrUsed ? min(ClrUsed, 256) : 256; + return TRUE; + } + return FALSE; + + case BI_JPEG: + case BI_PNG: + *ColorTableSize = ClrUsed; + return TRUE; + + default: + return FALSE; + } } /** @@ -170,142 +170,142 @@ CalculateColorTableSize( LPBITMAPINFO WINAPI ConvertBitmapInfo( - CONST BITMAPINFO *BitmapInfo, - UINT ColorSpec, - UINT *BitmapInfoSize, - BOOL FollowedByData) + CONST BITMAPINFO *BitmapInfo, + UINT ColorSpec, + UINT *BitmapInfoSize, + BOOL FollowedByData) { - LPBITMAPINFO NewBitmapInfo = (LPBITMAPINFO)BitmapInfo; - LPBITMAPCOREINFO CoreBitmapInfo = (LPBITMAPCOREINFO)BitmapInfo; - DWORD Size = 0; - ULONG DataSize = 0; - UINT PaletteEntryCount = 0; + LPBITMAPINFO NewBitmapInfo = (LPBITMAPINFO)BitmapInfo; + LPBITMAPCOREINFO CoreBitmapInfo = (LPBITMAPCOREINFO)BitmapInfo; + DWORD Size = 0; + ULONG DataSize = 0; + UINT PaletteEntryCount = 0; - /* - * At first check if the passed BitmapInfo structure has valid size. It - * can have one of these headers: BITMAPCOREHEADER, BITMAPINFOHEADER, - * BITMAPV4HEADER or BITMAPV5HEADER (see CalculateColorTableSize for - * description). - */ + /* + * At first check if the passed BitmapInfo structure has valid size. It + * can have one of these headers: BITMAPCOREHEADER, BITMAPINFOHEADER, + * BITMAPV4HEADER or BITMAPV5HEADER (see CalculateColorTableSize for + * description). + */ - if ( !BitmapInfo || - (BitmapInfo->bmiHeader.biSize != sizeof(BITMAPCOREHEADER) && - (BitmapInfo->bmiHeader.biSize < sizeof(BITMAPINFOHEADER) || - BitmapInfo->bmiHeader.biSize > sizeof(BITMAPV5HEADER)))) - { - return NULL; - } + if ( !BitmapInfo || + (BitmapInfo->bmiHeader.biSize != sizeof(BITMAPCOREHEADER) && + (BitmapInfo->bmiHeader.biSize < sizeof(BITMAPINFOHEADER) || + BitmapInfo->bmiHeader.biSize > sizeof(BITMAPV5HEADER)))) + { + return NULL; + } - /* - * Now calculate the color table size. Also if the bitmap info contains - * invalid color information it's rejected here. - */ + /* + * Now calculate the color table size. Also if the bitmap info contains + * invalid color information it's rejected here. + */ - if (!CalculateColorTableSize(&BitmapInfo->bmiHeader, &ColorSpec, - &PaletteEntryCount)) - { - return NULL; - } + if (!CalculateColorTableSize(&BitmapInfo->bmiHeader, &ColorSpec, + &PaletteEntryCount)) + { + return NULL; + } - /* - * Calculate the size of image data if applicable. We must be careful - * to do proper aligning on line ends. - */ + /* + * Calculate the size of image data if applicable. We must be careful + * to do proper aligning on line ends. + */ - if (FollowedByData) - { - DataSize = DIB_BitmapBitsSize((PBITMAPINFO)BitmapInfo ); - } + if (FollowedByData) + { + DataSize = DIB_BitmapBitsSize((PBITMAPINFO)BitmapInfo ); + } - /* - * If BitmapInfo was originally BITMAPCOREINFO then we need to convert - * it to the standard BITMAPINFO layout. - */ + /* + * If BitmapInfo was originally BITMAPCOREINFO then we need to convert + * it to the standard BITMAPINFO layout. + */ - if (BitmapInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) - { - Size = sizeof(BITMAPINFOHEADER); - if (ColorSpec == DIB_RGB_COLORS) - Size += PaletteEntryCount * sizeof(RGBQUAD); - else - Size += PaletteEntryCount * sizeof(USHORT); - Size += DataSize; + if (BitmapInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) + { + Size = sizeof(BITMAPINFOHEADER); + if (ColorSpec == DIB_RGB_COLORS) + Size += PaletteEntryCount * sizeof(RGBQUAD); + else + Size += PaletteEntryCount * sizeof(USHORT); + Size += DataSize; - NewBitmapInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size); - if (NewBitmapInfo == NULL) - { - return NULL; - } + NewBitmapInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size); + if (NewBitmapInfo == NULL) + { + return NULL; + } - NewBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); - NewBitmapInfo->bmiHeader.biWidth = CoreBitmapInfo->bmciHeader.bcWidth; - NewBitmapInfo->bmiHeader.biHeight = CoreBitmapInfo->bmciHeader.bcHeight; - NewBitmapInfo->bmiHeader.biPlanes = CoreBitmapInfo->bmciHeader.bcPlanes; - NewBitmapInfo->bmiHeader.biBitCount = CoreBitmapInfo->bmciHeader.bcBitCount; - NewBitmapInfo->bmiHeader.biCompression = BI_RGB; - NewBitmapInfo->bmiHeader.biSizeImage = 0; - NewBitmapInfo->bmiHeader.biXPelsPerMeter = 0; - NewBitmapInfo->bmiHeader.biYPelsPerMeter = 0; - NewBitmapInfo->bmiHeader.biClrUsed = 0; - NewBitmapInfo->bmiHeader.biClrImportant = 0; + NewBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + NewBitmapInfo->bmiHeader.biWidth = CoreBitmapInfo->bmciHeader.bcWidth; + NewBitmapInfo->bmiHeader.biHeight = CoreBitmapInfo->bmciHeader.bcHeight; + NewBitmapInfo->bmiHeader.biPlanes = CoreBitmapInfo->bmciHeader.bcPlanes; + NewBitmapInfo->bmiHeader.biBitCount = CoreBitmapInfo->bmciHeader.bcBitCount; + NewBitmapInfo->bmiHeader.biCompression = BI_RGB; + NewBitmapInfo->bmiHeader.biSizeImage = 0; + NewBitmapInfo->bmiHeader.biXPelsPerMeter = 0; + NewBitmapInfo->bmiHeader.biYPelsPerMeter = 0; + NewBitmapInfo->bmiHeader.biClrUsed = 0; + NewBitmapInfo->bmiHeader.biClrImportant = 0; - if (PaletteEntryCount != 0) - { - if (ColorSpec == DIB_RGB_COLORS) - { - ULONG Index; - - for (Index = 0; Index < PaletteEntryCount; Index++) + if (PaletteEntryCount != 0) + { + if (ColorSpec == DIB_RGB_COLORS) { - NewBitmapInfo->bmiColors[Index].rgbRed = - CoreBitmapInfo->bmciColors[Index].rgbtRed; - NewBitmapInfo->bmiColors[Index].rgbGreen = - CoreBitmapInfo->bmciColors[Index].rgbtGreen; - NewBitmapInfo->bmiColors[Index].rgbBlue = - CoreBitmapInfo->bmciColors[Index].rgbtBlue; - NewBitmapInfo->bmiColors[Index].rgbReserved = 0; + ULONG Index; + + for (Index = 0; Index < PaletteEntryCount; Index++) + { + NewBitmapInfo->bmiColors[Index].rgbRed = + CoreBitmapInfo->bmciColors[Index].rgbtRed; + NewBitmapInfo->bmiColors[Index].rgbGreen = + CoreBitmapInfo->bmciColors[Index].rgbtGreen; + NewBitmapInfo->bmiColors[Index].rgbBlue = + CoreBitmapInfo->bmciColors[Index].rgbtBlue; + NewBitmapInfo->bmiColors[Index].rgbReserved = 0; + } } - } - else - { - RtlCopyMemory(NewBitmapInfo->bmiColors, - CoreBitmapInfo->bmciColors, - PaletteEntryCount * sizeof(USHORT)); - } - } + else + { + RtlCopyMemory(NewBitmapInfo->bmiColors, + CoreBitmapInfo->bmciColors, + PaletteEntryCount * sizeof(USHORT)); + } + } - if (FollowedByData) - { - ULONG_PTR NewDataPtr, OldDataPtr; + if (FollowedByData) + { + ULONG_PTR NewDataPtr, OldDataPtr; - if (ColorSpec == DIB_RGB_COLORS) - { - NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors + - PaletteEntryCount); - OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors + - PaletteEntryCount); - } - else - { - NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors) + - PaletteEntryCount * sizeof(USHORT); - OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors) + - PaletteEntryCount * sizeof(USHORT); - } + if (ColorSpec == DIB_RGB_COLORS) + { + NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors + + PaletteEntryCount); + OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors + + PaletteEntryCount); + } + else + { + NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors) + + PaletteEntryCount * sizeof(USHORT); + OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors) + + PaletteEntryCount * sizeof(USHORT); + } - RtlCopyMemory((PVOID)NewDataPtr, (PVOID)OldDataPtr, DataSize); - } - } + RtlCopyMemory((PVOID)NewDataPtr, (PVOID)OldDataPtr, DataSize); + } + } - Size = NewBitmapInfo->bmiHeader.biSize; - if (ColorSpec == DIB_RGB_COLORS) - Size += PaletteEntryCount * sizeof(RGBQUAD); - else - Size += PaletteEntryCount * sizeof(USHORT); - Size += DataSize; - *BitmapInfoSize = Size; + Size = NewBitmapInfo->bmiHeader.biSize; + if (ColorSpec == DIB_RGB_COLORS) + Size += PaletteEntryCount * sizeof(RGBQUAD); + else + Size += PaletteEntryCount * sizeof(USHORT); + Size += DataSize; + *BitmapInfoSize = Size; - return NewBitmapInfo; + return NewBitmapInfo; } VOID @@ -315,21 +315,21 @@ LogFontA2W(LPLOGFONTW pW, CONST LOGFONTA *pA) #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, pA->f, len, pW->f, len ) #define COPYN(f) pW->f = pA->f - COPYN(lfHeight); - COPYN(lfWidth); - COPYN(lfEscapement); - COPYN(lfOrientation); - COPYN(lfWeight); - COPYN(lfItalic); - COPYN(lfUnderline); - COPYN(lfStrikeOut); - COPYN(lfCharSet); - COPYN(lfOutPrecision); - COPYN(lfClipPrecision); - COPYN(lfQuality); - COPYN(lfPitchAndFamily); - COPYS(lfFaceName,LF_FACESIZE); - pW->lfFaceName[LF_FACESIZE - 1] = '\0'; + COPYN(lfHeight); + COPYN(lfWidth); + COPYN(lfEscapement); + COPYN(lfOrientation); + COPYN(lfWeight); + COPYN(lfItalic); + COPYN(lfUnderline); + COPYN(lfStrikeOut); + COPYN(lfCharSet); + COPYN(lfOutPrecision); + COPYN(lfClipPrecision); + COPYN(lfQuality); + COPYN(lfPitchAndFamily); + COPYS(lfFaceName,LF_FACESIZE); + pW->lfFaceName[LF_FACESIZE - 1] = '\0'; #undef COPYN #undef COPYS @@ -342,21 +342,21 @@ LogFontW2A(LPLOGFONTA pA, CONST LOGFONTW *pW) #define COPYS(f,len) WideCharToMultiByte ( CP_THREAD_ACP, 0, pW->f, len, pA->f, len, NULL, NULL ) #define COPYN(f) pA->f = pW->f - COPYN(lfHeight); - COPYN(lfWidth); - COPYN(lfEscapement); - COPYN(lfOrientation); - COPYN(lfWeight); - COPYN(lfItalic); - COPYN(lfUnderline); - COPYN(lfStrikeOut); - COPYN(lfCharSet); - COPYN(lfOutPrecision); - COPYN(lfClipPrecision); - COPYN(lfQuality); - COPYN(lfPitchAndFamily); - COPYS(lfFaceName,LF_FACESIZE); - pA->lfFaceName[LF_FACESIZE - 1] = '\0'; + COPYN(lfHeight); + COPYN(lfWidth); + COPYN(lfEscapement); + COPYN(lfOrientation); + COPYN(lfWeight); + COPYN(lfItalic); + COPYN(lfUnderline); + COPYN(lfStrikeOut); + COPYN(lfCharSet); + COPYN(lfOutPrecision); + COPYN(lfClipPrecision); + COPYN(lfQuality); + COPYN(lfPitchAndFamily); + COPYS(lfFaceName,LF_FACESIZE); + pA->lfFaceName[LF_FACESIZE - 1] = '\0'; #undef COPYN #undef COPYS @@ -369,13 +369,13 @@ EnumLogFontExW2A( LPENUMLOGFONTEXA fontA, CONST ENUMLOGFONTEXW *fontW ) LogFontW2A( (LPLOGFONTA)fontA, (CONST LOGFONTW *)fontW ); WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfFullName, -1, - (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL ); + (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL ); fontA->elfFullName[LF_FULLFACESIZE-1] = '\0'; WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfStyle, -1, - (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL ); + (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL ); fontA->elfStyle[LF_FACESIZE-1] = '\0'; WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfScript, -1, - (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL ); + (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL ); fontA->elfScript[LF_FACESIZE-1] = '\0'; }