Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-01 07:28:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

{WIN32K]

Browse source 
- Add some annotations
- Fix some 64bit issues
- Fix a typo
- reduce ENUM_RECT_LIMIT to 32, which is more than enough and doesn't waste as much stack space
- remove some unused macros

svn path=/trunk/; revision=58076
This commit is contained in:
Timo Kreuzer 2013-01-01 09:40:48 +00:00
parent 319425e1d9
commit 737708cfb0
21 changed files with 311 additions and 273 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
reactos/win32ss/gdi/eng/alphablend.c
View file

@ -17,13 +17,14 @@
*/ */
BOOL BOOL
APIENTRY APIENTRY
EngAlphaBlend(IN SURFOBJ *psoDest, EngAlphaBlend(
IN SURFOBJ *psoSource, _Inout_ SURFOBJ *psoDest,
IN CLIPOBJ *ClipRegion, _In_ SURFOBJ *psoSource,
IN XLATEOBJ *ColorTranslation, _In_opt_ CLIPOBJ *ClipRegion,
IN PRECTL DestRect, _In_opt_ XLATEOBJ *ColorTranslation,
IN PRECTL SourceRect, _In_ RECTL *DestRect,
IN BLENDOBJ *BlendObj) _In_ RECTL *SourceRect,
_In_ BLENDOBJ *BlendObj)
{ {
RECTL InputRect; RECTL InputRect;
RECTL OutputRect; RECTL OutputRect;

120
reactos/win32ss/gdi/eng/bitblt.c
View file

@ -296,18 +296,20 @@ NtGdiEngBitBlt(
/* /*
* @implemented * @implemented
*/ */
BOOL APIENTRY BOOL
EngBitBlt(SURFOBJ *DestObj, APIENTRY
SURFOBJ *SourceObj, EngBitBlt(
SURFOBJ *Mask, _Inout_ SURFOBJ *psoTrg,
CLIPOBJ *ClipRegion, _In_opt_ SURFOBJ *psoSrc,
XLATEOBJ *ColorTranslation, _In_opt_ SURFOBJ *psoMask,
RECTL *DestRect, _In_opt_ CLIPOBJ *pco,
POINTL *SourcePoint, _In_opt_ XLATEOBJ *pxlo,
POINTL *MaskOrigin, _In_ RECTL *prclTrg,
BRUSHOBJ *pbo, _When_(psoSrc, _In_) POINTL *pptlSrc,
POINTL *BrushOrigin, _When_(psoMask, _In_) POINTL *pptlMask,
ROP4 Rop4) _In_opt_ BRUSHOBJ *pbo,
_When_(pbo, _In_) POINTL *pptlBrush,
_In_ ROP4 rop4)
{ {
BYTE clippingType; BYTE clippingType;
RECTL CombinedRect; RECTL CombinedRect;
@ -321,36 +323,36 @@ EngBitBlt(SURFOBJ *DestObj,
PBLTRECTFUNC BltRectFunc; PBLTRECTFUNC BltRectFunc;
BOOLEAN Ret = TRUE; BOOLEAN Ret = TRUE;
RECTL ClipRect; RECTL ClipRect;
unsigned i; ULONG i;
POINTL Pt; POINTL Pt;
ULONG Direction; ULONG Direction;
BOOL UsesSource, UsesMask; BOOL UsesSource, UsesMask;
POINTL AdjustedBrushOrigin; POINTL AdjustedBrushOrigin;
UsesSource = ROP4_USES_SOURCE(Rop4); UsesSource = ROP4_USES_SOURCE(rop4);
UsesMask = ROP4_USES_MASK(Rop4); UsesMask = ROP4_USES_MASK(rop4);
if (Rop4 == ROP4_NOOP) if (rop4 == ROP4_NOOP)
{ {
/* Copy destination onto itself: nop */ /* Copy destination onto itself: nop */
return TRUE; return TRUE;
} }
//DPRINT1("Rop4 : 0x%08x\n", Rop4); //DPRINT1("rop4 : 0x%08x\n", rop4);
OutputRect = *DestRect; OutputRect = *prclTrg;
RECTL_vMakeWellOrdered(&OutputRect); RECTL_vMakeWellOrdered(&OutputRect);
if (UsesSource) if (UsesSource)
{ {
if (NULL == SourcePoint) if (!psoSrc || !pptlSrc)
{ {
return FALSE; return FALSE;
} }
/* Make sure we don't try to copy anything outside the valid source /* Make sure we don't try to copy anything outside the valid source
region */ region */
InputPoint = *SourcePoint; InputPoint = *pptlSrc;
if (InputPoint.x < 0) if (InputPoint.x < 0)
{ {
OutputRect.left -= InputPoint.x; OutputRect.left -= InputPoint.x;
@ -361,17 +363,17 @@ EngBitBlt(SURFOBJ *DestObj,
OutputRect.top -= InputPoint.y; OutputRect.top -= InputPoint.y;
InputPoint.y = 0; InputPoint.y = 0;
} }
if (SourceObj->sizlBitmap.cx < InputPoint.x + if (psoSrc->sizlBitmap.cx < InputPoint.x +
OutputRect.right - OutputRect.left) OutputRect.right - OutputRect.left)
{ {
OutputRect.right = OutputRect.left + OutputRect.right = OutputRect.left +
SourceObj->sizlBitmap.cx - InputPoint.x; psoSrc->sizlBitmap.cx - InputPoint.x;
} }
if (SourceObj->sizlBitmap.cy < InputPoint.y + if (psoSrc->sizlBitmap.cy < InputPoint.y +
OutputRect.bottom - OutputRect.top) OutputRect.bottom - OutputRect.top)
{ {
OutputRect.bottom = OutputRect.top + OutputRect.bottom = OutputRect.top +
SourceObj->sizlBitmap.cy - InputPoint.y; psoSrc->sizlBitmap.cy - InputPoint.y;
} }
InputRect.left = InputPoint.x; InputRect.left = InputPoint.x;
@ -379,40 +381,40 @@ EngBitBlt(SURFOBJ *DestObj,
InputRect.top = InputPoint.y; InputRect.top = InputPoint.y;
InputRect.bottom = InputPoint.y + (OutputRect.bottom - OutputRect.top); InputRect.bottom = InputPoint.y + (OutputRect.bottom - OutputRect.top);
InputObj = SourceObj; InputObj = psoSrc;
} }
else else
{ {
InputPoint.x = InputPoint.y = 0; InputPoint.x = InputPoint.y = 0;
InputRect.left = 0; InputRect.left = 0;
InputRect.right = DestRect->right - DestRect->left; InputRect.right = prclTrg->right - prclTrg->left;
InputRect.top = 0; InputRect.top = 0;
InputRect.bottom = DestRect->bottom - DestRect->top; InputRect.bottom = prclTrg->bottom - prclTrg->top;
} }
if (NULL != ClipRegion) if (NULL != pco)
{ {
if (OutputRect.left < ClipRegion->rclBounds.left) if (OutputRect.left < pco->rclBounds.left)
{ {
InputRect.left += ClipRegion->rclBounds.left - OutputRect.left; InputRect.left += pco->rclBounds.left - OutputRect.left;
InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left; InputPoint.x += pco->rclBounds.left - OutputRect.left;
OutputRect.left = ClipRegion->rclBounds.left; OutputRect.left = pco->rclBounds.left;
} }
if (ClipRegion->rclBounds.right < OutputRect.right) if (pco->rclBounds.right < OutputRect.right)
{ {
InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right; InputRect.right -= OutputRect.right - pco->rclBounds.right;
OutputRect.right = ClipRegion->rclBounds.right; OutputRect.right = pco->rclBounds.right;
} }
if (OutputRect.top < ClipRegion->rclBounds.top) if (OutputRect.top < pco->rclBounds.top)
{ {
InputRect.top += ClipRegion->rclBounds.top - OutputRect.top; InputRect.top += pco->rclBounds.top - OutputRect.top;
InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top; InputPoint.y += pco->rclBounds.top - OutputRect.top;
OutputRect.top = ClipRegion->rclBounds.top; OutputRect.top = pco->rclBounds.top;
} }
if (ClipRegion->rclBounds.bottom < OutputRect.bottom) if (pco->rclBounds.bottom < OutputRect.bottom)
{ {
InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom; InputRect.bottom -= OutputRect.bottom - pco->rclBounds.bottom;
OutputRect.bottom = ClipRegion->rclBounds.bottom; OutputRect.bottom = pco->rclBounds.bottom;
} }
} }
@ -424,12 +426,12 @@ EngBitBlt(SURFOBJ *DestObj,
return TRUE; return TRUE;
} }
OutputObj = DestObj; OutputObj = psoTrg;
if (BrushOrigin) if (pptlBrush)
{ {
AdjustedBrushOrigin.x = BrushOrigin->x; AdjustedBrushOrigin.x = pptlBrush->x;
AdjustedBrushOrigin.y = BrushOrigin->y; AdjustedBrushOrigin.y = pptlBrush->y;
} }
else else
{ {
@ -438,20 +440,20 @@ EngBitBlt(SURFOBJ *DestObj,
} }
/* Determine clipping type */ /* Determine clipping type */
if (ClipRegion == (CLIPOBJ *) NULL) if (pco == (CLIPOBJ *) NULL)
{ {
clippingType = DC_TRIVIAL; clippingType = DC_TRIVIAL;
} }
else else
{ {
clippingType = ClipRegion->iDComplexity; clippingType = pco->iDComplexity;
} }
if (UsesMask) if (UsesMask)
{ {
BltRectFunc = BltMask; BltRectFunc = BltMask;
} }
else if ((Rop4 & 0xFF) == R3_OPINDEX_PATCOPY) else if ((rop4 & 0xFF) == R3_OPINDEX_PATCOPY)
{ {
if (pbo && pbo->iSolidColor == 0xFFFFFFFF) if (pbo && pbo->iSolidColor == 0xFFFFFFFF)
BltRectFunc = CallDibBitBlt; BltRectFunc = CallDibBitBlt;
@ -512,10 +514,10 @@ EngBitBlt(SURFOBJ *DestObj,
{ {
Direction = CD_ANY; Direction = CD_ANY;
} }
CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0); CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, Direction, 0);
do do
{ {
EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), EnumMore = CLIPOBJ_bEnum(pco, sizeof(RectEnum),
(PVOID) &RectEnum); (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c; i++) for (i = 0; i < RectEnum.c; i++)
@ -535,10 +537,16 @@ EngBitBlt(SURFOBJ *DestObj,
#endif #endif
Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, Ret = (*BltRectFunc)(OutputObj,
ColorTranslation, &CombinedRect, &Pt, InputObj,
MaskOrigin, pbo, &AdjustedBrushOrigin, psoMask,
Rop4) && Ret; pxlo,
&CombinedRect,
&Pt,
pptlMask,
pbo,
&AdjustedBrushOrigin,
rop4) && Ret;
} }
} }
} }
@ -965,7 +973,7 @@ IntEngMaskBlt(SURFOBJ *psoDest,
{ {
BOOLEAN ret; BOOLEAN ret;
RECTL OutputRect; RECTL OutputRect;
POINTL InputPoint; POINTL InputPoint = {0,0};
//SURFACE *psurfDest; //SURFACE *psurfDest;
ASSERT(psoMask); ASSERT(psoMask);

57
reactos/win32ss/gdi/eng/clip.c
View file

@ -188,13 +188,15 @@ CompareSpans(
return Cmp; return Cmp;
} }
VOID FASTCALL VOID
FASTCALL
IntEngDeleteClipRegion(CLIPOBJ *ClipObj) IntEngDeleteClipRegion(CLIPOBJ *ClipObj)
{ {
EngFreeMem(ObjToGDI(ClipObj, CLIP)); EngFreeMem(ObjToGDI(ClipObj, CLIP));
} }
CLIPOBJ* FASTCALL CLIPOBJ*
FASTCALL
IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds) IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds)
{ {
CLIPGDI *Clip; CLIPGDI *Clip;
@ -250,7 +252,8 @@ IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds)
/* /*
* @implemented * @implemented
*/ */
CLIPOBJ * APIENTRY CLIPOBJ *
APIENTRY
EngCreateClip(VOID) EngCreateClip(VOID)
{ {
CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), GDITAG_CLIPOBJ); CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), GDITAG_CLIPOBJ);
@ -265,32 +268,35 @@ EngCreateClip(VOID)
/* /*
* @implemented * @implemented
*/ */
VOID APIENTRY VOID
EngDeleteClip(CLIPOBJ *ClipRegion) APIENTRY
EngDeleteClip(
_In_ _Post_ptr_invalid_ CLIPOBJ *pco)
{ {
EngFreeMem(ObjToGDI(ClipRegion, CLIP)); EngFreeMem(ObjToGDI(pco, CLIP));
} }
/* /*
* @implemented * @implemented
*/ */
ULONG APIENTRY ULONG
APIENTRY
CLIPOBJ_cEnumStart( CLIPOBJ_cEnumStart(
IN CLIPOBJ* ClipObj, _Inout_ CLIPOBJ *pco,
IN BOOL ShouldDoAll, _In_ BOOL bAll,
IN ULONG ClipType, _In_ ULONG iType,
IN ULONG BuildOrder, _In_ ULONG iDirection,
IN ULONG MaxRects) _In_ ULONG cMaxRects)
{ {
CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP); CLIPGDI *ClipGDI = ObjToGDI(pco, CLIP);
SORTCOMP CompareFunc; SORTCOMP CompareFunc;
ClipGDI->EnumPos = 0; ClipGDI->EnumPos = 0;
ClipGDI->EnumMax = (MaxRects > 0) ? MaxRects : ClipGDI->EnumRects.c; ClipGDI->EnumMax = (cMaxRects > 0) ? cMaxRects : ClipGDI->EnumRects.c;
if (CD_ANY != BuildOrder && ClipGDI->EnumOrder != BuildOrder) if (CD_ANY != iDirection && ClipGDI->EnumOrder != iDirection)
{ {
switch (BuildOrder) switch (iDirection)
{ {
case CD_RIGHTDOWN: case CD_RIGHTDOWN:
CompareFunc = (SORTCOMP) CompareRightDown; CompareFunc = (SORTCOMP) CompareRightDown;
@ -320,11 +326,11 @@ CLIPOBJ_cEnumStart(
EngSort((PBYTE) ClipGDI->EnumRects.arcl, sizeof(RECTL), ClipGDI->EnumRects.c, CompareFunc); EngSort((PBYTE) ClipGDI->EnumRects.arcl, sizeof(RECTL), ClipGDI->EnumRects.c, CompareFunc);
} }
ClipGDI->EnumOrder = BuildOrder; ClipGDI->EnumOrder = iDirection;
} }
/* Return the number of rectangles enumerated */ /* Return the number of rectangles enumerated */
if ((MaxRects > 0) && (ClipGDI->EnumRects.c > MaxRects)) if ((cMaxRects > 0) && (ClipGDI->EnumRects.c > cMaxRects))
{ {
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
@ -335,21 +341,22 @@ CLIPOBJ_cEnumStart(
/* /*
* @implemented * @implemented
*/ */
BOOL APIENTRY BOOL
APIENTRY
CLIPOBJ_bEnum( CLIPOBJ_bEnum(
IN CLIPOBJ* ClipObj, _In_ CLIPOBJ *pco,
IN ULONG ObjSize, _In_ ULONG cj,
OUT ULONG *EnumRects) _Out_bytecap_(cj) ULONG *pulEnumRects)
{ {
RECTL *dest, *src; RECTL *dest, *src;
CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP); CLIPGDI *ClipGDI = ObjToGDI(pco, CLIP);
ULONG nCopy, i; ULONG nCopy, i;
ENUMRECTS* pERects = (ENUMRECTS*)EnumRects; ENUMRECTS* pERects = (ENUMRECTS*)pulEnumRects;
// Calculate how many rectangles we should copy // Calculate how many rectangles we should copy
nCopy = min( ClipGDI->EnumMax - ClipGDI->EnumPos, nCopy = min( ClipGDI->EnumMax - ClipGDI->EnumPos,
min( ClipGDI->EnumRects.c - ClipGDI->EnumPos, min( ClipGDI->EnumRects.c - ClipGDI->EnumPos,
(ObjSize - sizeof(ULONG)) / sizeof(RECTL))); (cj - sizeof(ULONG)) / sizeof(RECTL)));
if(nCopy == 0) if(nCopy == 0)
{ {

15
reactos/win32ss/gdi/eng/copybits.c
View file

@ -15,12 +15,13 @@
* @implemented * @implemented
*/ */
BOOL APIENTRY BOOL APIENTRY
EngCopyBits(SURFOBJ *psoDest, EngCopyBits(
SURFOBJ *psoSource, _In_ SURFOBJ *psoDest,
CLIPOBJ *Clip, _In_ SURFOBJ *psoSource,
XLATEOBJ *ColorTranslation, _In_opt_ CLIPOBJ *Clip,
RECTL *DestRect, _In_opt_ XLATEOBJ *ColorTranslation,
POINTL *SourcePoint) _In_ RECTL *DestRect,
_In_ POINTL *SourcePoint)
{ {
BOOL ret; BOOL ret;
BYTE clippingType; BYTE clippingType;
@ -50,7 +51,7 @@ EngCopyBits(SURFOBJ *psoDest,
rclDest.bottom = psoDest->sizlBitmap.cy; rclDest.bottom = psoDest->sizlBitmap.cy;
if (RECTL_bIsEmptyRect(&rclDest)) return TRUE; if (RECTL_bIsEmptyRect(&rclDest)) return TRUE;
DestRect = &rclDest; DestRect = &rclDest;
// FIXME: Don't punt to the driver's DrvCopyBits immediately. Instead, // FIXME: Don't punt to the driver's DrvCopyBits immediately. Instead,
// mark the copy block function to be DrvCopyBits instead of the // mark the copy block function to be DrvCopyBits instead of the
// GDI's copy bit function so as to remove clipping from the // GDI's copy bit function so as to remove clipping from the

12
reactos/win32ss/gdi/eng/debug.c
View file

@ -1,4 +1,4 @@
/* /*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* PURPOSE: * PURPOSE:
@ -14,10 +14,12 @@
/* /*
* @implemented * @implemented
*/ */
VOID APIENTRY VOID
EngDebugPrint(PCHAR StandardPrefix, APIENTRY
PCHAR DebugMessage, EngDebugPrint(
va_list ap) _In_z_ PCHAR StandardPrefix,
_In_z_ PCHAR DebugMessage,
_In_ va_list ap)
{ {
vDbgPrintExWithPrefix(StandardPrefix, vDbgPrintExWithPrefix(StandardPrefix,
-1, -1,

44
reactos/win32ss/gdi/eng/device.c
View file

@ -47,6 +47,7 @@ EngpRegisterGraphicsDevice(
NTSTATUS Status; NTSTATUS Status;
PWSTR pwsz; PWSTR pwsz;
ULONG i, cj, cModes = 0; ULONG i, cj, cModes = 0;
SIZE_T cjWritten;
BOOL bEnable = TRUE; BOOL bEnable = TRUE;
PDEVMODEINFO pdminfo; PDEVMODEINFO pdminfo;
PDEVMODEW pdm, pdmEnd; PDEVMODEW pdm, pdmEnd;
@ -77,7 +78,7 @@ EngpRegisterGraphicsDevice(
} }
/* Enable the device */ /* Enable the device */
EngFileWrite(pFileObject, &bEnable, sizeof(BOOL), &cj); EngFileWrite(pFileObject, &bEnable, sizeof(BOOL), &cjWritten);
/* Copy the device and file object pointers */ /* Copy the device and file object pointers */
pGraphicsDevice->DeviceObject = pDeviceObject; pGraphicsDevice->DeviceObject = pDeviceObject;
@ -288,11 +289,11 @@ static
NTSTATUS NTSTATUS
EngpFileIoRequest( EngpFileIoRequest(
PFILE_OBJECT pFileObject, PFILE_OBJECT pFileObject,
ULONG ulMajorFunction, ULONG ulMajorFunction,
LPVOID lpBuffer, LPVOID lpBuffer,
DWORD nBufferSize, SIZE_T nBufferSize,
ULONGLONG ullStartOffset, ULONGLONG ullStartOffset,
OUT LPDWORD lpInformation) OUT PULONG_PTR lpInformation)
{ {
PDEVICE_OBJECT pDeviceObject; PDEVICE_OBJECT pDeviceObject;
KEVENT Event; KEVENT Event;
@ -316,7 +317,7 @@ EngpFileIoRequest(
pIrp = IoBuildSynchronousFsdRequest(ulMajorFunction, pIrp = IoBuildSynchronousFsdRequest(ulMajorFunction,
pDeviceObject, pDeviceObject,
lpBuffer, lpBuffer,
nBufferSize, (ULONG)nBufferSize,
&liStartOffset, &liStartOffset,
&Event, &Event,
&Iosb); &Iosb);
@ -367,7 +368,7 @@ EngFileIoControl(
IN SIZE_T nInBufferSize, IN SIZE_T nInBufferSize,
OUT PVOID lpOutBuffer, OUT PVOID lpOutBuffer,
IN SIZE_T nOutBufferSize, IN SIZE_T nOutBufferSize,
OUT LPDWORD lpInformation) OUT PULONG_PTR lpInformation)
{ {
PDEVICE_OBJECT pDeviceObject; PDEVICE_OBJECT pDeviceObject;
KEVENT Event; KEVENT Event;
@ -389,9 +390,9 @@ EngFileIoControl(
pIrp = IoBuildDeviceIoControlRequest(dwIoControlCode, pIrp = IoBuildDeviceIoControlRequest(dwIoControlCode,
pDeviceObject, pDeviceObject,
lpInBuffer, lpInBuffer,
nInBufferSize, (ULONG)nInBufferSize,
lpOutBuffer, lpOutBuffer,
nOutBufferSize, (ULONG)nOutBufferSize,
FALSE, FALSE,
&Event, &Event,
&Iosb); &Iosb);
@ -422,13 +423,13 @@ EngFileIoControl(
*/ */
DWORD APIENTRY DWORD APIENTRY
EngDeviceIoControl( EngDeviceIoControl(
HANDLE hDevice, _In_ HANDLE hDevice,
DWORD dwIoControlCode, _In_ DWORD dwIoControlCode,
LPVOID lpInBuffer, _In_opt_bytecount_(cjInBufferSize) LPVOID lpInBuffer,
DWORD nInBufferSize, _In_ DWORD cjInBufferSize,
LPVOID lpOutBuffer, _Out_opt_bytecap_(cjOutBufferSize) LPVOID lpOutBuffer,
DWORD nOutBufferSize, _In_ DWORD cjOutBufferSize,
DWORD *lpBytesReturned) _Out_ LPDWORD lpBytesReturned)
{ {
PIRP Irp; PIRP Irp;
NTSTATUS Status; NTSTATUS Status;
@ -445,9 +446,12 @@ EngDeviceIoControl(
Irp = IoBuildDeviceIoControlRequest(dwIoControlCode, Irp = IoBuildDeviceIoControlRequest(dwIoControlCode,
DeviceObject, DeviceObject,
lpInBuffer, lpInBuffer,
nInBufferSize, cjInBufferSize,
lpOutBuffer, lpOutBuffer,
nOutBufferSize, FALSE, &Event, &Iosb); cjOutBufferSize,
FALSE,
&Event,
&Iosb);
if (!Irp) return ERROR_NOT_ENOUGH_MEMORY; if (!Irp) return ERROR_NOT_ENOUGH_MEMORY;
Status = IoCallDriver(DeviceObject, Irp); Status = IoCallDriver(DeviceObject, Irp);
@ -462,7 +466,7 @@ EngDeviceIoControl(
Iosb.Information); Iosb.Information);
/* Return information to the caller about the operation. */ /* Return information to the caller about the operation. */
*lpBytesReturned = Iosb.Information; *lpBytesReturned = (DWORD)Iosb.Information;
/* Convert NT status values to win32 error codes. */ /* Convert NT status values to win32 error codes. */
switch (Status) switch (Status)

17
reactos/win32ss/gdi/eng/driverobj.c
View file

@ -36,12 +36,13 @@ DRIVEROBJ_Cleanup(PVOID pObject)
/** Public interface **********************************************************/ /** Public interface **********************************************************/
_Must_inspect_result_
HDRVOBJ HDRVOBJ
APIENTRY APIENTRY
EngCreateDriverObj( EngCreateDriverObj(
IN PVOID pvObj, _In_ PVOID pvObj,
IN FREEOBJPROC pFreeObjProc, _In_opt_ FREEOBJPROC pFreeObjProc,
IN HDEV hdev) _In_ HDEV hdev)
{ {
PEDRIVEROBJ pedo; PEDRIVEROBJ pedo;
HDRVOBJ hdo; HDRVOBJ hdo;
@ -72,9 +73,9 @@ EngCreateDriverObj(
BOOL BOOL
APIENTRY APIENTRY
EngDeleteDriverObj( EngDeleteDriverObj(
IN HDRVOBJ hdo, _In_ _Post_ptr_invalid_ HDRVOBJ hdo,
IN BOOL bCallBack, _In_ BOOL bCallBack,
IN BOOL bLocked) _In_ BOOL bLocked)
{ {
PEDRIVEROBJ pedo; PEDRIVEROBJ pedo;
@ -111,7 +112,7 @@ EngDeleteDriverObj(
PDRIVEROBJ PDRIVEROBJ
APIENTRY APIENTRY
EngLockDriverObj( EngLockDriverObj(
IN HDRVOBJ hdo) _In_ HDRVOBJ hdo)
{ {
PEDRIVEROBJ pedo; PEDRIVEROBJ pedo;
@ -126,7 +127,7 @@ EngLockDriverObj(
BOOL BOOL
APIENTRY APIENTRY
EngUnlockDriverObj( EngUnlockDriverObj(
IN HDRVOBJ hdo) _In_ _Post_ptr_invalid_ HDRVOBJ hdo)
{ {
PEDRIVEROBJ pedo; PEDRIVEROBJ pedo;
ULONG cLocks; ULONG cLocks;

20
reactos/win32ss/gdi/eng/engbrush.c
View file

@ -287,7 +287,7 @@ NTAPI
EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo, BOOL bCallDriver) EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo, BOOL bCallDriver)
{ {
BOOL bResult; BOOL bResult;
PFN_DrvRealizeBrush pfnRealzizeBrush = NULL; PFN_DrvRealizeBrush pfnRealizeBrush = NULL;
PSURFACE psurfPattern, psurfMask; PSURFACE psurfPattern, psurfMask;
PPDEVOBJ ppdev; PPDEVOBJ ppdev;
EXLATEOBJ exlo; EXLATEOBJ exlo;
@ -303,10 +303,10 @@ EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo, BOOL bCallDriver)
if (!ppdev) ppdev = gppdevPrimary; if (!ppdev) ppdev = gppdevPrimary;
if (bCallDriver) if (bCallDriver)
pfnRealzizeBrush = ppdev->DriverFunctions.RealizeBrush; pfnRealizeBrush = ppdev->DriverFunctions.RealizeBrush;
if (!pfnRealzizeBrush) if (!pfnRealizeBrush)
pfnRealzizeBrush = EngRealizeBrush; pfnRealizeBrush = EngRealizeBrush;
/* Check if this is a hatch brush */ /* Check if this is a hatch brush */
if (pbr->flAttrs & BR_IS_HATCH) if (pbr->flAttrs & BR_IS_HATCH)
@ -351,12 +351,12 @@ EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo, BOOL bCallDriver)
pebo->crCurrentText); pebo->crCurrentText);
/* Create the realization */ /* Create the realization */
bResult = pfnRealzizeBrush(&pebo->BrushObject, bResult = pfnRealizeBrush(&pebo->BrushObject,
&pebo->psurfTrg->SurfObj, &pebo->psurfTrg->SurfObj,
&psurfPattern->SurfObj, &psurfPattern->SurfObj,
psurfMask ? &psurfMask->SurfObj : NULL, psurfMask ? &psurfMask->SurfObj : NULL,
&exlo.xlo, &exlo.xlo,
iHatch); iHatch);
/* Cleanup the XLATEOBJ */ /* Cleanup the XLATEOBJ */
EXLATEOBJ_vCleanup(&exlo); EXLATEOBJ_vCleanup(&exlo);

34
reactos/win32ss/gdi/eng/engevent.c
View file

@ -17,7 +17,8 @@
BOOL BOOL
APIENTRY APIENTRY
EngCreateEvent(OUT PEVENT* Event) EngCreateEvent(
_Deref_out_opt_ PEVENT* Event)
{ {
BOOLEAN Result = TRUE; BOOLEAN Result = TRUE;
PENG_EVENT EngEvent; PENG_EVENT EngEvent;
@ -54,7 +55,8 @@ EngCreateEvent(OUT PEVENT* Event)
BOOL BOOL
APIENTRY APIENTRY
EngDeleteEvent(IN PEVENT Event) EngDeleteEvent(
_In_ _Post_ptr_invalid_ PEVENT Event)
{ {
DPRINT("EngDeleteEvent(%p)\n", Event); DPRINT("EngDeleteEvent(%p)\n", Event);
@ -75,7 +77,8 @@ EngDeleteEvent(IN PEVENT Event)
VOID VOID
APIENTRY APIENTRY
EngClearEvent(IN PEVENT Event) EngClearEvent(
_In_ PEVENT Event)
{ {
/* Clear the event */ /* Clear the event */
KeClearEvent(Event->pKEvent); KeClearEvent(Event->pKEvent);
@ -83,7 +86,8 @@ EngClearEvent(IN PEVENT Event)
LONG LONG
APIENTRY APIENTRY
EngSetEvent(IN PEVENT Event) EngSetEvent(
_In_ PEVENT Event)
{ {
/* Set the event */ /* Set the event */
return KeSetEvent(Event->pKEvent, return KeSetEvent(Event->pKEvent,
@ -93,7 +97,8 @@ EngSetEvent(IN PEVENT Event)
LONG LONG
APIENTRY APIENTRY
EngReadStateEvent(IN PEVENT Event) EngReadStateEvent(
_In_ PEVENT Event)
{ {
/* Read the event state */ /* Read the event state */
return KeReadStateEvent(Event->pKEvent); return KeReadStateEvent(Event->pKEvent);
@ -101,11 +106,12 @@ EngReadStateEvent(IN PEVENT Event)
PEVENT PEVENT
APIENTRY APIENTRY
EngMapEvent(IN HDEV hDev, EngMapEvent(
IN HANDLE hUserObject, _In_ HDEV hDev,
IN PVOID Reserved1, _In_ HANDLE hUserObject,
IN PVOID Reserved2, _Reserved_ PVOID Reserved1,
IN PVOID Reserved3) _Reserved_ PVOID Reserved2,
_Reserved_ PVOID Reserved3)
{ {
PENG_EVENT EngEvent; PENG_EVENT EngEvent;
NTSTATUS Status; NTSTATUS Status;
@ -147,7 +153,8 @@ EngMapEvent(IN HDEV hDev,
BOOL BOOL
APIENTRY APIENTRY
EngUnmapEvent(IN PEVENT Event) EngUnmapEvent(
_In_ PEVENT Event)
{ {
/* Must be a usermapped event */ /* Must be a usermapped event */
if (!(Event->fFlags & ENG_EVENT_USERMAPPED)) return FALSE; if (!(Event->fFlags & ENG_EVENT_USERMAPPED)) return FALSE;
@ -162,8 +169,9 @@ EngUnmapEvent(IN PEVENT Event)
BOOL BOOL
APIENTRY APIENTRY
EngWaitForSingleObject(IN PEVENT Event, EngWaitForSingleObject(
IN PLARGE_INTEGER TimeOut) _In_ PEVENT Event,
_In_opt_ PLARGE_INTEGER TimeOut)
{ {
NTSTATUS Status; NTSTATUS Status;
DPRINT("EngWaitForSingleObject(%p %I64d)\n", Event, TimeOut->QuadPart); DPRINT("EngWaitForSingleObject(%p %I64d)\n", Event, TimeOut->QuadPart);

9
reactos/win32ss/gdi/eng/engmisc.c
View file

@ -229,8 +229,9 @@ EngGetProcessHandle(VOID)
VOID VOID
APIENTRY APIENTRY
EngGetCurrentCodePage(OUT PUSHORT OemCodePage, EngGetCurrentCodePage(
OUT PUSHORT AnsiCodePage) _Out_ PUSHORT OemCodePage,
_Out_ PUSHORT AnsiCodePage)
{ {
/* Forward to kernel */ /* Forward to kernel */
RtlGetDefaultCodePage(AnsiCodePage, OemCodePage); RtlGetDefaultCodePage(AnsiCodePage, OemCodePage);
@ -239,8 +240,8 @@ EngGetCurrentCodePage(OUT PUSHORT OemCodePage,
BOOL BOOL
APIENTRY APIENTRY
EngQuerySystemAttribute( EngQuerySystemAttribute(
IN ENG_SYSTEM_ATTRIBUTE CapNum, _In_ ENG_SYSTEM_ATTRIBUTE CapNum,
OUT PDWORD pCapability) _Out_ PDWORD pCapability)
{ {
SYSTEM_BASIC_INFORMATION sbi; SYSTEM_BASIC_INFORMATION sbi;
SYSTEM_PROCESSOR_INFORMATION spi; SYSTEM_PROCESSOR_INFORMATION spi;

2
reactos/win32ss/gdi/eng/error.c
View file

@ -24,7 +24,7 @@ EngGetLastError(VOID)
*/ */
VOID VOID
APIENTRY APIENTRY
EngSetLastError(IN ULONG iError) EngSetLastError(_In_ ULONG iError)
{ {
PTEB pTeb = NtCurrentTeb(); PTEB pTeb = NtCurrentTeb();
if (pTeb) if (pTeb)

6
reactos/win32ss/gdi/eng/float.c
View file

@ -18,7 +18,7 @@
BOOL BOOL
APIENTRY APIENTRY
EngRestoreFloatingPointState( EngRestoreFloatingPointState(
IN VOID *Buffer) _In_ VOID *Buffer)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -34,8 +34,8 @@ EngRestoreFloatingPointState(
ULONG ULONG
APIENTRY APIENTRY
EngSaveFloatingPointState( EngSaveFloatingPointState(
OUT VOID *Buffer, _Out_ VOID *Buffer,
IN ULONG BufferSize) _In_ ULONG BufferSize)
{ {
KFLOATING_SAVE TempBuffer; KFLOATING_SAVE TempBuffer;
NTSTATUS Status; NTSTATUS Status;

22
reactos/win32ss/gdi/eng/gradient.c
View file

@ -1,4 +1,4 @@
/* /*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Gradient Functions * PURPOSE: GDI Driver Gradient Functions
@ -443,16 +443,16 @@ IntEngIsNULLTriangle(TRIVERTEX *pVertex, GRADIENT_TRIANGLE *gt)
BOOL APIENTRY BOOL APIENTRY
EngGradientFill( EngGradientFill(
IN SURFOBJ *psoDest, _Inout_ SURFOBJ *psoDest,
IN CLIPOBJ *pco, _In_ CLIPOBJ *pco,
IN XLATEOBJ *pxlo, _In_opt_ XLATEOBJ *pxlo,
IN TRIVERTEX *pVertex, _In_ TRIVERTEX *pVertex,
IN ULONG nVertex, _In_ ULONG nVertex,
IN PVOID pMesh, _In_ PVOID pMesh,
IN ULONG nMesh, _In_ ULONG nMesh,
IN RECTL *prclExtents, _In_ RECTL *prclExtents,
IN POINTL *pptlDitherOrg, _In_ POINTL *pptlDitherOrg,
IN ULONG ulMode) _In_ ULONG ulMode)
{ {
ULONG i; ULONG i;
BOOL ret = FALSE; BOOL ret = FALSE;

2
reactos/win32ss/gdi/eng/inteng.h
View file

@ -2,7 +2,7 @@
typedef ULONG HCLIP; typedef ULONG HCLIP;
#define ENUM_RECT_LIMIT 50 #define ENUM_RECT_LIMIT 32
typedef struct _RECT_ENUM typedef struct _RECT_ENUM
{ {

10
reactos/win32ss/gdi/eng/ldevobj.c
View file

@ -324,7 +324,7 @@ EngLoadImageEx(
WCHAR acwBuffer[MAX_PATH]; WCHAR acwBuffer[MAX_PATH];
PLDEVOBJ pldev; PLDEVOBJ pldev;
UNICODE_STRING strDriverName; UNICODE_STRING strDriverName;
ULONG cwcLength; SIZE_T cwcLength;
LPWSTR pwsz; LPWSTR pwsz;
DPRINT("EngLoadImageEx(%ls, %lu)\n", pwszDriverName, ldevtype); DPRINT("EngLoadImageEx(%ls, %lu)\n", pwszDriverName, ldevtype);
@ -442,7 +442,7 @@ leave:
HANDLE HANDLE
APIENTRY APIENTRY
EngLoadImage( EngLoadImage(
LPWSTR pwszDriverName) _In_ LPWSTR pwszDriverName)
{ {
return (HANDLE)EngLoadImageEx(pwszDriverName, LDEV_IMAGE); return (HANDLE)EngLoadImageEx(pwszDriverName, LDEV_IMAGE);
} }
@ -451,7 +451,7 @@ EngLoadImage(
VOID VOID
APIENTRY APIENTRY
EngUnloadImage( EngUnloadImage(
IN HANDLE hModule) _In_ HANDLE hModule)
{ {
PLDEVOBJ pldev = (PLDEVOBJ)hModule; PLDEVOBJ pldev = (PLDEVOBJ)hModule;
@ -486,8 +486,8 @@ EngUnloadImage(
PVOID PVOID
APIENTRY APIENTRY
EngFindImageProcAddress( EngFindImageProcAddress(
IN HANDLE hModule, _In_ HANDLE hModule,
IN LPSTR lpProcName) _In_ LPSTR lpProcName)
{ {
PLDEVOBJ pldev = (PLDEVOBJ)hModule; PLDEVOBJ pldev = (PLDEVOBJ)hModule;

19
reactos/win32ss/gdi/eng/lineto.c
View file

@ -316,15 +316,16 @@ SEtoNW(SURFOBJ* OutputObj, CLIPOBJ* Clip,
* @implemented * @implemented
*/ */
BOOL APIENTRY BOOL APIENTRY
EngLineTo(SURFOBJ *DestObj, EngLineTo(
CLIPOBJ *Clip, _Inout_ SURFOBJ *DestObj,
BRUSHOBJ *pbo, _In_ CLIPOBJ *Clip,
LONG x1, _In_ BRUSHOBJ *pbo,
LONG y1, _In_ LONG x1,
LONG x2, _In_ LONG y1,
LONG y2, _In_ LONG x2,
RECTL *RectBounds, _In_ LONG y2,
MIX mix) _In_opt_ RECTL *RectBounds,
_In_ MIX mix)
{ {
LONG x, y, deltax, deltay, xchange, ychange, hx, vy; LONG x, y, deltax, deltay, xchange, ychange, hx, vy;
ULONG i; ULONG i;

46
reactos/win32ss/gdi/eng/mapping.c
View file

@ -419,7 +419,8 @@ EngLoadModuleEx(
HANDLE HANDLE
APIENTRY APIENTRY
EngLoadModule(LPWSTR pwsz) EngLoadModule(
_In_ LPWSTR pwsz)
{ {
/* Forward to EngLoadModuleEx */ /* Forward to EngLoadModuleEx */
return (HANDLE)EngLoadModuleEx(pwsz, 0, FVF_READONLY | FVF_SYSTEMROOT); return (HANDLE)EngLoadModuleEx(pwsz, 0, FVF_READONLY | FVF_SYSTEMROOT);
@ -428,8 +429,8 @@ EngLoadModule(LPWSTR pwsz)
HANDLE HANDLE
APIENTRY APIENTRY
EngLoadModuleForWrite( EngLoadModuleForWrite(
IN LPWSTR pwsz, _In_ LPWSTR pwsz,
IN ULONG cjSizeOfModule) _In_ ULONG cjSizeOfModule)
{ {
/* Forward to EngLoadModuleEx */ /* Forward to EngLoadModuleEx */
return (HANDLE)EngLoadModuleEx(pwsz, cjSizeOfModule, FVF_SYSTEMROOT); return (HANDLE)EngLoadModuleEx(pwsz, cjSizeOfModule, FVF_SYSTEMROOT);
@ -438,15 +439,15 @@ EngLoadModuleForWrite(
PVOID PVOID
APIENTRY APIENTRY
EngMapModule( EngMapModule(
IN HANDLE h, _In_ HANDLE h,
OUT PULONG pulSize) _Out_ PULONG pulSize)
{ {
PFILEVIEW pFileView = (PFILEVIEW)h; PFILEVIEW pFileView = (PFILEVIEW)h;
NTSTATUS Status; NTSTATUS Status;
pFileView->cjView = 0; pFileView->cjView = 0;
/* FIXME: Use system space because ARM3 doesn't support executable sections yet */ /* FIXME: Use system space because ARM3 doesn't support executable sections yet */
Status = MmMapViewInSystemSpace(pFileView->pSection, Status = MmMapViewInSystemSpace(pFileView->pSection,
&pFileView->pvKView, &pFileView->pvKView,
&pFileView->cjView); &pFileView->cjView);
@ -457,18 +458,19 @@ EngMapModule(
return NULL; return NULL;
} }
*pulSize = pFileView->cjView; *pulSize = (ULONG)pFileView->cjView;
return pFileView->pvKView; return pFileView->pvKView;
} }
VOID VOID
APIENTRY APIENTRY
EngFreeModule(IN HANDLE h) EngFreeModule(
_In_ HANDLE h)
{ {
PFILEVIEW pFileView = (PFILEVIEW)h; PFILEVIEW pFileView = (PFILEVIEW)h;
NTSTATUS Status; NTSTATUS Status;
/* FIXME: Use system space because ARM3 doesn't support executable sections yet */ /* FIXME: Use system space because ARM3 doesn't support executable sections yet */
Status = MmUnmapViewInSystemSpace(pFileView->pvKView); Status = MmUnmapViewInSystemSpace(pFileView->pvKView);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -483,12 +485,14 @@ EngFreeModule(IN HANDLE h)
EngFreeMem(pFileView); EngFreeMem(pFileView);
} }
_Success_(return != 0)
_When_(cjSize != 0, _At_(return, _Out_writes_bytes_(cjSize)))
PVOID PVOID
APIENTRY APIENTRY
EngMapFile( EngMapFile(
IN LPWSTR pwsz, _In_ LPWSTR pwsz,
IN ULONG cjSize, _In_ ULONG cjSize,
OUT ULONG_PTR *piFile) _Out_ ULONG_PTR *piFile)
{ {
HANDLE hModule; HANDLE hModule;
PVOID pvBase; PVOID pvBase;
@ -517,7 +521,7 @@ EngMapFile(
BOOL BOOL
APIENTRY APIENTRY
EngUnmapFile( EngUnmapFile(
IN ULONG_PTR iFile) _In_ ULONG_PTR iFile)
{ {
HANDLE hModule = (HANDLE)iFile; HANDLE hModule = (HANDLE)iFile;
@ -530,9 +534,9 @@ EngUnmapFile(
BOOL BOOL
APIENTRY APIENTRY
EngMapFontFileFD( EngMapFontFileFD(
IN ULONG_PTR iFile, _In_ ULONG_PTR iFile,
OUT PULONG *ppjBuf, _Outptr_result_bytebuffer_(*pcjBuf) PULONG *ppjBuf,
OUT ULONG *pcjBuf) _Out_ ULONG *pcjBuf)
{ {
// www.osr.com/ddk/graphics/gdifncs_0co7.htm // www.osr.com/ddk/graphics/gdifncs_0co7.htm
UNIMPLEMENTED; UNIMPLEMENTED;
@ -542,7 +546,7 @@ EngMapFontFileFD(
VOID VOID
APIENTRY APIENTRY
EngUnmapFontFileFD( EngUnmapFontFileFD(
IN ULONG_PTR iFile) _In_ ULONG_PTR iFile)
{ {
// http://www.osr.com/ddk/graphics/gdifncs_6wbr.htm // http://www.osr.com/ddk/graphics/gdifncs_6wbr.htm
UNIMPLEMENTED; UNIMPLEMENTED;
@ -551,9 +555,9 @@ EngUnmapFontFileFD(
BOOL BOOL
APIENTRY APIENTRY
EngMapFontFile( EngMapFontFile(
ULONG_PTR iFile, _In_ ULONG_PTR iFile,
PULONG *ppjBuf, _Outptr_result_bytebuffer_(*pcjBuf) PULONG *ppjBuf,
ULONG *pcjBuf) _Out_ ULONG *pcjBuf)
{ {
// www.osr.com/ddk/graphics/gdifncs_3up3.htm // www.osr.com/ddk/graphics/gdifncs_3up3.htm
return EngMapFontFileFD(iFile, ppjBuf, pcjBuf); return EngMapFontFileFD(iFile, ppjBuf, pcjBuf);
@ -562,7 +566,7 @@ EngMapFontFile(
VOID VOID
APIENTRY APIENTRY
EngUnmapFontFile( EngUnmapFontFile(
IN ULONG_PTR iFile) _In_ ULONG_PTR iFile)
{ {
// www.osr.com/ddk/graphics/gdifncs_09wn.htm // www.osr.com/ddk/graphics/gdifncs_09wn.htm
EngUnmapFontFileFD(iFile); EngUnmapFontFileFD(iFile);

59
reactos/win32ss/gdi/eng/surface.c
View file

@ -275,11 +275,11 @@ SURFACE_AllocSurface(
HBITMAP HBITMAP
APIENTRY APIENTRY
EngCreateBitmap( EngCreateBitmap(
IN SIZEL sizl, _In_ SIZEL sizl,
IN LONG lWidth, _In_ LONG lWidth,
IN ULONG iFormat, _In_ ULONG iFormat,
IN ULONG fl, _In_ ULONG fl,
IN PVOID pvBits) _In_ PVOID pvBits)
{ {
PSURFACE psurf; PSURFACE psurf;
HBITMAP hbmp; HBITMAP hbmp;
@ -315,9 +315,9 @@ EngCreateBitmap(
HBITMAP HBITMAP
APIENTRY APIENTRY
EngCreateDeviceBitmap( EngCreateDeviceBitmap(
IN DHSURF dhsurf, _In_ DHSURF dhsurf,
IN SIZEL sizl, _In_ SIZEL sizl,
IN ULONG iFormat) _In_ ULONG iFormat)
{ {
PSURFACE psurf; PSURFACE psurf;
HBITMAP hbmp; HBITMAP hbmp;
@ -353,9 +353,9 @@ EngCreateDeviceBitmap(
HSURF HSURF
APIENTRY APIENTRY
EngCreateDeviceSurface( EngCreateDeviceSurface(
IN DHSURF dhsurf, _In_ DHSURF dhsurf,
IN SIZEL sizl, _In_ SIZEL sizl,
IN ULONG iFormat) _In_ ULONG iFormat)
{ {
PSURFACE psurf; PSURFACE psurf;
HSURF hsurf; HSURF hsurf;
@ -391,9 +391,9 @@ EngCreateDeviceSurface(
BOOL BOOL
APIENTRY APIENTRY
EngAssociateSurface( EngAssociateSurface(
IN HSURF hsurf, _In_ HSURF hsurf,
IN HDEV hdev, _In_ HDEV hdev,
IN FLONG flHooks) _In_ FLONG flHooks)
{ {
SURFOBJ *pso; SURFOBJ *pso;
PSURFACE psurf; PSURFACE psurf;
@ -431,14 +431,14 @@ EngAssociateSurface(
BOOL BOOL
APIENTRY APIENTRY
EngModifySurface( EngModifySurface(
IN HSURF hsurf, _In_ HSURF hsurf,
IN HDEV hdev, _In_ HDEV hdev,
IN FLONG flHooks, _In_ FLONG flHooks,
IN FLONG flSurface, _In_ FLONG flSurface,
IN DHSURF dhsurf, _In_ DHSURF dhsurf,
OUT VOID *pvScan0, _In_ VOID *pvScan0,
IN LONG lDelta, _In_ LONG lDelta,
IN VOID *pvReserved) _Reserved_ VOID *pvReserved)
{ {
SURFOBJ *pso; SURFOBJ *pso;
PSURFACE psurf; PSURFACE psurf;
@ -478,7 +478,8 @@ EngModifySurface(
BOOL BOOL
APIENTRY APIENTRY
EngDeleteSurface(IN HSURF hsurf) EngDeleteSurface(
_In_ HSURF hsurf)
{ {
PSURFACE psurf; PSURFACE psurf;
@ -496,9 +497,9 @@ EngDeleteSurface(IN HSURF hsurf)
BOOL BOOL
APIENTRY APIENTRY
EngEraseSurface( EngEraseSurface(
SURFOBJ *pso, _In_ SURFOBJ *pso,
RECTL *prcl, _In_ RECTL *prcl,
ULONG iColor) _In_ ULONG iColor)
{ {
ASSERT(pso); ASSERT(pso);
ASSERT(prcl); ASSERT(prcl);
@ -517,7 +518,8 @@ NtGdiEngLockSurface(IN HSURF hsurf)
SURFOBJ * SURFOBJ *
APIENTRY APIENTRY
EngLockSurface(IN HSURF hsurf) EngLockSurface(
_In_ HSURF hsurf)
{ {
SURFACE *psurf = SURFACE_ShareLockSurface(hsurf); SURFACE *psurf = SURFACE_ShareLockSurface(hsurf);
@ -534,7 +536,8 @@ NtGdiEngUnlockSurface(IN SURFOBJ *pso)
VOID VOID
APIENTRY APIENTRY
EngUnlockSurface(IN SURFOBJ *pso) EngUnlockSurface(
_In_ SURFOBJ *pso)
{ {
if (pso != NULL) if (pso != NULL)
{ {

43
reactos/win32ss/gdi/eng/xlateobj.c
View file

@ -42,7 +42,9 @@ _Always_(_Post_satisfies_(return==iColor))
_Function_class_(FN_XLATE) _Function_class_(FN_XLATE)
ULONG ULONG
FASTCALL FASTCALL
EXLATEOBJ_iXlateTrivial(PEXLATEOBJ pexlo, ULONG iColor) EXLATEOBJ_iXlateTrivial(
_In_ PEXLATEOBJ pexlo,
_In_ ULONG iColor)
{ {
return iColor; return iColor;
} }
@ -50,7 +52,7 @@ EXLATEOBJ_iXlateTrivial(PEXLATEOBJ pexlo, ULONG iColor)
_Function_class_(FN_XLATE) _Function_class_(FN_XLATE)
ULONG ULONG
FASTCALL FASTCALL
EXLATEOBJ_iXlateToMono(PEXLATEOBJ pexlo, ULONG iColor) EXLATEOBJ_iXlateToMono(_In_ PEXLATEOBJ pexlo, ULONG iColor)
{ {
return (iColor == pexlo->xlo.pulXlate[0]); return (iColor == pexlo->xlo.pulXlate[0]);
} }
@ -354,12 +356,12 @@ EXLATEOBJ_iXlateBitfieldsToPal(PEXLATEOBJ pexlo, ULONG iColor)
VOID VOID
NTAPI NTAPI
EXLATEOBJ_vInitialize( EXLATEOBJ_vInitialize(
PEXLATEOBJ pexlo, _Out_ PEXLATEOBJ pexlo,
PALETTE *ppalSrc, _In_opt_ PALETTE *ppalSrc,
PALETTE *ppalDst, _In_opt_ PALETTE *ppalDst,
COLORREF crSrcBackColor, _In_ COLORREF crSrcBackColor,
COLORREF crDstBackColor, _In_ COLORREF crDstBackColor,
COLORREF crDstForeColor) _In_ COLORREF crDstForeColor)
{ {
ULONG cEntries; ULONG cEntries;
ULONG i, ulColor; ULONG i, ulColor;
@ -607,9 +609,9 @@ EXLATEOBJ_vInitialize(
VOID VOID
NTAPI NTAPI
EXLATEOBJ_vInitXlateFromDCs( EXLATEOBJ_vInitXlateFromDCs(
EXLATEOBJ* pexlo, _Out_ EXLATEOBJ* pexlo,
PDC pdcSrc, _In_ PDC pdcSrc,
PDC pdcDst) _In_ PDC pdcDst)
{ {
PSURFACE psurfDst, psurfSrc; PSURFACE psurfDst, psurfSrc;
@ -644,7 +646,8 @@ VOID NTAPI EXLATEOBJ_vInitSrcMonoXlate(
VOID VOID
NTAPI NTAPI
EXLATEOBJ_vCleanup(PEXLATEOBJ pexlo) EXLATEOBJ_vCleanup(
_Inout_ PEXLATEOBJ pexlo)
{ {
if (pexlo->xlo.pulXlate != pexlo->aulXlate) if (pexlo->xlo.pulXlate != pexlo->aulXlate)
{ {
@ -658,7 +661,9 @@ EXLATEOBJ_vCleanup(PEXLATEOBJ pexlo)
#undef XLATEOBJ_iXlate #undef XLATEOBJ_iXlate
ULONG ULONG
NTAPI NTAPI
XLATEOBJ_iXlate(XLATEOBJ *pxlo, ULONG iColor) XLATEOBJ_iXlate(
_In_ XLATEOBJ *pxlo,
_In_ ULONG iColor)
{ {
PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo; PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo;
@ -671,7 +676,11 @@ XLATEOBJ_iXlate(XLATEOBJ *pxlo, ULONG iColor)
ULONG ULONG
NTAPI NTAPI
XLATEOBJ_cGetPalette(XLATEOBJ *pxlo, ULONG iPal, ULONG cPal, ULONG *pPalOut) XLATEOBJ_cGetPalette(
_In_ XLATEOBJ *pxlo,
_In_ ULONG iPal,
_In_ ULONG cPal,
_Out_cap_(cPal) ULONG *pPalOut)
{ {
PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo; PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo;
PPALETTE ppal; PPALETTE ppal;
@ -741,7 +750,8 @@ XLATEOBJ_cGetPalette(XLATEOBJ *pxlo, ULONG iPal, ULONG cPal, ULONG *pPalOut)
HANDLE HANDLE
NTAPI NTAPI
XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo) XLATEOBJ_hGetColorTransform(
_In_ XLATEOBJ *pxlo)
{ {
PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo; PEXLATEOBJ pexlo = (PEXLATEOBJ)pxlo;
return pexlo->hColorTransform; return pexlo->hColorTransform;
@ -749,7 +759,8 @@ XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
PULONG PULONG
NTAPI NTAPI
XLATEOBJ_piVector(XLATEOBJ *pxlo) XLATEOBJ_piVector(
_In_ XLATEOBJ *pxlo)
{ {
if (pxlo->iSrcType == PAL_INDEXED) if (pxlo->iSrcType == PAL_INDEXED)
{ {

9
reactos/win32ss/gdi/ntgdi/gdifloat.h
View file

@ -1,5 +1,10 @@
#pragma once #pragma once
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:28110) // disable "Drivers must protect floating point hardware state" warning
#endif
typedef struct tagFLOAT_POINT typedef struct tagFLOAT_POINT
{ {
FLOAT x, y; FLOAT x, y;
@ -99,3 +104,7 @@ static __inline void INTERNAL_LPTODP(DC *dc, LPPOINT point)
MulDiv((tx), (pdcattr)->szlViewportExt.cx, (pdcattr)->szlWindowExt.cx) MulDiv((tx), (pdcattr)->szlViewportExt.cx, (pdcattr)->szlWindowExt.cx)
#define YLSTODS(pdcattr,ty) \ #define YLSTODS(pdcattr,ty) \
MulDiv((ty), (pdcattr)->szlViewportExt.cy, (pdcattr)->szlWindowExt.cy) MulDiv((ty), (pdcattr)->szlViewportExt.cy, (pdcattr)->szlWindowExt.cy)
#ifdef _MSC_VER
#pragma warning(pop)
#endif

23
reactos/win32ss/user/ntuser/object.h
View file

@ -6,29 +6,6 @@ typedef struct _USER_REFERENCE_ENTRY
PVOID obj; PVOID obj;
} USER_REFERENCE_ENTRY, *PUSER_REFERENCE_ENTRY; } USER_REFERENCE_ENTRY, *PUSER_REFERENCE_ENTRY;
#define USER_ASSERT(exp,file,line) \
if (!(exp)) {RtlAssert(#exp,(PVOID)file,line,"");}
static __inline VOID
UserAssertLastRef(PVOID obj, const char *file, int line)
{
PTHREADINFO W32Thread;
PSINGLE_LIST_ENTRY ReferenceEntry;
PUSER_REFERENCE_ENTRY UserReferenceEntry;
USER_ASSERT(obj != NULL, file, line);
W32Thread = PsGetCurrentThreadWin32Thread();
USER_ASSERT(W32Thread != NULL, file, line);
ReferenceEntry = W32Thread->ReferencesList.Next;
USER_ASSERT(ReferenceEntry != NULL, file, line);
UserReferenceEntry = CONTAINING_RECORD(ReferenceEntry, USER_REFERENCE_ENTRY, Entry);
USER_ASSERT(UserReferenceEntry != NULL, file, line);
USER_ASSERT(obj == UserReferenceEntry->obj, file, line);
}
#define ASSERT_LAST_REF(_obj_) UserAssertLastRef(_obj,__FILE__,__LINE__)
#undef USER_ASSERT
extern PUSER_HANDLE_TABLE gHandleTable; extern PUSER_HANDLE_TABLE gHandleTable;
VOID FASTCALL UserReferenceObject(PVOID obj); VOID FASTCALL UserReferenceObject(PVOID obj);
PVOID FASTCALL UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type); PVOID FASTCALL UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type);