rgn1 = (const union _rgn *)clip->RgnData;
- trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
+ trace("size %u, type %u, count %u, rgn size %u, bound %s\n",
rgn1->data.rdh.dwSize, rgn1->data.rdh.iType,
rgn1->data.rdh.nCount, rgn1->data.rdh.nRgnSize,
- rgn1->data.rdh.rcBound.left, rgn1->data.rdh.rcBound.top,
- rgn1->data.rdh.rcBound.right, rgn1->data.rdh.rcBound.bottom);
+ wine_dbgstr_rect(&rgn1->data.rdh.rcBound));
ok(EqualRect(&rgn1->data.rdh.rcBound, rc), "rects don't match\n");
rect = *(const RECT *)rgn1->data.Buffer;
- trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
+ trace("rect %s\n", wine_dbgstr_rect(&rect));
ok(EqualRect(&rect, rc), "rects don't match\n");
ok(rgn1->data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn1->data.rdh.dwSize);
ret = GetRegionData(hrgn, sizeof(rgn2), &rgn2.data);
ok(ret == sizeof(rgn2), "expected sizeof(rgn2), got %u\n", ret);
- trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
- rgn2.data.rdh.dwSize, rgn2.data.rdh.iType,
- rgn2.data.rdh.nCount, rgn2.data.rdh.nRgnSize,
- rgn2.data.rdh.rcBound.left, rgn2.data.rdh.rcBound.top,
- rgn2.data.rdh.rcBound.right, rgn2.data.rdh.rcBound.bottom);
+ trace("size %u, type %u, count %u, rgn size %u, bound %s\n", rgn2.data.rdh.dwSize,
+ rgn2.data.rdh.iType, rgn2.data.rdh.nCount, rgn2.data.rdh.nRgnSize,
+ wine_dbgstr_rect(&rgn2.data.rdh.rcBound));
rect = rgn2.data.rdh.rcBound;
rc_transformed = *rc;
translate((POINT *)&rc_transformed, 2, &xform);
- trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
- rc_transformed.right, rc_transformed.bottom);
+ trace("transformed %s\n", wine_dbgstr_rect(&rc_transformed));
ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
rect = *(const RECT *)rgn2.data.Buffer;
- trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
+ trace("rect %s\n", wine_dbgstr_rect(&rect));
rc_transformed = *rc;
translate((POINT *)&rc_transformed, 2, &xform);
- trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
- rc_transformed.right, rc_transformed.bottom);
+ trace("transformed %s\n", wine_dbgstr_rect(&rc_transformed));
ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
ok(rgn2.data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn2.data.rdh.dwSize);
SetRect(&rc_res, -1, -1, -1, -1);
ret = GetClipBox(hdc, &rc_res);
ok(ret == SIMPLEREGION, "got %d\n", ret);
- ok(EqualRect(&rc_res, &rc_sclip),
- "expected (%d,%d)-(%d,%d), got (%d,%d)-(%d,%d)\n",
- rc_sclip.left, rc_sclip.top, rc_sclip.right, rc_sclip.bottom,
- rc_res.left, rc_res.top, rc_res.right, rc_res.bottom);
+ ok(EqualRect(&rc_res, &rc_sclip), "expected %s, got %s\n", wine_dbgstr_rect(&rc_sclip),
+ wine_dbgstr_rect(&rc_res));
OffsetRect(&rc_sclip, -100, -100);
ret = OffsetClipRgn(hdc, -100, -100);
SetRect(&rc_res, -1, -1, -1, -1);
ret = GetClipBox(hdc, &rc_res);
ok(ret == SIMPLEREGION, "got %d\n", ret);
- ok(EqualRect(&rc_res, &rc_sclip),
- "expected (%d,%d)-(%d,%d), got (%d,%d)-(%d,%d)\n",
- rc_sclip.left, rc_sclip.top, rc_sclip.right, rc_sclip.bottom,
- rc_res.left, rc_res.top, rc_res.right, rc_res.bottom);
+ ok(EqualRect(&rc_res, &rc_sclip), "expected %s, got %s\n", wine_dbgstr_rect(&rc_sclip),
+ wine_dbgstr_rect(&rc_res));
ret = IntersectClipRect(hdc, 0, 0, 100, 100);
ok(ret == SIMPLEREGION || broken(ret == COMPLEXREGION) /* XP */, "got %d\n", ret);
SetRect(&rc_res, -1, -1, -1, -1);
ret = GetClipBox(hdc, &rc_res);
ok(ret == SIMPLEREGION, "got %d\n", ret);
- ok(EqualRect(&rc_res, &rc),
- "expected (%d,%d)-(%d,%d), got (%d,%d)-(%d,%d)\n",
- rc.left, rc.top, rc.right, rc.bottom,
- rc_res.left, rc_res.top, rc_res.right, rc_res.bottom);
+ ok(EqualRect(&rc_res, &rc), "expected %s, got %s\n", wine_dbgstr_rect(&rc),
+ wine_dbgstr_rect(&rc_res));
SetRect(&rc_sclip, 0, 0, 100, 50);
ret = ExcludeClipRect(hdc, 0, 50, 100, 100);
SetRect(&rc_res, -1, -1, -1, -1);
ret = GetClipBox(hdc, &rc_res);
ok(ret == SIMPLEREGION, "got %d\n", ret);
- ok(EqualRect(&rc_res, &rc_sclip),
- "expected (%d,%d)-(%d,%d), got (%d,%d)-(%d,%d)\n",
- rc_sclip.left, rc_sclip.top, rc_sclip.right, rc_sclip.bottom,
- rc_res.left, rc_res.top, rc_res.right, rc_res.bottom);
+ ok(EqualRect(&rc_res, &rc_sclip), "expected %s, got %s\n", wine_dbgstr_rect(&rc_sclip),
+ wine_dbgstr_rect(&rc_res));
hemf = CloseEnhMetaFile(hdc);
DeleteEnhMetaFile(hemf);
if (!wmfDC) return;
SetWindowExtEx(wmfDC, 100, 100, NULL);
- rect.left = rect.top = 0;
- rect.right = rect.bottom = 50;
+ SetRect(&rect, 0, 0, 50, 50);
FillRect(wmfDC, &rect, GetStockObject(BLACK_BRUSH));
wmf = CloseMetaFile(wmfDC);
ok(wmf != NULL, "Metafile creation failed\n");
static void getwinmetafilebits(UINT mode, int scale, RECT *rc)
{
- HENHMETAFILE emf;
+ HENHMETAFILE emf, emf2;
HDC display_dc, emf_dc;
- ENHMETAHEADER *enh_header;
- UINT size, emf_size, i;
+ ENHMETAHEADER *enh_header, *enh2_header;
+ UINT size, emf_size, i, emf2_size;
WORD check = 0;
DWORD rec_num = 0;
METAHEADER *mh = NULL;
METARECORD *rec;
INT horz_res, vert_res, horz_size, vert_size;
INT curve_caps, line_caps, poly_caps;
+ METAFILEPICT mfp;
display_dc = GetDC(NULL);
ok(display_dc != NULL, "display_dc is NULL\n");
rec = (METARECORD*)((WORD*)rec + rec->rdSize);
}
+ /* Show that we get the original back when we do the reverse conversion.
+ mfp is ignored in this case. */
+ mfp.mm = MM_ISOTROPIC;
+ mfp.xExt = 0xcafe;
+ mfp.yExt = 0xbeef;
+ emf2 = SetWinMetaFileBits( size, (BYTE*)mh, NULL, &mfp );
+ ok( !!emf2, "got NULL\n" );
+ emf2_size = GetEnhMetaFileBits( emf2, 0, NULL );
+ enh2_header = HeapAlloc( GetProcessHeap(), 0, emf2_size );
+ emf2_size = GetEnhMetaFileBits( emf2, emf2_size, (BYTE*)enh2_header );
+ ok( emf_size == emf2_size, "%d %d\n", emf_size, emf2_size );
+ ok( !memcmp( enh_header, enh2_header, emf_size ), "mismatch\n" );
+ HeapFree( GetProcessHeap(), 0, enh2_header );
+ DeleteEnhMetaFile( emf2 );
+
end:
HeapFree(GetProcessHeap(), 0, mh);
HeapFree(GetProcessHeap(), 0, enh_header);
static const unsigned char EMF_PATH_BITS[] =
{
0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xef, 0xff, 0xff, 0xff, 0xea, 0xff, 0xff, 0xff,
+ 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+ 0x96, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00,
+ 0x90, 0x01, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00,
+ 0x70, 0x17, 0x00, 0x00, 0x70, 0x17, 0x00, 0x00,
0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
- 0x0c, 0x02, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+ 0xf8, 0x02, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x80, 0x07, 0x00, 0x00, 0x3e, 0x04, 0x00, 0x00,
+ 0x20, 0x03, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00,
0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
0x15, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
0x1d, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
- 0x15, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+ 0x15, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+ 0x28, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+ 0x17, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+ 0x1a, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+ 0x1b, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+ 0x17, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
0x28, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x0a, 0x00,
0x0a, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00,
- 0x5a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+ 0x59, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+ 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+ 0x14, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00,
+ 0x14, 0x00, 0x14, 0x00, 0x5a, 0x00, 0x00, 0x00,
+ 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00,
+ 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+ 0x14, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00,
+ 0x14, 0x00, 0x14, 0x00, 0x5c, 0x00, 0x00, 0x00,
+ 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0x09, 0x00, 0x00, 0x00,
0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x0a, 0x00,
0x0a, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00,
- 0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
- 0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
- 0x14, 0x00, 0x00, 0x00
+ 0x1e, 0x00, 0x1e, 0x00, 0x28, 0x00, 0x14, 0x00,
+ 0x14, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x14, 0x00,
+ 0x14, 0x00, 0x0a, 0x00, 0x06, 0x02, 0x04, 0x04,
+ 0x04, 0x02, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00,
+ 0x29, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+ 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+ 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb4, 0x42,
+ 0x00, 0x00, 0x34, 0x43, 0x3c, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,
+ 0x18, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+ 0x0a, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00,
+ 0x96, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,
+ 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x00,
+ 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
};
-static void test_emf_GetPath(void)
+static const unsigned char EMF_EMPTY_PATH_BITS[] =
{
- POINT pts[4] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}};
+ 0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xd8, 0xff, 0xff, 0xff, 0xd8, 0xff, 0xff, 0xff,
+ 0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
+ 0xc8, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x20, 0x03, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00,
+ 0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
+ 0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
+ 0x08, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+ 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
+};
+
+static void test_emf_paths(void)
+{
+ POINT pts[9] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}, {30, 30}, {40, 20}, {20, 30}, {20, 20}, {20, 10}};
DWORD counts[2] = {2, 2};
+ BYTE types[9] = { PT_MOVETO, PT_LINETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO, PT_LINETO,
+ PT_LINETO | PT_CLOSEFIGURE, PT_MOVETO, PT_LINETO };
HDC hdcMetafile;
HENHMETAFILE hemf;
BOOL ret;
ok( ret, "LineTo error %d.\n", GetLastError());
Rectangle(hdcMetafile, 10, 10, 20, 20);
Arc(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
+ ArcTo(hdcMetafile, 23, 23, 37, 27, 37, 27, 23, 23);
Chord(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
Pie(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
Ellipse(hdcMetafile, 10, 10, 20, 20);
RoundRect(hdcMetafile, 10, 10, 20, 20, 3, 5);
Polyline(hdcMetafile, pts, 4);
+ PolylineTo(hdcMetafile, pts, 4);
PolyPolyline(hdcMetafile, pts, counts, 2);
+ PolyDraw(hdcMetafile, pts, types, 9);
+ AngleArc(hdcMetafile, 37, 36, 23, 90, 180);
EndPath(hdcMetafile);
size = GetPath(hdcMetafile, NULL, NULL, 0);
- todo_wine ok( size == 77, "GetPath returned %d.\n", size);
+ ok( size == 112, "GetPath returned %d.\n", size);
+
+ ret = StrokeAndFillPath( hdcMetafile );
+ ok( ret, "StrokeAndFillPath failed err %d\n", GetLastError() );
+ ret = StrokeAndFillPath( hdcMetafile );
+ ok( !ret, "StrokeAndFillPath succeeded\n" );
+
+ hemf = CloseEnhMetaFile(hdcMetafile);
+ ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
+
+ if (compare_emf_bits(hemf, EMF_PATH_BITS, sizeof(EMF_PATH_BITS), "test_emf_paths", FALSE) != 0)
+ {
+ dump_emf_bits(hemf, "test_emf_paths");
+ dump_emf_records(hemf, "test_emf_paths");
+ }
+
+ DeleteEnhMetaFile(hemf);
+
+ SetLastError(0xdeadbeef);
+ hdcMetafile = CreateEnhMetaFileA(GetDC(0), NULL, NULL, NULL);
+ ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
+
+ ret = BeginPath(hdcMetafile);
+ ok( ret, "BeginPath failed error %d\n", GetLastError() );
+ ret = CloseFigure(hdcMetafile);
+ ok( ret, "CloseFigure failed error %d\n", GetLastError() );
+ ret = BeginPath(hdcMetafile);
+ ok( ret, "BeginPath failed error %d\n", GetLastError() );
+ ret = EndPath(hdcMetafile);
+ ok( ret, "EndPath failed error %d\n", GetLastError() );
+ ret = EndPath(hdcMetafile);
+ ok( !ret, "EndPath succeeded\n" );
+ ret = CloseFigure(hdcMetafile);
+ ok( !ret, "CloseFigure succeeded\n" );
+ ret = BeginPath(hdcMetafile);
+ ok( ret, "BeginPath failed error %d\n", GetLastError() );
+ ret = AbortPath(hdcMetafile);
+ ok( ret, "AbortPath failed error %d\n", GetLastError() );
+ ret = AbortPath(hdcMetafile);
+ ok( ret, "AbortPath failed error %d\n", GetLastError() );
hemf = CloseEnhMetaFile(hdcMetafile);
ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
- if (compare_emf_bits(hemf, EMF_PATH_BITS, sizeof(EMF_PATH_BITS), "test_emf_GetPath", FALSE) != 0)
+ if (compare_emf_bits(hemf, EMF_EMPTY_PATH_BITS, sizeof(EMF_EMPTY_PATH_BITS), "empty path", FALSE) != 0)
{
- dump_emf_bits(hemf, "test_emf_GetPath");
- dump_emf_records(hemf, "test_emf_GetPath");
+ dump_emf_bits(hemf, "empty path");
+ dump_emf_records(hemf, "empty path");
}
DeleteEnhMetaFile(hemf);
test_emf_ExtTextOut_on_path();
test_emf_clipping();
test_emf_polybezier();
- test_emf_GetPath();
+ test_emf_paths();
test_emf_PolyPolyline();
test_emf_GradientFill();
BYTE buffer[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
BITMAPINFO *bi = (BITMAPINFO *)buffer;
HDC hdc;
+ HRGN rgn;
HBITMAP orig, dib;
void *bits;
BOOL ret;
ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
"wrong error %u\n", GetLastError() );
+ SetLastError( 0xdeadbeef );
+ rgn = PathToRegion( hdc );
+ ok( !rgn, "PathToRegion succeeded\n" );
+ ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
+ "wrong error %u\n", GetLastError() );
+
SetLastError( 0xdeadbeef );
ret = EndPath( hdc );
ok( !ret, "SelectClipPath succeeded\n" );
ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
"wrong error %u\n", GetLastError() );
+ AbortPath( hdc );
+ BeginPath( hdc );
+ Rectangle( hdc, 1, 1, 10, 10 ); /* region needs some contents */
+ SetLastError( 0xdeadbeef );
+ rgn = PathToRegion( hdc );
+ ok( !rgn, "PathToRegion succeeded\n" );
+ ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
+ "wrong error %u\n", GetLastError() );
+
AbortPath( hdc );
BeginPath( hdc );
ret = CloseFigure( hdc );
EndPath( hdc );
ret = WidenPath( hdc );
ok( ret, "WidenPath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" );
AbortPath( hdc );
BeginPath( hdc );
EndPath( hdc );
ret = FlattenPath( hdc );
ok( ret, "FlattenPath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" );
AbortPath( hdc );
BeginPath( hdc );
EndPath( hdc );
ret = StrokePath( hdc );
ok( ret, "StrokePath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
- AbortPath( hdc );
BeginPath( hdc );
EndPath( hdc );
ret = FillPath( hdc );
ok( ret, "FillPath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
- AbortPath( hdc );
BeginPath( hdc );
EndPath( hdc );
ret = StrokeAndFillPath( hdc );
ok( ret, "StrokeAndFillPath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
- AbortPath( hdc );
BeginPath( hdc );
Rectangle( hdc, 1, 1, 10, 10 ); /* region needs some contents */
EndPath( hdc );
ret = SelectClipPath( hdc, RGN_OR );
ok( ret, "SelectClipPath failed\n" );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
+
+ BeginPath( hdc );
+ EndPath( hdc );
+ SetLastError( 0xdeadbeef );
+ ret = SelectClipPath( hdc, RGN_OR );
+ ok( !ret, "SelectClipPath succeeded on empty path\n" );
+ ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
+
+ BeginPath( hdc );
+ Rectangle( hdc, 1, 1, 10, 10 ); /* region needs some contents */
+ EndPath( hdc );
+ rgn = PathToRegion( hdc );
+ ok( rgn != 0, "PathToRegion failed\n" );
+ DeleteObject( rgn );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
+
+ BeginPath( hdc );
+ EndPath( hdc );
+ SetLastError( 0xdeadbeef );
+ rgn = PathToRegion( hdc );
+ ok( !rgn, "PathToRegion succeeded on empty path\n" );
+ ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
+ DeleteObject( rgn );
+ ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
- AbortPath( hdc );
BeginPath( hdc );
EndPath( hdc );
SetLastError( 0xdeadbeef );
EndPath( hdc );
SetLastError( 0xdeadbeef );
ret = EndPath( hdc );
- ok( !ret, "SelectClipPath succeeded\n" );
+ ok( !ret, "EndPath succeeded\n" );
ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
"wrong error %u\n", GetLastError() );
{
int x, y;
BYTE type;
-
- /* How many extra entries before this one only on wine
- * but not on native? */
- int wine_only_entries_preceding;
-
- /* 0 - This entry matches on wine.
- * 1 - This entry corresponds to a single entry on wine that does not match the native entry.
- * 2 - This entry is currently skipped on wine but present on native. */
- int todo;
} path_test_t;
/* Helper function to verify that the current path in the given DC matches the expected path.
* greater than 2, the trace() output is a C path_test_t array structure, useful for making
* new tests that use this function.
*/
-static void ok_path(HDC hdc, const char *path_name, const path_test_t *expected, int expected_size, BOOL todo_size)
+static void ok_path(HDC hdc, const char *path_name, const path_test_t *expected, int expected_size)
{
static const char *type_string[8] = { "Unknown (0)", "PT_CLOSEFIGURE", "PT_LINETO",
"PT_LINETO | PT_CLOSEFIGURE", "PT_BEZIERTO",
"PT_BEZIERTO | PT_CLOSEFIGURE", "PT_MOVETO", "PT_MOVETO | PT_CLOSEFIGURE"};
- POINT *pnt = NULL;
- BYTE *types = NULL;
- int size, numskip,
- idx = 0, eidx = 0;
+ POINT *pnt;
+ BYTE *types;
+ int size, idx;
/* Get the path */
assert(hdc != 0);
size = GetPath(hdc, NULL, NULL, 0);
ok(size > 0, "GetPath returned size %d, last error %d\n", size, GetLastError());
- if (size <= 0)
- {
- skip("Cannot perform path comparisons due to failure to retrieve path.\n");
- return;
- }
+ if (size <= 0) return;
+
pnt = HeapAlloc(GetProcessHeap(), 0, size*sizeof(POINT));
assert(pnt != 0);
types = HeapAlloc(GetProcessHeap(), 0, size*sizeof(BYTE));
size = GetPath(hdc, pnt, types, size);
assert(size > 0);
- todo_wine_if (todo_size)
- ok(size == expected_size, "Path size %d does not match expected size %d\n", size, expected_size);
+ ok( size == expected_size, "%s: Path size %d does not match expected size %d\n",
+ path_name, size, expected_size);
- if (winetest_debug > 2)
- trace("static const path_test_t %s[] = {\n", path_name);
-
- numskip = expected_size ? expected[eidx].wine_only_entries_preceding : 0;
- while (idx < size && eidx < expected_size)
+ for (idx = 0; idx < min( size, expected_size ); idx++)
{
/* We allow a few pixels fudge in matching X and Y coordinates to account for imprecision in
* floating point to integer conversion */
- BOOL match = (types[idx] == expected[eidx].type) &&
- (pnt[idx].x >= expected[eidx].x-2 && pnt[idx].x <= expected[eidx].x+2) &&
- (pnt[idx].y >= expected[eidx].y-2 && pnt[idx].y <= expected[eidx].y+2);
-
- todo_wine_if (expected[eidx].todo || numskip)
- ok(match, "Expected #%d: %s (%d,%d) but got %s (%d,%d)\n", eidx,
- type_string[expected[eidx].type], expected[eidx].x, expected[eidx].y,
- type_string[types[idx]], pnt[idx].x, pnt[idx].y);
-
- if (match || expected[eidx].todo != 2)
- {
- if (winetest_debug > 2)
- trace(" {%d, %d, %s, 0, 0}%s /* %d */\n", pnt[idx].x, pnt[idx].y,
- type_string[types[idx]], idx < size-1 ? "," : "};", idx);
- idx++;
- }
- if (match || !numskip--)
- numskip = expected[++eidx].wine_only_entries_preceding;
+ static const int fudge = 2;
+
+ ok( types[idx] == expected[idx].type, "%s: Expected #%d: %s (%d,%d) but got %s (%d,%d)\n",
+ path_name, idx, type_string[expected[idx].type], expected[idx].x, expected[idx].y,
+ type_string[types[idx]], pnt[idx].x, pnt[idx].y);
+
+ if (types[idx] == expected[idx].type)
+ ok( (pnt[idx].x >= expected[idx].x - fudge && pnt[idx].x <= expected[idx].x + fudge) &&
+ (pnt[idx].y >= expected[idx].y - fudge && pnt[idx].y <= expected[idx].y + fudge),
+ "%s: Expected #%d: %s position (%d,%d) but got (%d,%d)\n", path_name, idx,
+ type_string[expected[idx].type], expected[idx].x, expected[idx].y, pnt[idx].x, pnt[idx].y);
}
- /* If we are debugging and the actual path is longer than the expected path, make
- * sure to display the entire path */
- if (winetest_debug > 2 && idx < size)
- for (; idx < size; idx++)
- trace(" {%d, %d, %s, 0, 0}%s /* %d */\n", pnt[idx].x, pnt[idx].y,
- type_string[types[idx]], idx < size-1 ? "," : "};", idx);
+ if (winetest_debug > 2)
+ {
+ printf("static const path_test_t %s[] =\n{\n", path_name);
+ for (idx = 0; idx < size; idx++)
+ printf(" {%d, %d, %s}, /* %d */\n", pnt[idx].x, pnt[idx].y, type_string[types[idx]], idx);
+ printf("};\n" );
+ }
HeapFree(GetProcessHeap(), 0, types);
HeapFree(GetProcessHeap(), 0, pnt);
}
-static const path_test_t arcto_path[] = {
- {0, 0, PT_MOVETO, 0, 0}, /* 0 */
- {229, 215, PT_LINETO, 0, 0}, /* 1 */
- {248, 205, PT_BEZIERTO, 0, 0}, /* 2 */
- {273, 200, PT_BEZIERTO, 0, 0}, /* 3 */
- {300, 200, PT_BEZIERTO, 0, 0}, /* 4 */
- {355, 200, PT_BEZIERTO, 0, 0}, /* 5 */
- {399, 222, PT_BEZIERTO, 0, 0}, /* 6 */
- {399, 250, PT_BEZIERTO, 0, 0}, /* 7 */
- {399, 263, PT_BEZIERTO, 0, 0}, /* 8 */
- {389, 275, PT_BEZIERTO, 0, 0}, /* 9 */
- {370, 285, PT_BEZIERTO, 0, 0}, /* 10 */
- {363, 277, PT_LINETO, 0, 0}, /* 11 */
- {380, 270, PT_BEZIERTO, 0, 0}, /* 12 */
- {389, 260, PT_BEZIERTO, 0, 0}, /* 13 */
- {389, 250, PT_BEZIERTO, 0, 0}, /* 14 */
- {389, 228, PT_BEZIERTO, 0, 0}, /* 15 */
- {349, 210, PT_BEZIERTO, 0, 0}, /* 16 */
- {300, 210, PT_BEZIERTO, 0, 0}, /* 17 */
- {276, 210, PT_BEZIERTO, 0, 0}, /* 18 */
- {253, 214, PT_BEZIERTO, 0, 0}, /* 19 */
- {236, 222, PT_BEZIERTO | PT_CLOSEFIGURE, 0, 0}}; /* 20 */
+static const path_test_t arcto_path[] =
+{
+ {0, 0, PT_MOVETO}, /* 0 */
+ {229, 215, PT_LINETO}, /* 1 */
+ {248, 205, PT_BEZIERTO}, /* 2 */
+ {273, 200, PT_BEZIERTO}, /* 3 */
+ {300, 200, PT_BEZIERTO}, /* 4 */
+ {355, 200, PT_BEZIERTO}, /* 5 */
+ {399, 222, PT_BEZIERTO}, /* 6 */
+ {399, 250, PT_BEZIERTO}, /* 7 */
+ {399, 263, PT_BEZIERTO}, /* 8 */
+ {389, 275, PT_BEZIERTO}, /* 9 */
+ {370, 285, PT_BEZIERTO}, /* 10 */
+ {363, 277, PT_LINETO}, /* 11 */
+ {380, 270, PT_BEZIERTO}, /* 12 */
+ {389, 260, PT_BEZIERTO}, /* 13 */
+ {389, 250, PT_BEZIERTO}, /* 14 */
+ {389, 228, PT_BEZIERTO}, /* 15 */
+ {349, 210, PT_BEZIERTO}, /* 16 */
+ {300, 210, PT_BEZIERTO}, /* 17 */
+ {276, 210, PT_BEZIERTO}, /* 18 */
+ {253, 214, PT_BEZIERTO}, /* 19 */
+ {236, 222, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 20 */
+};
static void test_arcto(void)
{
CloseFigure(hdc);
EndPath(hdc);
- ok_path(hdc, "arcto_path", arcto_path, sizeof(arcto_path)/sizeof(path_test_t), 0);
+ ok_path(hdc, "arcto_path", arcto_path, sizeof(arcto_path)/sizeof(path_test_t));
done:
ReleaseDC(0, hdc);
}
-static const path_test_t anglearc_path[] = {
- {0, 0, PT_MOVETO, 0, 0}, /* 0 */
- {371, 229, PT_LINETO, 0, 0}, /* 1 */
- {352, 211, PT_BEZIERTO, 0, 0}, /* 2 */
- {327, 200, PT_BEZIERTO, 0, 0}, /* 3 */
- {300, 200, PT_BEZIERTO, 0, 0}, /* 4 */
- {245, 200, PT_BEZIERTO, 0, 0}, /* 5 */
- {200, 245, PT_BEZIERTO, 0, 0}, /* 6 */
- {200, 300, PT_BEZIERTO, 0, 0}, /* 7 */
- {200, 300, PT_BEZIERTO, 0, 0}, /* 8 */
- {200, 300, PT_BEZIERTO, 0, 0}, /* 9 */
- {200, 300, PT_BEZIERTO, 0, 0}, /* 10 */
- {231, 260, PT_LINETO, 0, 0}, /* 11 */
- {245, 235, PT_BEZIERTO, 0, 0}, /* 12 */
- {271, 220, PT_BEZIERTO, 0, 0}, /* 13 */
- {300, 220, PT_BEZIERTO, 0, 0}, /* 14 */
- {344, 220, PT_BEZIERTO, 0, 0}, /* 15 */
- {380, 256, PT_BEZIERTO, 0, 0}, /* 16 */
- {380, 300, PT_BEZIERTO, 0, 0}, /* 17 */
- {380, 314, PT_BEZIERTO, 0, 0}, /* 18 */
- {376, 328, PT_BEZIERTO, 0, 0}, /* 19 */
- {369, 340, PT_BEZIERTO | PT_CLOSEFIGURE, 0, 0}}; /* 20 */
+static const path_test_t anglearc_path[] =
+{
+ {0, 0, PT_MOVETO}, /* 0 */
+ {371, 229, PT_LINETO}, /* 1 */
+ {352, 211, PT_BEZIERTO}, /* 2 */
+ {327, 200, PT_BEZIERTO}, /* 3 */
+ {300, 200, PT_BEZIERTO}, /* 4 */
+ {245, 200, PT_BEZIERTO}, /* 5 */
+ {200, 245, PT_BEZIERTO}, /* 6 */
+ {200, 300, PT_BEZIERTO}, /* 7 */
+ {200, 300, PT_BEZIERTO}, /* 8 */
+ {200, 300, PT_BEZIERTO}, /* 9 */
+ {200, 300, PT_BEZIERTO}, /* 10 */
+ {231, 260, PT_LINETO}, /* 11 */
+ {245, 235, PT_BEZIERTO}, /* 12 */
+ {271, 220, PT_BEZIERTO}, /* 13 */
+ {300, 220, PT_BEZIERTO}, /* 14 */
+ {344, 220, PT_BEZIERTO}, /* 15 */
+ {380, 256, PT_BEZIERTO}, /* 16 */
+ {380, 300, PT_BEZIERTO}, /* 17 */
+ {380, 314, PT_BEZIERTO}, /* 18 */
+ {376, 328, PT_BEZIERTO}, /* 19 */
+ {369, 340, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 20 */
+};
static void test_anglearc(void)
{
CloseFigure(hdc);
EndPath(hdc);
- ok_path(hdc, "anglearc_path", anglearc_path, sizeof(anglearc_path)/sizeof(path_test_t), 0);
+ ok_path(hdc, "anglearc_path", anglearc_path, sizeof(anglearc_path)/sizeof(path_test_t));
done:
ReleaseDC(0, hdc);
}
-static const path_test_t polydraw_path[] = {
- {0, 0, PT_MOVETO, 0, 0}, /*0*/
- {10, 10, PT_LINETO, 0, 0}, /*1*/
- {10, 15, PT_LINETO | PT_CLOSEFIGURE, 0, 0}, /*2*/
- {100, 100, PT_MOVETO, 0, 0}, /*3*/
- {95, 95, PT_LINETO, 0, 0}, /*4*/
- {10, 10, PT_LINETO, 0, 0}, /*5*/
- {10, 15, PT_LINETO | PT_CLOSEFIGURE, 0, 0}, /*6*/
- {100, 100, PT_MOVETO, 0, 0}, /*7*/
- {15, 15, PT_LINETO, 0, 0}, /*8*/
- {25, 25, PT_MOVETO, 0, 0}, /*9*/
- {25, 30, PT_LINETO, 0, 0}, /*10*/
- {100, 100, PT_MOVETO, 0, 0}, /*11*/
- {30, 30, PT_BEZIERTO, 0, 0}, /*12*/
- {30, 35, PT_BEZIERTO, 0, 0}, /*13*/
- {35, 35, PT_BEZIERTO, 0, 0}, /*14*/
- {35, 40, PT_LINETO, 0, 0}, /*15*/
- {40, 40, PT_MOVETO, 0, 0}, /*16*/
- {40, 45, PT_LINETO, 0, 0}, /*17*/
- {35, 40, PT_MOVETO, 0, 0}, /*18*/
- {45, 50, PT_LINETO, 0, 0}, /*19*/
- {35, 40, PT_MOVETO, 0, 0}, /*20*/
- {50, 55, PT_LINETO, 0, 0}, /*21*/
- {45, 50, PT_LINETO, 0, 0}, /*22*/
- {35, 40, PT_MOVETO, 0, 0}, /*23*/
- {60, 60, PT_LINETO, 0, 0}, /*24*/
- {60, 65, PT_MOVETO, 0, 0}, /*25*/
- {65, 65, PT_LINETO, 0, 0} /*26*/
- };
+static const path_test_t polydraw_path[] =
+{
+ {-20, -20, PT_MOVETO}, /* 0 */
+ {10, 10, PT_LINETO}, /* 1 */
+ {10, 15, PT_LINETO | PT_CLOSEFIGURE}, /* 2 */
+ {-20, -20, PT_MOVETO}, /* 3 */
+ {-10, -10, PT_LINETO}, /* 4 */
+ {100, 100, PT_MOVETO}, /* 5 */
+ {95, 95, PT_LINETO}, /* 6 */
+ {10, 10, PT_LINETO}, /* 7 */
+ {10, 15, PT_LINETO | PT_CLOSEFIGURE}, /* 8 */
+ {100, 100, PT_MOVETO}, /* 9 */
+ {15, 15, PT_LINETO}, /* 10 */
+ {25, 25, PT_MOVETO}, /* 11 */
+ {25, 30, PT_LINETO}, /* 12 */
+ {100, 100, PT_MOVETO}, /* 13 */
+ {30, 30, PT_BEZIERTO}, /* 14 */
+ {30, 35, PT_BEZIERTO}, /* 15 */
+ {35, 35, PT_BEZIERTO}, /* 16 */
+ {35, 40, PT_LINETO}, /* 17 */
+ {40, 40, PT_MOVETO}, /* 18 */
+ {40, 45, PT_LINETO}, /* 19 */
+ {35, 40, PT_MOVETO}, /* 20 */
+ {45, 50, PT_LINETO}, /* 21 */
+ {35, 40, PT_MOVETO}, /* 22 */
+ {50, 55, PT_LINETO}, /* 23 */
+ {45, 50, PT_LINETO}, /* 24 */
+ {35, 40, PT_MOVETO}, /* 25 */
+ {60, 60, PT_LINETO}, /* 26 */
+ {60, 65, PT_MOVETO}, /* 27 */
+ {65, 65, PT_LINETO}, /* 28 */
+ {75, 75, PT_MOVETO}, /* 29 */
+ {80, 80, PT_LINETO | PT_CLOSEFIGURE}, /* 30 */
+};
static POINT polydraw_pts[] = {
{10, 10}, {10, 15},
{40, 40}, {40, 45}, {45, 45},
{45, 50}, {50, 50},
{50, 55}, {45, 50}, {55, 60},
- {60, 60}, {60, 65}, {65, 65}};
+ {60, 60}, {60, 65}, {65, 65},
+ {70, 70}, {75, 70}, {75, 75}, {80, 80}};
static BYTE polydraw_tps[] =
{PT_LINETO, PT_CLOSEFIGURE | PT_LINETO, /* 2 */
PT_MOVETO, PT_LINETO, PT_CLOSEFIGURE, /* 15 */
PT_LINETO, PT_MOVETO | PT_CLOSEFIGURE, /* 17 */
PT_LINETO, PT_LINETO, PT_MOVETO | PT_CLOSEFIGURE, /* 20 */
- PT_LINETO, PT_MOVETO | PT_LINETO, PT_LINETO}; /* 23 */
+ PT_LINETO, PT_MOVETO | PT_LINETO, PT_LINETO, /* 23 */
+ PT_MOVETO, PT_MOVETO, PT_MOVETO, PT_LINETO | PT_CLOSEFIGURE}; /* 27 */
static void test_polydraw(void)
{
BOOL retb;
+ POINT pos;
HDC hdc = GetDC(0);
+
+ MoveToEx( hdc, -20, -20, NULL );
+
BeginPath(hdc);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == -20 && pos.y == -20, "wrong pos %d,%d\n", pos.x, pos.y );
/* closefigure with no previous moveto */
if (!(retb = PolyDraw(hdc, polydraw_pts, polydraw_tps, 2)) &&
goto done;
}
expect(TRUE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
+ LineTo(hdc, -10, -10);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == -10 && pos.y == -10, "wrong pos %d,%d\n", pos.x, pos.y );
MoveToEx(hdc, 100, 100, NULL);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
LineTo(hdc, 95, 95);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 95 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
/* closefigure with previous moveto */
retb = PolyDraw(hdc, polydraw_pts, polydraw_tps, 2);
expect(TRUE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
/* bad bezier points */
retb = PolyDraw(hdc, &(polydraw_pts[2]), &(polydraw_tps[2]), 4);
expect(FALSE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
retb = PolyDraw(hdc, &(polydraw_pts[6]), &(polydraw_tps[6]), 4);
expect(FALSE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
/* good bezier points */
retb = PolyDraw(hdc, &(polydraw_pts[8]), &(polydraw_tps[8]), 4);
expect(TRUE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
/* does lineto or bezierto take precedence? */
retb = PolyDraw(hdc, &(polydraw_pts[12]), &(polydraw_tps[12]), 4);
expect(FALSE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
/* bad point type, has already moved cursor position */
retb = PolyDraw(hdc, &(polydraw_pts[15]), &(polydraw_tps[15]), 4);
expect(FALSE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
/* bad point type, cursor position is moved, but back to its original spot */
retb = PolyDraw(hdc, &(polydraw_pts[17]), &(polydraw_tps[17]), 4);
expect(FALSE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
/* does lineto or moveto take precedence? */
retb = PolyDraw(hdc, &(polydraw_pts[20]), &(polydraw_tps[20]), 3);
expect(TRUE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 65 && pos.y == 65, "wrong pos %d,%d\n", pos.x, pos.y );
+ /* consecutive movetos */
+ retb = PolyDraw(hdc, &(polydraw_pts[23]), &(polydraw_tps[23]), 4);
+ expect(TRUE, retb);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y );
EndPath(hdc);
- ok_path(hdc, "polydraw_path", polydraw_path, sizeof(polydraw_path)/sizeof(path_test_t), 0);
+ ok_path(hdc, "polydraw_path", polydraw_path, sizeof(polydraw_path)/sizeof(path_test_t));
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y );
done:
ReleaseDC(0, hdc);
}
static void test_closefigure(void) {
int nSize, nSizeWitness;
+ POINT pos;
HDC hdc = GetDC(0);
+ MoveToEx( hdc, 100, 100, NULL );
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
+
BeginPath(hdc);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
MoveToEx(hdc, 95, 95, NULL);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 95 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
LineTo(hdc, 95, 0);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 95 && pos.y == 0, "wrong pos %d,%d\n", pos.x, pos.y );
LineTo(hdc, 0, 95);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
CloseFigure(hdc);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
EndPath(hdc);
+ GetCurrentPositionEx( hdc, &pos );
+ ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
nSize = GetPath(hdc, NULL, NULL, 0);
AbortPath(hdc);
ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
}
+static const path_test_t rectangle_path[] =
+{
+ {39, 20, PT_MOVETO}, /* 0 */
+ {20, 20, PT_LINETO}, /* 1 */
+ {20, 39, PT_LINETO}, /* 2 */
+ {39, 39, PT_LINETO | PT_CLOSEFIGURE}, /* 3 */
+ {54, 35, PT_MOVETO}, /* 4 */
+ {30, 35, PT_LINETO}, /* 5 */
+ {30, 49, PT_LINETO}, /* 6 */
+ {54, 49, PT_LINETO | PT_CLOSEFIGURE}, /* 7 */
+ {59, 45, PT_MOVETO}, /* 8 */
+ {35, 45, PT_LINETO}, /* 9 */
+ {35, 59, PT_LINETO}, /* 10 */
+ {59, 59, PT_LINETO | PT_CLOSEFIGURE}, /* 11 */
+ {80, 80, PT_MOVETO}, /* 12 */
+ {80, 80, PT_LINETO}, /* 13 */
+ {80, 80, PT_LINETO}, /* 14 */
+ {80, 80, PT_LINETO | PT_CLOSEFIGURE}, /* 15 */
+ {39, 39, PT_MOVETO}, /* 16 */
+ {20, 39, PT_LINETO}, /* 17 */
+ {20, 20, PT_LINETO}, /* 18 */
+ {39, 20, PT_LINETO | PT_CLOSEFIGURE}, /* 19 */
+ {54, 49, PT_MOVETO}, /* 20 */
+ {30, 49, PT_LINETO}, /* 21 */
+ {30, 35, PT_LINETO}, /* 22 */
+ {54, 35, PT_LINETO | PT_CLOSEFIGURE}, /* 23 */
+ {59, 59, PT_MOVETO}, /* 24 */
+ {35, 59, PT_LINETO}, /* 25 */
+ {35, 45, PT_LINETO}, /* 26 */
+ {59, 45, PT_LINETO | PT_CLOSEFIGURE}, /* 27 */
+ {80, 80, PT_MOVETO}, /* 28 */
+ {80, 80, PT_LINETO}, /* 29 */
+ {80, 80, PT_LINETO}, /* 30 */
+ {80, 80, PT_LINETO | PT_CLOSEFIGURE}, /* 31 */
+ {-41, 40, PT_MOVETO}, /* 32 */
+ {-80, 40, PT_LINETO}, /* 33 */
+ {-80, 79, PT_LINETO}, /* 34 */
+ {-41, 79, PT_LINETO | PT_CLOSEFIGURE}, /* 35 */
+ {-61, 70, PT_MOVETO}, /* 36 */
+ {-110, 70, PT_LINETO}, /* 37 */
+ {-110, 99, PT_LINETO}, /* 38 */
+ {-61, 99, PT_LINETO | PT_CLOSEFIGURE}, /* 39 */
+ {119, -120, PT_MOVETO}, /* 40 */
+ {60, -120, PT_LINETO}, /* 41 */
+ {60, -61, PT_LINETO}, /* 42 */
+ {119, -61, PT_LINETO | PT_CLOSEFIGURE}, /* 43 */
+ {164, -150, PT_MOVETO}, /* 44 */
+ {90, -150, PT_LINETO}, /* 45 */
+ {90, -106, PT_LINETO}, /* 46 */
+ {164, -106, PT_LINETO | PT_CLOSEFIGURE}, /* 47 */
+ {-4, -6, PT_MOVETO}, /* 48 */
+ {-6, -6, PT_LINETO}, /* 49 */
+ {-6, -4, PT_LINETO}, /* 50 */
+ {-4, -4, PT_LINETO | PT_CLOSEFIGURE}, /* 51 */
+ {40, 20, PT_MOVETO}, /* 52 */
+ {20, 20, PT_LINETO}, /* 53 */
+ {20, 40, PT_LINETO}, /* 54 */
+ {40, 40, PT_LINETO | PT_CLOSEFIGURE}, /* 55 */
+ {55, 35, PT_MOVETO}, /* 56 */
+ {30, 35, PT_LINETO}, /* 57 */
+ {30, 50, PT_LINETO}, /* 58 */
+ {55, 50, PT_LINETO | PT_CLOSEFIGURE}, /* 59 */
+ {60, 45, PT_MOVETO}, /* 60 */
+ {35, 45, PT_LINETO}, /* 61 */
+ {35, 60, PT_LINETO}, /* 62 */
+ {60, 60, PT_LINETO | PT_CLOSEFIGURE}, /* 63 */
+ {70, 70, PT_MOVETO}, /* 64 */
+ {50, 70, PT_LINETO}, /* 65 */
+ {50, 70, PT_LINETO}, /* 66 */
+ {70, 70, PT_LINETO | PT_CLOSEFIGURE}, /* 67 */
+ {75, 75, PT_MOVETO}, /* 68 */
+ {75, 75, PT_LINETO}, /* 69 */
+ {75, 85, PT_LINETO}, /* 70 */
+ {75, 85, PT_LINETO | PT_CLOSEFIGURE}, /* 71 */
+ {81, 80, PT_MOVETO}, /* 72 */
+ {80, 80, PT_LINETO}, /* 73 */
+ {80, 81, PT_LINETO}, /* 74 */
+ {81, 81, PT_LINETO | PT_CLOSEFIGURE}, /* 75 */
+ {40, 40, PT_MOVETO}, /* 76 */
+ {20, 40, PT_LINETO}, /* 77 */
+ {20, 20, PT_LINETO}, /* 78 */
+ {40, 20, PT_LINETO | PT_CLOSEFIGURE}, /* 79 */
+ {55, 50, PT_MOVETO}, /* 80 */
+ {30, 50, PT_LINETO}, /* 81 */
+ {30, 35, PT_LINETO}, /* 82 */
+ {55, 35, PT_LINETO | PT_CLOSEFIGURE}, /* 83 */
+ {60, 60, PT_MOVETO}, /* 84 */
+ {35, 60, PT_LINETO}, /* 85 */
+ {35, 45, PT_LINETO}, /* 86 */
+ {60, 45, PT_LINETO | PT_CLOSEFIGURE}, /* 87 */
+ {70, 70, PT_MOVETO}, /* 88 */
+ {50, 70, PT_LINETO}, /* 89 */
+ {50, 70, PT_LINETO}, /* 90 */
+ {70, 70, PT_LINETO | PT_CLOSEFIGURE}, /* 91 */
+ {75, 85, PT_MOVETO}, /* 92 */
+ {75, 85, PT_LINETO}, /* 93 */
+ {75, 75, PT_LINETO}, /* 94 */
+ {75, 75, PT_LINETO | PT_CLOSEFIGURE}, /* 95 */
+ {81, 81, PT_MOVETO}, /* 96 */
+ {80, 81, PT_LINETO}, /* 97 */
+ {80, 80, PT_LINETO}, /* 98 */
+ {81, 80, PT_LINETO | PT_CLOSEFIGURE}, /* 99 */
+};
+
+static void test_rectangle(void)
+{
+ HDC hdc = GetDC( 0 );
+
+ BeginPath( hdc );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ Rectangle( hdc, 60, 60, 35, 45 );
+ Rectangle( hdc, 70, 70, 50, 70 );
+ Rectangle( hdc, 75, 75, 75, 85 );
+ Rectangle( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ Rectangle( hdc, 60, 60, 35, 45 );
+ Rectangle( hdc, 70, 70, 50, 70 );
+ Rectangle( hdc, 75, 75, 75, 85 );
+ Rectangle( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ SetMapMode( hdc, MM_ANISOTROPIC );
+ SetViewportExtEx( hdc, -2, 2, NULL );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ SetViewportExtEx( hdc, 3, -3, NULL );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ SetWindowExtEx( hdc, -20, 20, NULL );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 24, 22, 21, 20 );
+ SetMapMode( hdc, MM_TEXT );
+ SetGraphicsMode( hdc, GM_ADVANCED );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ Rectangle( hdc, 60, 60, 35, 45 );
+ Rectangle( hdc, 70, 70, 50, 70 );
+ Rectangle( hdc, 75, 75, 75, 85 );
+ Rectangle( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ Rectangle( hdc, 20, 20, 40, 40 );
+ Rectangle( hdc, 30, 50, 55, 35 );
+ Rectangle( hdc, 60, 60, 35, 45 );
+ Rectangle( hdc, 70, 70, 50, 70 );
+ Rectangle( hdc, 75, 75, 75, 85 );
+ Rectangle( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ EndPath( hdc );
+ SetMapMode( hdc, MM_TEXT );
+ ok_path( hdc, "rectangle_path", rectangle_path, sizeof(rectangle_path)/sizeof(path_test_t) );
+ ReleaseDC( 0, hdc );
+}
+
+static const path_test_t roundrect_path[] =
+{
+ {39, 25, PT_MOVETO}, /* 0 */
+ {39, 22, PT_BEZIERTO}, /* 1 */
+ {37, 20, PT_BEZIERTO}, /* 2 */
+ {34, 20, PT_BEZIERTO}, /* 3 */
+ {25, 20, PT_LINETO}, /* 4 */
+ {22, 20, PT_BEZIERTO}, /* 5 */
+ {20, 22, PT_BEZIERTO}, /* 6 */
+ {20, 25, PT_BEZIERTO}, /* 7 */
+ {20, 34, PT_LINETO}, /* 8 */
+ {20, 37, PT_BEZIERTO}, /* 9 */
+ {22, 39, PT_BEZIERTO}, /* 10 */
+ {25, 39, PT_BEZIERTO}, /* 11 */
+ {34, 39, PT_LINETO}, /* 12 */
+ {37, 39, PT_BEZIERTO}, /* 13 */
+ {39, 37, PT_BEZIERTO}, /* 14 */
+ {39, 34, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 15 */
+ {54, 42, PT_MOVETO}, /* 16 */
+ {54, 38, PT_BEZIERTO}, /* 17 */
+ {49, 35, PT_BEZIERTO}, /* 18 */
+ {42, 35, PT_BEZIERTO}, /* 19 */
+ {42, 35, PT_LINETO}, /* 20 */
+ {35, 35, PT_BEZIERTO}, /* 21 */
+ {30, 38, PT_BEZIERTO}, /* 22 */
+ {30, 42, PT_BEZIERTO}, /* 23 */
+ {30, 42, PT_LINETO}, /* 24 */
+ {30, 46, PT_BEZIERTO}, /* 25 */
+ {35, 49, PT_BEZIERTO}, /* 26 */
+ {42, 49, PT_BEZIERTO}, /* 27 */
+ {42, 49, PT_LINETO}, /* 28 */
+ {49, 49, PT_BEZIERTO}, /* 29 */
+ {54, 46, PT_BEZIERTO}, /* 30 */
+ {54, 42, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 31 */
+ {59, 46, PT_MOVETO}, /* 32 */
+ {59, 45, PT_BEZIERTO}, /* 33 */
+ {58, 45, PT_BEZIERTO}, /* 34 */
+ {57, 45, PT_BEZIERTO}, /* 35 */
+ {37, 45, PT_LINETO}, /* 36 */
+ {36, 45, PT_BEZIERTO}, /* 37 */
+ {35, 45, PT_BEZIERTO}, /* 38 */
+ {35, 46, PT_BEZIERTO}, /* 39 */
+ {35, 58, PT_LINETO}, /* 40 */
+ {35, 59, PT_BEZIERTO}, /* 41 */
+ {36, 59, PT_BEZIERTO}, /* 42 */
+ {37, 59, PT_BEZIERTO}, /* 43 */
+ {57, 59, PT_LINETO}, /* 44 */
+ {58, 59, PT_BEZIERTO}, /* 45 */
+ {59, 59, PT_BEZIERTO}, /* 46 */
+ {59, 58, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 47 */
+ {80, 80, PT_MOVETO}, /* 48 */
+ {80, 80, PT_BEZIERTO}, /* 49 */
+ {80, 80, PT_BEZIERTO}, /* 50 */
+ {80, 80, PT_BEZIERTO}, /* 51 */
+ {80, 80, PT_LINETO}, /* 52 */
+ {80, 80, PT_BEZIERTO}, /* 53 */
+ {80, 80, PT_BEZIERTO}, /* 54 */
+ {80, 80, PT_BEZIERTO}, /* 55 */
+ {80, 80, PT_LINETO}, /* 56 */
+ {80, 80, PT_BEZIERTO}, /* 57 */
+ {80, 80, PT_BEZIERTO}, /* 58 */
+ {80, 80, PT_BEZIERTO}, /* 59 */
+ {80, 80, PT_LINETO}, /* 60 */
+ {80, 80, PT_BEZIERTO}, /* 61 */
+ {80, 80, PT_BEZIERTO}, /* 62 */
+ {80, 80, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 63 */
+ {94, 85, PT_MOVETO}, /* 64 */
+ {90, 85, PT_LINETO}, /* 65 */
+ {90, 89, PT_LINETO}, /* 66 */
+ {94, 89, PT_LINETO | PT_CLOSEFIGURE}, /* 67 */
+ {39, 34, PT_MOVETO}, /* 68 */
+ {39, 37, PT_BEZIERTO}, /* 69 */
+ {37, 39, PT_BEZIERTO}, /* 70 */
+ {34, 39, PT_BEZIERTO}, /* 71 */
+ {25, 39, PT_LINETO}, /* 72 */
+ {22, 39, PT_BEZIERTO}, /* 73 */
+ {20, 37, PT_BEZIERTO}, /* 74 */
+ {20, 34, PT_BEZIERTO}, /* 75 */
+ {20, 25, PT_LINETO}, /* 76 */
+ {20, 22, PT_BEZIERTO}, /* 77 */
+ {22, 20, PT_BEZIERTO}, /* 78 */
+ {25, 20, PT_BEZIERTO}, /* 79 */
+ {34, 20, PT_LINETO}, /* 80 */
+ {37, 20, PT_BEZIERTO}, /* 81 */
+ {39, 22, PT_BEZIERTO}, /* 82 */
+ {39, 25, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 83 */
+ {54, 42, PT_MOVETO}, /* 84 */
+ {54, 46, PT_BEZIERTO}, /* 85 */
+ {49, 49, PT_BEZIERTO}, /* 86 */
+ {42, 49, PT_BEZIERTO}, /* 87 */
+ {42, 49, PT_LINETO}, /* 88 */
+ {35, 49, PT_BEZIERTO}, /* 89 */
+ {30, 46, PT_BEZIERTO}, /* 90 */
+ {30, 42, PT_BEZIERTO}, /* 91 */
+ {30, 42, PT_LINETO}, /* 92 */
+ {30, 38, PT_BEZIERTO}, /* 93 */
+ {35, 35, PT_BEZIERTO}, /* 94 */
+ {42, 35, PT_BEZIERTO}, /* 95 */
+ {42, 35, PT_LINETO}, /* 96 */
+ {49, 35, PT_BEZIERTO}, /* 97 */
+ {54, 38, PT_BEZIERTO}, /* 98 */
+ {54, 42, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 99 */
+ {-41, 52, PT_MOVETO}, /* 100 */
+ {-41, 45, PT_BEZIERTO}, /* 101 */
+ {-47, 40, PT_BEZIERTO}, /* 102 */
+ {-56, 40, PT_BEZIERTO}, /* 103 */
+ {-65, 40, PT_LINETO}, /* 104 */
+ {-73, 40, PT_BEZIERTO}, /* 105 */
+ {-80, 45, PT_BEZIERTO}, /* 106 */
+ {-80, 52, PT_BEZIERTO}, /* 107 */
+ {-80, 67, PT_LINETO}, /* 108 */
+ {-80, 74, PT_BEZIERTO}, /* 109 */
+ {-73, 79, PT_BEZIERTO}, /* 110 */
+ {-65, 79, PT_BEZIERTO}, /* 111 */
+ {-56, 79, PT_LINETO}, /* 112 */
+ {-47, 79, PT_BEZIERTO}, /* 113 */
+ {-41, 74, PT_BEZIERTO}, /* 114 */
+ {-41, 67, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 115 */
+ {-61, 79, PT_MOVETO}, /* 116 */
+ {-61, 74, PT_BEZIERTO}, /* 117 */
+ {-64, 70, PT_BEZIERTO}, /* 118 */
+ {-68, 70, PT_BEZIERTO}, /* 119 */
+ {-103, 70, PT_LINETO}, /* 120 */
+ {-107, 70, PT_BEZIERTO}, /* 121 */
+ {-110, 74, PT_BEZIERTO}, /* 122 */
+ {-110, 79, PT_BEZIERTO}, /* 123 */
+ {-110, 90, PT_LINETO}, /* 124 */
+ {-110, 95, PT_BEZIERTO}, /* 125 */
+ {-107, 99, PT_BEZIERTO}, /* 126 */
+ {-103, 99, PT_BEZIERTO}, /* 127 */
+ {-68, 99, PT_LINETO}, /* 128 */
+ {-64, 99, PT_BEZIERTO}, /* 129 */
+ {-61, 95, PT_BEZIERTO}, /* 130 */
+ {-61, 90, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 131 */
+ {119, -102, PT_MOVETO}, /* 132 */
+ {119, -112, PT_BEZIERTO}, /* 133 */
+ {109, -120, PT_BEZIERTO}, /* 134 */
+ {97, -120, PT_BEZIERTO}, /* 135 */
+ {82, -120, PT_LINETO}, /* 136 */
+ {70, -120, PT_BEZIERTO}, /* 137 */
+ {60, -112, PT_BEZIERTO}, /* 138 */
+ {60, -102, PT_BEZIERTO}, /* 139 */
+ {60, -79, PT_LINETO}, /* 140 */
+ {60, -69, PT_BEZIERTO}, /* 141 */
+ {70, -61, PT_BEZIERTO}, /* 142 */
+ {82, -61, PT_BEZIERTO}, /* 143 */
+ {97, -61, PT_LINETO}, /* 144 */
+ {109, -61, PT_BEZIERTO}, /* 145 */
+ {119, -69, PT_BEZIERTO}, /* 146 */
+ {119, -79, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 147 */
+ {164, -144, PT_MOVETO}, /* 148 */
+ {164, -147, PT_BEZIERTO}, /* 149 */
+ {162, -150, PT_BEZIERTO}, /* 150 */
+ {160, -150, PT_BEZIERTO}, /* 151 */
+ {94, -150, PT_LINETO}, /* 152 */
+ {92, -150, PT_BEZIERTO}, /* 153 */
+ {90, -147, PT_BEZIERTO}, /* 154 */
+ {90, -144, PT_BEZIERTO}, /* 155 */
+ {90, -112, PT_LINETO}, /* 156 */
+ {90, -109, PT_BEZIERTO}, /* 157 */
+ {92, -106, PT_BEZIERTO}, /* 158 */
+ {94, -106, PT_BEZIERTO}, /* 159 */
+ {160, -106, PT_LINETO}, /* 160 */
+ {162, -106, PT_BEZIERTO}, /* 161 */
+ {164, -109, PT_BEZIERTO}, /* 162 */
+ {164, -112, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 163 */
+ {-4, -6, PT_MOVETO}, /* 164 */
+ {-4, -6, PT_BEZIERTO}, /* 165 */
+ {-4, -6, PT_BEZIERTO}, /* 166 */
+ {-4, -6, PT_BEZIERTO}, /* 167 */
+ {-6, -6, PT_LINETO}, /* 168 */
+ {-6, -6, PT_BEZIERTO}, /* 169 */
+ {-6, -6, PT_BEZIERTO}, /* 170 */
+ {-6, -6, PT_BEZIERTO}, /* 171 */
+ {-6, -4, PT_LINETO}, /* 172 */
+ {-6, -4, PT_BEZIERTO}, /* 173 */
+ {-6, -4, PT_BEZIERTO}, /* 174 */
+ {-6, -4, PT_BEZIERTO}, /* 175 */
+ {-4, -4, PT_LINETO}, /* 176 */
+ {-4, -4, PT_BEZIERTO}, /* 177 */
+ {-4, -4, PT_BEZIERTO}, /* 178 */
+ {-4, -4, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 179 */
+ {40, 25, PT_MOVETO}, /* 180 */
+ {40, 22, PT_BEZIERTO}, /* 181 */
+ {38, 20, PT_BEZIERTO}, /* 182 */
+ {35, 20, PT_BEZIERTO}, /* 183 */
+ {25, 20, PT_LINETO}, /* 184 */
+ {22, 20, PT_BEZIERTO}, /* 185 */
+ {20, 22, PT_BEZIERTO}, /* 186 */
+ {20, 25, PT_BEZIERTO}, /* 187 */
+ {20, 35, PT_LINETO}, /* 188 */
+ {20, 38, PT_BEZIERTO}, /* 189 */
+ {22, 40, PT_BEZIERTO}, /* 190 */
+ {25, 40, PT_BEZIERTO}, /* 191 */
+ {35, 40, PT_LINETO}, /* 192 */
+ {38, 40, PT_BEZIERTO}, /* 193 */
+ {40, 38, PT_BEZIERTO}, /* 194 */
+ {40, 35, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 195 */
+ {55, 43, PT_MOVETO}, /* 196 */
+ {55, 38, PT_BEZIERTO}, /* 197 */
+ {49, 35, PT_BEZIERTO}, /* 198 */
+ {43, 35, PT_BEZIERTO}, /* 199 */
+ {43, 35, PT_LINETO}, /* 200 */
+ {36, 35, PT_BEZIERTO}, /* 201 */
+ {30, 38, PT_BEZIERTO}, /* 202 */
+ {30, 43, PT_BEZIERTO}, /* 203 */
+ {30, 43, PT_LINETO}, /* 204 */
+ {30, 47, PT_BEZIERTO}, /* 205 */
+ {36, 50, PT_BEZIERTO}, /* 206 */
+ {43, 50, PT_BEZIERTO}, /* 207 */
+ {43, 50, PT_LINETO}, /* 208 */
+ {49, 50, PT_BEZIERTO}, /* 209 */
+ {55, 47, PT_BEZIERTO}, /* 210 */
+ {55, 43, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 211 */
+ {60, 46, PT_MOVETO}, /* 212 */
+ {60, 46, PT_BEZIERTO}, /* 213 */
+ {59, 45, PT_BEZIERTO}, /* 214 */
+ {58, 45, PT_BEZIERTO}, /* 215 */
+ {38, 45, PT_LINETO}, /* 216 */
+ {36, 45, PT_BEZIERTO}, /* 217 */
+ {35, 46, PT_BEZIERTO}, /* 218 */
+ {35, 46, PT_BEZIERTO}, /* 219 */
+ {35, 59, PT_LINETO}, /* 220 */
+ {35, 60, PT_BEZIERTO}, /* 221 */
+ {36, 60, PT_BEZIERTO}, /* 222 */
+ {38, 60, PT_BEZIERTO}, /* 223 */
+ {58, 60, PT_LINETO}, /* 224 */
+ {59, 60, PT_BEZIERTO}, /* 225 */
+ {60, 60, PT_BEZIERTO}, /* 226 */
+ {60, 59, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 227 */
+ {70, 70, PT_MOVETO}, /* 228 */
+ {70, 70, PT_BEZIERTO}, /* 229 */
+ {70, 70, PT_BEZIERTO}, /* 230 */
+ {70, 70, PT_BEZIERTO}, /* 231 */
+ {50, 70, PT_LINETO}, /* 232 */
+ {50, 70, PT_BEZIERTO}, /* 233 */
+ {50, 70, PT_BEZIERTO}, /* 234 */
+ {50, 70, PT_BEZIERTO}, /* 235 */
+ {50, 70, PT_LINETO}, /* 236 */
+ {50, 70, PT_BEZIERTO}, /* 237 */
+ {50, 70, PT_BEZIERTO}, /* 238 */
+ {50, 70, PT_BEZIERTO}, /* 239 */
+ {70, 70, PT_LINETO}, /* 240 */
+ {70, 70, PT_BEZIERTO}, /* 241 */
+ {70, 70, PT_BEZIERTO}, /* 242 */
+ {70, 70, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 243 */
+ {75, 75, PT_MOVETO}, /* 244 */
+ {75, 75, PT_BEZIERTO}, /* 245 */
+ {75, 75, PT_BEZIERTO}, /* 246 */
+ {75, 75, PT_BEZIERTO}, /* 247 */
+ {75, 75, PT_LINETO}, /* 248 */
+ {75, 75, PT_BEZIERTO}, /* 249 */
+ {75, 75, PT_BEZIERTO}, /* 250 */
+ {75, 75, PT_BEZIERTO}, /* 251 */
+ {75, 85, PT_LINETO}, /* 252 */
+ {75, 85, PT_BEZIERTO}, /* 253 */
+ {75, 85, PT_BEZIERTO}, /* 254 */
+ {75, 85, PT_BEZIERTO}, /* 255 */
+ {75, 85, PT_LINETO}, /* 256 */
+ {75, 85, PT_BEZIERTO}, /* 257 */
+ {75, 85, PT_BEZIERTO}, /* 258 */
+ {75, 85, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 259 */
+ {81, 81, PT_MOVETO}, /* 260 */
+ {81, 80, PT_BEZIERTO}, /* 261 */
+ {81, 80, PT_BEZIERTO}, /* 262 */
+ {81, 80, PT_BEZIERTO}, /* 263 */
+ {81, 80, PT_LINETO}, /* 264 */
+ {80, 80, PT_BEZIERTO}, /* 265 */
+ {80, 80, PT_BEZIERTO}, /* 266 */
+ {80, 81, PT_BEZIERTO}, /* 267 */
+ {80, 81, PT_LINETO}, /* 268 */
+ {80, 81, PT_BEZIERTO}, /* 269 */
+ {80, 81, PT_BEZIERTO}, /* 270 */
+ {81, 81, PT_BEZIERTO}, /* 271 */
+ {81, 81, PT_LINETO}, /* 272 */
+ {81, 81, PT_BEZIERTO}, /* 273 */
+ {81, 81, PT_BEZIERTO}, /* 274 */
+ {81, 81, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 275 */
+ {95, 85, PT_MOVETO}, /* 276 */
+ {90, 85, PT_LINETO}, /* 277 */
+ {90, 90, PT_LINETO}, /* 278 */
+ {95, 90, PT_LINETO | PT_CLOSEFIGURE}, /* 279 */
+ {40, 35, PT_MOVETO}, /* 280 */
+ {40, 38, PT_BEZIERTO}, /* 281 */
+ {38, 40, PT_BEZIERTO}, /* 282 */
+ {35, 40, PT_BEZIERTO}, /* 283 */
+ {25, 40, PT_LINETO}, /* 284 */
+ {22, 40, PT_BEZIERTO}, /* 285 */
+ {20, 38, PT_BEZIERTO}, /* 286 */
+ {20, 35, PT_BEZIERTO}, /* 287 */
+ {20, 25, PT_LINETO}, /* 288 */
+ {20, 22, PT_BEZIERTO}, /* 289 */
+ {22, 20, PT_BEZIERTO}, /* 290 */
+ {25, 20, PT_BEZIERTO}, /* 291 */
+ {35, 20, PT_LINETO}, /* 292 */
+ {38, 20, PT_BEZIERTO}, /* 293 */
+ {40, 22, PT_BEZIERTO}, /* 294 */
+ {40, 25, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 295 */
+ {55, 43, PT_MOVETO}, /* 296 */
+ {55, 47, PT_BEZIERTO}, /* 297 */
+ {49, 50, PT_BEZIERTO}, /* 298 */
+ {43, 50, PT_BEZIERTO}, /* 299 */
+ {43, 50, PT_LINETO}, /* 300 */
+ {36, 50, PT_BEZIERTO}, /* 301 */
+ {30, 47, PT_BEZIERTO}, /* 302 */
+ {30, 43, PT_BEZIERTO}, /* 303 */
+ {30, 43, PT_LINETO}, /* 304 */
+ {30, 38, PT_BEZIERTO}, /* 305 */
+ {36, 35, PT_BEZIERTO}, /* 306 */
+ {43, 35, PT_BEZIERTO}, /* 307 */
+ {43, 35, PT_LINETO}, /* 308 */
+ {49, 35, PT_BEZIERTO}, /* 309 */
+ {55, 38, PT_BEZIERTO}, /* 310 */
+ {55, 43, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 311 */
+};
+
+static void test_roundrect(void)
+{
+ HDC hdc = GetDC( 0 );
+
+ BeginPath( hdc );
+ RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
+ RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
+ RoundRect( hdc, 60, 60, 35, 45, 5, 2 );
+ RoundRect( hdc, 70, 70, 50, 70, 3, 5 );
+ RoundRect( hdc, 75, 75, 75, 85, 6, 4 );
+ RoundRect( hdc, 80, 80, 81, 81, 8, 9 );
+ RoundRect( hdc, 90, 90, 95, 85, 0, 7 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
+ RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ SetMapMode( hdc, MM_ANISOTROPIC );
+ SetViewportExtEx( hdc, -2, 2, NULL );
+ RoundRect( hdc, 20, 20, 40, 40, 15, 12 );
+ RoundRect( hdc, 30, 50, 55, 35, 7, 9 );
+ SetViewportExtEx( hdc, 3, -3, NULL );
+ RoundRect( hdc, 20, 20, 40, 40, 15, 12 );
+ RoundRect( hdc, 30, 50, 55, 35, 3, 4 );
+ SetWindowExtEx( hdc, -20, 20, NULL );
+ RoundRect( hdc, 20, 20, 40, 40, 2, 1 );
+ RoundRect( hdc, 24, 22, 21, 20, 4, 4 );
+ SetMapMode( hdc, MM_TEXT );
+ SetGraphicsMode( hdc, GM_ADVANCED );
+ RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
+ RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
+ RoundRect( hdc, 60, 60, 35, 45, 5, 2 );
+ RoundRect( hdc, 70, 70, 50, 70, 3, 5 );
+ RoundRect( hdc, 75, 75, 75, 85, 6, 4 );
+ RoundRect( hdc, 80, 80, 81, 81, 8, 9 );
+ RoundRect( hdc, 90, 90, 95, 85, 0, 7 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
+ RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ EndPath( hdc );
+ SetMapMode( hdc, MM_TEXT );
+ ok_path( hdc, "roundrect_path", roundrect_path, sizeof(roundrect_path)/sizeof(path_test_t) );
+ ReleaseDC( 0, hdc );
+}
+
+static const path_test_t ellipse_path[] =
+{
+ {39, 30, PT_MOVETO}, /* 0 */
+ {39, 24, PT_BEZIERTO}, /* 1 */
+ {35, 20, PT_BEZIERTO}, /* 2 */
+ {30, 20, PT_BEZIERTO}, /* 3 */
+ {24, 20, PT_BEZIERTO}, /* 4 */
+ {20, 24, PT_BEZIERTO}, /* 5 */
+ {20, 30, PT_BEZIERTO}, /* 6 */
+ {20, 35, PT_BEZIERTO}, /* 7 */
+ {24, 39, PT_BEZIERTO}, /* 8 */
+ {30, 39, PT_BEZIERTO}, /* 9 */
+ {35, 39, PT_BEZIERTO}, /* 10 */
+ {39, 35, PT_BEZIERTO}, /* 11 */
+ {39, 30, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 12 */
+ {54, 42, PT_MOVETO}, /* 13 */
+ {54, 38, PT_BEZIERTO}, /* 14 */
+ {49, 35, PT_BEZIERTO}, /* 15 */
+ {42, 35, PT_BEZIERTO}, /* 16 */
+ {35, 35, PT_BEZIERTO}, /* 17 */
+ {30, 38, PT_BEZIERTO}, /* 18 */
+ {30, 42, PT_BEZIERTO}, /* 19 */
+ {30, 46, PT_BEZIERTO}, /* 20 */
+ {35, 49, PT_BEZIERTO}, /* 21 */
+ {42, 49, PT_BEZIERTO}, /* 22 */
+ {49, 49, PT_BEZIERTO}, /* 23 */
+ {54, 46, PT_BEZIERTO}, /* 24 */
+ {54, 42, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 25 */
+ {59, 52, PT_MOVETO}, /* 26 */
+ {59, 48, PT_BEZIERTO}, /* 27 */
+ {54, 45, PT_BEZIERTO}, /* 28 */
+ {47, 45, PT_BEZIERTO}, /* 29 */
+ {40, 45, PT_BEZIERTO}, /* 30 */
+ {35, 48, PT_BEZIERTO}, /* 31 */
+ {35, 52, PT_BEZIERTO}, /* 32 */
+ {35, 56, PT_BEZIERTO}, /* 33 */
+ {40, 59, PT_BEZIERTO}, /* 34 */
+ {47, 59, PT_BEZIERTO}, /* 35 */
+ {54, 59, PT_BEZIERTO}, /* 36 */
+ {59, 56, PT_BEZIERTO}, /* 37 */
+ {59, 52, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 38 */
+ {80, 80, PT_MOVETO}, /* 39 */
+ {80, 80, PT_BEZIERTO}, /* 40 */
+ {80, 80, PT_BEZIERTO}, /* 41 */
+ {80, 80, PT_BEZIERTO}, /* 42 */
+ {80, 80, PT_BEZIERTO}, /* 43 */
+ {80, 80, PT_BEZIERTO}, /* 44 */
+ {80, 80, PT_BEZIERTO}, /* 45 */
+ {80, 80, PT_BEZIERTO}, /* 46 */
+ {80, 80, PT_BEZIERTO}, /* 47 */
+ {80, 80, PT_BEZIERTO}, /* 48 */
+ {80, 80, PT_BEZIERTO}, /* 49 */
+ {80, 80, PT_BEZIERTO}, /* 50 */
+ {80, 80, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 51 */
+ {39, 30, PT_MOVETO}, /* 52 */
+ {39, 35, PT_BEZIERTO}, /* 53 */
+ {35, 39, PT_BEZIERTO}, /* 54 */
+ {30, 39, PT_BEZIERTO}, /* 55 */
+ {24, 39, PT_BEZIERTO}, /* 56 */
+ {20, 35, PT_BEZIERTO}, /* 57 */
+ {20, 30, PT_BEZIERTO}, /* 58 */
+ {20, 24, PT_BEZIERTO}, /* 59 */
+ {24, 20, PT_BEZIERTO}, /* 60 */
+ {30, 20, PT_BEZIERTO}, /* 61 */
+ {35, 20, PT_BEZIERTO}, /* 62 */
+ {39, 24, PT_BEZIERTO}, /* 63 */
+ {39, 30, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 64 */
+ {54, 42, PT_MOVETO}, /* 65 */
+ {54, 46, PT_BEZIERTO}, /* 66 */
+ {49, 49, PT_BEZIERTO}, /* 67 */
+ {42, 49, PT_BEZIERTO}, /* 68 */
+ {35, 49, PT_BEZIERTO}, /* 69 */
+ {30, 46, PT_BEZIERTO}, /* 70 */
+ {30, 42, PT_BEZIERTO}, /* 71 */
+ {30, 38, PT_BEZIERTO}, /* 72 */
+ {35, 35, PT_BEZIERTO}, /* 73 */
+ {42, 35, PT_BEZIERTO}, /* 74 */
+ {49, 35, PT_BEZIERTO}, /* 75 */
+ {54, 38, PT_BEZIERTO}, /* 76 */
+ {54, 42, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 77 */
+ {59, 52, PT_MOVETO}, /* 78 */
+ {59, 56, PT_BEZIERTO}, /* 79 */
+ {54, 59, PT_BEZIERTO}, /* 80 */
+ {47, 59, PT_BEZIERTO}, /* 81 */
+ {40, 59, PT_BEZIERTO}, /* 82 */
+ {35, 56, PT_BEZIERTO}, /* 83 */
+ {35, 52, PT_BEZIERTO}, /* 84 */
+ {35, 48, PT_BEZIERTO}, /* 85 */
+ {40, 45, PT_BEZIERTO}, /* 86 */
+ {47, 45, PT_BEZIERTO}, /* 87 */
+ {54, 45, PT_BEZIERTO}, /* 88 */
+ {59, 48, PT_BEZIERTO}, /* 89 */
+ {59, 52, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 90 */
+ {80, 80, PT_MOVETO}, /* 91 */
+ {80, 80, PT_BEZIERTO}, /* 92 */
+ {80, 80, PT_BEZIERTO}, /* 93 */
+ {80, 80, PT_BEZIERTO}, /* 94 */
+ {80, 80, PT_BEZIERTO}, /* 95 */
+ {80, 80, PT_BEZIERTO}, /* 96 */
+ {80, 80, PT_BEZIERTO}, /* 97 */
+ {80, 80, PT_BEZIERTO}, /* 98 */
+ {80, 80, PT_BEZIERTO}, /* 99 */
+ {80, 80, PT_BEZIERTO}, /* 100 */
+ {80, 80, PT_BEZIERTO}, /* 101 */
+ {80, 80, PT_BEZIERTO}, /* 102 */
+ {80, 80, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 103 */
+ {-41, 60, PT_MOVETO}, /* 104 */
+ {-41, 49, PT_BEZIERTO}, /* 105 */
+ {-50, 40, PT_BEZIERTO}, /* 106 */
+ {-60, 40, PT_BEZIERTO}, /* 107 */
+ {-71, 40, PT_BEZIERTO}, /* 108 */
+ {-80, 49, PT_BEZIERTO}, /* 109 */
+ {-80, 60, PT_BEZIERTO}, /* 110 */
+ {-80, 70, PT_BEZIERTO}, /* 111 */
+ {-71, 79, PT_BEZIERTO}, /* 112 */
+ {-60, 79, PT_BEZIERTO}, /* 113 */
+ {-50, 79, PT_BEZIERTO}, /* 114 */
+ {-41, 70, PT_BEZIERTO}, /* 115 */
+ {-41, 60, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 116 */
+ {-61, 85, PT_MOVETO}, /* 117 */
+ {-61, 77, PT_BEZIERTO}, /* 118 */
+ {-72, 70, PT_BEZIERTO}, /* 119 */
+ {-85, 70, PT_BEZIERTO}, /* 120 */
+ {-99, 70, PT_BEZIERTO}, /* 121 */
+ {-110, 77, PT_BEZIERTO}, /* 122 */
+ {-110, 85, PT_BEZIERTO}, /* 123 */
+ {-110, 93, PT_BEZIERTO}, /* 124 */
+ {-99, 99, PT_BEZIERTO}, /* 125 */
+ {-85, 99, PT_BEZIERTO}, /* 126 */
+ {-72, 99, PT_BEZIERTO}, /* 127 */
+ {-61, 93, PT_BEZIERTO}, /* 128 */
+ {-61, 85, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 129 */
+ {119, -90, PT_MOVETO}, /* 130 */
+ {119, -107, PT_BEZIERTO}, /* 131 */
+ {106, -120, PT_BEZIERTO}, /* 132 */
+ {90, -120, PT_BEZIERTO}, /* 133 */
+ {73, -120, PT_BEZIERTO}, /* 134 */
+ {60, -107, PT_BEZIERTO}, /* 135 */
+ {60, -90, PT_BEZIERTO}, /* 136 */
+ {60, -74, PT_BEZIERTO}, /* 137 */
+ {73, -61, PT_BEZIERTO}, /* 138 */
+ {90, -61, PT_BEZIERTO}, /* 139 */
+ {106, -61, PT_BEZIERTO}, /* 140 */
+ {119, -74, PT_BEZIERTO}, /* 141 */
+ {119, -90, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 142 */
+ {164, -128, PT_MOVETO}, /* 143 */
+ {164, -140, PT_BEZIERTO}, /* 144 */
+ {147, -150, PT_BEZIERTO}, /* 145 */
+ {127, -150, PT_BEZIERTO}, /* 146 */
+ {107, -150, PT_BEZIERTO}, /* 147 */
+ {90, -140, PT_BEZIERTO}, /* 148 */
+ {90, -128, PT_BEZIERTO}, /* 149 */
+ {90, -116, PT_BEZIERTO}, /* 150 */
+ {107, -106, PT_BEZIERTO}, /* 151 */
+ {127, -106, PT_BEZIERTO}, /* 152 */
+ {147, -106, PT_BEZIERTO}, /* 153 */
+ {164, -116, PT_BEZIERTO}, /* 154 */
+ {164, -128, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 155 */
+ {-4, -5, PT_MOVETO}, /* 156 */
+ {-4, -5, PT_BEZIERTO}, /* 157 */
+ {-4, -6, PT_BEZIERTO}, /* 158 */
+ {-5, -6, PT_BEZIERTO}, /* 159 */
+ {-6, -6, PT_BEZIERTO}, /* 160 */
+ {-6, -5, PT_BEZIERTO}, /* 161 */
+ {-6, -5, PT_BEZIERTO}, /* 162 */
+ {-6, -4, PT_BEZIERTO}, /* 163 */
+ {-6, -4, PT_BEZIERTO}, /* 164 */
+ {-5, -4, PT_BEZIERTO}, /* 165 */
+ {-4, -4, PT_BEZIERTO}, /* 166 */
+ {-4, -4, PT_BEZIERTO}, /* 167 */
+ {-4, -5, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 168 */
+ {40, 30, PT_MOVETO}, /* 169 */
+ {40, 25, PT_BEZIERTO}, /* 170 */
+ {36, 20, PT_BEZIERTO}, /* 171 */
+ {30, 20, PT_BEZIERTO}, /* 172 */
+ {24, 20, PT_BEZIERTO}, /* 173 */
+ {20, 25, PT_BEZIERTO}, /* 174 */
+ {20, 30, PT_BEZIERTO}, /* 175 */
+ {20, 36, PT_BEZIERTO}, /* 176 */
+ {24, 40, PT_BEZIERTO}, /* 177 */
+ {30, 40, PT_BEZIERTO}, /* 178 */
+ {36, 40, PT_BEZIERTO}, /* 179 */
+ {40, 36, PT_BEZIERTO}, /* 180 */
+ {40, 30, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 181 */
+ {55, 43, PT_MOVETO}, /* 182 */
+ {55, 38, PT_BEZIERTO}, /* 183 */
+ {49, 35, PT_BEZIERTO}, /* 184 */
+ {43, 35, PT_BEZIERTO}, /* 185 */
+ {36, 35, PT_BEZIERTO}, /* 186 */
+ {30, 38, PT_BEZIERTO}, /* 187 */
+ {30, 43, PT_BEZIERTO}, /* 188 */
+ {30, 47, PT_BEZIERTO}, /* 189 */
+ {36, 50, PT_BEZIERTO}, /* 190 */
+ {43, 50, PT_BEZIERTO}, /* 191 */
+ {49, 50, PT_BEZIERTO}, /* 192 */
+ {55, 47, PT_BEZIERTO}, /* 193 */
+ {55, 43, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 194 */
+ {60, 53, PT_MOVETO}, /* 195 */
+ {60, 48, PT_BEZIERTO}, /* 196 */
+ {54, 45, PT_BEZIERTO}, /* 197 */
+ {48, 45, PT_BEZIERTO}, /* 198 */
+ {41, 45, PT_BEZIERTO}, /* 199 */
+ {35, 48, PT_BEZIERTO}, /* 200 */
+ {35, 53, PT_BEZIERTO}, /* 201 */
+ {35, 57, PT_BEZIERTO}, /* 202 */
+ {41, 60, PT_BEZIERTO}, /* 203 */
+ {48, 60, PT_BEZIERTO}, /* 204 */
+ {54, 60, PT_BEZIERTO}, /* 205 */
+ {60, 57, PT_BEZIERTO}, /* 206 */
+ {60, 53, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 207 */
+ {70, 70, PT_MOVETO}, /* 208 */
+ {70, 70, PT_BEZIERTO}, /* 209 */
+ {66, 70, PT_BEZIERTO}, /* 210 */
+ {60, 70, PT_BEZIERTO}, /* 211 */
+ {54, 70, PT_BEZIERTO}, /* 212 */
+ {50, 70, PT_BEZIERTO}, /* 213 */
+ {50, 70, PT_BEZIERTO}, /* 214 */
+ {50, 70, PT_BEZIERTO}, /* 215 */
+ {54, 70, PT_BEZIERTO}, /* 216 */
+ {60, 70, PT_BEZIERTO}, /* 217 */
+ {66, 70, PT_BEZIERTO}, /* 218 */
+ {70, 70, PT_BEZIERTO}, /* 219 */
+ {70, 70, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 220 */
+ {75, 80, PT_MOVETO}, /* 221 */
+ {75, 77, PT_BEZIERTO}, /* 222 */
+ {75, 75, PT_BEZIERTO}, /* 223 */
+ {75, 75, PT_BEZIERTO}, /* 224 */
+ {75, 75, PT_BEZIERTO}, /* 225 */
+ {75, 77, PT_BEZIERTO}, /* 226 */
+ {75, 80, PT_BEZIERTO}, /* 227 */
+ {75, 83, PT_BEZIERTO}, /* 228 */
+ {75, 85, PT_BEZIERTO}, /* 229 */
+ {75, 85, PT_BEZIERTO}, /* 230 */
+ {75, 85, PT_BEZIERTO}, /* 231 */
+ {75, 83, PT_BEZIERTO}, /* 232 */
+ {75, 80, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 233 */
+ {81, 81, PT_MOVETO}, /* 234 */
+ {81, 80, PT_BEZIERTO}, /* 235 */
+ {81, 80, PT_BEZIERTO}, /* 236 */
+ {81, 80, PT_BEZIERTO}, /* 237 */
+ {80, 80, PT_BEZIERTO}, /* 238 */
+ {80, 80, PT_BEZIERTO}, /* 239 */
+ {80, 81, PT_BEZIERTO}, /* 240 */
+ {80, 81, PT_BEZIERTO}, /* 241 */
+ {80, 81, PT_BEZIERTO}, /* 242 */
+ {81, 81, PT_BEZIERTO}, /* 243 */
+ {81, 81, PT_BEZIERTO}, /* 244 */
+ {81, 81, PT_BEZIERTO}, /* 245 */
+ {81, 81, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 246 */
+ {40, 30, PT_MOVETO}, /* 247 */
+ {40, 36, PT_BEZIERTO}, /* 248 */
+ {36, 40, PT_BEZIERTO}, /* 249 */
+ {30, 40, PT_BEZIERTO}, /* 250 */
+ {24, 40, PT_BEZIERTO}, /* 251 */
+ {20, 36, PT_BEZIERTO}, /* 252 */
+ {20, 30, PT_BEZIERTO}, /* 253 */
+ {20, 24, PT_BEZIERTO}, /* 254 */
+ {24, 20, PT_BEZIERTO}, /* 255 */
+ {30, 20, PT_BEZIERTO}, /* 256 */
+ {36, 20, PT_BEZIERTO}, /* 257 */
+ {40, 24, PT_BEZIERTO}, /* 258 */
+ {40, 30, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 259 */
+ {55, 43, PT_MOVETO}, /* 260 */
+ {55, 47, PT_BEZIERTO}, /* 261 */
+ {49, 50, PT_BEZIERTO}, /* 262 */
+ {43, 50, PT_BEZIERTO}, /* 263 */
+ {36, 50, PT_BEZIERTO}, /* 264 */
+ {30, 47, PT_BEZIERTO}, /* 265 */
+ {30, 43, PT_BEZIERTO}, /* 266 */
+ {30, 38, PT_BEZIERTO}, /* 267 */
+ {36, 35, PT_BEZIERTO}, /* 268 */
+ {43, 35, PT_BEZIERTO}, /* 269 */
+ {49, 35, PT_BEZIERTO}, /* 270 */
+ {55, 38, PT_BEZIERTO}, /* 271 */
+ {55, 43, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 272 */
+ {60, 53, PT_MOVETO}, /* 273 */
+ {60, 57, PT_BEZIERTO}, /* 274 */
+ {54, 60, PT_BEZIERTO}, /* 275 */
+ {48, 60, PT_BEZIERTO}, /* 276 */
+ {41, 60, PT_BEZIERTO}, /* 277 */
+ {35, 57, PT_BEZIERTO}, /* 278 */
+ {35, 53, PT_BEZIERTO}, /* 279 */
+ {35, 48, PT_BEZIERTO}, /* 280 */
+ {41, 45, PT_BEZIERTO}, /* 281 */
+ {48, 45, PT_BEZIERTO}, /* 282 */
+ {54, 45, PT_BEZIERTO}, /* 283 */
+ {60, 48, PT_BEZIERTO}, /* 284 */
+ {60, 53, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 285 */
+ {70, 70, PT_MOVETO}, /* 286 */
+ {70, 70, PT_BEZIERTO}, /* 287 */
+ {66, 70, PT_BEZIERTO}, /* 288 */
+ {60, 70, PT_BEZIERTO}, /* 289 */
+ {54, 70, PT_BEZIERTO}, /* 290 */
+ {50, 70, PT_BEZIERTO}, /* 291 */
+ {50, 70, PT_BEZIERTO}, /* 292 */
+ {50, 70, PT_BEZIERTO}, /* 293 */
+ {54, 70, PT_BEZIERTO}, /* 294 */
+ {60, 70, PT_BEZIERTO}, /* 295 */
+ {66, 70, PT_BEZIERTO}, /* 296 */
+ {70, 70, PT_BEZIERTO}, /* 297 */
+ {70, 70, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 298 */
+ {75, 80, PT_MOVETO}, /* 299 */
+ {75, 83, PT_BEZIERTO}, /* 300 */
+ {75, 85, PT_BEZIERTO}, /* 301 */
+ {75, 85, PT_BEZIERTO}, /* 302 */
+ {75, 85, PT_BEZIERTO}, /* 303 */
+ {75, 83, PT_BEZIERTO}, /* 304 */
+ {75, 80, PT_BEZIERTO}, /* 305 */
+ {75, 77, PT_BEZIERTO}, /* 306 */
+ {75, 75, PT_BEZIERTO}, /* 307 */
+ {75, 75, PT_BEZIERTO}, /* 308 */
+ {75, 75, PT_BEZIERTO}, /* 309 */
+ {75, 77, PT_BEZIERTO}, /* 310 */
+ {75, 80, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 311 */
+ {81, 81, PT_MOVETO}, /* 312 */
+ {81, 81, PT_BEZIERTO}, /* 313 */
+ {81, 81, PT_BEZIERTO}, /* 314 */
+ {81, 81, PT_BEZIERTO}, /* 315 */
+ {80, 81, PT_BEZIERTO}, /* 316 */
+ {80, 81, PT_BEZIERTO}, /* 317 */
+ {80, 81, PT_BEZIERTO}, /* 318 */
+ {80, 80, PT_BEZIERTO}, /* 319 */
+ {80, 80, PT_BEZIERTO}, /* 320 */
+ {81, 80, PT_BEZIERTO}, /* 321 */
+ {81, 80, PT_BEZIERTO}, /* 322 */
+ {81, 80, PT_BEZIERTO}, /* 323 */
+ {81, 81, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 324 */
+};
+
+static void test_ellipse(void)
+{
+ HDC hdc = GetDC( 0 );
+
+ BeginPath( hdc );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ Ellipse( hdc, 60, 60, 35, 45 );
+ Ellipse( hdc, 70, 70, 50, 70 );
+ Ellipse( hdc, 75, 75, 75, 85 );
+ Ellipse( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ Ellipse( hdc, 60, 60, 35, 45 );
+ Ellipse( hdc, 70, 70, 50, 70 );
+ Ellipse( hdc, 75, 75, 75, 85 );
+ Ellipse( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ SetMapMode( hdc, MM_ANISOTROPIC );
+ SetViewportExtEx( hdc, -2, 2, NULL );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ SetViewportExtEx( hdc, 3, -3, NULL );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ SetWindowExtEx( hdc, -20, 20, NULL );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 24, 22, 21, 20 );
+ SetMapMode( hdc, MM_TEXT );
+ SetGraphicsMode( hdc, GM_ADVANCED );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ Ellipse( hdc, 60, 60, 35, 45 );
+ Ellipse( hdc, 70, 70, 50, 70 );
+ Ellipse( hdc, 75, 75, 75, 85 );
+ Ellipse( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_CLOCKWISE );
+ Ellipse( hdc, 20, 20, 40, 40 );
+ Ellipse( hdc, 30, 50, 55, 35 );
+ Ellipse( hdc, 60, 60, 35, 45 );
+ Ellipse( hdc, 70, 70, 50, 70 );
+ Ellipse( hdc, 75, 75, 75, 85 );
+ Ellipse( hdc, 80, 80, 81, 81 );
+ SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
+ EndPath( hdc );
+ SetMapMode( hdc, MM_TEXT );
+ ok_path( hdc, "ellipse_path", ellipse_path, sizeof(ellipse_path)/sizeof(path_test_t) );
+}
+
+static const path_test_t all_funcs_path[] =
+{
+ {0, 0, PT_MOVETO}, /* 0 */
+ {50, 150, PT_LINETO}, /* 1 */
+ {50, 50, PT_MOVETO}, /* 2 */
+ {150, 150, PT_LINETO}, /* 3 */
+ {150, 50, PT_LINETO}, /* 4 */
+ {50, 50, PT_LINETO}, /* 5 */
+ {37, 13, PT_LINETO}, /* 6 */
+ {24, 13, PT_BEZIERTO}, /* 7 */
+ {14, 23, PT_BEZIERTO}, /* 8 */
+ {14, 36, PT_BEZIERTO}, /* 9 */
+ {14, 49, PT_BEZIERTO}, /* 10 */
+ {24, 59, PT_BEZIERTO}, /* 11 */
+ {37, 59, PT_BEZIERTO}, /* 12 */
+ {37, 59, PT_BEZIERTO}, /* 13 */
+ {37, 59, PT_BEZIERTO}, /* 14 */
+ {37, 59, PT_BEZIERTO}, /* 15 */
+ {10, 10, PT_MOVETO}, /* 16 */
+ {20, 10, PT_LINETO}, /* 17 */
+ {10, 20, PT_LINETO}, /* 18 */
+ {20, 20, PT_LINETO}, /* 19 */
+ {36, 27, PT_MOVETO}, /* 20 */
+ {37, 26, PT_BEZIERTO}, /* 21 */
+ {38, 25, PT_BEZIERTO}, /* 22 */
+ {38, 25, PT_BEZIERTO}, /* 23 */
+ {38, 23, PT_BEZIERTO}, /* 24 */
+ {34, 21, PT_BEZIERTO}, /* 25 */
+ {30, 21, PT_BEZIERTO}, /* 26 */
+ {27, 21, PT_BEZIERTO}, /* 27 */
+ {25, 21, PT_BEZIERTO}, /* 28 */
+ {24, 22, PT_BEZIERTO}, /* 29 */
+ {37, 59, PT_MOVETO}, /* 30 */
+ {10, 10, PT_LINETO}, /* 31 */
+ {20, 10, PT_LINETO}, /* 32 */
+ {10, 20, PT_LINETO}, /* 33 */
+ {20, 20, PT_LINETO}, /* 34 */
+ {34, 26, PT_LINETO}, /* 35 */
+ {35, 25, PT_BEZIERTO}, /* 36 */
+ {36, 25, PT_BEZIERTO}, /* 37 */
+ {36, 25, PT_BEZIERTO}, /* 38 */
+ {36, 24, PT_BEZIERTO}, /* 39 */
+ {33, 23, PT_BEZIERTO}, /* 40 */
+ {30, 23, PT_BEZIERTO}, /* 41 */
+ {28, 23, PT_BEZIERTO}, /* 42 */
+ {26, 23, PT_BEZIERTO}, /* 43 */
+ {25, 23, PT_BEZIERTO}, /* 44 */
+ {10, 10, PT_MOVETO}, /* 45 */
+ {20, 10, PT_LINETO}, /* 46 */
+ {10, 20, PT_LINETO}, /* 47 */
+ {20, 20, PT_LINETO}, /* 48 */
+ {30, 30, PT_MOVETO}, /* 49 */
+ {40, 20, PT_LINETO}, /* 50 */
+ {20, 30, PT_LINETO}, /* 51 */
+ {30, 40, PT_LINETO}, /* 52 */
+ {10, 50, PT_LINETO}, /* 53 */
+ {45, 45, PT_MOVETO}, /* 54 */
+ {45, 45, PT_BEZIERTO}, /* 55 */
+ {44, 46, PT_BEZIERTO}, /* 56 */
+ {43, 47, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 57 */
+ {10, 10, PT_MOVETO}, /* 58 */
+ {20, 10, PT_LINETO}, /* 59 */
+ {10, 20, PT_BEZIERTO}, /* 60 */
+ {20, 20, PT_BEZIERTO}, /* 61 */
+ {30, 30, PT_BEZIERTO}, /* 62 */
+ {40, 20, PT_LINETO}, /* 63 */
+ {20, 30, PT_LINETO | PT_CLOSEFIGURE}, /* 64 */
+ {30, 40, PT_MOVETO}, /* 65 */
+ {10, 50, PT_LINETO}, /* 66 */
+ {55, 55, PT_MOVETO}, /* 67 */
+ {54, 55, PT_BEZIERTO}, /* 68 */
+ {54, 56, PT_BEZIERTO}, /* 69 */
+ {54, 56, PT_BEZIERTO}, /* 70 */
+ {58, 61, PT_LINETO | PT_CLOSEFIGURE}, /* 71 */
+ {10, 10, PT_MOVETO}, /* 72 */
+ {20, 10, PT_LINETO}, /* 73 */
+ {10, 20, PT_LINETO}, /* 74 */
+ {20, 20, PT_LINETO}, /* 75 */
+ {30, 30, PT_LINETO}, /* 76 */
+ {40, 20, PT_LINETO}, /* 77 */
+ {20, 30, PT_LINETO}, /* 78 */
+ {30, 40, PT_LINETO}, /* 79 */
+ {10, 50, PT_LINETO | PT_CLOSEFIGURE}, /* 80 */
+ {43, 49, PT_MOVETO}, /* 81 */
+ {43, 40, PT_BEZIERTO}, /* 82 */
+ {38, 33, PT_BEZIERTO}, /* 83 */
+ {33, 33, PT_BEZIERTO}, /* 84 */
+ {27, 33, PT_BEZIERTO}, /* 85 */
+ {22, 40, PT_BEZIERTO}, /* 86 */
+ {22, 49, PT_BEZIERTO}, /* 87 */
+ {22, 58, PT_BEZIERTO}, /* 88 */
+ {27, 65, PT_BEZIERTO}, /* 89 */
+ {33, 65, PT_BEZIERTO}, /* 90 */
+ {38, 65, PT_BEZIERTO}, /* 91 */
+ {43, 58, PT_BEZIERTO}, /* 92 */
+ {43, 49, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 93 */
+ {79, 70, PT_MOVETO}, /* 94 */
+ {60, 70, PT_LINETO}, /* 95 */
+ {60, 89, PT_LINETO}, /* 96 */
+ {79, 89, PT_LINETO | PT_CLOSEFIGURE}, /* 97 */
+ {199, 122, PT_MOVETO}, /* 98 */
+ {199, 110, PT_BEZIERTO}, /* 99 */
+ {191, 100, PT_BEZIERTO}, /* 100 */
+ {182, 100, PT_BEZIERTO}, /* 101 */
+ {117, 100, PT_LINETO}, /* 102 */
+ {108, 100, PT_BEZIERTO}, /* 103 */
+ {100, 110, PT_BEZIERTO}, /* 104 */
+ {100, 122, PT_BEZIERTO}, /* 105 */
+ {100, 177, PT_LINETO}, /* 106 */
+ {100, 189, PT_BEZIERTO}, /* 107 */
+ {108, 199, PT_BEZIERTO}, /* 108 */
+ {117, 199, PT_BEZIERTO}, /* 109 */
+ {182, 199, PT_LINETO}, /* 110 */
+ {191, 199, PT_BEZIERTO}, /* 111 */
+ {199, 189, PT_BEZIERTO}, /* 112 */
+ {199, 177, PT_BEZIERTO | PT_CLOSEFIGURE}, /* 113 */
+ {10, 10, PT_MOVETO}, /* 114 */
+ {20, 10, PT_BEZIERTO}, /* 115 */
+ {10, 20, PT_BEZIERTO}, /* 116 */
+ {20, 20, PT_BEZIERTO}, /* 117 */
+ {30, 30, PT_BEZIERTO}, /* 118 */
+ {40, 20, PT_BEZIERTO}, /* 119 */
+ {20, 30, PT_BEZIERTO}, /* 120 */
+ {10, 10, PT_MOVETO}, /* 121 */
+ {20, 10, PT_LINETO}, /* 122 */
+ {10, 20, PT_LINETO}, /* 123 */
+ {20, 20, PT_LINETO | PT_CLOSEFIGURE}, /* 124 */
+ {30, 30, PT_MOVETO}, /* 125 */
+ {40, 20, PT_LINETO}, /* 126 */
+ {20, 30, PT_LINETO}, /* 127 */
+ {30, 40, PT_LINETO}, /* 128 */
+ {10, 50, PT_LINETO | PT_CLOSEFIGURE}, /* 129 */
+ {10, 50, PT_MOVETO}, /* 130 */
+ {10, 10, PT_BEZIERTO}, /* 131 */
+ {20, 10, PT_BEZIERTO}, /* 132 */
+ {10, 20, PT_BEZIERTO}, /* 133 */
+ {20, 20, PT_BEZIERTO}, /* 134 */
+ {30, 30, PT_BEZIERTO}, /* 135 */
+ {40, 20, PT_BEZIERTO}, /* 136 */
+ {20, 30, PT_BEZIERTO}, /* 137 */
+ {30, 40, PT_BEZIERTO}, /* 138 */
+ {10, 50, PT_BEZIERTO}, /* 139 */
+ {150, 150, PT_LINETO}, /* 140 */
+};
+
+/* run once through all functions that support paths */
+static void test_all_functions(void)
+{
+ POINT pts[9] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}, {30, 30}, {40, 20},
+ {20, 30}, {30, 40}, {10, 50}};
+ DWORD counts[5] = {4, 5, 0, 1, 2};
+ BYTE types[9] = { PT_MOVETO, PT_LINETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO, PT_LINETO,
+ PT_LINETO | PT_CLOSEFIGURE, PT_MOVETO, PT_LINETO };
+ HDC hdc = GetDC( 0 );
+
+ BeginPath( hdc );
+ LineTo( hdc, 50, 150 );
+ MoveToEx( hdc, 50, 50, NULL );
+ LineTo( hdc, 150, 150 );
+ LineTo( hdc, 150, 50 );
+ LineTo( hdc, 50, 50 );
+ AngleArc( hdc, 37, 36, 23, 90, 180 );
+ Polyline( hdc, pts, 4 );
+ Arc( hdc, 21, 21, 39, 29, 39, 29, 21, 21 );
+ PolylineTo( hdc, pts, 4 );
+ ArcTo( hdc, 23, 23, 37, 27, 37, 27, 23, 23 );
+ PolyPolyline( hdc, pts, counts, 2 );
+ Chord( hdc, 42, 43, 57, 66, 39, 29, 21, 21 );
+ PolyDraw( hdc, pts, types, 9 );
+ Pie( hdc, 52, 54, 65, 68, 39, 29, 21, 21 );
+ Polygon( hdc, pts, 9 );
+ Ellipse( hdc, 22, 33, 44, 66 );
+ Rectangle( hdc, 60, 70, 80, 90 );
+ RoundRect( hdc, 100, 100, 200, 200, 35, 45 );
+ PolyBezier( hdc, pts, 7 );
+ PolyPolygon( hdc, pts, (int *)counts, 2 );
+ PolyBezierTo( hdc, pts, 9 );
+ LineTo( hdc, 150, 150 );
+ /* FIXME: ExtTextOut */
+ EndPath( hdc );
+ ok_path( hdc, "all_funcs_path", all_funcs_path, sizeof(all_funcs_path)/sizeof(path_test_t) );
+ ReleaseDC( 0, hdc );
+}
+
START_TEST(path)
{
test_path_state();
test_polydraw();
test_closefigure();
test_linedda();
+ test_rectangle();
+ test_roundrect();
+ test_ellipse();
+ test_all_functions();
}