2 * Unit test suite for paths
4 * Copyright 2007 Laurent Vromman
5 * Copyright 2007 Misha Koshelev
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "wine/test.h"
34 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
36 static void test_path_state(void)
38 BYTE buffer
[sizeof(BITMAPINFO
) + 256 * sizeof(RGBQUAD
)];
39 BITMAPINFO
*bi
= (BITMAPINFO
*)buffer
;
46 hdc
= CreateCompatibleDC( 0 );
47 memset( buffer
, 0, sizeof(buffer
) );
48 bi
->bmiHeader
.biSize
= sizeof(bi
->bmiHeader
);
49 bi
->bmiHeader
.biHeight
= 256;
50 bi
->bmiHeader
.biWidth
= 256;
51 bi
->bmiHeader
.biBitCount
= 32;
52 bi
->bmiHeader
.biPlanes
= 1;
53 bi
->bmiHeader
.biCompression
= BI_RGB
;
54 dib
= CreateDIBSection( 0, bi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0 );
55 orig
= SelectObject( hdc
, dib
);
58 LineTo( hdc
, 100, 100 );
59 ret
= WidenPath( hdc
);
60 ok( !ret
, "WidenPath succeeded\n" );
62 /* selecting another bitmap doesn't affect the path */
63 SelectObject( hdc
, orig
);
64 ret
= WidenPath( hdc
);
65 ok( !ret
, "WidenPath succeeded\n" );
67 SelectObject( hdc
, dib
);
68 ret
= WidenPath( hdc
);
69 ok( !ret
, "WidenPath succeeded\n" );
72 ok( ret
, "EndPath failed error %u\n", GetLastError() );
73 ret
= WidenPath( hdc
);
74 ok( ret
, "WidenPath failed error %u\n", GetLastError() );
76 SelectObject( hdc
, orig
);
77 ret
= WidenPath( hdc
);
78 ok( ret
, "WidenPath failed error %u\n", GetLastError() );
81 LineTo( hdc
, 100, 100 );
82 ret
= WidenPath( hdc
);
83 ok( !ret
, "WidenPath succeeded\n" );
85 SelectObject( hdc
, dib
);
87 ok( ret
, "EndPath failed error %u\n", GetLastError() );
88 ret
= WidenPath( hdc
);
89 ok( ret
, "WidenPath failed error %u\n", GetLastError() );
91 /* path should be open again after RestoreDC */
93 ret
= WidenPath( hdc
);
94 ok( !ret
, "WidenPath succeeded\n" );
96 ok( ret
, "EndPath failed error %u\n", GetLastError() );
100 RestoreDC( hdc
, -1 );
101 ret
= WidenPath( hdc
);
102 ok( ret
, "WidenPath failed error %u\n", GetLastError() );
104 /* test all functions with no path at all */
106 SetLastError( 0xdeadbeef );
107 ret
= WidenPath( hdc
);
108 ok( !ret
, "WidenPath succeeded\n" );
109 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
110 "wrong error %u\n", GetLastError() );
112 SetLastError( 0xdeadbeef );
113 ret
= FlattenPath( hdc
);
114 ok( !ret
, "FlattenPath succeeded\n" );
115 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
116 "wrong error %u\n", GetLastError() );
118 SetLastError( 0xdeadbeef );
119 ret
= StrokePath( hdc
);
120 ok( !ret
, "StrokePath succeeded\n" );
121 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
122 "wrong error %u\n", GetLastError() );
124 SetLastError( 0xdeadbeef );
125 ret
= FillPath( hdc
);
126 ok( !ret
, "FillPath succeeded\n" );
127 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
128 "wrong error %u\n", GetLastError() );
130 SetLastError( 0xdeadbeef );
131 ret
= StrokeAndFillPath( hdc
);
132 ok( !ret
, "StrokeAndFillPath succeeded\n" );
133 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
134 "wrong error %u\n", GetLastError() );
136 SetLastError( 0xdeadbeef );
137 ret
= SelectClipPath( hdc
, RGN_OR
);
138 ok( !ret
, "SelectClipPath succeeded\n" );
139 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
140 "wrong error %u\n", GetLastError() );
142 SetLastError( 0xdeadbeef );
143 rgn
= PathToRegion( hdc
);
144 ok( !rgn
, "PathToRegion succeeded\n" );
145 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
146 "wrong error %u\n", GetLastError() );
148 SetLastError( 0xdeadbeef );
149 ret
= EndPath( hdc
);
150 ok( !ret
, "SelectClipPath succeeded\n" );
151 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
152 "wrong error %u\n", GetLastError() );
154 SetLastError( 0xdeadbeef );
155 ret
= CloseFigure( hdc
);
156 ok( !ret
, "CloseFigure succeeded\n" );
157 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
158 "wrong error %u\n", GetLastError() );
160 /* test all functions with an open path */
163 SetLastError( 0xdeadbeef );
164 ret
= WidenPath( hdc
);
165 ok( !ret
, "WidenPath succeeded\n" );
166 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
167 "wrong error %u\n", GetLastError() );
171 SetLastError( 0xdeadbeef );
172 ret
= FlattenPath( hdc
);
173 ok( !ret
, "FlattenPath succeeded\n" );
174 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
175 "wrong error %u\n", GetLastError() );
179 SetLastError( 0xdeadbeef );
180 ret
= StrokePath( hdc
);
181 ok( !ret
, "StrokePath succeeded\n" );
182 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
183 "wrong error %u\n", GetLastError() );
187 SetLastError( 0xdeadbeef );
188 ret
= FillPath( hdc
);
189 ok( !ret
, "FillPath succeeded\n" );
190 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
191 "wrong error %u\n", GetLastError() );
195 SetLastError( 0xdeadbeef );
196 ret
= StrokeAndFillPath( hdc
);
197 ok( !ret
, "StrokeAndFillPath succeeded\n" );
198 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
199 "wrong error %u\n", GetLastError() );
203 Rectangle( hdc
, 1, 1, 10, 10 ); /* region needs some contents */
204 SetLastError( 0xdeadbeef );
205 ret
= SelectClipPath( hdc
, RGN_OR
);
206 ok( !ret
, "SelectClipPath succeeded\n" );
207 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
208 "wrong error %u\n", GetLastError() );
212 Rectangle( hdc
, 1, 1, 10, 10 ); /* region needs some contents */
213 SetLastError( 0xdeadbeef );
214 rgn
= PathToRegion( hdc
);
215 ok( !rgn
, "PathToRegion succeeded\n" );
216 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
217 "wrong error %u\n", GetLastError() );
221 ret
= CloseFigure( hdc
);
222 ok( ret
, "CloseFigure failed\n" );
224 /* test all functions with a closed path */
228 ret
= WidenPath( hdc
);
229 ok( ret
, "WidenPath failed\n" );
230 ok( GetPath( hdc
, NULL
, NULL
, 0 ) != -1, "path deleted\n" );
235 ret
= FlattenPath( hdc
);
236 ok( ret
, "FlattenPath failed\n" );
237 ok( GetPath( hdc
, NULL
, NULL
, 0 ) != -1, "path deleted\n" );
242 ret
= StrokePath( hdc
);
243 ok( ret
, "StrokePath failed\n" );
244 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
248 ret
= FillPath( hdc
);
249 ok( ret
, "FillPath failed\n" );
250 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
254 ret
= StrokeAndFillPath( hdc
);
255 ok( ret
, "StrokeAndFillPath failed\n" );
256 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
259 Rectangle( hdc
, 1, 1, 10, 10 ); /* region needs some contents */
261 ret
= SelectClipPath( hdc
, RGN_OR
);
262 ok( ret
, "SelectClipPath failed\n" );
263 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
267 SetLastError( 0xdeadbeef );
268 ret
= SelectClipPath( hdc
, RGN_OR
);
269 ok( !ret
, "SelectClipPath succeeded on empty path\n" );
270 ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
271 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
274 Rectangle( hdc
, 1, 1, 10, 10 ); /* region needs some contents */
276 rgn
= PathToRegion( hdc
);
277 ok( rgn
!= 0, "PathToRegion failed\n" );
279 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
283 SetLastError( 0xdeadbeef );
284 rgn
= PathToRegion( hdc
);
285 ok( !rgn
, "PathToRegion succeeded on empty path\n" );
286 ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
288 ok( GetPath( hdc
, NULL
, NULL
, 0 ) == -1, "path not deleted\n" );
292 SetLastError( 0xdeadbeef );
293 ret
= CloseFigure( hdc
);
294 ok( !ret
, "CloseFigure succeeded\n" );
295 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
296 "wrong error %u\n", GetLastError() );
301 SetLastError( 0xdeadbeef );
302 ret
= EndPath( hdc
);
303 ok( !ret
, "EndPath succeeded\n" );
304 ok( GetLastError() == ERROR_CAN_NOT_COMPLETE
|| broken(GetLastError() == 0xdeadbeef),
305 "wrong error %u\n", GetLastError() );
311 static void test_widenpath(void)
314 HPEN greenPen
, narrowPen
;
319 /* Create a pen to be used in WidenPath */
320 greenPen
= CreatePen(PS_SOLID
, 10, RGB(0,0,0));
321 SelectObject(hdc
, greenPen
);
337 /* Set a polyline path */
339 Polyline(hdc
, pnt
, 6);
342 /* Widen the polyline path */
343 ok(WidenPath(hdc
), "WidenPath fails while widening a poyline path.\n");
345 /* Test if WidenPath seems to have done his job */
346 nSize
= GetPath(hdc
, NULL
, NULL
, 0);
347 ok(nSize
!= -1, "GetPath fails after calling WidenPath.\n");
348 ok(nSize
> 6, "Path number of points is too low. Should be more than 6 but is %d\n", nSize
);
352 /* Test WidenPath with an open path (last error only set on Win2k and later) */
353 SetLastError(0xdeadbeef);
355 ret
= WidenPath(hdc
);
356 ok(ret
== FALSE
&& (GetLastError() == ERROR_CAN_NOT_COMPLETE
|| GetLastError() == 0xdeadbeef),
357 "WidenPath fails while widening an open path. Return value is %d, should be %d. Error is %u\n", ret
, FALSE
, GetLastError());
361 /* Test when the pen width is equal to 1. The path should change too */
362 narrowPen
= CreatePen(PS_SOLID
, 1, RGB(0,0,0));
363 SelectObject(hdc
, narrowPen
);
365 Polyline(hdc
, pnt
, 6);
367 ret
= WidenPath(hdc
);
368 ok(ret
== TRUE
, "WidenPath failed: %d\n", GetLastError());
369 nSize
= GetPath(hdc
, NULL
, NULL
, 0);
370 ok(nSize
> 6, "WidenPath should compute a widened path with a 1px wide pen. Path length is %d, should be more than 6\n", nSize
);
377 * Tests for GDI drawing functions in paths
386 /* Helper function to verify that the current path in the given DC matches the expected path.
388 * We use a "smart" matching algorithm that allows us to detect partial improvements
389 * in conformance. Specifically, two running indices are kept, one through the actual
390 * path and one through the expected path. The actual path index increases unless there is
391 * no match and the todo field of the appropriate path_test_t element is 2. Similarly,
392 * if the wine_entries_preceding field of the appropriate path_test_t element is non-zero,
393 * the expected path index does not increase for that many elements as long as there
394 * is no match. This allows us to todo_wine extra path elements that are present only
395 * on wine but not on native and vice versa.
397 * Note that if expected_size is zero and the WINETEST_DEBUG environment variable is
398 * greater than 2, the trace() output is a C path_test_t array structure, useful for making
399 * new tests that use this function.
401 static void ok_path(HDC hdc
, const char *path_name
, const path_test_t
*expected
, int expected_size
)
403 static const char *type_string
[8] = { "Unknown (0)", "PT_CLOSEFIGURE", "PT_LINETO",
404 "PT_LINETO | PT_CLOSEFIGURE", "PT_BEZIERTO",
405 "PT_BEZIERTO | PT_CLOSEFIGURE", "PT_MOVETO", "PT_MOVETO | PT_CLOSEFIGURE"};
412 size
= GetPath(hdc
, NULL
, NULL
, 0);
413 ok(size
> 0, "GetPath returned size %d, last error %d\n", size
, GetLastError());
414 if (size
<= 0) return;
416 pnt
= HeapAlloc(GetProcessHeap(), 0, size
*sizeof(POINT
));
418 types
= HeapAlloc(GetProcessHeap(), 0, size
*sizeof(BYTE
));
420 size
= GetPath(hdc
, pnt
, types
, size
);
423 ok( size
== expected_size
, "%s: Path size %d does not match expected size %d\n",
424 path_name
, size
, expected_size
);
426 for (idx
= 0; idx
< min( size
, expected_size
); idx
++)
428 /* We allow a few pixels fudge in matching X and Y coordinates to account for imprecision in
429 * floating point to integer conversion */
430 static const int fudge
= 2;
432 ok( types
[idx
] == expected
[idx
].type
, "%s: Expected #%d: %s (%d,%d) but got %s (%d,%d)\n",
433 path_name
, idx
, type_string
[expected
[idx
].type
], expected
[idx
].x
, expected
[idx
].y
,
434 type_string
[types
[idx
]], pnt
[idx
].x
, pnt
[idx
].y
);
436 if (types
[idx
] == expected
[idx
].type
)
437 ok( (pnt
[idx
].x
>= expected
[idx
].x
- fudge
&& pnt
[idx
].x
<= expected
[idx
].x
+ fudge
) &&
438 (pnt
[idx
].y
>= expected
[idx
].y
- fudge
&& pnt
[idx
].y
<= expected
[idx
].y
+ fudge
),
439 "%s: Expected #%d: %s position (%d,%d) but got (%d,%d)\n", path_name
, idx
,
440 type_string
[expected
[idx
].type
], expected
[idx
].x
, expected
[idx
].y
, pnt
[idx
].x
, pnt
[idx
].y
);
443 if (winetest_debug
> 2)
445 printf("static const path_test_t %s[] =\n{\n", path_name
);
446 for (idx
= 0; idx
< size
; idx
++)
447 printf(" {%d, %d, %s}, /* %d */\n", pnt
[idx
].x
, pnt
[idx
].y
, type_string
[types
[idx
]], idx
);
451 HeapFree(GetProcessHeap(), 0, types
);
452 HeapFree(GetProcessHeap(), 0, pnt
);
455 static const path_test_t arcto_path
[] =
457 {0, 0, PT_MOVETO
}, /* 0 */
458 {229, 215, PT_LINETO
}, /* 1 */
459 {248, 205, PT_BEZIERTO
}, /* 2 */
460 {273, 200, PT_BEZIERTO
}, /* 3 */
461 {300, 200, PT_BEZIERTO
}, /* 4 */
462 {355, 200, PT_BEZIERTO
}, /* 5 */
463 {399, 222, PT_BEZIERTO
}, /* 6 */
464 {399, 250, PT_BEZIERTO
}, /* 7 */
465 {399, 263, PT_BEZIERTO
}, /* 8 */
466 {389, 275, PT_BEZIERTO
}, /* 9 */
467 {370, 285, PT_BEZIERTO
}, /* 10 */
468 {363, 277, PT_LINETO
}, /* 11 */
469 {380, 270, PT_BEZIERTO
}, /* 12 */
470 {389, 260, PT_BEZIERTO
}, /* 13 */
471 {389, 250, PT_BEZIERTO
}, /* 14 */
472 {389, 228, PT_BEZIERTO
}, /* 15 */
473 {349, 210, PT_BEZIERTO
}, /* 16 */
474 {300, 210, PT_BEZIERTO
}, /* 17 */
475 {276, 210, PT_BEZIERTO
}, /* 18 */
476 {253, 214, PT_BEZIERTO
}, /* 19 */
477 {236, 222, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 20 */
480 static void test_arcto(void)
485 SetArcDirection(hdc
, AD_CLOCKWISE
);
486 if (!ArcTo(hdc
, 200, 200, 400, 300, 200, 200, 400, 300) &&
487 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
489 /* ArcTo is only available on Win2k and later */
490 win_skip("ArcTo is not available\n");
493 SetArcDirection(hdc
, AD_COUNTERCLOCKWISE
);
494 ArcTo(hdc
, 210, 210, 390, 290, 390, 290, 210, 210);
498 ok_path(hdc
, "arcto_path", arcto_path
, ARRAY_SIZE(arcto_path
));
503 static const path_test_t anglearc_path
[] =
505 {0, 0, PT_MOVETO
}, /* 0 */
506 {371, 229, PT_LINETO
}, /* 1 */
507 {352, 211, PT_BEZIERTO
}, /* 2 */
508 {327, 200, PT_BEZIERTO
}, /* 3 */
509 {300, 200, PT_BEZIERTO
}, /* 4 */
510 {245, 200, PT_BEZIERTO
}, /* 5 */
511 {200, 245, PT_BEZIERTO
}, /* 6 */
512 {200, 300, PT_BEZIERTO
}, /* 7 */
513 {200, 300, PT_BEZIERTO
}, /* 8 */
514 {200, 300, PT_BEZIERTO
}, /* 9 */
515 {200, 300, PT_BEZIERTO
}, /* 10 */
516 {231, 260, PT_LINETO
}, /* 11 */
517 {245, 235, PT_BEZIERTO
}, /* 12 */
518 {271, 220, PT_BEZIERTO
}, /* 13 */
519 {300, 220, PT_BEZIERTO
}, /* 14 */
520 {344, 220, PT_BEZIERTO
}, /* 15 */
521 {380, 256, PT_BEZIERTO
}, /* 16 */
522 {380, 300, PT_BEZIERTO
}, /* 17 */
523 {380, 314, PT_BEZIERTO
}, /* 18 */
524 {376, 328, PT_BEZIERTO
}, /* 19 */
525 {369, 340, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 20 */
528 static void test_anglearc(void)
532 if (!AngleArc(hdc
, 300, 300, 100, 45.0, 135.0) &&
533 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
535 /* AngleArc is only available on Win2k and later */
536 win_skip("AngleArc is not available\n");
539 AngleArc(hdc
, 300, 300, 80, 150.0, -180.0);
543 ok_path(hdc
, "anglearc_path", anglearc_path
, ARRAY_SIZE(anglearc_path
));
548 static const path_test_t polydraw_path
[] =
550 {-20, -20, PT_MOVETO
}, /* 0 */
551 {10, 10, PT_LINETO
}, /* 1 */
552 {10, 15, PT_LINETO
| PT_CLOSEFIGURE
}, /* 2 */
553 {-20, -20, PT_MOVETO
}, /* 3 */
554 {-10, -10, PT_LINETO
}, /* 4 */
555 {100, 100, PT_MOVETO
}, /* 5 */
556 {95, 95, PT_LINETO
}, /* 6 */
557 {10, 10, PT_LINETO
}, /* 7 */
558 {10, 15, PT_LINETO
| PT_CLOSEFIGURE
}, /* 8 */
559 {100, 100, PT_MOVETO
}, /* 9 */
560 {15, 15, PT_LINETO
}, /* 10 */
561 {25, 25, PT_MOVETO
}, /* 11 */
562 {25, 30, PT_LINETO
}, /* 12 */
563 {100, 100, PT_MOVETO
}, /* 13 */
564 {30, 30, PT_BEZIERTO
}, /* 14 */
565 {30, 35, PT_BEZIERTO
}, /* 15 */
566 {35, 35, PT_BEZIERTO
}, /* 16 */
567 {35, 40, PT_LINETO
}, /* 17 */
568 {40, 40, PT_MOVETO
}, /* 18 */
569 {40, 45, PT_LINETO
}, /* 19 */
570 {35, 40, PT_MOVETO
}, /* 20 */
571 {45, 50, PT_LINETO
}, /* 21 */
572 {35, 40, PT_MOVETO
}, /* 22 */
573 {50, 55, PT_LINETO
}, /* 23 */
574 {45, 50, PT_LINETO
}, /* 24 */
575 {35, 40, PT_MOVETO
}, /* 25 */
576 {60, 60, PT_LINETO
}, /* 26 */
577 {60, 65, PT_MOVETO
}, /* 27 */
578 {65, 65, PT_LINETO
}, /* 28 */
579 {75, 75, PT_MOVETO
}, /* 29 */
580 {80, 80, PT_LINETO
| PT_CLOSEFIGURE
}, /* 30 */
583 static POINT polydraw_pts
[] = {
585 {15, 15}, {15, 20}, {20, 20}, {20, 25},
587 {30, 30}, {30, 35}, {35, 35}, {35, 40},
588 {40, 40}, {40, 45}, {45, 45},
590 {50, 55}, {45, 50}, {55, 60},
591 {60, 60}, {60, 65}, {65, 65},
592 {70, 70}, {75, 70}, {75, 75}, {80, 80}};
594 static BYTE polydraw_tps
[] =
595 {PT_LINETO
, PT_CLOSEFIGURE
| PT_LINETO
, /* 2 */
596 PT_LINETO
, PT_BEZIERTO
, PT_LINETO
, PT_LINETO
, /* 6 */
597 PT_MOVETO
, PT_LINETO
, /* 8 */
598 PT_BEZIERTO
, PT_BEZIERTO
, PT_BEZIERTO
, PT_LINETO
, /* 12 */
599 PT_MOVETO
, PT_LINETO
, PT_CLOSEFIGURE
, /* 15 */
600 PT_LINETO
, PT_MOVETO
| PT_CLOSEFIGURE
, /* 17 */
601 PT_LINETO
, PT_LINETO
, PT_MOVETO
| PT_CLOSEFIGURE
, /* 20 */
602 PT_LINETO
, PT_MOVETO
| PT_LINETO
, PT_LINETO
, /* 23 */
603 PT_MOVETO
, PT_MOVETO
, PT_MOVETO
, PT_LINETO
| PT_CLOSEFIGURE
}; /* 27 */
605 static void test_polydraw(void)
611 MoveToEx( hdc
, -20, -20, NULL
);
614 GetCurrentPositionEx( hdc
, &pos
);
615 ok( pos
.x
== -20 && pos
.y
== -20, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
617 /* closefigure with no previous moveto */
618 if (!(retb
= PolyDraw(hdc
, polydraw_pts
, polydraw_tps
, 2)) &&
619 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
621 /* PolyDraw is only available on Win2k and later */
622 win_skip("PolyDraw is not available\n");
626 GetCurrentPositionEx( hdc
, &pos
);
627 ok( pos
.x
== 10 && pos
.y
== 15, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
628 LineTo(hdc
, -10, -10);
629 GetCurrentPositionEx( hdc
, &pos
);
630 ok( pos
.x
== -10 && pos
.y
== -10, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
632 MoveToEx(hdc
, 100, 100, NULL
);
633 GetCurrentPositionEx( hdc
, &pos
);
634 ok( pos
.x
== 100 && pos
.y
== 100, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
636 GetCurrentPositionEx( hdc
, &pos
);
637 ok( pos
.x
== 95 && pos
.y
== 95, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
638 /* closefigure with previous moveto */
639 retb
= PolyDraw(hdc
, polydraw_pts
, polydraw_tps
, 2);
641 GetCurrentPositionEx( hdc
, &pos
);
642 ok( pos
.x
== 10 && pos
.y
== 15, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
643 /* bad bezier points */
644 retb
= PolyDraw(hdc
, &(polydraw_pts
[2]), &(polydraw_tps
[2]), 4);
646 GetCurrentPositionEx( hdc
, &pos
);
647 ok( pos
.x
== 10 && pos
.y
== 15, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
648 retb
= PolyDraw(hdc
, &(polydraw_pts
[6]), &(polydraw_tps
[6]), 4);
650 GetCurrentPositionEx( hdc
, &pos
);
651 ok( pos
.x
== 10 && pos
.y
== 15, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
652 /* good bezier points */
653 retb
= PolyDraw(hdc
, &(polydraw_pts
[8]), &(polydraw_tps
[8]), 4);
655 GetCurrentPositionEx( hdc
, &pos
);
656 ok( pos
.x
== 35 && pos
.y
== 40, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
657 /* does lineto or bezierto take precedence? */
658 retb
= PolyDraw(hdc
, &(polydraw_pts
[12]), &(polydraw_tps
[12]), 4);
660 GetCurrentPositionEx( hdc
, &pos
);
661 ok( pos
.x
== 35 && pos
.y
== 40, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
662 /* bad point type, has already moved cursor position */
663 retb
= PolyDraw(hdc
, &(polydraw_pts
[15]), &(polydraw_tps
[15]), 4);
665 GetCurrentPositionEx( hdc
, &pos
);
666 ok( pos
.x
== 35 && pos
.y
== 40, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
667 /* bad point type, cursor position is moved, but back to its original spot */
668 retb
= PolyDraw(hdc
, &(polydraw_pts
[17]), &(polydraw_tps
[17]), 4);
670 GetCurrentPositionEx( hdc
, &pos
);
671 ok( pos
.x
== 35 && pos
.y
== 40, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
672 /* does lineto or moveto take precedence? */
673 retb
= PolyDraw(hdc
, &(polydraw_pts
[20]), &(polydraw_tps
[20]), 3);
675 GetCurrentPositionEx( hdc
, &pos
);
676 ok( pos
.x
== 65 && pos
.y
== 65, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
677 /* consecutive movetos */
678 retb
= PolyDraw(hdc
, &(polydraw_pts
[23]), &(polydraw_tps
[23]), 4);
680 GetCurrentPositionEx( hdc
, &pos
);
681 ok( pos
.x
== 80 && pos
.y
== 80, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
684 ok_path(hdc
, "polydraw_path", polydraw_path
, ARRAY_SIZE(polydraw_path
));
685 GetCurrentPositionEx( hdc
, &pos
);
686 ok( pos
.x
== 80 && pos
.y
== 80, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
691 static void test_closefigure(void) {
692 int nSize
, nSizeWitness
;
696 MoveToEx( hdc
, 100, 100, NULL
);
697 GetCurrentPositionEx( hdc
, &pos
);
698 ok( pos
.x
== 100 && pos
.y
== 100, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
701 GetCurrentPositionEx( hdc
, &pos
);
702 ok( pos
.x
== 100 && pos
.y
== 100, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
703 MoveToEx(hdc
, 95, 95, NULL
);
704 GetCurrentPositionEx( hdc
, &pos
);
705 ok( pos
.x
== 95 && pos
.y
== 95, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
707 GetCurrentPositionEx( hdc
, &pos
);
708 ok( pos
.x
== 95 && pos
.y
== 0, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
710 GetCurrentPositionEx( hdc
, &pos
);
711 ok( pos
.x
== 0 && pos
.y
== 95, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
714 GetCurrentPositionEx( hdc
, &pos
);
715 ok( pos
.x
== 0 && pos
.y
== 95, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
717 GetCurrentPositionEx( hdc
, &pos
);
718 ok( pos
.x
== 0 && pos
.y
== 95, "wrong pos %d,%d\n", pos
.x
, pos
.y
);
719 nSize
= GetPath(hdc
, NULL
, NULL
, 0);
724 MoveToEx(hdc
, 95, 95, NULL
);
729 nSizeWitness
= GetPath(hdc
, NULL
, NULL
, 0);
731 /* This test shows CloseFigure does not have to add a point at the end of the path */
732 ok(nSize
== nSizeWitness
, "Wrong number of points, no point should be added by CloseFigure\n");
737 static void WINAPI
linedda_callback(INT x
, INT y
, LPARAM lparam
)
739 POINT
**pt
= (POINT
**)lparam
;
740 ok((*pt
)->x
== x
&& (*pt
)->y
== y
, "point mismatch expect(%d,%d) got(%d,%d)\n",
741 (*pt
)->x
, (*pt
)->y
, x
, y
);
747 static void test_linedda(void)
750 static const POINT array_10_20_20_40
[] = {{10,20},{10,21},{11,22},{11,23},
751 {12,24},{12,25},{13,26},{13,27},
752 {14,28},{14,29},{15,30},{15,31},
753 {16,32},{16,33},{17,34},{17,35},
754 {18,36},{18,37},{19,38},{19,39},
756 static const POINT array_10_20_20_43
[] = {{10,20},{10,21},{11,22},{11,23},
757 {12,24},{12,25},{13,26},{13,27},
758 {13,28},{14,29},{14,30},{15,31},
759 {15,32},{16,33},{16,34},{17,35},
760 {17,36},{17,37},{18,38},{18,39},
761 {19,40},{19,41},{20,42},{-1,-1}};
763 static const POINT array_10_20_10_20
[] = {{-1,-1}};
764 static const POINT array_10_20_11_27
[] = {{10,20},{10,21},{10,22},{10,23},
765 {11,24},{11,25},{11,26},{-1,-1}};
767 static const POINT array_20_43_10_20
[] = {{20,43},{20,42},{19,41},{19,40},
768 {18,39},{18,38},{17,37},{17,36},
769 {17,35},{16,34},{16,33},{15,32},
770 {15,31},{14,30},{14,29},{13,28},
771 {13,27},{13,26},{12,25},{12,24},
772 {11,23},{11,22},{10,21},{-1,-1}};
774 static const POINT array_20_20_10_43
[] = {{20,20},{20,21},{19,22},{19,23},
775 {18,24},{18,25},{17,26},{17,27},
776 {17,28},{16,29},{16,30},{15,31},
777 {15,32},{14,33},{14,34},{13,35},
778 {13,36},{13,37},{12,38},{12,39},
779 {11,40},{11,41},{10,42},{-1,-1}};
781 static const POINT array_20_20_43_10
[] = {{20,20},{21,20},{22,19},{23,19},
782 {24,18},{25,18},{26,17},{27,17},
783 {28,17},{29,16},{30,16},{31,15},
784 {32,15},{33,14},{34,14},{35,13},
785 {36,13},{37,13},{38,12},{39,12},
786 {40,11},{41,11},{42,10},{-1,-1}};
789 pt
= array_10_20_20_40
;
790 LineDDA(10, 20, 20, 40, linedda_callback
, (LPARAM
)&pt
);
791 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
793 pt
= array_10_20_20_43
;
794 LineDDA(10, 20, 20, 43, linedda_callback
, (LPARAM
)&pt
);
795 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
797 pt
= array_10_20_10_20
;
798 LineDDA(10, 20, 10, 20, linedda_callback
, (LPARAM
)&pt
);
799 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
801 pt
= array_10_20_11_27
;
802 LineDDA(10, 20, 11, 27, linedda_callback
, (LPARAM
)&pt
);
803 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
805 pt
= array_20_43_10_20
;
806 LineDDA(20, 43, 10, 20, linedda_callback
, (LPARAM
)&pt
);
807 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
809 pt
= array_20_20_10_43
;
810 LineDDA(20, 20, 10, 43, linedda_callback
, (LPARAM
)&pt
);
811 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
813 pt
= array_20_20_43_10
;
814 LineDDA(20, 20, 43, 10, linedda_callback
, (LPARAM
)&pt
);
815 ok(pt
->x
== -1 && pt
->y
== -1, "didn't find terminator\n");
818 static const path_test_t rectangle_path
[] =
820 {39, 20, PT_MOVETO
}, /* 0 */
821 {20, 20, PT_LINETO
}, /* 1 */
822 {20, 39, PT_LINETO
}, /* 2 */
823 {39, 39, PT_LINETO
| PT_CLOSEFIGURE
}, /* 3 */
824 {54, 35, PT_MOVETO
}, /* 4 */
825 {30, 35, PT_LINETO
}, /* 5 */
826 {30, 49, PT_LINETO
}, /* 6 */
827 {54, 49, PT_LINETO
| PT_CLOSEFIGURE
}, /* 7 */
828 {59, 45, PT_MOVETO
}, /* 8 */
829 {35, 45, PT_LINETO
}, /* 9 */
830 {35, 59, PT_LINETO
}, /* 10 */
831 {59, 59, PT_LINETO
| PT_CLOSEFIGURE
}, /* 11 */
832 {80, 80, PT_MOVETO
}, /* 12 */
833 {80, 80, PT_LINETO
}, /* 13 */
834 {80, 80, PT_LINETO
}, /* 14 */
835 {80, 80, PT_LINETO
| PT_CLOSEFIGURE
}, /* 15 */
836 {39, 39, PT_MOVETO
}, /* 16 */
837 {20, 39, PT_LINETO
}, /* 17 */
838 {20, 20, PT_LINETO
}, /* 18 */
839 {39, 20, PT_LINETO
| PT_CLOSEFIGURE
}, /* 19 */
840 {54, 49, PT_MOVETO
}, /* 20 */
841 {30, 49, PT_LINETO
}, /* 21 */
842 {30, 35, PT_LINETO
}, /* 22 */
843 {54, 35, PT_LINETO
| PT_CLOSEFIGURE
}, /* 23 */
844 {59, 59, PT_MOVETO
}, /* 24 */
845 {35, 59, PT_LINETO
}, /* 25 */
846 {35, 45, PT_LINETO
}, /* 26 */
847 {59, 45, PT_LINETO
| PT_CLOSEFIGURE
}, /* 27 */
848 {80, 80, PT_MOVETO
}, /* 28 */
849 {80, 80, PT_LINETO
}, /* 29 */
850 {80, 80, PT_LINETO
}, /* 30 */
851 {80, 80, PT_LINETO
| PT_CLOSEFIGURE
}, /* 31 */
852 {-41, 40, PT_MOVETO
}, /* 32 */
853 {-80, 40, PT_LINETO
}, /* 33 */
854 {-80, 79, PT_LINETO
}, /* 34 */
855 {-41, 79, PT_LINETO
| PT_CLOSEFIGURE
}, /* 35 */
856 {-61, 70, PT_MOVETO
}, /* 36 */
857 {-110, 70, PT_LINETO
}, /* 37 */
858 {-110, 99, PT_LINETO
}, /* 38 */
859 {-61, 99, PT_LINETO
| PT_CLOSEFIGURE
}, /* 39 */
860 {119, -120, PT_MOVETO
}, /* 40 */
861 {60, -120, PT_LINETO
}, /* 41 */
862 {60, -61, PT_LINETO
}, /* 42 */
863 {119, -61, PT_LINETO
| PT_CLOSEFIGURE
}, /* 43 */
864 {164, -150, PT_MOVETO
}, /* 44 */
865 {90, -150, PT_LINETO
}, /* 45 */
866 {90, -106, PT_LINETO
}, /* 46 */
867 {164, -106, PT_LINETO
| PT_CLOSEFIGURE
}, /* 47 */
868 {-4, -6, PT_MOVETO
}, /* 48 */
869 {-6, -6, PT_LINETO
}, /* 49 */
870 {-6, -4, PT_LINETO
}, /* 50 */
871 {-4, -4, PT_LINETO
| PT_CLOSEFIGURE
}, /* 51 */
872 {40, 20, PT_MOVETO
}, /* 52 */
873 {20, 20, PT_LINETO
}, /* 53 */
874 {20, 40, PT_LINETO
}, /* 54 */
875 {40, 40, PT_LINETO
| PT_CLOSEFIGURE
}, /* 55 */
876 {55, 35, PT_MOVETO
}, /* 56 */
877 {30, 35, PT_LINETO
}, /* 57 */
878 {30, 50, PT_LINETO
}, /* 58 */
879 {55, 50, PT_LINETO
| PT_CLOSEFIGURE
}, /* 59 */
880 {60, 45, PT_MOVETO
}, /* 60 */
881 {35, 45, PT_LINETO
}, /* 61 */
882 {35, 60, PT_LINETO
}, /* 62 */
883 {60, 60, PT_LINETO
| PT_CLOSEFIGURE
}, /* 63 */
884 {70, 70, PT_MOVETO
}, /* 64 */
885 {50, 70, PT_LINETO
}, /* 65 */
886 {50, 70, PT_LINETO
}, /* 66 */
887 {70, 70, PT_LINETO
| PT_CLOSEFIGURE
}, /* 67 */
888 {75, 75, PT_MOVETO
}, /* 68 */
889 {75, 75, PT_LINETO
}, /* 69 */
890 {75, 85, PT_LINETO
}, /* 70 */
891 {75, 85, PT_LINETO
| PT_CLOSEFIGURE
}, /* 71 */
892 {81, 80, PT_MOVETO
}, /* 72 */
893 {80, 80, PT_LINETO
}, /* 73 */
894 {80, 81, PT_LINETO
}, /* 74 */
895 {81, 81, PT_LINETO
| PT_CLOSEFIGURE
}, /* 75 */
896 {40, 40, PT_MOVETO
}, /* 76 */
897 {20, 40, PT_LINETO
}, /* 77 */
898 {20, 20, PT_LINETO
}, /* 78 */
899 {40, 20, PT_LINETO
| PT_CLOSEFIGURE
}, /* 79 */
900 {55, 50, PT_MOVETO
}, /* 80 */
901 {30, 50, PT_LINETO
}, /* 81 */
902 {30, 35, PT_LINETO
}, /* 82 */
903 {55, 35, PT_LINETO
| PT_CLOSEFIGURE
}, /* 83 */
904 {60, 60, PT_MOVETO
}, /* 84 */
905 {35, 60, PT_LINETO
}, /* 85 */
906 {35, 45, PT_LINETO
}, /* 86 */
907 {60, 45, PT_LINETO
| PT_CLOSEFIGURE
}, /* 87 */
908 {70, 70, PT_MOVETO
}, /* 88 */
909 {50, 70, PT_LINETO
}, /* 89 */
910 {50, 70, PT_LINETO
}, /* 90 */
911 {70, 70, PT_LINETO
| PT_CLOSEFIGURE
}, /* 91 */
912 {75, 85, PT_MOVETO
}, /* 92 */
913 {75, 85, PT_LINETO
}, /* 93 */
914 {75, 75, PT_LINETO
}, /* 94 */
915 {75, 75, PT_LINETO
| PT_CLOSEFIGURE
}, /* 95 */
916 {81, 81, PT_MOVETO
}, /* 96 */
917 {80, 81, PT_LINETO
}, /* 97 */
918 {80, 80, PT_LINETO
}, /* 98 */
919 {81, 80, PT_LINETO
| PT_CLOSEFIGURE
}, /* 99 */
922 static void test_rectangle(void)
924 HDC hdc
= GetDC( 0 );
927 Rectangle( hdc
, 20, 20, 40, 40 );
928 Rectangle( hdc
, 30, 50, 55, 35 );
929 Rectangle( hdc
, 60, 60, 35, 45 );
930 Rectangle( hdc
, 70, 70, 50, 70 );
931 Rectangle( hdc
, 75, 75, 75, 85 );
932 Rectangle( hdc
, 80, 80, 81, 81 );
933 SetArcDirection( hdc
, AD_CLOCKWISE
);
934 Rectangle( hdc
, 20, 20, 40, 40 );
935 Rectangle( hdc
, 30, 50, 55, 35 );
936 Rectangle( hdc
, 60, 60, 35, 45 );
937 Rectangle( hdc
, 70, 70, 50, 70 );
938 Rectangle( hdc
, 75, 75, 75, 85 );
939 Rectangle( hdc
, 80, 80, 81, 81 );
940 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
941 SetMapMode( hdc
, MM_ANISOTROPIC
);
942 SetViewportExtEx( hdc
, -2, 2, NULL
);
943 Rectangle( hdc
, 20, 20, 40, 40 );
944 Rectangle( hdc
, 30, 50, 55, 35 );
945 SetViewportExtEx( hdc
, 3, -3, NULL
);
946 Rectangle( hdc
, 20, 20, 40, 40 );
947 Rectangle( hdc
, 30, 50, 55, 35 );
948 SetWindowExtEx( hdc
, -20, 20, NULL
);
949 Rectangle( hdc
, 20, 20, 40, 40 );
950 Rectangle( hdc
, 24, 22, 21, 20 );
951 SetMapMode( hdc
, MM_TEXT
);
952 SetGraphicsMode( hdc
, GM_ADVANCED
);
953 Rectangle( hdc
, 20, 20, 40, 40 );
954 Rectangle( hdc
, 30, 50, 55, 35 );
955 Rectangle( hdc
, 60, 60, 35, 45 );
956 Rectangle( hdc
, 70, 70, 50, 70 );
957 Rectangle( hdc
, 75, 75, 75, 85 );
958 Rectangle( hdc
, 80, 80, 81, 81 );
959 SetArcDirection( hdc
, AD_CLOCKWISE
);
960 Rectangle( hdc
, 20, 20, 40, 40 );
961 Rectangle( hdc
, 30, 50, 55, 35 );
962 Rectangle( hdc
, 60, 60, 35, 45 );
963 Rectangle( hdc
, 70, 70, 50, 70 );
964 Rectangle( hdc
, 75, 75, 75, 85 );
965 Rectangle( hdc
, 80, 80, 81, 81 );
966 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
968 SetMapMode( hdc
, MM_TEXT
);
969 ok_path( hdc
, "rectangle_path", rectangle_path
, ARRAY_SIZE(rectangle_path
) );
973 static const path_test_t roundrect_path
[] =
975 {39, 25, PT_MOVETO
}, /* 0 */
976 {39, 22, PT_BEZIERTO
}, /* 1 */
977 {37, 20, PT_BEZIERTO
}, /* 2 */
978 {34, 20, PT_BEZIERTO
}, /* 3 */
979 {25, 20, PT_LINETO
}, /* 4 */
980 {22, 20, PT_BEZIERTO
}, /* 5 */
981 {20, 22, PT_BEZIERTO
}, /* 6 */
982 {20, 25, PT_BEZIERTO
}, /* 7 */
983 {20, 34, PT_LINETO
}, /* 8 */
984 {20, 37, PT_BEZIERTO
}, /* 9 */
985 {22, 39, PT_BEZIERTO
}, /* 10 */
986 {25, 39, PT_BEZIERTO
}, /* 11 */
987 {34, 39, PT_LINETO
}, /* 12 */
988 {37, 39, PT_BEZIERTO
}, /* 13 */
989 {39, 37, PT_BEZIERTO
}, /* 14 */
990 {39, 34, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 15 */
991 {54, 42, PT_MOVETO
}, /* 16 */
992 {54, 38, PT_BEZIERTO
}, /* 17 */
993 {49, 35, PT_BEZIERTO
}, /* 18 */
994 {42, 35, PT_BEZIERTO
}, /* 19 */
995 {42, 35, PT_LINETO
}, /* 20 */
996 {35, 35, PT_BEZIERTO
}, /* 21 */
997 {30, 38, PT_BEZIERTO
}, /* 22 */
998 {30, 42, PT_BEZIERTO
}, /* 23 */
999 {30, 42, PT_LINETO
}, /* 24 */
1000 {30, 46, PT_BEZIERTO
}, /* 25 */
1001 {35, 49, PT_BEZIERTO
}, /* 26 */
1002 {42, 49, PT_BEZIERTO
}, /* 27 */
1003 {42, 49, PT_LINETO
}, /* 28 */
1004 {49, 49, PT_BEZIERTO
}, /* 29 */
1005 {54, 46, PT_BEZIERTO
}, /* 30 */
1006 {54, 42, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 31 */
1007 {59, 46, PT_MOVETO
}, /* 32 */
1008 {59, 45, PT_BEZIERTO
}, /* 33 */
1009 {58, 45, PT_BEZIERTO
}, /* 34 */
1010 {57, 45, PT_BEZIERTO
}, /* 35 */
1011 {37, 45, PT_LINETO
}, /* 36 */
1012 {36, 45, PT_BEZIERTO
}, /* 37 */
1013 {35, 45, PT_BEZIERTO
}, /* 38 */
1014 {35, 46, PT_BEZIERTO
}, /* 39 */
1015 {35, 58, PT_LINETO
}, /* 40 */
1016 {35, 59, PT_BEZIERTO
}, /* 41 */
1017 {36, 59, PT_BEZIERTO
}, /* 42 */
1018 {37, 59, PT_BEZIERTO
}, /* 43 */
1019 {57, 59, PT_LINETO
}, /* 44 */
1020 {58, 59, PT_BEZIERTO
}, /* 45 */
1021 {59, 59, PT_BEZIERTO
}, /* 46 */
1022 {59, 58, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 47 */
1023 {80, 80, PT_MOVETO
}, /* 48 */
1024 {80, 80, PT_BEZIERTO
}, /* 49 */
1025 {80, 80, PT_BEZIERTO
}, /* 50 */
1026 {80, 80, PT_BEZIERTO
}, /* 51 */
1027 {80, 80, PT_LINETO
}, /* 52 */
1028 {80, 80, PT_BEZIERTO
}, /* 53 */
1029 {80, 80, PT_BEZIERTO
}, /* 54 */
1030 {80, 80, PT_BEZIERTO
}, /* 55 */
1031 {80, 80, PT_LINETO
}, /* 56 */
1032 {80, 80, PT_BEZIERTO
}, /* 57 */
1033 {80, 80, PT_BEZIERTO
}, /* 58 */
1034 {80, 80, PT_BEZIERTO
}, /* 59 */
1035 {80, 80, PT_LINETO
}, /* 60 */
1036 {80, 80, PT_BEZIERTO
}, /* 61 */
1037 {80, 80, PT_BEZIERTO
}, /* 62 */
1038 {80, 80, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 63 */
1039 {94, 85, PT_MOVETO
}, /* 64 */
1040 {90, 85, PT_LINETO
}, /* 65 */
1041 {90, 89, PT_LINETO
}, /* 66 */
1042 {94, 89, PT_LINETO
| PT_CLOSEFIGURE
}, /* 67 */
1043 {39, 34, PT_MOVETO
}, /* 68 */
1044 {39, 37, PT_BEZIERTO
}, /* 69 */
1045 {37, 39, PT_BEZIERTO
}, /* 70 */
1046 {34, 39, PT_BEZIERTO
}, /* 71 */
1047 {25, 39, PT_LINETO
}, /* 72 */
1048 {22, 39, PT_BEZIERTO
}, /* 73 */
1049 {20, 37, PT_BEZIERTO
}, /* 74 */
1050 {20, 34, PT_BEZIERTO
}, /* 75 */
1051 {20, 25, PT_LINETO
}, /* 76 */
1052 {20, 22, PT_BEZIERTO
}, /* 77 */
1053 {22, 20, PT_BEZIERTO
}, /* 78 */
1054 {25, 20, PT_BEZIERTO
}, /* 79 */
1055 {34, 20, PT_LINETO
}, /* 80 */
1056 {37, 20, PT_BEZIERTO
}, /* 81 */
1057 {39, 22, PT_BEZIERTO
}, /* 82 */
1058 {39, 25, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 83 */
1059 {54, 42, PT_MOVETO
}, /* 84 */
1060 {54, 46, PT_BEZIERTO
}, /* 85 */
1061 {49, 49, PT_BEZIERTO
}, /* 86 */
1062 {42, 49, PT_BEZIERTO
}, /* 87 */
1063 {42, 49, PT_LINETO
}, /* 88 */
1064 {35, 49, PT_BEZIERTO
}, /* 89 */
1065 {30, 46, PT_BEZIERTO
}, /* 90 */
1066 {30, 42, PT_BEZIERTO
}, /* 91 */
1067 {30, 42, PT_LINETO
}, /* 92 */
1068 {30, 38, PT_BEZIERTO
}, /* 93 */
1069 {35, 35, PT_BEZIERTO
}, /* 94 */
1070 {42, 35, PT_BEZIERTO
}, /* 95 */
1071 {42, 35, PT_LINETO
}, /* 96 */
1072 {49, 35, PT_BEZIERTO
}, /* 97 */
1073 {54, 38, PT_BEZIERTO
}, /* 98 */
1074 {54, 42, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 99 */
1075 {-41, 52, PT_MOVETO
}, /* 100 */
1076 {-41, 45, PT_BEZIERTO
}, /* 101 */
1077 {-47, 40, PT_BEZIERTO
}, /* 102 */
1078 {-56, 40, PT_BEZIERTO
}, /* 103 */
1079 {-65, 40, PT_LINETO
}, /* 104 */
1080 {-73, 40, PT_BEZIERTO
}, /* 105 */
1081 {-80, 45, PT_BEZIERTO
}, /* 106 */
1082 {-80, 52, PT_BEZIERTO
}, /* 107 */
1083 {-80, 67, PT_LINETO
}, /* 108 */
1084 {-80, 74, PT_BEZIERTO
}, /* 109 */
1085 {-73, 79, PT_BEZIERTO
}, /* 110 */
1086 {-65, 79, PT_BEZIERTO
}, /* 111 */
1087 {-56, 79, PT_LINETO
}, /* 112 */
1088 {-47, 79, PT_BEZIERTO
}, /* 113 */
1089 {-41, 74, PT_BEZIERTO
}, /* 114 */
1090 {-41, 67, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 115 */
1091 {-61, 79, PT_MOVETO
}, /* 116 */
1092 {-61, 74, PT_BEZIERTO
}, /* 117 */
1093 {-64, 70, PT_BEZIERTO
}, /* 118 */
1094 {-68, 70, PT_BEZIERTO
}, /* 119 */
1095 {-103, 70, PT_LINETO
}, /* 120 */
1096 {-107, 70, PT_BEZIERTO
}, /* 121 */
1097 {-110, 74, PT_BEZIERTO
}, /* 122 */
1098 {-110, 79, PT_BEZIERTO
}, /* 123 */
1099 {-110, 90, PT_LINETO
}, /* 124 */
1100 {-110, 95, PT_BEZIERTO
}, /* 125 */
1101 {-107, 99, PT_BEZIERTO
}, /* 126 */
1102 {-103, 99, PT_BEZIERTO
}, /* 127 */
1103 {-68, 99, PT_LINETO
}, /* 128 */
1104 {-64, 99, PT_BEZIERTO
}, /* 129 */
1105 {-61, 95, PT_BEZIERTO
}, /* 130 */
1106 {-61, 90, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 131 */
1107 {119, -102, PT_MOVETO
}, /* 132 */
1108 {119, -112, PT_BEZIERTO
}, /* 133 */
1109 {109, -120, PT_BEZIERTO
}, /* 134 */
1110 {97, -120, PT_BEZIERTO
}, /* 135 */
1111 {82, -120, PT_LINETO
}, /* 136 */
1112 {70, -120, PT_BEZIERTO
}, /* 137 */
1113 {60, -112, PT_BEZIERTO
}, /* 138 */
1114 {60, -102, PT_BEZIERTO
}, /* 139 */
1115 {60, -79, PT_LINETO
}, /* 140 */
1116 {60, -69, PT_BEZIERTO
}, /* 141 */
1117 {70, -61, PT_BEZIERTO
}, /* 142 */
1118 {82, -61, PT_BEZIERTO
}, /* 143 */
1119 {97, -61, PT_LINETO
}, /* 144 */
1120 {109, -61, PT_BEZIERTO
}, /* 145 */
1121 {119, -69, PT_BEZIERTO
}, /* 146 */
1122 {119, -79, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 147 */
1123 {164, -144, PT_MOVETO
}, /* 148 */
1124 {164, -147, PT_BEZIERTO
}, /* 149 */
1125 {162, -150, PT_BEZIERTO
}, /* 150 */
1126 {160, -150, PT_BEZIERTO
}, /* 151 */
1127 {94, -150, PT_LINETO
}, /* 152 */
1128 {92, -150, PT_BEZIERTO
}, /* 153 */
1129 {90, -147, PT_BEZIERTO
}, /* 154 */
1130 {90, -144, PT_BEZIERTO
}, /* 155 */
1131 {90, -112, PT_LINETO
}, /* 156 */
1132 {90, -109, PT_BEZIERTO
}, /* 157 */
1133 {92, -106, PT_BEZIERTO
}, /* 158 */
1134 {94, -106, PT_BEZIERTO
}, /* 159 */
1135 {160, -106, PT_LINETO
}, /* 160 */
1136 {162, -106, PT_BEZIERTO
}, /* 161 */
1137 {164, -109, PT_BEZIERTO
}, /* 162 */
1138 {164, -112, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 163 */
1139 {-4, -6, PT_MOVETO
}, /* 164 */
1140 {-4, -6, PT_BEZIERTO
}, /* 165 */
1141 {-4, -6, PT_BEZIERTO
}, /* 166 */
1142 {-4, -6, PT_BEZIERTO
}, /* 167 */
1143 {-6, -6, PT_LINETO
}, /* 168 */
1144 {-6, -6, PT_BEZIERTO
}, /* 169 */
1145 {-6, -6, PT_BEZIERTO
}, /* 170 */
1146 {-6, -6, PT_BEZIERTO
}, /* 171 */
1147 {-6, -4, PT_LINETO
}, /* 172 */
1148 {-6, -4, PT_BEZIERTO
}, /* 173 */
1149 {-6, -4, PT_BEZIERTO
}, /* 174 */
1150 {-6, -4, PT_BEZIERTO
}, /* 175 */
1151 {-4, -4, PT_LINETO
}, /* 176 */
1152 {-4, -4, PT_BEZIERTO
}, /* 177 */
1153 {-4, -4, PT_BEZIERTO
}, /* 178 */
1154 {-4, -4, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 179 */
1155 {40, 25, PT_MOVETO
}, /* 180 */
1156 {40, 22, PT_BEZIERTO
}, /* 181 */
1157 {38, 20, PT_BEZIERTO
}, /* 182 */
1158 {35, 20, PT_BEZIERTO
}, /* 183 */
1159 {25, 20, PT_LINETO
}, /* 184 */
1160 {22, 20, PT_BEZIERTO
}, /* 185 */
1161 {20, 22, PT_BEZIERTO
}, /* 186 */
1162 {20, 25, PT_BEZIERTO
}, /* 187 */
1163 {20, 35, PT_LINETO
}, /* 188 */
1164 {20, 38, PT_BEZIERTO
}, /* 189 */
1165 {22, 40, PT_BEZIERTO
}, /* 190 */
1166 {25, 40, PT_BEZIERTO
}, /* 191 */
1167 {35, 40, PT_LINETO
}, /* 192 */
1168 {38, 40, PT_BEZIERTO
}, /* 193 */
1169 {40, 38, PT_BEZIERTO
}, /* 194 */
1170 {40, 35, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 195 */
1171 {55, 43, PT_MOVETO
}, /* 196 */
1172 {55, 38, PT_BEZIERTO
}, /* 197 */
1173 {49, 35, PT_BEZIERTO
}, /* 198 */
1174 {43, 35, PT_BEZIERTO
}, /* 199 */
1175 {43, 35, PT_LINETO
}, /* 200 */
1176 {36, 35, PT_BEZIERTO
}, /* 201 */
1177 {30, 38, PT_BEZIERTO
}, /* 202 */
1178 {30, 43, PT_BEZIERTO
}, /* 203 */
1179 {30, 43, PT_LINETO
}, /* 204 */
1180 {30, 47, PT_BEZIERTO
}, /* 205 */
1181 {36, 50, PT_BEZIERTO
}, /* 206 */
1182 {43, 50, PT_BEZIERTO
}, /* 207 */
1183 {43, 50, PT_LINETO
}, /* 208 */
1184 {49, 50, PT_BEZIERTO
}, /* 209 */
1185 {55, 47, PT_BEZIERTO
}, /* 210 */
1186 {55, 43, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 211 */
1187 {60, 46, PT_MOVETO
}, /* 212 */
1188 {60, 46, PT_BEZIERTO
}, /* 213 */
1189 {59, 45, PT_BEZIERTO
}, /* 214 */
1190 {58, 45, PT_BEZIERTO
}, /* 215 */
1191 {38, 45, PT_LINETO
}, /* 216 */
1192 {36, 45, PT_BEZIERTO
}, /* 217 */
1193 {35, 46, PT_BEZIERTO
}, /* 218 */
1194 {35, 46, PT_BEZIERTO
}, /* 219 */
1195 {35, 59, PT_LINETO
}, /* 220 */
1196 {35, 60, PT_BEZIERTO
}, /* 221 */
1197 {36, 60, PT_BEZIERTO
}, /* 222 */
1198 {38, 60, PT_BEZIERTO
}, /* 223 */
1199 {58, 60, PT_LINETO
}, /* 224 */
1200 {59, 60, PT_BEZIERTO
}, /* 225 */
1201 {60, 60, PT_BEZIERTO
}, /* 226 */
1202 {60, 59, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 227 */
1203 {70, 70, PT_MOVETO
}, /* 228 */
1204 {70, 70, PT_BEZIERTO
}, /* 229 */
1205 {70, 70, PT_BEZIERTO
}, /* 230 */
1206 {70, 70, PT_BEZIERTO
}, /* 231 */
1207 {50, 70, PT_LINETO
}, /* 232 */
1208 {50, 70, PT_BEZIERTO
}, /* 233 */
1209 {50, 70, PT_BEZIERTO
}, /* 234 */
1210 {50, 70, PT_BEZIERTO
}, /* 235 */
1211 {50, 70, PT_LINETO
}, /* 236 */
1212 {50, 70, PT_BEZIERTO
}, /* 237 */
1213 {50, 70, PT_BEZIERTO
}, /* 238 */
1214 {50, 70, PT_BEZIERTO
}, /* 239 */
1215 {70, 70, PT_LINETO
}, /* 240 */
1216 {70, 70, PT_BEZIERTO
}, /* 241 */
1217 {70, 70, PT_BEZIERTO
}, /* 242 */
1218 {70, 70, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 243 */
1219 {75, 75, PT_MOVETO
}, /* 244 */
1220 {75, 75, PT_BEZIERTO
}, /* 245 */
1221 {75, 75, PT_BEZIERTO
}, /* 246 */
1222 {75, 75, PT_BEZIERTO
}, /* 247 */
1223 {75, 75, PT_LINETO
}, /* 248 */
1224 {75, 75, PT_BEZIERTO
}, /* 249 */
1225 {75, 75, PT_BEZIERTO
}, /* 250 */
1226 {75, 75, PT_BEZIERTO
}, /* 251 */
1227 {75, 85, PT_LINETO
}, /* 252 */
1228 {75, 85, PT_BEZIERTO
}, /* 253 */
1229 {75, 85, PT_BEZIERTO
}, /* 254 */
1230 {75, 85, PT_BEZIERTO
}, /* 255 */
1231 {75, 85, PT_LINETO
}, /* 256 */
1232 {75, 85, PT_BEZIERTO
}, /* 257 */
1233 {75, 85, PT_BEZIERTO
}, /* 258 */
1234 {75, 85, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 259 */
1235 {81, 81, PT_MOVETO
}, /* 260 */
1236 {81, 80, PT_BEZIERTO
}, /* 261 */
1237 {81, 80, PT_BEZIERTO
}, /* 262 */
1238 {81, 80, PT_BEZIERTO
}, /* 263 */
1239 {81, 80, PT_LINETO
}, /* 264 */
1240 {80, 80, PT_BEZIERTO
}, /* 265 */
1241 {80, 80, PT_BEZIERTO
}, /* 266 */
1242 {80, 81, PT_BEZIERTO
}, /* 267 */
1243 {80, 81, PT_LINETO
}, /* 268 */
1244 {80, 81, PT_BEZIERTO
}, /* 269 */
1245 {80, 81, PT_BEZIERTO
}, /* 270 */
1246 {81, 81, PT_BEZIERTO
}, /* 271 */
1247 {81, 81, PT_LINETO
}, /* 272 */
1248 {81, 81, PT_BEZIERTO
}, /* 273 */
1249 {81, 81, PT_BEZIERTO
}, /* 274 */
1250 {81, 81, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 275 */
1251 {95, 85, PT_MOVETO
}, /* 276 */
1252 {90, 85, PT_LINETO
}, /* 277 */
1253 {90, 90, PT_LINETO
}, /* 278 */
1254 {95, 90, PT_LINETO
| PT_CLOSEFIGURE
}, /* 279 */
1255 {40, 35, PT_MOVETO
}, /* 280 */
1256 {40, 38, PT_BEZIERTO
}, /* 281 */
1257 {38, 40, PT_BEZIERTO
}, /* 282 */
1258 {35, 40, PT_BEZIERTO
}, /* 283 */
1259 {25, 40, PT_LINETO
}, /* 284 */
1260 {22, 40, PT_BEZIERTO
}, /* 285 */
1261 {20, 38, PT_BEZIERTO
}, /* 286 */
1262 {20, 35, PT_BEZIERTO
}, /* 287 */
1263 {20, 25, PT_LINETO
}, /* 288 */
1264 {20, 22, PT_BEZIERTO
}, /* 289 */
1265 {22, 20, PT_BEZIERTO
}, /* 290 */
1266 {25, 20, PT_BEZIERTO
}, /* 291 */
1267 {35, 20, PT_LINETO
}, /* 292 */
1268 {38, 20, PT_BEZIERTO
}, /* 293 */
1269 {40, 22, PT_BEZIERTO
}, /* 294 */
1270 {40, 25, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 295 */
1271 {55, 43, PT_MOVETO
}, /* 296 */
1272 {55, 47, PT_BEZIERTO
}, /* 297 */
1273 {49, 50, PT_BEZIERTO
}, /* 298 */
1274 {43, 50, PT_BEZIERTO
}, /* 299 */
1275 {43, 50, PT_LINETO
}, /* 300 */
1276 {36, 50, PT_BEZIERTO
}, /* 301 */
1277 {30, 47, PT_BEZIERTO
}, /* 302 */
1278 {30, 43, PT_BEZIERTO
}, /* 303 */
1279 {30, 43, PT_LINETO
}, /* 304 */
1280 {30, 38, PT_BEZIERTO
}, /* 305 */
1281 {36, 35, PT_BEZIERTO
}, /* 306 */
1282 {43, 35, PT_BEZIERTO
}, /* 307 */
1283 {43, 35, PT_LINETO
}, /* 308 */
1284 {49, 35, PT_BEZIERTO
}, /* 309 */
1285 {55, 38, PT_BEZIERTO
}, /* 310 */
1286 {55, 43, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 311 */
1289 static void test_roundrect(void)
1291 HDC hdc
= GetDC( 0 );
1294 RoundRect( hdc
, 20, 20, 40, 40, 10, 10 );
1295 RoundRect( hdc
, 30, 50, 55, 35, -30, -30 );
1296 RoundRect( hdc
, 60, 60, 35, 45, 5, 2 );
1297 RoundRect( hdc
, 70, 70, 50, 70, 3, 5 );
1298 RoundRect( hdc
, 75, 75, 75, 85, 6, 4 );
1299 RoundRect( hdc
, 80, 80, 81, 81, 8, 9 );
1300 RoundRect( hdc
, 90, 90, 95, 85, 0, 7 );
1301 SetArcDirection( hdc
, AD_CLOCKWISE
);
1302 RoundRect( hdc
, 20, 20, 40, 40, 10, 10 );
1303 RoundRect( hdc
, 30, 50, 55, 35, -30, -30 );
1304 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
1305 SetMapMode( hdc
, MM_ANISOTROPIC
);
1306 SetViewportExtEx( hdc
, -2, 2, NULL
);
1307 RoundRect( hdc
, 20, 20, 40, 40, 15, 12 );
1308 RoundRect( hdc
, 30, 50, 55, 35, 7, 9 );
1309 SetViewportExtEx( hdc
, 3, -3, NULL
);
1310 RoundRect( hdc
, 20, 20, 40, 40, 15, 12 );
1311 RoundRect( hdc
, 30, 50, 55, 35, 3, 4 );
1312 SetWindowExtEx( hdc
, -20, 20, NULL
);
1313 RoundRect( hdc
, 20, 20, 40, 40, 2, 1 );
1314 RoundRect( hdc
, 24, 22, 21, 20, 4, 4 );
1315 SetMapMode( hdc
, MM_TEXT
);
1316 SetGraphicsMode( hdc
, GM_ADVANCED
);
1317 RoundRect( hdc
, 20, 20, 40, 40, 10, 10 );
1318 RoundRect( hdc
, 30, 50, 55, 35, -30, -30 );
1319 RoundRect( hdc
, 60, 60, 35, 45, 5, 2 );
1320 RoundRect( hdc
, 70, 70, 50, 70, 3, 5 );
1321 RoundRect( hdc
, 75, 75, 75, 85, 6, 4 );
1322 RoundRect( hdc
, 80, 80, 81, 81, 8, 9 );
1323 RoundRect( hdc
, 90, 90, 95, 85, 0, 7 );
1324 SetArcDirection( hdc
, AD_CLOCKWISE
);
1325 RoundRect( hdc
, 20, 20, 40, 40, 10, 10 );
1326 RoundRect( hdc
, 30, 50, 55, 35, -30, -30 );
1327 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
1329 SetMapMode( hdc
, MM_TEXT
);
1330 ok_path( hdc
, "roundrect_path", roundrect_path
, ARRAY_SIZE(roundrect_path
) );
1331 ReleaseDC( 0, hdc
);
1334 static const path_test_t ellipse_path
[] =
1336 {39, 30, PT_MOVETO
}, /* 0 */
1337 {39, 24, PT_BEZIERTO
}, /* 1 */
1338 {35, 20, PT_BEZIERTO
}, /* 2 */
1339 {30, 20, PT_BEZIERTO
}, /* 3 */
1340 {24, 20, PT_BEZIERTO
}, /* 4 */
1341 {20, 24, PT_BEZIERTO
}, /* 5 */
1342 {20, 30, PT_BEZIERTO
}, /* 6 */
1343 {20, 35, PT_BEZIERTO
}, /* 7 */
1344 {24, 39, PT_BEZIERTO
}, /* 8 */
1345 {30, 39, PT_BEZIERTO
}, /* 9 */
1346 {35, 39, PT_BEZIERTO
}, /* 10 */
1347 {39, 35, PT_BEZIERTO
}, /* 11 */
1348 {39, 30, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 12 */
1349 {54, 42, PT_MOVETO
}, /* 13 */
1350 {54, 38, PT_BEZIERTO
}, /* 14 */
1351 {49, 35, PT_BEZIERTO
}, /* 15 */
1352 {42, 35, PT_BEZIERTO
}, /* 16 */
1353 {35, 35, PT_BEZIERTO
}, /* 17 */
1354 {30, 38, PT_BEZIERTO
}, /* 18 */
1355 {30, 42, PT_BEZIERTO
}, /* 19 */
1356 {30, 46, PT_BEZIERTO
}, /* 20 */
1357 {35, 49, PT_BEZIERTO
}, /* 21 */
1358 {42, 49, PT_BEZIERTO
}, /* 22 */
1359 {49, 49, PT_BEZIERTO
}, /* 23 */
1360 {54, 46, PT_BEZIERTO
}, /* 24 */
1361 {54, 42, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 25 */
1362 {59, 52, PT_MOVETO
}, /* 26 */
1363 {59, 48, PT_BEZIERTO
}, /* 27 */
1364 {54, 45, PT_BEZIERTO
}, /* 28 */
1365 {47, 45, PT_BEZIERTO
}, /* 29 */
1366 {40, 45, PT_BEZIERTO
}, /* 30 */
1367 {35, 48, PT_BEZIERTO
}, /* 31 */
1368 {35, 52, PT_BEZIERTO
}, /* 32 */
1369 {35, 56, PT_BEZIERTO
}, /* 33 */
1370 {40, 59, PT_BEZIERTO
}, /* 34 */
1371 {47, 59, PT_BEZIERTO
}, /* 35 */
1372 {54, 59, PT_BEZIERTO
}, /* 36 */
1373 {59, 56, PT_BEZIERTO
}, /* 37 */
1374 {59, 52, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 38 */
1375 {80, 80, PT_MOVETO
}, /* 39 */
1376 {80, 80, PT_BEZIERTO
}, /* 40 */
1377 {80, 80, PT_BEZIERTO
}, /* 41 */
1378 {80, 80, PT_BEZIERTO
}, /* 42 */
1379 {80, 80, PT_BEZIERTO
}, /* 43 */
1380 {80, 80, PT_BEZIERTO
}, /* 44 */
1381 {80, 80, PT_BEZIERTO
}, /* 45 */
1382 {80, 80, PT_BEZIERTO
}, /* 46 */
1383 {80, 80, PT_BEZIERTO
}, /* 47 */
1384 {80, 80, PT_BEZIERTO
}, /* 48 */
1385 {80, 80, PT_BEZIERTO
}, /* 49 */
1386 {80, 80, PT_BEZIERTO
}, /* 50 */
1387 {80, 80, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 51 */
1388 {39, 30, PT_MOVETO
}, /* 52 */
1389 {39, 35, PT_BEZIERTO
}, /* 53 */
1390 {35, 39, PT_BEZIERTO
}, /* 54 */
1391 {30, 39, PT_BEZIERTO
}, /* 55 */
1392 {24, 39, PT_BEZIERTO
}, /* 56 */
1393 {20, 35, PT_BEZIERTO
}, /* 57 */
1394 {20, 30, PT_BEZIERTO
}, /* 58 */
1395 {20, 24, PT_BEZIERTO
}, /* 59 */
1396 {24, 20, PT_BEZIERTO
}, /* 60 */
1397 {30, 20, PT_BEZIERTO
}, /* 61 */
1398 {35, 20, PT_BEZIERTO
}, /* 62 */
1399 {39, 24, PT_BEZIERTO
}, /* 63 */
1400 {39, 30, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 64 */
1401 {54, 42, PT_MOVETO
}, /* 65 */
1402 {54, 46, PT_BEZIERTO
}, /* 66 */
1403 {49, 49, PT_BEZIERTO
}, /* 67 */
1404 {42, 49, PT_BEZIERTO
}, /* 68 */
1405 {35, 49, PT_BEZIERTO
}, /* 69 */
1406 {30, 46, PT_BEZIERTO
}, /* 70 */
1407 {30, 42, PT_BEZIERTO
}, /* 71 */
1408 {30, 38, PT_BEZIERTO
}, /* 72 */
1409 {35, 35, PT_BEZIERTO
}, /* 73 */
1410 {42, 35, PT_BEZIERTO
}, /* 74 */
1411 {49, 35, PT_BEZIERTO
}, /* 75 */
1412 {54, 38, PT_BEZIERTO
}, /* 76 */
1413 {54, 42, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 77 */
1414 {59, 52, PT_MOVETO
}, /* 78 */
1415 {59, 56, PT_BEZIERTO
}, /* 79 */
1416 {54, 59, PT_BEZIERTO
}, /* 80 */
1417 {47, 59, PT_BEZIERTO
}, /* 81 */
1418 {40, 59, PT_BEZIERTO
}, /* 82 */
1419 {35, 56, PT_BEZIERTO
}, /* 83 */
1420 {35, 52, PT_BEZIERTO
}, /* 84 */
1421 {35, 48, PT_BEZIERTO
}, /* 85 */
1422 {40, 45, PT_BEZIERTO
}, /* 86 */
1423 {47, 45, PT_BEZIERTO
}, /* 87 */
1424 {54, 45, PT_BEZIERTO
}, /* 88 */
1425 {59, 48, PT_BEZIERTO
}, /* 89 */
1426 {59, 52, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 90 */
1427 {80, 80, PT_MOVETO
}, /* 91 */
1428 {80, 80, PT_BEZIERTO
}, /* 92 */
1429 {80, 80, PT_BEZIERTO
}, /* 93 */
1430 {80, 80, PT_BEZIERTO
}, /* 94 */
1431 {80, 80, PT_BEZIERTO
}, /* 95 */
1432 {80, 80, PT_BEZIERTO
}, /* 96 */
1433 {80, 80, PT_BEZIERTO
}, /* 97 */
1434 {80, 80, PT_BEZIERTO
}, /* 98 */
1435 {80, 80, PT_BEZIERTO
}, /* 99 */
1436 {80, 80, PT_BEZIERTO
}, /* 100 */
1437 {80, 80, PT_BEZIERTO
}, /* 101 */
1438 {80, 80, PT_BEZIERTO
}, /* 102 */
1439 {80, 80, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 103 */
1440 {-41, 60, PT_MOVETO
}, /* 104 */
1441 {-41, 49, PT_BEZIERTO
}, /* 105 */
1442 {-50, 40, PT_BEZIERTO
}, /* 106 */
1443 {-60, 40, PT_BEZIERTO
}, /* 107 */
1444 {-71, 40, PT_BEZIERTO
}, /* 108 */
1445 {-80, 49, PT_BEZIERTO
}, /* 109 */
1446 {-80, 60, PT_BEZIERTO
}, /* 110 */
1447 {-80, 70, PT_BEZIERTO
}, /* 111 */
1448 {-71, 79, PT_BEZIERTO
}, /* 112 */
1449 {-60, 79, PT_BEZIERTO
}, /* 113 */
1450 {-50, 79, PT_BEZIERTO
}, /* 114 */
1451 {-41, 70, PT_BEZIERTO
}, /* 115 */
1452 {-41, 60, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 116 */
1453 {-61, 85, PT_MOVETO
}, /* 117 */
1454 {-61, 77, PT_BEZIERTO
}, /* 118 */
1455 {-72, 70, PT_BEZIERTO
}, /* 119 */
1456 {-85, 70, PT_BEZIERTO
}, /* 120 */
1457 {-99, 70, PT_BEZIERTO
}, /* 121 */
1458 {-110, 77, PT_BEZIERTO
}, /* 122 */
1459 {-110, 85, PT_BEZIERTO
}, /* 123 */
1460 {-110, 93, PT_BEZIERTO
}, /* 124 */
1461 {-99, 99, PT_BEZIERTO
}, /* 125 */
1462 {-85, 99, PT_BEZIERTO
}, /* 126 */
1463 {-72, 99, PT_BEZIERTO
}, /* 127 */
1464 {-61, 93, PT_BEZIERTO
}, /* 128 */
1465 {-61, 85, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 129 */
1466 {119, -90, PT_MOVETO
}, /* 130 */
1467 {119, -107, PT_BEZIERTO
}, /* 131 */
1468 {106, -120, PT_BEZIERTO
}, /* 132 */
1469 {90, -120, PT_BEZIERTO
}, /* 133 */
1470 {73, -120, PT_BEZIERTO
}, /* 134 */
1471 {60, -107, PT_BEZIERTO
}, /* 135 */
1472 {60, -90, PT_BEZIERTO
}, /* 136 */
1473 {60, -74, PT_BEZIERTO
}, /* 137 */
1474 {73, -61, PT_BEZIERTO
}, /* 138 */
1475 {90, -61, PT_BEZIERTO
}, /* 139 */
1476 {106, -61, PT_BEZIERTO
}, /* 140 */
1477 {119, -74, PT_BEZIERTO
}, /* 141 */
1478 {119, -90, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 142 */
1479 {164, -128, PT_MOVETO
}, /* 143 */
1480 {164, -140, PT_BEZIERTO
}, /* 144 */
1481 {147, -150, PT_BEZIERTO
}, /* 145 */
1482 {127, -150, PT_BEZIERTO
}, /* 146 */
1483 {107, -150, PT_BEZIERTO
}, /* 147 */
1484 {90, -140, PT_BEZIERTO
}, /* 148 */
1485 {90, -128, PT_BEZIERTO
}, /* 149 */
1486 {90, -116, PT_BEZIERTO
}, /* 150 */
1487 {107, -106, PT_BEZIERTO
}, /* 151 */
1488 {127, -106, PT_BEZIERTO
}, /* 152 */
1489 {147, -106, PT_BEZIERTO
}, /* 153 */
1490 {164, -116, PT_BEZIERTO
}, /* 154 */
1491 {164, -128, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 155 */
1492 {-4, -5, PT_MOVETO
}, /* 156 */
1493 {-4, -5, PT_BEZIERTO
}, /* 157 */
1494 {-4, -6, PT_BEZIERTO
}, /* 158 */
1495 {-5, -6, PT_BEZIERTO
}, /* 159 */
1496 {-6, -6, PT_BEZIERTO
}, /* 160 */
1497 {-6, -5, PT_BEZIERTO
}, /* 161 */
1498 {-6, -5, PT_BEZIERTO
}, /* 162 */
1499 {-6, -4, PT_BEZIERTO
}, /* 163 */
1500 {-6, -4, PT_BEZIERTO
}, /* 164 */
1501 {-5, -4, PT_BEZIERTO
}, /* 165 */
1502 {-4, -4, PT_BEZIERTO
}, /* 166 */
1503 {-4, -4, PT_BEZIERTO
}, /* 167 */
1504 {-4, -5, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 168 */
1505 {40, 30, PT_MOVETO
}, /* 169 */
1506 {40, 25, PT_BEZIERTO
}, /* 170 */
1507 {36, 20, PT_BEZIERTO
}, /* 171 */
1508 {30, 20, PT_BEZIERTO
}, /* 172 */
1509 {24, 20, PT_BEZIERTO
}, /* 173 */
1510 {20, 25, PT_BEZIERTO
}, /* 174 */
1511 {20, 30, PT_BEZIERTO
}, /* 175 */
1512 {20, 36, PT_BEZIERTO
}, /* 176 */
1513 {24, 40, PT_BEZIERTO
}, /* 177 */
1514 {30, 40, PT_BEZIERTO
}, /* 178 */
1515 {36, 40, PT_BEZIERTO
}, /* 179 */
1516 {40, 36, PT_BEZIERTO
}, /* 180 */
1517 {40, 30, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 181 */
1518 {55, 43, PT_MOVETO
}, /* 182 */
1519 {55, 38, PT_BEZIERTO
}, /* 183 */
1520 {49, 35, PT_BEZIERTO
}, /* 184 */
1521 {43, 35, PT_BEZIERTO
}, /* 185 */
1522 {36, 35, PT_BEZIERTO
}, /* 186 */
1523 {30, 38, PT_BEZIERTO
}, /* 187 */
1524 {30, 43, PT_BEZIERTO
}, /* 188 */
1525 {30, 47, PT_BEZIERTO
}, /* 189 */
1526 {36, 50, PT_BEZIERTO
}, /* 190 */
1527 {43, 50, PT_BEZIERTO
}, /* 191 */
1528 {49, 50, PT_BEZIERTO
}, /* 192 */
1529 {55, 47, PT_BEZIERTO
}, /* 193 */
1530 {55, 43, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 194 */
1531 {60, 53, PT_MOVETO
}, /* 195 */
1532 {60, 48, PT_BEZIERTO
}, /* 196 */
1533 {54, 45, PT_BEZIERTO
}, /* 197 */
1534 {48, 45, PT_BEZIERTO
}, /* 198 */
1535 {41, 45, PT_BEZIERTO
}, /* 199 */
1536 {35, 48, PT_BEZIERTO
}, /* 200 */
1537 {35, 53, PT_BEZIERTO
}, /* 201 */
1538 {35, 57, PT_BEZIERTO
}, /* 202 */
1539 {41, 60, PT_BEZIERTO
}, /* 203 */
1540 {48, 60, PT_BEZIERTO
}, /* 204 */
1541 {54, 60, PT_BEZIERTO
}, /* 205 */
1542 {60, 57, PT_BEZIERTO
}, /* 206 */
1543 {60, 53, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 207 */
1544 {70, 70, PT_MOVETO
}, /* 208 */
1545 {70, 70, PT_BEZIERTO
}, /* 209 */
1546 {66, 70, PT_BEZIERTO
}, /* 210 */
1547 {60, 70, PT_BEZIERTO
}, /* 211 */
1548 {54, 70, PT_BEZIERTO
}, /* 212 */
1549 {50, 70, PT_BEZIERTO
}, /* 213 */
1550 {50, 70, PT_BEZIERTO
}, /* 214 */
1551 {50, 70, PT_BEZIERTO
}, /* 215 */
1552 {54, 70, PT_BEZIERTO
}, /* 216 */
1553 {60, 70, PT_BEZIERTO
}, /* 217 */
1554 {66, 70, PT_BEZIERTO
}, /* 218 */
1555 {70, 70, PT_BEZIERTO
}, /* 219 */
1556 {70, 70, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 220 */
1557 {75, 80, PT_MOVETO
}, /* 221 */
1558 {75, 77, PT_BEZIERTO
}, /* 222 */
1559 {75, 75, PT_BEZIERTO
}, /* 223 */
1560 {75, 75, PT_BEZIERTO
}, /* 224 */
1561 {75, 75, PT_BEZIERTO
}, /* 225 */
1562 {75, 77, PT_BEZIERTO
}, /* 226 */
1563 {75, 80, PT_BEZIERTO
}, /* 227 */
1564 {75, 83, PT_BEZIERTO
}, /* 228 */
1565 {75, 85, PT_BEZIERTO
}, /* 229 */
1566 {75, 85, PT_BEZIERTO
}, /* 230 */
1567 {75, 85, PT_BEZIERTO
}, /* 231 */
1568 {75, 83, PT_BEZIERTO
}, /* 232 */
1569 {75, 80, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 233 */
1570 {81, 81, PT_MOVETO
}, /* 234 */
1571 {81, 80, PT_BEZIERTO
}, /* 235 */
1572 {81, 80, PT_BEZIERTO
}, /* 236 */
1573 {81, 80, PT_BEZIERTO
}, /* 237 */
1574 {80, 80, PT_BEZIERTO
}, /* 238 */
1575 {80, 80, PT_BEZIERTO
}, /* 239 */
1576 {80, 81, PT_BEZIERTO
}, /* 240 */
1577 {80, 81, PT_BEZIERTO
}, /* 241 */
1578 {80, 81, PT_BEZIERTO
}, /* 242 */
1579 {81, 81, PT_BEZIERTO
}, /* 243 */
1580 {81, 81, PT_BEZIERTO
}, /* 244 */
1581 {81, 81, PT_BEZIERTO
}, /* 245 */
1582 {81, 81, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 246 */
1583 {40, 30, PT_MOVETO
}, /* 247 */
1584 {40, 36, PT_BEZIERTO
}, /* 248 */
1585 {36, 40, PT_BEZIERTO
}, /* 249 */
1586 {30, 40, PT_BEZIERTO
}, /* 250 */
1587 {24, 40, PT_BEZIERTO
}, /* 251 */
1588 {20, 36, PT_BEZIERTO
}, /* 252 */
1589 {20, 30, PT_BEZIERTO
}, /* 253 */
1590 {20, 24, PT_BEZIERTO
}, /* 254 */
1591 {24, 20, PT_BEZIERTO
}, /* 255 */
1592 {30, 20, PT_BEZIERTO
}, /* 256 */
1593 {36, 20, PT_BEZIERTO
}, /* 257 */
1594 {40, 24, PT_BEZIERTO
}, /* 258 */
1595 {40, 30, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 259 */
1596 {55, 43, PT_MOVETO
}, /* 260 */
1597 {55, 47, PT_BEZIERTO
}, /* 261 */
1598 {49, 50, PT_BEZIERTO
}, /* 262 */
1599 {43, 50, PT_BEZIERTO
}, /* 263 */
1600 {36, 50, PT_BEZIERTO
}, /* 264 */
1601 {30, 47, PT_BEZIERTO
}, /* 265 */
1602 {30, 43, PT_BEZIERTO
}, /* 266 */
1603 {30, 38, PT_BEZIERTO
}, /* 267 */
1604 {36, 35, PT_BEZIERTO
}, /* 268 */
1605 {43, 35, PT_BEZIERTO
}, /* 269 */
1606 {49, 35, PT_BEZIERTO
}, /* 270 */
1607 {55, 38, PT_BEZIERTO
}, /* 271 */
1608 {55, 43, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 272 */
1609 {60, 53, PT_MOVETO
}, /* 273 */
1610 {60, 57, PT_BEZIERTO
}, /* 274 */
1611 {54, 60, PT_BEZIERTO
}, /* 275 */
1612 {48, 60, PT_BEZIERTO
}, /* 276 */
1613 {41, 60, PT_BEZIERTO
}, /* 277 */
1614 {35, 57, PT_BEZIERTO
}, /* 278 */
1615 {35, 53, PT_BEZIERTO
}, /* 279 */
1616 {35, 48, PT_BEZIERTO
}, /* 280 */
1617 {41, 45, PT_BEZIERTO
}, /* 281 */
1618 {48, 45, PT_BEZIERTO
}, /* 282 */
1619 {54, 45, PT_BEZIERTO
}, /* 283 */
1620 {60, 48, PT_BEZIERTO
}, /* 284 */
1621 {60, 53, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 285 */
1622 {70, 70, PT_MOVETO
}, /* 286 */
1623 {70, 70, PT_BEZIERTO
}, /* 287 */
1624 {66, 70, PT_BEZIERTO
}, /* 288 */
1625 {60, 70, PT_BEZIERTO
}, /* 289 */
1626 {54, 70, PT_BEZIERTO
}, /* 290 */
1627 {50, 70, PT_BEZIERTO
}, /* 291 */
1628 {50, 70, PT_BEZIERTO
}, /* 292 */
1629 {50, 70, PT_BEZIERTO
}, /* 293 */
1630 {54, 70, PT_BEZIERTO
}, /* 294 */
1631 {60, 70, PT_BEZIERTO
}, /* 295 */
1632 {66, 70, PT_BEZIERTO
}, /* 296 */
1633 {70, 70, PT_BEZIERTO
}, /* 297 */
1634 {70, 70, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 298 */
1635 {75, 80, PT_MOVETO
}, /* 299 */
1636 {75, 83, PT_BEZIERTO
}, /* 300 */
1637 {75, 85, PT_BEZIERTO
}, /* 301 */
1638 {75, 85, PT_BEZIERTO
}, /* 302 */
1639 {75, 85, PT_BEZIERTO
}, /* 303 */
1640 {75, 83, PT_BEZIERTO
}, /* 304 */
1641 {75, 80, PT_BEZIERTO
}, /* 305 */
1642 {75, 77, PT_BEZIERTO
}, /* 306 */
1643 {75, 75, PT_BEZIERTO
}, /* 307 */
1644 {75, 75, PT_BEZIERTO
}, /* 308 */
1645 {75, 75, PT_BEZIERTO
}, /* 309 */
1646 {75, 77, PT_BEZIERTO
}, /* 310 */
1647 {75, 80, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 311 */
1648 {81, 81, PT_MOVETO
}, /* 312 */
1649 {81, 81, PT_BEZIERTO
}, /* 313 */
1650 {81, 81, PT_BEZIERTO
}, /* 314 */
1651 {81, 81, PT_BEZIERTO
}, /* 315 */
1652 {80, 81, PT_BEZIERTO
}, /* 316 */
1653 {80, 81, PT_BEZIERTO
}, /* 317 */
1654 {80, 81, PT_BEZIERTO
}, /* 318 */
1655 {80, 80, PT_BEZIERTO
}, /* 319 */
1656 {80, 80, PT_BEZIERTO
}, /* 320 */
1657 {81, 80, PT_BEZIERTO
}, /* 321 */
1658 {81, 80, PT_BEZIERTO
}, /* 322 */
1659 {81, 80, PT_BEZIERTO
}, /* 323 */
1660 {81, 81, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 324 */
1663 static void test_ellipse(void)
1665 HDC hdc
= GetDC( 0 );
1668 Ellipse( hdc
, 20, 20, 40, 40 );
1669 Ellipse( hdc
, 30, 50, 55, 35 );
1670 Ellipse( hdc
, 60, 60, 35, 45 );
1671 Ellipse( hdc
, 70, 70, 50, 70 );
1672 Ellipse( hdc
, 75, 75, 75, 85 );
1673 Ellipse( hdc
, 80, 80, 81, 81 );
1674 SetArcDirection( hdc
, AD_CLOCKWISE
);
1675 Ellipse( hdc
, 20, 20, 40, 40 );
1676 Ellipse( hdc
, 30, 50, 55, 35 );
1677 Ellipse( hdc
, 60, 60, 35, 45 );
1678 Ellipse( hdc
, 70, 70, 50, 70 );
1679 Ellipse( hdc
, 75, 75, 75, 85 );
1680 Ellipse( hdc
, 80, 80, 81, 81 );
1681 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
1682 SetMapMode( hdc
, MM_ANISOTROPIC
);
1683 SetViewportExtEx( hdc
, -2, 2, NULL
);
1684 Ellipse( hdc
, 20, 20, 40, 40 );
1685 Ellipse( hdc
, 30, 50, 55, 35 );
1686 SetViewportExtEx( hdc
, 3, -3, NULL
);
1687 Ellipse( hdc
, 20, 20, 40, 40 );
1688 Ellipse( hdc
, 30, 50, 55, 35 );
1689 SetWindowExtEx( hdc
, -20, 20, NULL
);
1690 Ellipse( hdc
, 20, 20, 40, 40 );
1691 Ellipse( hdc
, 24, 22, 21, 20 );
1692 SetMapMode( hdc
, MM_TEXT
);
1693 SetGraphicsMode( hdc
, GM_ADVANCED
);
1694 Ellipse( hdc
, 20, 20, 40, 40 );
1695 Ellipse( hdc
, 30, 50, 55, 35 );
1696 Ellipse( hdc
, 60, 60, 35, 45 );
1697 Ellipse( hdc
, 70, 70, 50, 70 );
1698 Ellipse( hdc
, 75, 75, 75, 85 );
1699 Ellipse( hdc
, 80, 80, 81, 81 );
1700 SetArcDirection( hdc
, AD_CLOCKWISE
);
1701 Ellipse( hdc
, 20, 20, 40, 40 );
1702 Ellipse( hdc
, 30, 50, 55, 35 );
1703 Ellipse( hdc
, 60, 60, 35, 45 );
1704 Ellipse( hdc
, 70, 70, 50, 70 );
1705 Ellipse( hdc
, 75, 75, 75, 85 );
1706 Ellipse( hdc
, 80, 80, 81, 81 );
1707 SetArcDirection( hdc
, AD_COUNTERCLOCKWISE
);
1709 SetMapMode( hdc
, MM_TEXT
);
1710 ok_path( hdc
, "ellipse_path", ellipse_path
, ARRAY_SIZE(ellipse_path
) );
1713 static const path_test_t all_funcs_path
[] =
1715 {0, 0, PT_MOVETO
}, /* 0 */
1716 {50, 150, PT_LINETO
}, /* 1 */
1717 {50, 50, PT_MOVETO
}, /* 2 */
1718 {150, 150, PT_LINETO
}, /* 3 */
1719 {150, 50, PT_LINETO
}, /* 4 */
1720 {50, 50, PT_LINETO
}, /* 5 */
1721 {37, 13, PT_LINETO
}, /* 6 */
1722 {24, 13, PT_BEZIERTO
}, /* 7 */
1723 {14, 23, PT_BEZIERTO
}, /* 8 */
1724 {14, 36, PT_BEZIERTO
}, /* 9 */
1725 {14, 49, PT_BEZIERTO
}, /* 10 */
1726 {24, 59, PT_BEZIERTO
}, /* 11 */
1727 {37, 59, PT_BEZIERTO
}, /* 12 */
1728 {37, 59, PT_BEZIERTO
}, /* 13 */
1729 {37, 59, PT_BEZIERTO
}, /* 14 */
1730 {37, 59, PT_BEZIERTO
}, /* 15 */
1731 {10, 10, PT_MOVETO
}, /* 16 */
1732 {20, 10, PT_LINETO
}, /* 17 */
1733 {10, 20, PT_LINETO
}, /* 18 */
1734 {20, 20, PT_LINETO
}, /* 19 */
1735 {36, 27, PT_MOVETO
}, /* 20 */
1736 {37, 26, PT_BEZIERTO
}, /* 21 */
1737 {38, 25, PT_BEZIERTO
}, /* 22 */
1738 {38, 25, PT_BEZIERTO
}, /* 23 */
1739 {38, 23, PT_BEZIERTO
}, /* 24 */
1740 {34, 21, PT_BEZIERTO
}, /* 25 */
1741 {30, 21, PT_BEZIERTO
}, /* 26 */
1742 {27, 21, PT_BEZIERTO
}, /* 27 */
1743 {25, 21, PT_BEZIERTO
}, /* 28 */
1744 {24, 22, PT_BEZIERTO
}, /* 29 */
1745 {37, 59, PT_MOVETO
}, /* 30 */
1746 {10, 10, PT_LINETO
}, /* 31 */
1747 {20, 10, PT_LINETO
}, /* 32 */
1748 {10, 20, PT_LINETO
}, /* 33 */
1749 {20, 20, PT_LINETO
}, /* 34 */
1750 {34, 26, PT_LINETO
}, /* 35 */
1751 {35, 25, PT_BEZIERTO
}, /* 36 */
1752 {36, 25, PT_BEZIERTO
}, /* 37 */
1753 {36, 25, PT_BEZIERTO
}, /* 38 */
1754 {36, 24, PT_BEZIERTO
}, /* 39 */
1755 {33, 23, PT_BEZIERTO
}, /* 40 */
1756 {30, 23, PT_BEZIERTO
}, /* 41 */
1757 {28, 23, PT_BEZIERTO
}, /* 42 */
1758 {26, 23, PT_BEZIERTO
}, /* 43 */
1759 {25, 23, PT_BEZIERTO
}, /* 44 */
1760 {10, 10, PT_MOVETO
}, /* 45 */
1761 {20, 10, PT_LINETO
}, /* 46 */
1762 {10, 20, PT_LINETO
}, /* 47 */
1763 {20, 20, PT_LINETO
}, /* 48 */
1764 {30, 30, PT_MOVETO
}, /* 49 */
1765 {40, 20, PT_LINETO
}, /* 50 */
1766 {20, 30, PT_LINETO
}, /* 51 */
1767 {30, 40, PT_LINETO
}, /* 52 */
1768 {10, 50, PT_LINETO
}, /* 53 */
1769 {45, 45, PT_MOVETO
}, /* 54 */
1770 {45, 45, PT_BEZIERTO
}, /* 55 */
1771 {44, 46, PT_BEZIERTO
}, /* 56 */
1772 {43, 47, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 57 */
1773 {10, 10, PT_MOVETO
}, /* 58 */
1774 {20, 10, PT_LINETO
}, /* 59 */
1775 {10, 20, PT_BEZIERTO
}, /* 60 */
1776 {20, 20, PT_BEZIERTO
}, /* 61 */
1777 {30, 30, PT_BEZIERTO
}, /* 62 */
1778 {40, 20, PT_LINETO
}, /* 63 */
1779 {20, 30, PT_LINETO
| PT_CLOSEFIGURE
}, /* 64 */
1780 {30, 40, PT_MOVETO
}, /* 65 */
1781 {10, 50, PT_LINETO
}, /* 66 */
1782 {55, 55, PT_MOVETO
}, /* 67 */
1783 {54, 55, PT_BEZIERTO
}, /* 68 */
1784 {54, 56, PT_BEZIERTO
}, /* 69 */
1785 {54, 56, PT_BEZIERTO
}, /* 70 */
1786 {58, 61, PT_LINETO
| PT_CLOSEFIGURE
}, /* 71 */
1787 {10, 10, PT_MOVETO
}, /* 72 */
1788 {20, 10, PT_LINETO
}, /* 73 */
1789 {10, 20, PT_LINETO
}, /* 74 */
1790 {20, 20, PT_LINETO
}, /* 75 */
1791 {30, 30, PT_LINETO
}, /* 76 */
1792 {40, 20, PT_LINETO
}, /* 77 */
1793 {20, 30, PT_LINETO
}, /* 78 */
1794 {30, 40, PT_LINETO
}, /* 79 */
1795 {10, 50, PT_LINETO
| PT_CLOSEFIGURE
}, /* 80 */
1796 {43, 49, PT_MOVETO
}, /* 81 */
1797 {43, 40, PT_BEZIERTO
}, /* 82 */
1798 {38, 33, PT_BEZIERTO
}, /* 83 */
1799 {33, 33, PT_BEZIERTO
}, /* 84 */
1800 {27, 33, PT_BEZIERTO
}, /* 85 */
1801 {22, 40, PT_BEZIERTO
}, /* 86 */
1802 {22, 49, PT_BEZIERTO
}, /* 87 */
1803 {22, 58, PT_BEZIERTO
}, /* 88 */
1804 {27, 65, PT_BEZIERTO
}, /* 89 */
1805 {33, 65, PT_BEZIERTO
}, /* 90 */
1806 {38, 65, PT_BEZIERTO
}, /* 91 */
1807 {43, 58, PT_BEZIERTO
}, /* 92 */
1808 {43, 49, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 93 */
1809 {79, 70, PT_MOVETO
}, /* 94 */
1810 {60, 70, PT_LINETO
}, /* 95 */
1811 {60, 89, PT_LINETO
}, /* 96 */
1812 {79, 89, PT_LINETO
| PT_CLOSEFIGURE
}, /* 97 */
1813 {199, 122, PT_MOVETO
}, /* 98 */
1814 {199, 110, PT_BEZIERTO
}, /* 99 */
1815 {191, 100, PT_BEZIERTO
}, /* 100 */
1816 {182, 100, PT_BEZIERTO
}, /* 101 */
1817 {117, 100, PT_LINETO
}, /* 102 */
1818 {108, 100, PT_BEZIERTO
}, /* 103 */
1819 {100, 110, PT_BEZIERTO
}, /* 104 */
1820 {100, 122, PT_BEZIERTO
}, /* 105 */
1821 {100, 177, PT_LINETO
}, /* 106 */
1822 {100, 189, PT_BEZIERTO
}, /* 107 */
1823 {108, 199, PT_BEZIERTO
}, /* 108 */
1824 {117, 199, PT_BEZIERTO
}, /* 109 */
1825 {182, 199, PT_LINETO
}, /* 110 */
1826 {191, 199, PT_BEZIERTO
}, /* 111 */
1827 {199, 189, PT_BEZIERTO
}, /* 112 */
1828 {199, 177, PT_BEZIERTO
| PT_CLOSEFIGURE
}, /* 113 */
1829 {10, 10, PT_MOVETO
}, /* 114 */
1830 {20, 10, PT_BEZIERTO
}, /* 115 */
1831 {10, 20, PT_BEZIERTO
}, /* 116 */
1832 {20, 20, PT_BEZIERTO
}, /* 117 */
1833 {30, 30, PT_BEZIERTO
}, /* 118 */
1834 {40, 20, PT_BEZIERTO
}, /* 119 */
1835 {20, 30, PT_BEZIERTO
}, /* 120 */
1836 {10, 10, PT_MOVETO
}, /* 121 */
1837 {20, 10, PT_LINETO
}, /* 122 */
1838 {10, 20, PT_LINETO
}, /* 123 */
1839 {20, 20, PT_LINETO
| PT_CLOSEFIGURE
}, /* 124 */
1840 {30, 30, PT_MOVETO
}, /* 125 */
1841 {40, 20, PT_LINETO
}, /* 126 */
1842 {20, 30, PT_LINETO
}, /* 127 */
1843 {30, 40, PT_LINETO
}, /* 128 */
1844 {10, 50, PT_LINETO
| PT_CLOSEFIGURE
}, /* 129 */
1845 {10, 50, PT_MOVETO
}, /* 130 */
1846 {10, 10, PT_BEZIERTO
}, /* 131 */
1847 {20, 10, PT_BEZIERTO
}, /* 132 */
1848 {10, 20, PT_BEZIERTO
}, /* 133 */
1849 {20, 20, PT_BEZIERTO
}, /* 134 */
1850 {30, 30, PT_BEZIERTO
}, /* 135 */
1851 {40, 20, PT_BEZIERTO
}, /* 136 */
1852 {20, 30, PT_BEZIERTO
}, /* 137 */
1853 {30, 40, PT_BEZIERTO
}, /* 138 */
1854 {10, 50, PT_BEZIERTO
}, /* 139 */
1855 {150, 150, PT_LINETO
}, /* 140 */
1858 /* run once through all functions that support paths */
1859 static void test_all_functions(void)
1861 POINT pts
[9] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}, {30, 30}, {40, 20},
1862 {20, 30}, {30, 40}, {10, 50}};
1863 DWORD counts
[5] = {4, 5, 0, 1, 2};
1864 BYTE types
[9] = { PT_MOVETO
, PT_LINETO
, PT_BEZIERTO
, PT_BEZIERTO
, PT_BEZIERTO
, PT_LINETO
,
1865 PT_LINETO
| PT_CLOSEFIGURE
, PT_MOVETO
, PT_LINETO
};
1866 HDC hdc
= GetDC( 0 );
1869 LineTo( hdc
, 50, 150 );
1870 MoveToEx( hdc
, 50, 50, NULL
);
1871 LineTo( hdc
, 150, 150 );
1872 LineTo( hdc
, 150, 50 );
1873 LineTo( hdc
, 50, 50 );
1874 AngleArc( hdc
, 37, 36, 23, 90, 180 );
1875 Polyline( hdc
, pts
, 4 );
1876 Arc( hdc
, 21, 21, 39, 29, 39, 29, 21, 21 );
1877 PolylineTo( hdc
, pts
, 4 );
1878 ArcTo( hdc
, 23, 23, 37, 27, 37, 27, 23, 23 );
1879 PolyPolyline( hdc
, pts
, counts
, 2 );
1880 Chord( hdc
, 42, 43, 57, 66, 39, 29, 21, 21 );
1881 PolyDraw( hdc
, pts
, types
, 9 );
1882 Pie( hdc
, 52, 54, 65, 68, 39, 29, 21, 21 );
1883 Polygon( hdc
, pts
, 9 );
1884 Ellipse( hdc
, 22, 33, 44, 66 );
1885 Rectangle( hdc
, 60, 70, 80, 90 );
1886 RoundRect( hdc
, 100, 100, 200, 200, 35, 45 );
1887 PolyBezier( hdc
, pts
, 7 );
1888 PolyPolygon( hdc
, pts
, (int *)counts
, 2 );
1889 PolyBezierTo( hdc
, pts
, 9 );
1890 LineTo( hdc
, 150, 150 );
1891 /* FIXME: ExtTextOut */
1893 ok_path( hdc
, "all_funcs_path", all_funcs_path
, ARRAY_SIZE(all_funcs_path
) );
1894 ReleaseDC( 0, hdc
);
1897 static void test_clipped_polygon_fill(void)
1899 const POINT pts
[3] = {{-10, -10}, {10, -5}, {0, 10}};
1900 HBRUSH brush
, oldbrush
;
1901 HBITMAP bmp
, oldbmp
;
1906 memdc
= CreateCompatibleDC( hdc
);
1907 bmp
= CreateCompatibleBitmap( hdc
, 20, 20 );
1908 brush
= CreateSolidBrush( RGB( 0x11, 0x22, 0x33 ) );
1909 oldbrush
= SelectObject( memdc
, brush
);
1910 oldbmp
= SelectObject( memdc
, bmp
);
1911 Polygon( memdc
, pts
, ARRAY_SIZE(pts
) );
1912 col
= GetPixel( memdc
, 1, 1 );
1913 ok( col
== RGB( 0x11, 0x22, 0x33 ), "got %06x\n", col
);
1914 SelectObject( memdc
, oldbrush
);
1915 SelectObject( memdc
, oldbmp
);
1916 DeleteObject( brush
);
1917 DeleteObject( bmp
);
1919 ReleaseDC( 0, hdc
);
1934 test_clipped_polygon_fill();
1935 test_all_functions();