18 #pragma warning(disable:4244) 21 #define NUM_ENTRIES_INITIAL 16 23 #define GROW_FACTOR_NUMER 2 24 #define GROW_FACTOR_DENOM 1 27 static int PathCount = 0;
45 TRACE(
"CreatePath p 0x%p\n", pPath);
55 pPath->numEntriesAllocated =
count;
63 pPath->numEntriesUsed = 0;
64 pPath->newStroke =
TRUE;
66 pPath->pos.x = pPath->pos.y = 0;
69 TRACE(
"Create Path %d\n",PathCount);
93 if (!hPath)
return FALSE;
95 if (!pPath)
return FALSE;
100 TRACE(
"Delete Path %d\n",PathCount);
168 const PPATH pPathSrc)
180 pPathDest->
pos = pPathSrc->
pos;
190 TRACE(
"PATH_SavePath\n");
193 TRACE(
"PATH_SavePath 1\n");
197 dst->dclevel.flPath =
src->dclevel.flPath;
211 TRACE(
"PATH_RestorePath\n");
213 if (
dst->dclevel.hPath ==
NULL)
216 TRACE(
"PATH_RestorePath 1\n");
218 dst->dclevel.flPath =
src->dclevel.flPath;
230 TRACE(
"PATH_RestorePath 2\n");
300 INT numEntriesToAllocate;
316 while (numEntriesToAllocate < numEntries)
320 numEntriesToAllocate = numEntries;
347 pPath->
pFlags = pFlagsNew;
508 if (!
path->newStroke &&
path->numEntriesUsed &&
510 path->pPoints[
path->numEntriesUsed - 1].x ==
path->pos.x &&
511 path->pPoints[
path->numEntriesUsed - 1].y ==
path->pos.y)
558 if (!pPath)
return FALSE;
563 TRACE(
"MoveTo has changed\n");
593 if (!pPath)
return FALSE;
604 TRACE(
"Line To : New Stroke\n");
640 if (!pPath)
return FALSE;
693 if (!pPath)
return FALSE;
713 TRACE(
"xOffset %d, yOffset %d, Rect WxH: %dx%d.\n",
721 ell_height =
EngMulDiv(ell_height, 1, 2);
796 TRACE(
"PATH_Ellipse: %p -> (%d, %d) - (%d, %d)\n",
819 TRACE(
"xOffset %d, yOffset %d, Rect WxH: %dx%d.\n",
868 ERR(
"PATH_Ellipse No add\n");
898 float xNorm[4], yNorm[4];
908 halfAngle = (angleEnd - angleStart) / 2.0;
909 if (
fabs(halfAngle) > 1
e-8)
911 a = 4.0 / 3.0 * (1 -
cos(halfAngle)) /
sin(halfAngle);
912 xNorm[0] =
cos(angleStart);
913 yNorm[0] =
sin(angleStart);
914 xNorm[1] = xNorm[0] -
a * yNorm[0];
915 yNorm[1] = yNorm[0] +
a * xNorm[0];
916 xNorm[3] =
cos(angleEnd);
917 yNorm[3] =
sin(angleEnd);
918 xNorm[2] = xNorm[3] +
a * yNorm[3];
919 yNorm[2] = yNorm[3] -
a * xNorm[3];
922 for (
i = 0;
i < 4;
i++)
924 xNorm[
i] =
cos(angleStart);
925 yNorm[
i] =
sin(angleStart);
929 start = !startEntryType;
968 double angleStart, angleEnd, angleStartQuadrant, angleEndQuadrant = 0.0;
971 POINT corners[2], pointStart, pointEnd;
972 POINT centre, pointCurPos;
984 if (!pPath)
return FALSE;
999 corners[0].
x =
x1; corners[0].
y =
y1;
1000 corners[1].
x =
x2; corners[1].
y =
y2;
1001 pointStart.
x = xStart; pointStart.
y = yStart;
1002 pointEnd.
x = xEnd; pointEnd.
y = yEnd;
1008 if (corners[0].
x > corners[1].
x)
1010 temp = corners[0].
x;
1011 corners[0].
x = corners[1].
x;
1012 corners[1].
x =
temp;
1014 if (corners[0].
y > corners[1].
y)
1016 temp = corners[0].
y;
1017 corners[0].
y = corners[1].
y;
1018 corners[1].
y =
temp;
1030 if (angleEnd <= angleStart)
1032 angleEnd += 2 *
M_PI;
1033 ASSERT(angleEnd >= angleStart);
1038 if (angleEnd >= angleStart)
1040 angleEnd -= 2 *
M_PI;
1041 ASSERT(angleEnd <= angleStart);
1074 angleStartQuadrant = angleStart;
1082 angleStartQuadrant = angleEndQuadrant;
1084 angleEndQuadrant +=
M_PI_2;
1086 angleEndQuadrant -=
M_PI_2;
1090 if ((clockwise && angleEnd < angleEndQuadrant) ||
1091 (!clockwise && angleEnd > angleEndQuadrant))
1094 angleEndQuadrant = angleEnd;
1119 centre.
x = (corners[0].
x + corners[1].
x) / 2;
1120 centre.
y = (corners[0].
y + corners[1].
y) / 2;
1144 if (!pPath)
return FALSE;
1167 if (!pPath)
return FALSE;
1187 POINT orig_pos, cur_pos;
1191 if (!pPath)
return FALSE;
1200 orig_pos = pPath->
pos;
1204 TRACE(
"PPD : Current pos X %d Y %d\n",pPath->
pos.
x, pPath->
pos.
y);
1205 TRACE(
"PPD : last %d pos X %d Y %d\n",lastmove, pPath->
pPoints[lastmove].
x, pPath->
pPoints[lastmove].
y);
1208 for(
i = 0;
i < cbPoints;
i++)
1214 pPath->
pos = pts[
i];
1241 pPath->
pos = orig_pos;
1243 TRACE(
"PPD Bad : pos X %d Y %d\n",pPath->
pos.
x, pPath->
pos.
y);
1255 TRACE(
"PPD close : pos X %d Y %d\n",pPath->
pos.
x, pPath->
pos.
y);
1276 if (cbPoints < 1)
return FALSE;
1279 if (!pPath)
return FALSE;
1303 if (!polygons)
return FALSE;
1306 if (!pPath)
return FALSE;
1309 for (poly =
count = 0; poly < polygons; poly++)
1311 if (counts[poly] < 2)
1316 count += counts[poly];
1327 for (poly = 0; poly < polygons;
type += counts[poly++])
1341 const DWORD* counts,
1359 for (
i = 0, poly = 0; poly < polylines; poly++)
1388 if (!pts)
return FALSE;
1390 for (
i = 1;
i <
no;
i++)
1411 TRACE(
"PATH_FlattenPath\n");
1438 TRACE(
"PATH_FlattenPath good\n");
1456 int i,
pos, polygons;
1465 ERR(
"Failed to allocate %lu strokes\n", (pPath->
numEntriesUsed / 2) *
sizeof(*counts));
1475 counts[polygons++] =
i -
pos;
1478 if (
i >
pos + 1) counts[polygons++] =
i -
pos;
1480 ASSERT( polygons <= pPath->numEntriesUsed / 2 );
1490 ERR(
"REGION_SetPolyPolygonRgn failed\n");
1520 INT mapMode, graphicsMode;
1521 SIZE ptViewportExt, ptWindowExt;
1522 POINTL ptViewportOrg, ptWindowOrg;
1537 TRACE(
"PFP : Fail P2R\n");
1603 INT nLinePts, nAlloc, jOldFillMode,
i = 0;
1605 POINT ptViewportOrg, ptWindowOrg;
1606 SIZE szViewportExt, szWindowExt;
1607 DWORD mapMode, graphicsMode;
1615 pbrLine =
dc->dclevel.pbrLine;
1636 ptViewportOrg =
dc->pdcattr->ptlViewportOrg;
1637 szWindowExt =
dc->pdcattr->szlWindowExt;
1638 ptWindowOrg =
dc->pdcattr->ptlWindowOrg;
1660 ERR(
"Can't allocate pool!\n");
1671 ERR(
"Expected PT_MOVETO %s, got path flag %d\n",
1672 i == 0 ?
"as first point" :
"after PT_CLOSEFIGURE",
1680 TRACE(
"Got PT_MOVETO (%ld, %ld)\n",
1684 pLinePts[nLinePts++] = pPath->
pPoints[
i];
1688 TRACE(
"Got PT_LINETO (%ld, %ld)\n",
1690 pLinePts[nLinePts++] = pPath->
pPoints[
i];
1693 TRACE(
"Got PT_BEZIERTO\n");
1697 ERR(
"Path didn't contain 3 successive PT_BEZIERTOs\n");
1703 INT nBzrPts, nMinAlloc;
1709 if (nAlloc < nMinAlloc)
1714 nAlloc = nMinAlloc * 2;
1717 nAlloc *
sizeof(
POINT),
1722 ERR(
"Can't allocate pool!\n");
1731 memcpy(&pLinePts[nLinePts], &pBzrPts[1], (nBzrPts - 1) *
sizeof(
POINT));
1732 nLinePts += nBzrPts - 1;
1738 ERR(
"Got path flag %d (not supported)\n", (
INT)pPath->
pFlags[
i]);
1744 pLinePts[nLinePts++] = pLinePts[0];
1787 #define round(x) ((int)((x)>0?(x)+0.5:(x)-0.5)) 1792 INT i,
j, numStrokes, numOldStrokes, penWidthIn, penWidthOut;
1793 PPATH flat_path, pNewPath, *pStrokes =
NULL, *pOldStrokes, pUpPath, pDownPath;
1795 DWORD joint, endcap;
1802 ERR(
"PATH_FlattenPath\n");
1806 penWidthIn = penWidth / 2;
1807 penWidthOut = penWidth / 2;
1808 if (penWidthIn + penWidthOut < penWidth)
1819 ERR(
"Expected PT_MOVETO %s, got path flag %c\n",
1820 i == 0 ?
"as first point" :
"after PT_CLOSEFIGURE",
1835 numOldStrokes = numStrokes;
1838 if (numStrokes == 1)
1842 pOldStrokes = pStrokes;
1861 if (!pStrokes[numStrokes - 1])
1875 ERR(
"Should never happen\n");
1878 ERR(
"Got path flag %c\n", flat_path->
pFlags[
i]);
1889 for (
i = 0;
i < numStrokes;
i++)
1901 if ((!(pStrokes[
i]->pFlags[pStrokes[
i]->numEntriesUsed - 1] &
PT_CLOSEFIGURE)) && (
j == 0 ||
j == pStrokes[
i]->numEntriesUsed - 1))
1922 theta =
atan2(ya - yo, xa - xo);
1943 corners[0].
x = xo - penWidthIn;
1944 corners[0].
y = yo - penWidthIn;
1945 corners[1].
x = xo + penWidthOut;
1946 corners[1].
y = yo + penWidthOut;
1959 double xa, ya, xb, yb, xo, yo;
1960 double alpha, theta, miterWidth;
1961 DWORD _joint = joint;
1963 PPATH pInsidePath, pOutsidePath;
1964 if (
j > 0 &&
j < pStrokes[
i]->numEntriesUsed - 1)
1985 theta =
atan2(yo - ya, xo - xa);
1995 pInsidePath = pUpPath;
1996 pOutsidePath = pDownPath;
2000 pInsidePath = pDownPath;
2001 pOutsidePath = pUpPath;
2121 PPATH pPath, pNewPath;
2140 UINT penWidth, penStyle;
2173 penStyle = ((
LOGPEN*)elp)->lopnStyle;
2199 return IntGdiWidenPath(pPath, penWidth, penStyle,
dc->dclevel.laPath.eMiterLimit);
2204 return (
f.fract >= 0x8000) ? (
f.value + 1) :
f.value;
2241 pt[1] = lppt[
i + 1];
2242 pt[2].x = (lppt[
i + 2].
x + lppt[
i + 1].
x) / 2;
2243 pt[2].y = (lppt[
i + 2].
y + lppt[
i + 1].
y) / 2;
2250 pt[1] = lppt[
i + 1];
2251 pt[2] = lppt[
i + 2];
2279 ERR(
"Unknown header type %lu\n",
header->dwType);
2293 switch(curve->
wType)
2299 for (
i = 0;
i < curve->
cpfx;
i++)
2322 for (
i = 0;
i < curve->
cpfx;
i++)
2335 ERR(
"Unknown curve type %04x\n", curve->
wType);
2378 ERR(
"PATH_ExtTextOut not open\n");
2469 if (!
dc->dclevel.hPath)
2481 dc->dclevel.hPath = 0;
2509 if (
dc->dclevel.hPath)
2511 TRACE(
"BeginPath 1 0x%p\n",
dc->dclevel.hPath);
2525 dc->dclevel.hPath =
NULL;
2533 TRACE(
"BP : Current pos X %d Y %d\n",pPath->
pos.
x, pPath->
pos.
y);
2608 TRACE(
"EndPath ERROR! 0x%p\n",
dc->dclevel.hPath);
2615 TRACE(
"EndPath 0x%p\n",
dc->dclevel.hPath);
2630 PPATH pPath, pNewPath;
2650 pdcattr =
dc->pdcattr;
2675 dc->dclevel.hPath = 0;
2746 *
pdwOut = pDc->dclevel.laPath.eMiterLimit;
2785 TRACE(
"NtGdiGetPath start\n");
2788 ERR(
"Can't lock dc!\n");
2810 else if (nSize < pPath->numEntriesUsed)
2839 TRACE(
"NtGdiGetPath exit %d\n",
ret);
2849 PPATH pPath, pNewPath;
2861 ERR(
"Failed to lock DC %p\n",
hDC);
2866 pdcattr = pDc->pdcattr;
2871 ERR(
"Failed to lock DC path %p\n", pDc->dclevel.hPath);
2879 ERR(
"Path is not closed!\n");
2888 ERR(
"Failed to allocate a region\n");
2904 ERR(
"PATH_PathToRegion failed\n");
2914 pDc->dclevel.hPath =
NULL;
2939 worker1.
f = pDc->dclevel.laPath.eMiterLimit;
2940 pDc->dclevel.laPath.eMiterLimit = worker.
f;
2967 PPATH pPath, pNewPath;
2986 pdcattr = pDc->pdcattr;
3012 pDc->dclevel.hPath = 0;
3026 PPATH pPath, pNewPath;
3046 pdcattr = pDc->pdcattr;
3066 pDc->dclevel.hPath = 0;
3080 TRACE(
"NtGdiWidenPat Enter\n");
3090 TRACE(
"WindenPath New Path\n");
3096 TRACE(
"NtGdiWidenPat Ret %d\n",Ret);
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
BOOL APIENTRY NtGdiStrokeAndFillPath(HDC hDC)
_Success_(return !=FALSE)
#define ERROR_INVALID_PARAMETER
#define XForm2MatrixS(m, x)
_Check_return_ _CRTIMP double __cdecl ceil(_In_ double x)
BOOL NTAPI GreModifyWorldTransform(PDC pdc, const XFORML *pxform, DWORD dwMode)
VOID FASTCALL PATH_EmptyPath(PPATH pPath)
int APIENTRY IntGdiSetMapMode(PDC dc, int MapMode)
BOOL FASTCALL PATH_AddEntry(PPATH pPath, const POINT *pPoint, BYTE flags)
valarray< _Tp > atan2(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
BOOL APIENTRY NtGdiBeginPath(HDC hDC)
BOOL FASTCALL PATH_Rectangle(PDC dc, INT x1, INT y1, INT x2, INT y2)
_In_ int _Inout_ LPRECT lprc
BOOL FASTCALL REGION_SetPolyPolygonRgn(_Inout_ PREGION prgn, _In_ const POINT *ppt, _In_ const ULONG *pcPoints, _In_ ULONG cPolygons, _In_ INT iMode)
VOID FASTCALL DC_vUpdateLineBrush(PDC pdc)
FORCEINLINE PDC DC_LockDc(HDC hdc)
BOOL PATH_RestorePath(DC *dst, DC *src)
static BOOLEAN PATH_ScaleNormalizedPoint(POINT corners[], FLOATL x, FLOATL y, POINT *pPoint)
static VOID FASTCALL PATH_BezierTo(PPATH pPath, POINT *lppt, INT n)
BOOL FASTCALL PATH_StrokePath(DC *dc, PPATH pPath)
PPATH FASTCALL PATH_WidenPathEx(DC *dc, PPATH pPath)
PPATH FASTCALL PATH_CreatePath(int count)
#define FLOATOBJ_DivLong(pf, l)
char ACPI_OBJECT_TYPE * Types
GLuint GLuint GLsizei count
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
BOOL FASTCALL PATH_MoveTo(PDC dc, PPATH pPath)
#define ERROR_INVALID_HANDLE
INT APIENTRY NtGdiGetPath(HDC hDC, LPPOINT Points, LPBYTE Types, INT nSize)
*nSize LPSTR _Inout_ LPDWORD nSize
#define ERROR_NOT_ENOUGH_MEMORY
BOOL FASTCALL PATH_PolyPolyline(PDC dc, const POINT *pts, const DWORD *counts, DWORD polylines)
static void reverse_points(POINT *points, UINT count)
GLint GLint GLint GLint GLint x
BOOL APIENTRY NtGdiStrokePath(HDC hDC)
BOOL PATH_SavePath(DC *dst, DC *src)
BOOL PATH_Ellipse(PDC dc, INT x1, INT y1, INT x2, INT y2)
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
#define FLOATOBJ_Div(pf, pf1)
#define GDI_OBJECT_TYPE_EXTPEN
BOOL FASTCALL PATH_PolyPolygon(PDC dc, const POINT *pts, const INT *counts, UINT polygons)
#define PATH_LockPath(hPath)
PPATH FASTCALL IntGdiWidenPath(PPATH pPath, UINT penWidth, UINT penStyle, FLOAT eMiterLimit)
#define FLOATOBJ_SetFloat(pf, f)
static void close_figure(PPATH path)
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
static PPATH FASTCALL PATH_WidenPath(DC *dc)
BOOL FASTCALL PATH_PolyBezierTo(PDC dc, const POINT *pts, DWORD cbPoints)
#define ERROR_CAN_NOT_COMPLETE
static const FLOATOBJ gef1
VOID FASTCALL IntGdiCloseFigure(PPATH pPath)
struct tagPOINTFX POINTFX
BOOL FASTCALL PATH_PathToRegion(PPATH pPath, INT Mode, PREGION Rgn)
PPATH FASTCALL PATH_FlattenPath(PPATH pPath)
#define FLOATOBJ_AddLong(pf, l)
_STLP_DECLSPEC complex< float > _STLP_CALL cos(const complex< float > &)
BOOL FASTCALL PATH_PolyDraw(PDC dc, const POINT *pts, const BYTE *types, DWORD cbPoints)
#define FLOATOBJ_Add(pf, pf1)
static void update_current_pos(PPATH path)
BOOL APIENTRY NtGdiWidenPath(HDC hDC)
FORCEINLINE LONG RECTL_lGetWidth(_In_ const RECTL *prcl)
#define PATH_UnlockPath(pPath)
BOOL FASTCALL IntGdiPolyline(DC *dc, LPPOINT pt, int Count)
#define ERROR_ARITHMETIC_OVERFLOW
static BYTE * add_points(PPATH path, const POINT *points, DWORD count, BYTE type)
#define GDI_HANDLE_GET_TYPE(h)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
VOID FASTCALL IntGetCurrentPositionEx(PDC dc, LPPOINT pt)
#define FLOATOBJ_bConvertToLong(pf, pl)
#define FLOATOBJ_MulLong(pf, l)
BOOL FASTCALL PATH_PolylineTo(PDC dc, const POINT *pts, DWORD cbPoints)
static WCHAR no[MAX_STRING_RESOURCE_LEN]
VOID NTAPI GDIOBJ_vDeleteObject(POBJ pobj)
#define GDI_OBJECT_TYPE_PEN
VOID FASTCALL PATH_DestroyGdiPath(PPATH pPath)
BOOL APIENTRY NtGdiAbortPath(HDC hDC)
#define EXCEPTION_EXECUTE_HANDLER
DBG_DEFAULT_CHANNEL(GdiPath)
static BOOL add_log_points_new_stroke(DC *dc, PPATH path, const POINT *points, DWORD count, BYTE type)
BOOL APIENTRY NtGdiEndPath(HDC hDC)
BOOL FASTCALL PATH_LineTo(PDC dc, INT x, INT y)
POINT * GDI_Bezier(const POINT *Points, INT count, INT *nPtsOut)
#define ExAllocatePoolWithTag(hernya, size, tag)
GLsizei const GLfloat * points
VOID NTAPI GDIOBJ_vUnlockObject(POBJ pobj)
BOOL FASTCALL PATH_PolyBezier(PDC dc, const POINT *pts, DWORD cbPoints)
HRGN APIENTRY NtGdiPathToRegion(HDC hDC)
#define MatrixS2XForm(x, m)
#define FLOATOBJ_GetFloat(pf)
#define FLOATOBJ_Sub(pf, pf1)
#define memcpy(s1, s2, n)
static BOOL start_new_stroke(PPATH path)
BOOL APIENTRY NtGdiCloseFigure(HDC hDC)
static BOOL PATH_CheckRect(DC *dc, RECTL *rect, INT x1, INT y1, INT x2, INT y2)
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG _In_ LONG y2
VOID FASTCALL SetLastNtError(NTSTATUS Status)
#define GROW_FACTOR_DENOM
BOOL PATH_RoundRect(DC *dc, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height)
static INT int_from_fixed(FIXED f)
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
static const FLOATOBJ gef2
static BOOLEAN IntDPtoLP(DC *pdc, PPOINTL ppt, UINT count)
BOOL APIENTRY NtGdiFillPath(HDC hDC)
#define FLOATOBJ_SetLong(pf, l)
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
BOOL APIENTRY NtGdiSetMiterLimit(IN HDC hdc, IN DWORD dwNew, IN OUT OPTIONAL PDWORD pdwOut)
BOOL IntGdiFillRgn(_In_ PDC pdc, _In_ PREGION prgn, _In_opt_ PBRUSH pbrFill)
static unsigned __int64 next
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
static BOOL FASTCALL PATH_add_outline(PDC dc, PPATH pPath, INT x, INT y, TTPOLYGONHEADER *header, DWORD size)
BOOL FASTCALL PATH_AssignGdiPath(PPATH pPathDest, const PPATH pPathSrc)
#define IntIsEffectiveWidePen(pbrLine)
BOOL FASTCALL PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECTL *lprc, LPCWSTR str, UINT count, const INT *dx)
BOOL FASTCALL PATH_FillPathEx(PDC dc, PPATH pPath, PBRUSH pbrFill)
ULONG FASTCALL ftGdiGetGlyphOutline(PDC dc, WCHAR wch, UINT iFormat, LPGLYPHMETRICS pgm, ULONG cjBuf, PVOID pvBuf, LPMAT2 pmat2, BOOL bIgnoreRotation)
BOOL FASTCALL PATH_Arc(PDC dc, INT x1, INT y1, INT x2, INT y2, INT xStart, INT yStart, INT xEnd, INT yEnd, INT direction, INT lines)
FORCEINLINE PSIZEL DC_pszlViewportExt(PDC pdc)
VOID FASTCALL PATH_InitGdiPath(PPATH pPath)
VOID FASTCALL DC_vPrepareDCsForBlit(PDC pdcDest, const RECT *rcDest, PDC pdcSrc, const RECT *rcSrc)
ENGAPI INT APIENTRY EngMulDiv(_In_ INT a, _In_ INT b, _In_ INT c)
GLint GLint GLint GLint GLint GLint y
BOOL APIENTRY NtGdiFlattenPath(HDC hDC)
BOOL FASTCALL PATH_AddFlatBezier(PPATH pPath, POINT *pt, BOOL closed)
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
FORCEINLINE LONG RECTL_lGetHeight(_In_ const RECTL *prcl)
VOID FASTCALL DC_vFinishBlit(PDC pdc1, PDC pdc2)
void * Realloc(void *, size_t)
#define CoordLPtoDP(pdc, ppt)
#define NUM_ENTRIES_INITIAL
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
#define PATH_AllocPathWithHandle()
BOOL FASTCALL GdiPathDPtoLP(PDC pdc, PPOINT ppt, INT count)
#define GROW_FACTOR_NUMER
GLclampf GLclampf GLclampf alpha
BOOL FASTCALL PATH_ReserveEntries(PPATH pPath, INT numEntries)
BOOL FASTCALL IntGdiMoveToEx(DC *dc, int X, int Y, LPPOINT Point)
#define RtlZeroMemory(Destination, Length)
char * cleanup(char *str)
#define RtlCopyMemory(Destination, Source, Length)
static BOOL PATH_DoArcPart(PPATH pPath, POINT corners[], double angleStart, double angleEnd, BYTE startEntryType)
#define _SEH2_EXCEPT(...)
_STLP_DECLSPEC complex< float > _STLP_CALL sin(const complex< float > &)
GLdouble GLdouble GLdouble GLdouble top
GLuint GLuint GLsizei GLenum type
#define _SEH2_GetExceptionCode()
#define _SEH2_YIELD(__stmt)
GLboolean GLboolean GLboolean GLboolean a
_Check_return_ _CRTIMP double __cdecl floor(_In_ double x)
static VOID PATH_NormalizePoint(POINTL corners[], const POINTL *pPoint, FLOATL *pX, FLOATL *pY)
PREGION FASTCALL REGION_AllocUserRgnWithHandle(INT nRgn)
#define ExFreePoolWithTag(_P, _T)
VOID FASTCALL REGION_Delete(PREGION pRgn)
static BOOLEAN INTERNAL_LPTODP(DC *dc, LPPOINT points, UINT count)
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
BOOL FASTCALL PATH_Delete(HPATH hPath)
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
INT NTAPI GreGetObject(IN HGDIOBJ hobj, IN INT cbCount, OUT PVOID pvBuffer)
BOOL FASTCALL PATH_FillPath(PDC dc, PPATH pPath)
VOID FASTCALL DC_vUpdateFillBrush(PDC pdc)
static BYTE * add_log_points(DC *dc, PPATH path, const POINT *points, DWORD count, BYTE type)
static BOOLEAN IntLPtoDP(DC *pdc, PPOINTL ppt, UINT count)
PULONG MinorVersion OPTIONAL