1 /* 2 * Unit test suite for paths 3 * 4 * Copyright 2007 Laurent Vromman 5 * Copyright 2007 Misha Koshelev 6 * 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. 11 * 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. 16 * 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 20 */ 21 22 #include <stdarg.h> 23 #include <stdio.h> 24 #include <assert.h> 25 #include "windef.h" 26 #include "winbase.h" 27 #include "wingdi.h" 28 29 #include "wine/test.h" 30 31 #include "winuser.h" 32 #include "winerror.h" 33 34 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got) 35 36 static void test_path_state(void) 37 { 38 BYTE buffer[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)]; 39 BITMAPINFO *bi = (BITMAPINFO *)buffer; 40 HDC hdc; 41 HRGN rgn; 42 HBITMAP orig, dib; 43 void *bits; 44 BOOL ret; 45 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 ); 56 57 BeginPath( hdc ); 58 LineTo( hdc, 100, 100 ); 59 ret = WidenPath( hdc ); 60 ok( !ret, "WidenPath succeeded\n" ); 61 62 /* selecting another bitmap doesn't affect the path */ 63 SelectObject( hdc, orig ); 64 ret = WidenPath( hdc ); 65 ok( !ret, "WidenPath succeeded\n" ); 66 67 SelectObject( hdc, dib ); 68 ret = WidenPath( hdc ); 69 ok( !ret, "WidenPath succeeded\n" ); 70 71 ret = EndPath( hdc ); 72 ok( ret, "EndPath failed error %u\n", GetLastError() ); 73 ret = WidenPath( hdc ); 74 ok( ret, "WidenPath failed error %u\n", GetLastError() ); 75 76 SelectObject( hdc, orig ); 77 ret = WidenPath( hdc ); 78 ok( ret, "WidenPath failed error %u\n", GetLastError() ); 79 80 BeginPath( hdc ); 81 LineTo( hdc, 100, 100 ); 82 ret = WidenPath( hdc ); 83 ok( !ret, "WidenPath succeeded\n" ); 84 SaveDC( hdc ); 85 SelectObject( hdc, dib ); 86 ret = EndPath( hdc ); 87 ok( ret, "EndPath failed error %u\n", GetLastError() ); 88 ret = WidenPath( hdc ); 89 ok( ret, "WidenPath failed error %u\n", GetLastError() ); 90 91 /* path should be open again after RestoreDC */ 92 RestoreDC( hdc, -1 ); 93 ret = WidenPath( hdc ); 94 ok( !ret, "WidenPath succeeded\n" ); 95 ret = EndPath( hdc ); 96 ok( ret, "EndPath failed error %u\n", GetLastError() ); 97 98 SaveDC( hdc ); 99 BeginPath( hdc ); 100 RestoreDC( hdc, -1 ); 101 ret = WidenPath( hdc ); 102 ok( ret, "WidenPath failed error %u\n", GetLastError() ); 103 104 /* test all functions with no path at all */ 105 AbortPath( hdc ); 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() ); 111 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() ); 117 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() ); 123 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() ); 129 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() ); 135 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() ); 141 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() ); 147 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() ); 153 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() ); 159 160 /* test all functions with an open path */ 161 AbortPath( hdc ); 162 BeginPath( hdc ); 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() ); 168 169 AbortPath( hdc ); 170 BeginPath( hdc ); 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() ); 176 177 AbortPath( hdc ); 178 BeginPath( hdc ); 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() ); 184 185 AbortPath( hdc ); 186 BeginPath( hdc ); 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() ); 192 193 AbortPath( hdc ); 194 BeginPath( hdc ); 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() ); 200 201 AbortPath( hdc ); 202 BeginPath( hdc ); 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() ); 209 210 AbortPath( hdc ); 211 BeginPath( hdc ); 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() ); 218 219 AbortPath( hdc ); 220 BeginPath( hdc ); 221 ret = CloseFigure( hdc ); 222 ok( ret, "CloseFigure failed\n" ); 223 224 /* test all functions with a closed path */ 225 AbortPath( hdc ); 226 BeginPath( hdc ); 227 EndPath( hdc ); 228 ret = WidenPath( hdc ); 229 ok( ret, "WidenPath failed\n" ); 230 ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" ); 231 232 AbortPath( hdc ); 233 BeginPath( hdc ); 234 EndPath( hdc ); 235 ret = FlattenPath( hdc ); 236 ok( ret, "FlattenPath failed\n" ); 237 ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" ); 238 239 AbortPath( hdc ); 240 BeginPath( hdc ); 241 EndPath( hdc ); 242 ret = StrokePath( hdc ); 243 ok( ret, "StrokePath failed\n" ); 244 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 245 246 BeginPath( hdc ); 247 EndPath( hdc ); 248 ret = FillPath( hdc ); 249 ok( ret, "FillPath failed\n" ); 250 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 251 252 BeginPath( hdc ); 253 EndPath( hdc ); 254 ret = StrokeAndFillPath( hdc ); 255 ok( ret, "StrokeAndFillPath failed\n" ); 256 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 257 258 BeginPath( hdc ); 259 Rectangle( hdc, 1, 1, 10, 10 ); /* region needs some contents */ 260 EndPath( hdc ); 261 ret = SelectClipPath( hdc, RGN_OR ); 262 ok( ret, "SelectClipPath failed\n" ); 263 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 264 265 BeginPath( hdc ); 266 EndPath( hdc ); 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" ); 272 273 BeginPath( hdc ); 274 Rectangle( hdc, 1, 1, 10, 10 ); /* region needs some contents */ 275 EndPath( hdc ); 276 rgn = PathToRegion( hdc ); 277 ok( rgn != 0, "PathToRegion failed\n" ); 278 DeleteObject( rgn ); 279 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 280 281 BeginPath( hdc ); 282 EndPath( hdc ); 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() ); 287 DeleteObject( rgn ); 288 ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" ); 289 290 BeginPath( hdc ); 291 EndPath( hdc ); 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() ); 297 298 AbortPath( hdc ); 299 BeginPath( hdc ); 300 EndPath( hdc ); 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() ); 306 307 DeleteDC( hdc ); 308 DeleteObject( dib ); 309 } 310 311 static void test_widenpath(void) 312 { 313 HDC hdc = GetDC(0); 314 HPEN greenPen, narrowPen; 315 POINT pnt[6]; 316 INT nSize; 317 BOOL ret; 318 319 /* Create a pen to be used in WidenPath */ 320 greenPen = CreatePen(PS_SOLID, 10, RGB(0,0,0)); 321 SelectObject(hdc, greenPen); 322 323 /* Prepare a path */ 324 pnt[0].x = 100; 325 pnt[0].y = 0; 326 pnt[1].x = 200; 327 pnt[1].y = 0; 328 pnt[2].x = 300; 329 pnt[2].y = 100; 330 pnt[3].x = 300; 331 pnt[3].y = 200; 332 pnt[4].x = 200; 333 pnt[4].y = 300; 334 pnt[5].x = 100; 335 pnt[5].y = 300; 336 337 /* Set a polyline path */ 338 BeginPath(hdc); 339 Polyline(hdc, pnt, 6); 340 EndPath(hdc); 341 342 /* Widen the polyline path */ 343 ok(WidenPath(hdc), "WidenPath fails while widening a poyline path.\n"); 344 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); 349 350 AbortPath(hdc); 351 352 /* Test WidenPath with an open path (last error only set on Win2k and later) */ 353 SetLastError(0xdeadbeef); 354 BeginPath(hdc); 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()); 358 359 AbortPath(hdc); 360 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); 364 BeginPath(hdc); 365 Polyline(hdc, pnt, 6); 366 EndPath(hdc); 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); 371 372 ReleaseDC(0, hdc); 373 return; 374 } 375 376 /* 377 * Tests for GDI drawing functions in paths 378 */ 379 380 typedef struct 381 { 382 int x, y; 383 BYTE type; 384 } path_test_t; 385 386 /* Helper function to verify that the current path in the given DC matches the expected path. 387 * 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. 396 * 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. 400 */ 401 static void ok_path(HDC hdc, const char *path_name, const path_test_t *expected, int expected_size) 402 { 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"}; 406 POINT *pnt; 407 BYTE *types; 408 int size, idx; 409 410 /* Get the path */ 411 assert(hdc != 0); 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; 415 416 pnt = HeapAlloc(GetProcessHeap(), 0, size*sizeof(POINT)); 417 assert(pnt != 0); 418 types = HeapAlloc(GetProcessHeap(), 0, size*sizeof(BYTE)); 419 assert(types != 0); 420 size = GetPath(hdc, pnt, types, size); 421 assert(size > 0); 422 423 ok( size == expected_size, "%s: Path size %d does not match expected size %d\n", 424 path_name, size, expected_size); 425 426 for (idx = 0; idx < min( size, expected_size ); idx++) 427 { 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; 431 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); 435 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); 441 } 442 443 if (winetest_debug > 2) 444 { 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); 448 printf("};\n" ); 449 } 450 451 HeapFree(GetProcessHeap(), 0, types); 452 HeapFree(GetProcessHeap(), 0, pnt); 453 } 454 455 static const path_test_t arcto_path[] = 456 { 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 */ 478 }; 479 480 static void test_arcto(void) 481 { 482 HDC hdc = GetDC(0); 483 484 BeginPath(hdc); 485 SetArcDirection(hdc, AD_CLOCKWISE); 486 if (!ArcTo(hdc, 200, 200, 400, 300, 200, 200, 400, 300) && 487 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) 488 { 489 /* ArcTo is only available on Win2k and later */ 490 win_skip("ArcTo is not available\n"); 491 goto done; 492 } 493 SetArcDirection(hdc, AD_COUNTERCLOCKWISE); 494 ArcTo(hdc, 210, 210, 390, 290, 390, 290, 210, 210); 495 CloseFigure(hdc); 496 EndPath(hdc); 497 498 ok_path(hdc, "arcto_path", arcto_path, sizeof(arcto_path)/sizeof(path_test_t)); 499 done: 500 ReleaseDC(0, hdc); 501 } 502 503 static const path_test_t anglearc_path[] = 504 { 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 */ 526 }; 527 528 static void test_anglearc(void) 529 { 530 HDC hdc = GetDC(0); 531 BeginPath(hdc); 532 if (!AngleArc(hdc, 300, 300, 100, 45.0, 135.0) && 533 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) 534 { 535 /* AngleArc is only available on Win2k and later */ 536 win_skip("AngleArc is not available\n"); 537 goto done; 538 } 539 AngleArc(hdc, 300, 300, 80, 150.0, -180.0); 540 CloseFigure(hdc); 541 EndPath(hdc); 542 543 ok_path(hdc, "anglearc_path", anglearc_path, sizeof(anglearc_path)/sizeof(path_test_t)); 544 done: 545 ReleaseDC(0, hdc); 546 } 547 548 static const path_test_t polydraw_path[] = 549 { 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 */ 581 }; 582 583 static POINT polydraw_pts[] = { 584 {10, 10}, {10, 15}, 585 {15, 15}, {15, 20}, {20, 20}, {20, 25}, 586 {25, 25}, {25, 30}, 587 {30, 30}, {30, 35}, {35, 35}, {35, 40}, 588 {40, 40}, {40, 45}, {45, 45}, 589 {45, 50}, {50, 50}, 590 {50, 55}, {45, 50}, {55, 60}, 591 {60, 60}, {60, 65}, {65, 65}, 592 {70, 70}, {75, 70}, {75, 75}, {80, 80}}; 593 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 */ 604 605 static void test_polydraw(void) 606 { 607 BOOL retb; 608 POINT pos; 609 HDC hdc = GetDC(0); 610 611 MoveToEx( hdc, -20, -20, NULL ); 612 613 BeginPath(hdc); 614 GetCurrentPositionEx( hdc, &pos ); 615 ok( pos.x == -20 && pos.y == -20, "wrong pos %d,%d\n", pos.x, pos.y ); 616 617 /* closefigure with no previous moveto */ 618 if (!(retb = PolyDraw(hdc, polydraw_pts, polydraw_tps, 2)) && 619 GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) 620 { 621 /* PolyDraw is only available on Win2k and later */ 622 win_skip("PolyDraw is not available\n"); 623 goto done; 624 } 625 expect(TRUE, retb); 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 ); 631 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 ); 635 LineTo(hdc, 95, 95); 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); 640 expect(TRUE, retb); 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); 645 expect(FALSE, retb); 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); 649 expect(FALSE, retb); 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); 654 expect(TRUE, retb); 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); 659 expect(FALSE, retb); 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); 664 expect(FALSE, retb); 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); 669 expect(FALSE, retb); 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); 674 expect(TRUE, retb); 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); 679 expect(TRUE, retb); 680 GetCurrentPositionEx( hdc, &pos ); 681 ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y ); 682 683 EndPath(hdc); 684 ok_path(hdc, "polydraw_path", polydraw_path, sizeof(polydraw_path)/sizeof(path_test_t)); 685 GetCurrentPositionEx( hdc, &pos ); 686 ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y ); 687 done: 688 ReleaseDC(0, hdc); 689 } 690 691 static void test_closefigure(void) { 692 int nSize, nSizeWitness; 693 POINT pos; 694 HDC hdc = GetDC(0); 695 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 ); 699 700 BeginPath(hdc); 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 ); 706 LineTo(hdc, 95, 0); 707 GetCurrentPositionEx( hdc, &pos ); 708 ok( pos.x == 95 && pos.y == 0, "wrong pos %d,%d\n", pos.x, pos.y ); 709 LineTo(hdc, 0, 95); 710 GetCurrentPositionEx( hdc, &pos ); 711 ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y ); 712 713 CloseFigure(hdc); 714 GetCurrentPositionEx( hdc, &pos ); 715 ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y ); 716 EndPath(hdc); 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); 720 721 AbortPath(hdc); 722 723 BeginPath(hdc); 724 MoveToEx(hdc, 95, 95, NULL); 725 LineTo(hdc, 95, 0); 726 LineTo(hdc, 0, 95); 727 728 EndPath(hdc); 729 nSizeWitness = GetPath(hdc, NULL, NULL, 0); 730 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"); 733 734 ReleaseDC(0, hdc); 735 } 736 737 static void WINAPI linedda_callback(INT x, INT y, LPARAM lparam) 738 { 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); 742 743 (*pt)++; 744 return; 745 } 746 747 static void test_linedda(void) 748 { 749 const POINT *pt; 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}, 755 {-1,-1}}; 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}}; 762 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}}; 766 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}}; 773 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}}; 780 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}}; 787 788 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"); 792 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"); 796 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"); 800 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"); 804 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"); 808 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"); 812 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"); 816 } 817 818 static const path_test_t rectangle_path[] = 819 { 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 */ 920 }; 921 922 static void test_rectangle(void) 923 { 924 HDC hdc = GetDC( 0 ); 925 926 BeginPath( hdc ); 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 ); 967 EndPath( hdc ); 968 SetMapMode( hdc, MM_TEXT ); 969 ok_path( hdc, "rectangle_path", rectangle_path, sizeof(rectangle_path)/sizeof(path_test_t) ); 970 ReleaseDC( 0, hdc ); 971 } 972 973 static const path_test_t roundrect_path[] = 974 { 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 */ 1287 }; 1288 1289 static void test_roundrect(void) 1290 { 1291 HDC hdc = GetDC( 0 ); 1292 1293 BeginPath( hdc ); 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 ); 1328 EndPath( hdc ); 1329 SetMapMode( hdc, MM_TEXT ); 1330 ok_path( hdc, "roundrect_path", roundrect_path, sizeof(roundrect_path)/sizeof(path_test_t) ); 1331 ReleaseDC( 0, hdc ); 1332 } 1333 1334 static const path_test_t ellipse_path[] = 1335 { 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 */ 1661 }; 1662 1663 static void test_ellipse(void) 1664 { 1665 HDC hdc = GetDC( 0 ); 1666 1667 BeginPath( hdc ); 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 ); 1708 EndPath( hdc ); 1709 SetMapMode( hdc, MM_TEXT ); 1710 ok_path( hdc, "ellipse_path", ellipse_path, sizeof(ellipse_path)/sizeof(path_test_t) ); 1711 } 1712 1713 static const path_test_t all_funcs_path[] = 1714 { 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 */ 1856 }; 1857 1858 /* run once through all functions that support paths */ 1859 static void test_all_functions(void) 1860 { 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 ); 1867 1868 BeginPath( hdc ); 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 */ 1892 EndPath( hdc ); 1893 ok_path( hdc, "all_funcs_path", all_funcs_path, sizeof(all_funcs_path)/sizeof(path_test_t) ); 1894 ReleaseDC( 0, hdc ); 1895 } 1896 1897 START_TEST(path) 1898 { 1899 test_path_state(); 1900 test_widenpath(); 1901 test_arcto(); 1902 test_anglearc(); 1903 test_polydraw(); 1904 test_closefigure(); 1905 test_linedda(); 1906 test_rectangle(); 1907 test_roundrect(); 1908 test_ellipse(); 1909 test_all_functions(); 1910 } 1911