rostests/winetests/gdiplus/graphics.c

   1 /*
   2  * Unit test suite for graphics objects
   3  *
   4  * Copyright (C) 2007 Google (Evan Stade)
   5  * Copyright (C) 2012 Dmitry Timoshkov
   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 <math.h>
  23
  24 #define WIN32_NO_STATUS
  25 #define _INC_WINDOWS
  26 #define COM_NO_WINDOWS_H
  27
  28 //#include "windows.h"
  29 #include <wine/test.h>
  30 #include <wingdi.h>
  31 #include <objbase.h>
  32 #include <gdiplus.h>
  33
  34 #define expect(expected, got) ok((got) == (expected), "Expected %d, got %d\n", (INT)(expected), (INT)(got))
  35 #define expectf_(expected, got, precision) ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))
  36 #define expectf(expected, got) expectf_((expected), (got), 0.001)
  37
  38 static const REAL mm_per_inch = 25.4;
  39 static const REAL point_per_inch = 72.0;
  40 static HWND hwnd;
  41
  42 static void set_rect_empty(RectF *rc)
  43 {
  44     rc->X = 0.0;
  45     rc->Y = 0.0;
  46     rc->Width = 0.0;
  47     rc->Height = 0.0;
  48 }
  49
  50 /* converts a given unit to its value in pixels */
  51 static REAL units_to_pixels(REAL units, GpUnit unit, REAL dpi)
  52 {
  53     switch (unit)
  54     {
  55     case UnitPixel:
  56     case UnitDisplay:
  57         return units;
  58     case UnitPoint:
  59         return units * dpi / point_per_inch;
  60     case UnitInch:
  61         return units * dpi;
  62     case UnitDocument:
  63         return units * dpi / 300.0; /* Per MSDN */
  64     case UnitMillimeter:
  65         return units * dpi / mm_per_inch;
  66     default:
  67         ok(0, "Unsupported unit: %d\n", unit);
  68         return 0;
  69     }
  70 }
  71
  72 /* converts value in pixels to a given unit */
  73 static REAL pixels_to_units(REAL pixels, GpUnit unit, REAL dpi)
  74 {
  75     switch (unit)
  76     {
  77     case UnitPixel:
  78     case UnitDisplay:
  79         return pixels;
  80     case UnitPoint:
  81         return pixels * point_per_inch / dpi;
  82     case UnitInch:
  83         return pixels / dpi;
  84     case UnitDocument:
  85         return pixels * 300.0 / dpi;
  86     case UnitMillimeter:
  87         return pixels * mm_per_inch / dpi;
  88     default:
  89         ok(0, "Unsupported unit: %d\n", unit);
  90         return 0;
  91     }
  92 }
  93
  94 static REAL units_scale(GpUnit from, GpUnit to, REAL dpi)
  95 {
  96     REAL pixels = units_to_pixels(1.0, from, dpi);
  97     return pixels_to_units(pixels, to, dpi);
  98 }
  99
 100 static GpGraphics *create_graphics(REAL res_x, REAL res_y, GpUnit unit, REAL scale, GpImage **image)
 101 {
 102     GpStatus status;
 103     union
 104     {
 105         GpBitmap *bitmap;
 106         GpImage *image;
 107     } u;
 108     GpGraphics *graphics = NULL;
 109     REAL res;
 110
 111     status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, NULL, &u.bitmap);
 112     expect(Ok, status);
 113
 114     status = GdipBitmapSetResolution(u.bitmap, res_x, res_y);
 115     expect(Ok, status);
 116     status = GdipGetImageHorizontalResolution(u.image, &res);
 117     expect(Ok, status);
 118     expectf(res_x, res);
 119     status = GdipGetImageVerticalResolution(u.image, &res);
 120     expect(Ok, status);
 121     expectf(res_y, res);
 122
 123     status = GdipGetImageGraphicsContext(u.image, &graphics);
 124     expect(Ok, status);
 125
 126     *image = u.image;
 127
 128     status = GdipGetDpiX(graphics, &res);
 129     expect(Ok, status);
 130     expectf(res_x, res);
 131     status = GdipGetDpiY(graphics, &res);
 132     expect(Ok, status);
 133     expectf(res_y, res);
 134
 135     status = GdipSetPageUnit(graphics, unit);
 136     expect(Ok, status);
 137     status = GdipSetPageScale(graphics, scale);
 138     expect(Ok, status);
 139
 140     return graphics;
 141 }
 142
 143 static void test_constructor_destructor(void)
 144 {
 145     GpStatus stat;
 146     GpGraphics *graphics = NULL;
 147     HDC hdc = GetDC( hwnd );
 148
 149     stat = GdipCreateFromHDC(NULL, &graphics);
 150     expect(OutOfMemory, stat);
 151     stat = GdipDeleteGraphics(graphics);
 152     expect(InvalidParameter, stat);
 153
 154     stat = GdipCreateFromHDC(hdc, &graphics);
 155     expect(Ok, stat);
 156     stat = GdipDeleteGraphics(graphics);
 157     expect(Ok, stat);
 158
 159     stat = GdipCreateFromHWND(NULL, &graphics);
 160     expect(Ok, stat);
 161     stat = GdipDeleteGraphics(graphics);
 162     expect(Ok, stat);
 163
 164     stat = GdipCreateFromHWNDICM(NULL, &graphics);
 165     expect(Ok, stat);
 166     stat = GdipDeleteGraphics(graphics);
 167     expect(Ok, stat);
 168
 169     stat = GdipDeleteGraphics(NULL);
 170     expect(InvalidParameter, stat);
 171     ReleaseDC(hwnd, hdc);
 172 }
 173
 174 typedef struct node{
 175     GraphicsState data;
 176     struct node * next;
 177 } node;
 178
 179 /* Linked list prepend function. */
 180 static void log_state(GraphicsState data, node ** log)
 181 {
 182     node * new_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(node));
 183
 184     new_entry->data = data;
 185     new_entry->next = *log;
 186     *log = new_entry;
 187 }
 188
 189 /* Checks if there are duplicates in the list, and frees it. */
 190 static void check_no_duplicates(node * log)
 191 {
 192     INT dups = 0;
 193     node * temp = NULL;
 194     node * temp2 = NULL;
 195     node * orig = log;
 196
 197     if(!log)
 198         goto end;
 199
 200     do{
 201         temp = log;
 202         while((temp = temp->next)){
 203             if(log->data == temp->data){
 204                 dups++;
 205                 break;
 206             }
 207             if(dups > 0)
 208                 break;
 209         }
 210     }while((log = log->next));
 211
 212     temp = orig;
 213     do{
 214         temp2 = temp->next;
 215         HeapFree(GetProcessHeap(), 0, temp);
 216         temp = temp2;
 217     }while(temp);
 218
 219 end:
 220     expect(0, dups);
 221 }
 222
 223 static void test_save_restore(void)
 224 {
 225     GpStatus stat;
 226     GraphicsState state_a, state_b, state_c;
 227     InterpolationMode mode;
 228     GpGraphics *graphics1, *graphics2;
 229     node * state_log = NULL;
 230     HDC hdc = GetDC( hwnd );
 231     state_a = state_b = state_c = 0xdeadbeef;
 232
 233     /* Invalid saving. */
 234     GdipCreateFromHDC(hdc, &graphics1);
 235     stat = GdipSaveGraphics(graphics1, NULL);
 236     expect(InvalidParameter, stat);
 237     stat = GdipSaveGraphics(NULL, &state_a);
 238     expect(InvalidParameter, stat);
 239     GdipDeleteGraphics(graphics1);
 240
 241     log_state(state_a, &state_log);
 242
 243     /* Basic save/restore. */
 244     GdipCreateFromHDC(hdc, &graphics1);
 245     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 246     stat = GdipSaveGraphics(graphics1, &state_a);
 247     expect(Ok, stat);
 248     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 249     stat = GdipRestoreGraphics(graphics1, state_a);
 250     expect(Ok, stat);
 251     GdipGetInterpolationMode(graphics1, &mode);
 252     expect(InterpolationModeBilinear, mode);
 253     GdipDeleteGraphics(graphics1);
 254
 255     log_state(state_a, &state_log);
 256
 257     /* Restoring garbage doesn't affect saves. */
 258     GdipCreateFromHDC(hdc, &graphics1);
 259     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 260     GdipSaveGraphics(graphics1, &state_a);
 261     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 262     GdipSaveGraphics(graphics1, &state_b);
 263     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 264     stat = GdipRestoreGraphics(graphics1, 0xdeadbeef);
 265     expect(Ok, stat);
 266     GdipRestoreGraphics(graphics1, state_b);
 267     GdipGetInterpolationMode(graphics1, &mode);
 268     expect(InterpolationModeBicubic, mode);
 269     GdipRestoreGraphics(graphics1, state_a);
 270     GdipGetInterpolationMode(graphics1, &mode);
 271     expect(InterpolationModeBilinear, mode);
 272     GdipDeleteGraphics(graphics1);
 273
 274     log_state(state_a, &state_log);
 275     log_state(state_b, &state_log);
 276
 277     /* Restoring older state invalidates newer saves (but not older saves). */
 278     GdipCreateFromHDC(hdc, &graphics1);
 279     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 280     GdipSaveGraphics(graphics1, &state_a);
 281     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 282     GdipSaveGraphics(graphics1, &state_b);
 283     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 284     GdipSaveGraphics(graphics1, &state_c);
 285     GdipSetInterpolationMode(graphics1, InterpolationModeHighQualityBilinear);
 286     GdipRestoreGraphics(graphics1, state_b);
 287     GdipGetInterpolationMode(graphics1, &mode);
 288     expect(InterpolationModeBicubic, mode);
 289     GdipRestoreGraphics(graphics1, state_c);
 290     GdipGetInterpolationMode(graphics1, &mode);
 291     expect(InterpolationModeBicubic, mode);
 292     GdipRestoreGraphics(graphics1, state_a);
 293     GdipGetInterpolationMode(graphics1, &mode);
 294     expect(InterpolationModeBilinear, mode);
 295     GdipDeleteGraphics(graphics1);
 296
 297     log_state(state_a, &state_log);
 298     log_state(state_b, &state_log);
 299     log_state(state_c, &state_log);
 300
 301     /* Restoring older save from one graphics object does not invalidate
 302      * newer save from other graphics object. */
 303     GdipCreateFromHDC(hdc, &graphics1);
 304     GdipCreateFromHDC(hdc, &graphics2);
 305     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 306     GdipSaveGraphics(graphics1, &state_a);
 307     GdipSetInterpolationMode(graphics2, InterpolationModeBicubic);
 308     GdipSaveGraphics(graphics2, &state_b);
 309     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 310     GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
 311     GdipRestoreGraphics(graphics1, state_a);
 312     GdipGetInterpolationMode(graphics1, &mode);
 313     expect(InterpolationModeBilinear, mode);
 314     GdipRestoreGraphics(graphics2, state_b);
 315     GdipGetInterpolationMode(graphics2, &mode);
 316     expect(InterpolationModeBicubic, mode);
 317     GdipDeleteGraphics(graphics1);
 318     GdipDeleteGraphics(graphics2);
 319
 320     /* You can't restore a state to a graphics object that didn't save it. */
 321     GdipCreateFromHDC(hdc, &graphics1);
 322     GdipCreateFromHDC(hdc, &graphics2);
 323     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 324     GdipSaveGraphics(graphics1, &state_a);
 325     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 326     GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
 327     GdipRestoreGraphics(graphics2, state_a);
 328     GdipGetInterpolationMode(graphics2, &mode);
 329     expect(InterpolationModeNearestNeighbor, mode);
 330     GdipDeleteGraphics(graphics1);
 331     GdipDeleteGraphics(graphics2);
 332
 333     log_state(state_a, &state_log);
 334
 335     /* The same state value should never be returned twice. */
 336     todo_wine
 337         check_no_duplicates(state_log);
 338
 339     ReleaseDC(hwnd, hdc);
 340 }
 341
 342 static void test_GdipFillClosedCurve2(void)
 343 {
 344     GpStatus status;
 345     GpGraphics *graphics = NULL;
 346     GpSolidFill *brush = NULL;
 347     HDC hdc = GetDC( hwnd );
 348     GpPointF points[3];
 349
 350     points[0].X = 0;
 351     points[0].Y = 0;
 352
 353     points[1].X = 40;
 354     points[1].Y = 20;
 355
 356     points[2].X = 10;
 357     points[2].Y = 40;
 358
 359     /* make a graphics object and brush object */
 360     ok(hdc != NULL, "Expected HDC to be initialized\n");
 361
 362     status = GdipCreateFromHDC(hdc, &graphics);
 363     expect(Ok, status);
 364     ok(graphics != NULL, "Expected graphics to be initialized\n");
 365
 366     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
 367
 368     /* InvalidParameter cases: null graphics, null brush, null points */
 369     status = GdipFillClosedCurve2(NULL, NULL, NULL, 3, 0.5, FillModeAlternate);
 370     expect(InvalidParameter, status);
 371
 372     status = GdipFillClosedCurve2(graphics, NULL, NULL, 3, 0.5, FillModeAlternate);
 373     expect(InvalidParameter, status);
 374
 375     status = GdipFillClosedCurve2(NULL, (GpBrush*)brush, NULL, 3, 0.5, FillModeAlternate);
 376     expect(InvalidParameter, status);
 377
 378     status = GdipFillClosedCurve2(NULL, NULL, points, 3, 0.5, FillModeAlternate);
 379     expect(InvalidParameter, status);
 380
 381     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, NULL, 3, 0.5, FillModeAlternate);
 382     expect(InvalidParameter, status);
 383
 384     status = GdipFillClosedCurve2(graphics, NULL, points, 3, 0.5, FillModeAlternate);
 385     expect(InvalidParameter, status);
 386
 387     status = GdipFillClosedCurve2(NULL, (GpBrush*)brush, points, 3, 0.5, FillModeAlternate);
 388     expect(InvalidParameter, status);
 389
 390     /* InvalidParameter cases: invalid count */
 391     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, points, -1, 0.5, FillModeAlternate);
 392     expect(InvalidParameter, status);
 393
 394     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, points, 0, 0.5, FillModeAlternate);
 395     expect(InvalidParameter, status);
 396
 397     /* Valid test cases */
 398     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, points, 1, 0.5, FillModeAlternate);
 399     expect(Ok, status);
 400
 401     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, points, 2, 0.5, FillModeAlternate);
 402     expect(Ok, status);
 403
 404     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, points, 3, 0.5, FillModeAlternate);
 405     expect(Ok, status);
 406
 407     GdipDeleteGraphics(graphics);
 408     GdipDeleteBrush((GpBrush*)brush);
 409
 410     ReleaseDC(hwnd, hdc);
 411 }
 412
 413 static void test_GdipFillClosedCurve2I(void)
 414 {
 415     GpStatus status;
 416     GpGraphics *graphics = NULL;
 417     GpSolidFill *brush = NULL;
 418     HDC hdc = GetDC( hwnd );
 419     GpPoint points[3];
 420
 421     points[0].X = 0;
 422     points[0].Y = 0;
 423
 424     points[1].X = 40;
 425     points[1].Y = 20;
 426
 427     points[2].X = 10;
 428     points[2].Y = 40;
 429
 430     /* make a graphics object and brush object */
 431     ok(hdc != NULL, "Expected HDC to be initialized\n");
 432
 433     status = GdipCreateFromHDC(hdc, &graphics);
 434     expect(Ok, status);
 435     ok(graphics != NULL, "Expected graphics to be initialized\n");
 436
 437     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
 438
 439     /* InvalidParameter cases: null graphics, null brush */
 440     /* Note: GdipFillClosedCurveI and GdipFillClosedCurve2I hang in Windows
 441              when points == NULL, so don't test this condition */
 442     status = GdipFillClosedCurve2I(NULL, NULL, points, 3, 0.5, FillModeAlternate);
 443     expect(InvalidParameter, status);
 444
 445     status = GdipFillClosedCurve2I(graphics, NULL, points, 3, 0.5, FillModeAlternate);
 446     expect(InvalidParameter, status);
 447
 448     status = GdipFillClosedCurve2I(NULL, (GpBrush*)brush, points, 3, 0.5, FillModeAlternate);
 449     expect(InvalidParameter, status);
 450
 451     /* InvalidParameter cases: invalid count */
 452     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, points, 0, 0.5, FillModeAlternate);
 453     expect(InvalidParameter, status);
 454
 455     /* OutOfMemory cases: large (unsigned) int */
 456     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, points, -1, 0.5, FillModeAlternate);
 457     expect(OutOfMemory, status);
 458
 459     /* Valid test cases */
 460     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, points, 1, 0.5, FillModeAlternate);
 461     expect(Ok, status);
 462
 463     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, points, 2, 0.5, FillModeAlternate);
 464     expect(Ok, status);
 465
 466     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, points, 3, 0.5, FillModeAlternate);
 467     expect(Ok, status);
 468
 469     GdipDeleteGraphics(graphics);
 470     GdipDeleteBrush((GpBrush*)brush);
 471
 472     ReleaseDC(hwnd, hdc);
 473 }
 474
 475 static void test_GdipDrawArc(void)
 476 {
 477     GpStatus status;
 478     GpGraphics *graphics = NULL;
 479     GpPen *pen = NULL;
 480     HDC hdc = GetDC( hwnd );
 481
 482     /* make a graphics object and pen object */
 483     ok(hdc != NULL, "Expected HDC to be initialized\n");
 484
 485     status = GdipCreateFromHDC(hdc, &graphics);
 486     expect(Ok, status);
 487     ok(graphics != NULL, "Expected graphics to be initialized\n");
 488
 489     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 490     expect(Ok, status);
 491     ok(pen != NULL, "Expected pen to be initialized\n");
 492
 493     /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
 494     status = GdipDrawArc(NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
 495     expect(InvalidParameter, status);
 496
 497     status = GdipDrawArc(graphics, NULL, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 498     expect(InvalidParameter, status);
 499
 500     status = GdipDrawArc(NULL, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 501     expect(InvalidParameter, status);
 502
 503     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 504     expect(InvalidParameter, status);
 505
 506     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
 507     expect(InvalidParameter, status);
 508
 509     /* successful case */
 510     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 511     expect(Ok, status);
 512
 513     GdipDeletePen(pen);
 514     GdipDeleteGraphics(graphics);
 515
 516     ReleaseDC(hwnd, hdc);
 517 }
 518
 519 static void test_GdipDrawArcI(void)
 520 {
 521     GpStatus status;
 522     GpGraphics *graphics = NULL;
 523     GpPen *pen = NULL;
 524     HDC hdc = GetDC( hwnd );
 525
 526     /* make a graphics object and pen object */
 527     ok(hdc != NULL, "Expected HDC to be initialized\n");
 528
 529     status = GdipCreateFromHDC(hdc, &graphics);
 530     expect(Ok, status);
 531     ok(graphics != NULL, "Expected graphics to be initialized\n");
 532
 533     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 534     expect(Ok, status);
 535     ok(pen != NULL, "Expected pen to be initialized\n");
 536
 537     /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
 538     status = GdipDrawArcI(NULL, NULL, 0, 0, 0, 0, 0, 0);
 539     expect(InvalidParameter, status);
 540
 541     status = GdipDrawArcI(graphics, NULL, 0, 0, 1, 1, 0, 0);
 542     expect(InvalidParameter, status);
 543
 544     status = GdipDrawArcI(NULL, pen, 0, 0, 1, 1, 0, 0);
 545     expect(InvalidParameter, status);
 546
 547     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 0, 0, 0);
 548     expect(InvalidParameter, status);
 549
 550     status = GdipDrawArcI(graphics, pen, 0, 0, 0, 1, 0, 0);
 551     expect(InvalidParameter, status);
 552
 553     /* successful case */
 554     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0, 0);
 555     expect(Ok, status);
 556
 557     GdipDeletePen(pen);
 558     GdipDeleteGraphics(graphics);
 559
 560     ReleaseDC(hwnd, hdc);
 561 }
 562
 563 static void test_BeginContainer2(void)
 564 {
 565     GpMatrix *transform;
 566     GpRectF clip;
 567     REAL defClip[] = {5, 10, 15, 20};
 568     REAL elems[6], defTrans[] = {1, 2, 3, 4, 5, 6};
 569     GraphicsContainer cont1, cont2, cont3, cont4;
 570     CompositingQuality compqual, defCompqual = CompositingQualityHighSpeed;
 571     CompositingMode compmode, defCompmode = CompositingModeSourceOver;
 572     InterpolationMode interp, defInterp = InterpolationModeHighQualityBicubic;
 573     REAL scale, defScale = 17;
 574     GpUnit unit, defUnit = UnitPixel;
 575     PixelOffsetMode offsetmode, defOffsetmode = PixelOffsetModeHighSpeed;
 576     SmoothingMode smoothmode, defSmoothmode = SmoothingModeAntiAlias;
 577     UINT contrast, defContrast = 5;
 578     TextRenderingHint texthint, defTexthint = TextRenderingHintAntiAlias;
 579
 580     GpStatus status;
 581     GpGraphics *graphics = NULL;
 582     HDC hdc = GetDC( hwnd );
 583
 584     ok(hdc != NULL, "Expected HDC to be initialized\n");
 585
 586     status = GdipCreateFromHDC(hdc, &graphics);
 587     expect(Ok, status);
 588     ok(graphics != NULL, "Expected graphics to be initialized\n");
 589
 590     /* null graphics, null container */
 591     status = GdipBeginContainer2(NULL, &cont1);
 592     expect(InvalidParameter, status);
 593
 594     status = GdipBeginContainer2(graphics, NULL);
 595     expect(InvalidParameter, status);
 596
 597     status = GdipEndContainer(NULL, cont1);
 598     expect(InvalidParameter, status);
 599
 600     /* test all quality-related values */
 601     GdipSetCompositingMode(graphics, defCompmode);
 602     GdipSetCompositingQuality(graphics, defCompqual);
 603     GdipSetInterpolationMode(graphics, defInterp);
 604     GdipSetPageScale(graphics, defScale);
 605     GdipSetPageUnit(graphics, defUnit);
 606     GdipSetPixelOffsetMode(graphics, defOffsetmode);
 607     GdipSetSmoothingMode(graphics, defSmoothmode);
 608     GdipSetTextContrast(graphics, defContrast);
 609     GdipSetTextRenderingHint(graphics, defTexthint);
 610
 611     status = GdipBeginContainer2(graphics, &cont1);
 612     expect(Ok, status);
 613
 614     GdipSetCompositingMode(graphics, CompositingModeSourceCopy);
 615     GdipSetCompositingQuality(graphics, CompositingQualityHighQuality);
 616     GdipSetInterpolationMode(graphics, InterpolationModeBilinear);
 617     GdipSetPageScale(graphics, 10);
 618     GdipSetPageUnit(graphics, UnitDocument);
 619     GdipSetPixelOffsetMode(graphics, PixelOffsetModeHalf);
 620     GdipSetSmoothingMode(graphics, SmoothingModeNone);
 621     GdipSetTextContrast(graphics, 7);
 622     GdipSetTextRenderingHint(graphics, TextRenderingHintClearTypeGridFit);
 623
 624     status = GdipEndContainer(graphics, cont1);
 625     expect(Ok, status);
 626
 627     GdipGetCompositingMode(graphics, &compmode);
 628     ok(defCompmode == compmode, "Expected Compositing Mode to be restored to %d, got %d\n", defCompmode, compmode);
 629
 630     GdipGetCompositingQuality(graphics, &compqual);
 631     ok(defCompqual == compqual, "Expected Compositing Quality to be restored to %d, got %d\n", defCompqual, compqual);
 632
 633     GdipGetInterpolationMode(graphics, &interp);
 634     ok(defInterp == interp, "Expected Interpolation Mode to be restored to %d, got %d\n", defInterp, interp);
 635
 636     GdipGetPageScale(graphics, &scale);
 637     ok(fabs(defScale - scale) < 0.0001, "Expected Page Scale to be restored to %f, got %f\n", defScale, scale);
 638
 639     GdipGetPageUnit(graphics, &unit);
 640     ok(defUnit == unit, "Expected Page Unit to be restored to %d, got %d\n", defUnit, unit);
 641
 642     GdipGetPixelOffsetMode(graphics, &offsetmode);
 643     ok(defOffsetmode == offsetmode, "Expected Pixel Offset Mode to be restored to %d, got %d\n", defOffsetmode, offsetmode);
 644
 645     GdipGetSmoothingMode(graphics, &smoothmode);
 646     ok(defSmoothmode == smoothmode, "Expected Smoothing Mode to be restored to %d, got %d\n", defSmoothmode, smoothmode);
 647
 648     GdipGetTextContrast(graphics, &contrast);
 649     ok(defContrast == contrast, "Expected Text Contrast to be restored to %d, got %d\n", defContrast, contrast);
 650
 651     GdipGetTextRenderingHint(graphics, &texthint);
 652     ok(defTexthint == texthint, "Expected Text Hint to be restored to %d, got %d\n", defTexthint, texthint);
 653
 654     /* test world transform */
 655     status = GdipBeginContainer2(graphics, &cont1);
 656     expect(Ok, status);
 657
 658     status = GdipCreateMatrix2(defTrans[0], defTrans[1], defTrans[2], defTrans[3],
 659             defTrans[4], defTrans[5], &transform);
 660     expect(Ok, status);
 661     GdipSetWorldTransform(graphics, transform);
 662     GdipDeleteMatrix(transform);
 663     transform = NULL;
 664
 665     status = GdipBeginContainer2(graphics, &cont2);
 666     expect(Ok, status);
 667
 668     status = GdipCreateMatrix2(10, 20, 30, 40, 50, 60, &transform);
 669     expect(Ok, status);
 670     GdipSetWorldTransform(graphics, transform);
 671     GdipDeleteMatrix(transform);
 672     transform = NULL;
 673
 674     status = GdipEndContainer(graphics, cont2);
 675     expect(Ok, status);
 676
 677     status = GdipCreateMatrix(&transform);
 678     expect(Ok, status);
 679     GdipGetWorldTransform(graphics, transform);
 680     GdipGetMatrixElements(transform, elems);
 681     ok(fabs(defTrans[0] - elems[0]) < 0.0001 &&
 682             fabs(defTrans[1] - elems[1]) < 0.0001 &&
 683             fabs(defTrans[2] - elems[2]) < 0.0001 &&
 684             fabs(defTrans[3] - elems[3]) < 0.0001 &&
 685             fabs(defTrans[4] - elems[4]) < 0.0001 &&
 686             fabs(defTrans[5] - elems[5]) < 0.0001,
 687             "Expected World Transform Matrix to be restored to [%f, %f, %f, %f, %f, %f], got [%f, %f, %f, %f, %f, %f]\n",
 688             defTrans[0], defTrans[1], defTrans[2], defTrans[3], defTrans[4], defTrans[5],
 689             elems[0], elems[1], elems[2], elems[3], elems[4], elems[5]);
 690     GdipDeleteMatrix(transform);
 691     transform = NULL;
 692
 693     status = GdipEndContainer(graphics, cont1);
 694     expect(Ok, status);
 695
 696     /* test clipping */
 697     status = GdipBeginContainer2(graphics, &cont1);
 698     expect(Ok, status);
 699
 700     GdipSetClipRect(graphics, defClip[0], defClip[1], defClip[2], defClip[3], CombineModeReplace);
 701
 702     status = GdipBeginContainer2(graphics, &cont2);
 703     expect(Ok, status);
 704
 705     GdipSetClipRect(graphics, 2, 4, 6, 8, CombineModeReplace);
 706
 707     status = GdipEndContainer(graphics, cont2);
 708     expect(Ok, status);
 709
 710     status = GdipGetClipBounds(graphics, &clip);
 711     expect(Ok, status);
 712
 713     ok(fabs(defClip[0] - clip.X) < 0.0001 &&
 714             fabs(defClip[1] - clip.Y) < 0.0001 &&
 715             fabs(defClip[2] - clip.Width) < 0.0001 &&
 716             fabs(defClip[3] - clip.Height) < 0.0001,
 717             "Expected Clipping Rectangle to be restored to [%f, %f, %f, %f], got [%f, %f, %f, %f]\n",
 718             defClip[0], defClip[1], defClip[2], defClip[3],
 719             clip.X, clip.Y, clip.Width, clip.Height);
 720
 721     status = GdipEndContainer(graphics, cont1);
 722     expect(Ok, status);
 723
 724     /* nesting */
 725     status = GdipBeginContainer2(graphics, &cont1);
 726     expect(Ok, status);
 727
 728     status = GdipBeginContainer2(graphics, &cont2);
 729     expect(Ok, status);
 730
 731     status = GdipBeginContainer2(graphics, &cont3);
 732     expect(Ok, status);
 733
 734     status = GdipEndContainer(graphics, cont3);
 735     expect(Ok, status);
 736
 737     status = GdipBeginContainer2(graphics, &cont4);
 738     expect(Ok, status);
 739
 740     status = GdipEndContainer(graphics, cont4);
 741     expect(Ok, status);
 742
 743     /* skip cont2 */
 744     status = GdipEndContainer(graphics, cont1);
 745     expect(Ok, status);
 746
 747     /* end an already-ended container */
 748     status = GdipEndContainer(graphics, cont1);
 749     expect(Ok, status);
 750
 751     GdipDeleteGraphics(graphics);
 752     ReleaseDC(hwnd, hdc);
 753 }
 754
 755 static void test_GdipDrawBezierI(void)
 756 {
 757     GpStatus status;
 758     GpGraphics *graphics = NULL;
 759     GpPen *pen = NULL;
 760     HDC hdc = GetDC( hwnd );
 761
 762     /* make a graphics object and pen object */
 763     ok(hdc != NULL, "Expected HDC to be initialized\n");
 764
 765     status = GdipCreateFromHDC(hdc, &graphics);
 766     expect(Ok, status);
 767     ok(graphics != NULL, "Expected graphics to be initialized\n");
 768
 769     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 770     expect(Ok, status);
 771     ok(pen != NULL, "Expected pen to be initialized\n");
 772
 773     /* InvalidParameter cases: null graphics, null pen */
 774     status = GdipDrawBezierI(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
 775     expect(InvalidParameter, status);
 776
 777     status = GdipDrawBezierI(graphics, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
 778     expect(InvalidParameter, status);
 779
 780     status = GdipDrawBezierI(NULL, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 781     expect(InvalidParameter, status);
 782
 783     /* successful case */
 784     status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 785     expect(Ok, status);
 786
 787     GdipDeletePen(pen);
 788     GdipDeleteGraphics(graphics);
 789
 790     ReleaseDC(hwnd, hdc);
 791 }
 792
 793 static void test_GdipDrawCurve3(void)
 794 {
 795     GpStatus status;
 796     GpGraphics *graphics = NULL;
 797     GpPen *pen = NULL;
 798     HDC hdc = GetDC( hwnd );
 799     GpPointF points[3];
 800
 801     points[0].X = 0;
 802     points[0].Y = 0;
 803
 804     points[1].X = 40;
 805     points[1].Y = 20;
 806
 807     points[2].X = 10;
 808     points[2].Y = 40;
 809
 810     /* make a graphics object and pen object */
 811     ok(hdc != NULL, "Expected HDC to be initialized\n");
 812
 813     status = GdipCreateFromHDC(hdc, &graphics);
 814     expect(Ok, status);
 815     ok(graphics != NULL, "Expected graphics to be initialized\n");
 816
 817     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 818     expect(Ok, status);
 819     ok(pen != NULL, "Expected pen to be initialized\n");
 820
 821     /* InvalidParameter cases: null graphics, null pen */
 822     status = GdipDrawCurve3(NULL, NULL, points, 3, 0, 2, 1);
 823     expect(InvalidParameter, status);
 824
 825     status = GdipDrawCurve3(graphics, NULL, points, 3, 0, 2, 1);
 826     expect(InvalidParameter, status);
 827
 828     status = GdipDrawCurve3(NULL, pen, points, 3, 0, 2, 1);
 829     expect(InvalidParameter, status);
 830
 831     /* InvalidParameter cases: invalid count */
 832     status = GdipDrawCurve3(graphics, pen, points, -1, 0, 2, 1);
 833     expect(InvalidParameter, status);
 834
 835     status = GdipDrawCurve3(graphics, pen, points, 0, 0, 2, 1);
 836     expect(InvalidParameter, status);
 837
 838     status = GdipDrawCurve3(graphics, pen, points, 1, 0, 0, 1);
 839     expect(InvalidParameter, status);
 840
 841     status = GdipDrawCurve3(graphics, pen, points, 3, 4, 2, 1);
 842     expect(InvalidParameter, status);
 843
 844     /* InvalidParameter cases: invalid number of segments */
 845     status = GdipDrawCurve3(graphics, pen, points, 3, 0, -1, 1);
 846     expect(InvalidParameter, status);
 847
 848     status = GdipDrawCurve3(graphics, pen, points, 3, 1, 2, 1);
 849     expect(InvalidParameter, status);
 850
 851     status = GdipDrawCurve3(graphics, pen, points, 2, 0, 2, 1);
 852     expect(InvalidParameter, status);
 853
 854     /* Valid test cases */
 855     status = GdipDrawCurve3(graphics, pen, points, 2, 0, 1, 1);
 856     expect(Ok, status);
 857
 858     status = GdipDrawCurve3(graphics, pen, points, 3, 0, 2, 2);
 859     expect(Ok, status);
 860
 861     status = GdipDrawCurve3(graphics, pen, points, 2, 0, 1, -2);
 862     expect(Ok, status);
 863
 864     status = GdipDrawCurve3(graphics, pen, points, 3, 1, 1, 0);
 865     expect(Ok, status);
 866
 867     GdipDeletePen(pen);
 868     GdipDeleteGraphics(graphics);
 869
 870     ReleaseDC(hwnd, hdc);
 871 }
 872
 873 static void test_GdipDrawCurve3I(void)
 874 {
 875     GpStatus status;
 876     GpGraphics *graphics = NULL;
 877     GpPen *pen = NULL;
 878     HDC hdc = GetDC( hwnd );
 879     GpPoint points[3];
 880
 881     points[0].X = 0;
 882     points[0].Y = 0;
 883
 884     points[1].X = 40;
 885     points[1].Y = 20;
 886
 887     points[2].X = 10;
 888     points[2].Y = 40;
 889
 890     /* make a graphics object and pen object */
 891     ok(hdc != NULL, "Expected HDC to be initialized\n");
 892
 893     status = GdipCreateFromHDC(hdc, &graphics);
 894     expect(Ok, status);
 895     ok(graphics != NULL, "Expected graphics to be initialized\n");
 896
 897     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 898     expect(Ok, status);
 899     ok(pen != NULL, "Expected pen to be initialized\n");
 900
 901     /* InvalidParameter cases: null graphics, null pen */
 902     status = GdipDrawCurve3I(NULL, NULL, points, 3, 0, 2, 1);
 903     expect(InvalidParameter, status);
 904
 905     status = GdipDrawCurve3I(graphics, NULL, points, 3, 0, 2, 1);
 906     expect(InvalidParameter, status);
 907
 908     status = GdipDrawCurve3I(NULL, pen, points, 3, 0, 2, 1);
 909     expect(InvalidParameter, status);
 910
 911     /* InvalidParameter cases: invalid count */
 912     status = GdipDrawCurve3I(graphics, pen, points, -1, -1, -1, 1);
 913     expect(OutOfMemory, status);
 914
 915     status = GdipDrawCurve3I(graphics, pen, points, 0, 0, 2, 1);
 916     expect(InvalidParameter, status);
 917
 918     status = GdipDrawCurve3I(graphics, pen, points, 1, 0, 0, 1);
 919     expect(InvalidParameter, status);
 920
 921     status = GdipDrawCurve3I(graphics, pen, points, 3, 4, 2, 1);
 922     expect(InvalidParameter, status);
 923
 924     /* InvalidParameter cases: invalid number of segments */
 925     status = GdipDrawCurve3I(graphics, pen, points, 3, 0, -1, 1);
 926     expect(InvalidParameter, status);
 927
 928     status = GdipDrawCurve3I(graphics, pen, points, 3, 1, 2, 1);
 929     expect(InvalidParameter, status);
 930
 931     status = GdipDrawCurve3I(graphics, pen, points, 2, 0, 2, 1);
 932     expect(InvalidParameter, status);
 933
 934     /* Valid test cases */
 935     status = GdipDrawCurve3I(graphics, pen, points, 2, 0, 1, 1);
 936     expect(Ok, status);
 937
 938     status = GdipDrawCurve3I(graphics, pen, points, 3, 0, 2, 2);
 939     expect(Ok, status);
 940
 941     status = GdipDrawCurve3I(graphics, pen, points, 2, 0, 1, -2);
 942     expect(Ok, status);
 943
 944     status = GdipDrawCurve3I(graphics, pen, points, 3, 1, 1, 0);
 945     expect(Ok, status);
 946
 947     GdipDeletePen(pen);
 948     GdipDeleteGraphics(graphics);
 949
 950     ReleaseDC(hwnd, hdc);
 951 }
 952
 953 static void test_GdipDrawCurve2(void)
 954 {
 955     GpStatus status;
 956     GpGraphics *graphics = NULL;
 957     GpPen *pen = NULL;
 958     HDC hdc = GetDC( hwnd );
 959     GpPointF points[3];
 960
 961     points[0].X = 0;
 962     points[0].Y = 0;
 963
 964     points[1].X = 40;
 965     points[1].Y = 20;
 966
 967     points[2].X = 10;
 968     points[2].Y = 40;
 969
 970     /* make a graphics object and pen object */
 971     ok(hdc != NULL, "Expected HDC to be initialized\n");
 972
 973     status = GdipCreateFromHDC(hdc, &graphics);
 974     expect(Ok, status);
 975     ok(graphics != NULL, "Expected graphics to be initialized\n");
 976
 977     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 978     expect(Ok, status);
 979     ok(pen != NULL, "Expected pen to be initialized\n");
 980
 981     /* InvalidParameter cases: null graphics, null pen */
 982     status = GdipDrawCurve2(NULL, NULL, points, 3, 1);
 983     expect(InvalidParameter, status);
 984
 985     status = GdipDrawCurve2(graphics, NULL, points, 3, 1);
 986     expect(InvalidParameter, status);
 987
 988     status = GdipDrawCurve2(NULL, pen, points, 3, 1);
 989     expect(InvalidParameter, status);
 990
 991     /* InvalidParameter cases: invalid count */
 992     status = GdipDrawCurve2(graphics, pen, points, -1, 1);
 993     expect(InvalidParameter, status);
 994
 995     status = GdipDrawCurve2(graphics, pen, points, 0, 1);
 996     expect(InvalidParameter, status);
 997
 998     status = GdipDrawCurve2(graphics, pen, points, 1, 1);
 999     expect(InvalidParameter, status);
1000
1001     /* Valid test cases */
1002     status = GdipDrawCurve2(graphics, pen, points, 2, 1);
1003     expect(Ok, status);
1004
1005     status = GdipDrawCurve2(graphics, pen, points, 3, 2);
1006     expect(Ok, status);
1007
1008     status = GdipDrawCurve2(graphics, pen, points, 3, -2);
1009     expect(Ok, status);
1010
1011     status = GdipDrawCurve2(graphics, pen, points, 3, 0);
1012     expect(Ok, status);
1013
1014     GdipDeletePen(pen);
1015     GdipDeleteGraphics(graphics);
1016
1017     ReleaseDC(hwnd, hdc);
1018 }
1019
1020 static void test_GdipDrawCurve2I(void)
1021 {
1022     GpStatus status;
1023     GpGraphics *graphics = NULL;
1024     GpPen *pen = NULL;
1025     HDC hdc = GetDC( hwnd );
1026     GpPoint points[3];
1027
1028     points[0].X = 0;
1029     points[0].Y = 0;
1030
1031     points[1].X = 40;
1032     points[1].Y = 20;
1033
1034     points[2].X = 10;
1035     points[2].Y = 40;
1036
1037     /* make a graphics object and pen object */
1038     ok(hdc != NULL, "Expected HDC to be initialized\n");
1039
1040     status = GdipCreateFromHDC(hdc, &graphics);
1041     expect(Ok, status);
1042     ok(graphics != NULL, "Expected graphics to be initialized\n");
1043
1044     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1045     expect(Ok, status);
1046     ok(pen != NULL, "Expected pen to be initialized\n");
1047
1048     /* InvalidParameter cases: null graphics, null pen */
1049     status = GdipDrawCurve2I(NULL, NULL, points, 3, 1);
1050     expect(InvalidParameter, status);
1051
1052     status = GdipDrawCurve2I(graphics, NULL, points, 3, 1);
1053     expect(InvalidParameter, status);
1054
1055     status = GdipDrawCurve2I(NULL, pen, points, 3, 1);
1056     expect(InvalidParameter, status);
1057
1058     /* InvalidParameter cases: invalid count */
1059     status = GdipDrawCurve2I(graphics, pen, points, -1, 1);
1060     expect(OutOfMemory, status);
1061
1062     status = GdipDrawCurve2I(graphics, pen, points, 0, 1);
1063     expect(InvalidParameter, status);
1064
1065     status = GdipDrawCurve2I(graphics, pen, points, 1, 1);
1066     expect(InvalidParameter, status);
1067
1068     /* Valid test cases */
1069     status = GdipDrawCurve2I(graphics, pen, points, 2, 1);
1070     expect(Ok, status);
1071
1072     status = GdipDrawCurve2I(graphics, pen, points, 3, 2);
1073     expect(Ok, status);
1074
1075     status = GdipDrawCurve2I(graphics, pen, points, 3, -2);
1076     expect(Ok, status);
1077
1078     status = GdipDrawCurve2I(graphics, pen, points, 3, 0);
1079     expect(Ok, status);
1080
1081     GdipDeletePen(pen);
1082     GdipDeleteGraphics(graphics);
1083
1084     ReleaseDC(hwnd, hdc);
1085 }
1086
1087 static void test_GdipDrawCurve(void)
1088 {
1089     GpStatus status;
1090     GpGraphics *graphics = NULL;
1091     GpPen *pen = NULL;
1092     HDC hdc = GetDC( hwnd );
1093     GpPointF points[3];
1094
1095     points[0].X = 0;
1096     points[0].Y = 0;
1097
1098     points[1].X = 40;
1099     points[1].Y = 20;
1100
1101     points[2].X = 10;
1102     points[2].Y = 40;
1103
1104     /* make a graphics object and pen object */
1105     ok(hdc != NULL, "Expected HDC to be initialized\n");
1106
1107     status = GdipCreateFromHDC(hdc, &graphics);
1108     expect(Ok, status);
1109     ok(graphics != NULL, "Expected graphics to be initialized\n");
1110
1111     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1112     expect(Ok, status);
1113     ok(pen != NULL, "Expected pen to be initialized\n");
1114
1115     /* InvalidParameter cases: null graphics, null pen */
1116     status = GdipDrawCurve(NULL, NULL, points, 3);
1117     expect(InvalidParameter, status);
1118
1119     status = GdipDrawCurve(graphics, NULL, points, 3);
1120     expect(InvalidParameter, status);
1121
1122     status = GdipDrawCurve(NULL, pen, points, 3);
1123     expect(InvalidParameter, status);
1124
1125     /* InvalidParameter cases: invalid count */
1126     status = GdipDrawCurve(graphics, pen, points, -1);
1127     expect(InvalidParameter, status);
1128
1129     status = GdipDrawCurve(graphics, pen, points, 0);
1130     expect(InvalidParameter, status);
1131
1132     status = GdipDrawCurve(graphics, pen, points, 1);
1133     expect(InvalidParameter, status);
1134
1135     /* Valid test cases */
1136     status = GdipDrawCurve(graphics, pen, points, 2);
1137     expect(Ok, status);
1138
1139     status = GdipDrawCurve(graphics, pen, points, 3);
1140     expect(Ok, status);
1141
1142     GdipDeletePen(pen);
1143     GdipDeleteGraphics(graphics);
1144
1145     ReleaseDC(hwnd, hdc);
1146 }
1147
1148 static void test_GdipDrawCurveI(void)
1149 {
1150     GpStatus status;
1151     GpGraphics *graphics = NULL;
1152     GpPen *pen = NULL;
1153     HDC hdc = GetDC( hwnd );
1154     GpPoint points[3];
1155
1156     points[0].X = 0;
1157     points[0].Y = 0;
1158
1159     points[1].X = 40;
1160     points[1].Y = 20;
1161
1162     points[2].X = 10;
1163     points[2].Y = 40;
1164
1165     /* make a graphics object and pen object */
1166     ok(hdc != NULL, "Expected HDC to be initialized\n");
1167
1168     status = GdipCreateFromHDC(hdc, &graphics);
1169     expect(Ok, status);
1170     ok(graphics != NULL, "Expected graphics to be initialized\n");
1171
1172     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1173     expect(Ok, status);
1174     ok(pen != NULL, "Expected pen to be initialized\n");
1175
1176     /* InvalidParameter cases: null graphics, null pen */
1177     status = GdipDrawCurveI(NULL, NULL, points, 3);
1178     expect(InvalidParameter, status);
1179
1180     status = GdipDrawCurveI(graphics, NULL, points, 3);
1181     expect(InvalidParameter, status);
1182
1183     status = GdipDrawCurveI(NULL, pen, points, 3);
1184     expect(InvalidParameter, status);
1185
1186     /* InvalidParameter cases: invalid count */
1187     status = GdipDrawCurveI(graphics, pen, points, -1);
1188     expect(OutOfMemory, status);
1189
1190     status = GdipDrawCurveI(graphics, pen, points, 0);
1191     expect(InvalidParameter, status);
1192
1193     status = GdipDrawCurveI(graphics, pen, points, 1);
1194     expect(InvalidParameter, status);
1195
1196     /* Valid test cases */
1197     status = GdipDrawCurveI(graphics, pen, points, 2);
1198     expect(Ok, status);
1199
1200     status = GdipDrawCurveI(graphics, pen, points, 3);
1201     expect(Ok, status);
1202
1203     GdipDeletePen(pen);
1204     GdipDeleteGraphics(graphics);
1205
1206     ReleaseDC(hwnd, hdc);
1207 }
1208
1209 static void test_GdipDrawLineI(void)
1210 {
1211     GpStatus status;
1212     GpGraphics *graphics = NULL;
1213     GpPen *pen = NULL;
1214     HDC hdc = GetDC( hwnd );
1215
1216     /* make a graphics object and pen object */
1217     ok(hdc != NULL, "Expected HDC to be initialized\n");
1218
1219     status = GdipCreateFromHDC(hdc, &graphics);
1220     expect(Ok, status);
1221     ok(graphics != NULL, "Expected graphics to be initialized\n");
1222
1223     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1224     expect(Ok, status);
1225     ok(pen != NULL, "Expected pen to be initialized\n");
1226
1227     /* InvalidParameter cases: null graphics, null pen */
1228     status = GdipDrawLineI(NULL, NULL, 0, 0, 0, 0);
1229     expect(InvalidParameter, status);
1230
1231     status = GdipDrawLineI(graphics, NULL, 0, 0, 0, 0);
1232     expect(InvalidParameter, status);
1233
1234     status = GdipDrawLineI(NULL, pen, 0, 0, 0, 0);
1235     expect(InvalidParameter, status);
1236
1237     /* successful case */
1238     status = GdipDrawLineI(graphics, pen, 0, 0, 0, 0);
1239     expect(Ok, status);
1240
1241     GdipDeletePen(pen);
1242     GdipDeleteGraphics(graphics);
1243
1244     ReleaseDC(hwnd, hdc);
1245 }
1246
1247 static void test_GdipDrawImagePointsRect(void)
1248 {
1249     GpStatus status;
1250     GpGraphics *graphics = NULL;
1251     GpPointF ptf[4];
1252     GpBitmap *bm = NULL;
1253     BYTE rbmi[sizeof(BITMAPINFOHEADER)];
1254     BYTE buff[400];
1255     BITMAPINFO *bmi = (BITMAPINFO*)rbmi;
1256     HDC hdc = GetDC( hwnd );
1257     if (!hdc)
1258         return;
1259
1260     memset(rbmi, 0, sizeof(rbmi));
1261     bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1262     bmi->bmiHeader.biWidth = 10;
1263     bmi->bmiHeader.biHeight = 10;
1264     bmi->bmiHeader.biPlanes = 1;
1265     bmi->bmiHeader.biBitCount = 32;
1266     bmi->bmiHeader.biCompression = BI_RGB;
1267     status = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
1268     expect(Ok, status);
1269     ok(NULL != bm, "Expected bitmap to be initialized\n");
1270     status = GdipCreateFromHDC(hdc, &graphics);
1271     expect(Ok, status);
1272     ptf[0].X = 0;
1273     ptf[0].Y = 0;
1274     ptf[1].X = 10;
1275     ptf[1].Y = 0;
1276     ptf[2].X = 0;
1277     ptf[2].Y = 10;
1278     ptf[3].X = 10;
1279     ptf[3].Y = 10;
1280     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, ptf, 4, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1281     expect(NotImplemented, status);
1282     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, ptf, 2, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1283     expect(InvalidParameter, status);
1284     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, ptf, 3, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1285     expect(Ok, status);
1286     status = GdipDrawImagePointsRect(graphics, NULL, ptf, 3, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1287     expect(InvalidParameter, status);
1288     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, NULL, 3, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1289     expect(InvalidParameter, status);
1290     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, ptf, 3, 0, 0, 0, 0, UnitPixel, NULL, NULL, NULL);
1291     expect(Ok, status);
1292     memset(ptf, 0, sizeof(ptf));
1293     status = GdipDrawImagePointsRect(graphics, (GpImage*)bm, ptf, 3, 0, 0, 10, 10, UnitPixel, NULL, NULL, NULL);
1294     expect(Ok, status);
1295
1296     GdipDisposeImage((GpImage*)bm);
1297     GdipDeleteGraphics(graphics);
1298     ReleaseDC(hwnd, hdc);
1299 }
1300
1301 static void test_GdipDrawLinesI(void)
1302 {
1303     GpStatus status;
1304     GpGraphics *graphics = NULL;
1305     GpPen *pen = NULL;
1306     GpPoint *ptf = NULL;
1307     HDC hdc = GetDC( hwnd );
1308
1309     /* make a graphics object and pen object */
1310     ok(hdc != NULL, "Expected HDC to be initialized\n");
1311
1312     status = GdipCreateFromHDC(hdc, &graphics);
1313     expect(Ok, status);
1314     ok(graphics != NULL, "Expected graphics to be initialized\n");
1315
1316     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1317     expect(Ok, status);
1318     ok(pen != NULL, "Expected pen to be initialized\n");
1319
1320     /* make some arbitrary valid points*/
1321     ptf = GdipAlloc(2 * sizeof(GpPointF));
1322
1323     ptf[0].X = 1;
1324     ptf[0].Y = 1;
1325
1326     ptf[1].X = 2;
1327     ptf[1].Y = 2;
1328
1329     /* InvalidParameter cases: null graphics, null pen, null points, count < 2*/
1330     status = GdipDrawLinesI(NULL, NULL, NULL, 0);
1331     expect(InvalidParameter, status);
1332
1333     status = GdipDrawLinesI(graphics, pen, ptf, 0);
1334     expect(InvalidParameter, status);
1335
1336     status = GdipDrawLinesI(graphics, NULL, ptf, 2);
1337     expect(InvalidParameter, status);
1338
1339     status = GdipDrawLinesI(NULL, pen, ptf, 2);
1340     expect(InvalidParameter, status);
1341
1342     /* successful case */
1343     status = GdipDrawLinesI(graphics, pen, ptf, 2);
1344     expect(Ok, status);
1345
1346     GdipFree(ptf);
1347     GdipDeletePen(pen);
1348     GdipDeleteGraphics(graphics);
1349
1350     ReleaseDC(hwnd, hdc);
1351 }
1352
1353 static void test_GdipFillClosedCurve(void)
1354 {
1355     GpStatus status;
1356     GpGraphics *graphics = NULL;
1357     GpSolidFill *brush = NULL;
1358     HDC hdc = GetDC( hwnd );
1359     GpPointF points[3];
1360
1361     points[0].X = 0;
1362     points[0].Y = 0;
1363
1364     points[1].X = 40;
1365     points[1].Y = 20;
1366
1367     points[2].X = 10;
1368     points[2].Y = 40;
1369
1370     /* make a graphics object and brush object */
1371     ok(hdc != NULL, "Expected HDC to be initialized\n");
1372
1373     status = GdipCreateFromHDC(hdc, &graphics);
1374     expect(Ok, status);
1375     ok(graphics != NULL, "Expected graphics to be initialized\n");
1376
1377     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
1378
1379     /* InvalidParameter cases: null graphics, null brush, null points */
1380     status = GdipFillClosedCurve(NULL, NULL, NULL, 3);
1381     expect(InvalidParameter, status);
1382
1383     status = GdipFillClosedCurve(graphics, NULL, NULL, 3);
1384     expect(InvalidParameter, status);
1385
1386     status = GdipFillClosedCurve(NULL, (GpBrush*)brush, NULL, 3);
1387     expect(InvalidParameter, status);
1388
1389     status = GdipFillClosedCurve(NULL, NULL, points, 3);
1390     expect(InvalidParameter, status);
1391
1392     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, NULL, 3);
1393     expect(InvalidParameter, status);
1394
1395     status = GdipFillClosedCurve(graphics, NULL, points, 3);
1396     expect(InvalidParameter, status);
1397
1398     status = GdipFillClosedCurve(NULL, (GpBrush*)brush, points, 3);
1399     expect(InvalidParameter, status);
1400
1401     /* InvalidParameter cases: invalid count */
1402     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, points, -1);
1403     expect(InvalidParameter, status);
1404
1405     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, points, 0);
1406     expect(InvalidParameter, status);
1407
1408     /* Valid test cases */
1409     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, points, 1);
1410     expect(Ok, status);
1411
1412     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, points, 2);
1413     expect(Ok, status);
1414
1415     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, points, 3);
1416     expect(Ok, status);
1417
1418     GdipDeleteGraphics(graphics);
1419     GdipDeleteBrush((GpBrush*)brush);
1420
1421     ReleaseDC(hwnd, hdc);
1422 }
1423
1424 static void test_GdipFillClosedCurveI(void)
1425 {
1426     GpStatus status;
1427     GpGraphics *graphics = NULL;
1428     GpSolidFill *brush = NULL;
1429     HDC hdc = GetDC( hwnd );
1430     GpPoint points[3];
1431
1432     points[0].X = 0;
1433     points[0].Y = 0;
1434
1435     points[1].X = 40;
1436     points[1].Y = 20;
1437
1438     points[2].X = 10;
1439     points[2].Y = 40;
1440
1441     /* make a graphics object and brush object */
1442     ok(hdc != NULL, "Expected HDC to be initialized\n");
1443
1444     status = GdipCreateFromHDC(hdc, &graphics);
1445     expect(Ok, status);
1446     ok(graphics != NULL, "Expected graphics to be initialized\n");
1447
1448     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
1449
1450     /* InvalidParameter cases: null graphics, null brush */
1451     /* Note: GdipFillClosedCurveI and GdipFillClosedCurve2I hang in Windows
1452              when points == NULL, so don't test this condition */
1453     status = GdipFillClosedCurveI(NULL, NULL, points, 3);
1454     expect(InvalidParameter, status);
1455
1456     status = GdipFillClosedCurveI(graphics, NULL, points, 3);
1457     expect(InvalidParameter, status);
1458
1459     status = GdipFillClosedCurveI(NULL, (GpBrush*)brush, points, 3);
1460     expect(InvalidParameter, status);
1461
1462     /* InvalidParameter cases: invalid count */
1463     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, points, 0);
1464     expect(InvalidParameter, status);
1465
1466     /* OutOfMemory cases: large (unsigned) int */
1467     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, points, -1);
1468     expect(OutOfMemory, status);
1469
1470     /* Valid test cases */
1471     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, points, 1);
1472     expect(Ok, status);
1473
1474     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, points, 2);
1475     expect(Ok, status);
1476
1477     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, points, 3);
1478     expect(Ok, status);
1479
1480     GdipDeleteGraphics(graphics);
1481     GdipDeleteBrush((GpBrush*)brush);
1482
1483     ReleaseDC(hwnd, hdc);
1484 }
1485
1486 static void test_Get_Release_DC(void)
1487 {
1488     GpStatus status;
1489     GpGraphics *graphics = NULL;
1490     GpPen *pen;
1491     GpSolidFill *brush;
1492     GpPath *path;
1493     HDC hdc = GetDC( hwnd );
1494     HDC retdc;
1495     REAL r;
1496     CompositingQuality quality;
1497     CompositingMode compmode;
1498     InterpolationMode intmode;
1499     GpMatrix *m;
1500     GpRegion *region;
1501     GpUnit unit;
1502     PixelOffsetMode offsetmode;
1503     SmoothingMode smoothmode;
1504     TextRenderingHint texthint;
1505     GpPointF ptf[5];
1506     GpPoint  pt[5];
1507     GpRectF  rectf[2];
1508     GpRect   rect[2];
1509     GpRegion *clip;
1510     INT i;
1511     BOOL res;
1512     ARGB color = 0x00000000;
1513     HRGN hrgn = CreateRectRgn(0, 0, 10, 10);
1514
1515     pt[0].X = 10;
1516     pt[0].Y = 10;
1517     pt[1].X = 20;
1518     pt[1].Y = 15;
1519     pt[2].X = 40;
1520     pt[2].Y = 80;
1521     pt[3].X = -20;
1522     pt[3].Y = 20;
1523     pt[4].X = 50;
1524     pt[4].Y = 110;
1525
1526     for(i = 0; i < 5;i++){
1527         ptf[i].X = (REAL)pt[i].X;
1528         ptf[i].Y = (REAL)pt[i].Y;
1529     }
1530
1531     rect[0].X = 0;
1532     rect[0].Y = 0;
1533     rect[0].Width  = 50;
1534     rect[0].Height = 70;
1535     rect[1].X = 0;
1536     rect[1].Y = 0;
1537     rect[1].Width  = 10;
1538     rect[1].Height = 20;
1539
1540     for(i = 0; i < 2;i++){
1541         rectf[i].X = (REAL)rect[i].X;
1542         rectf[i].Y = (REAL)rect[i].Y;
1543         rectf[i].Height = (REAL)rect[i].Height;
1544         rectf[i].Width  = (REAL)rect[i].Width;
1545     }
1546
1547     status = GdipCreateMatrix(&m);
1548     expect(Ok, status);
1549     GdipCreateRegion(&region);
1550     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
1551     GdipCreatePath(FillModeAlternate, &path);
1552     GdipCreateRegion(&clip);
1553
1554     status = GdipCreateFromHDC(hdc, &graphics);
1555     expect(Ok, status);
1556     ok(graphics != NULL, "Expected graphics to be initialized\n");
1557     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
1558     expect(Ok, status);
1559
1560     /* NULL arguments */
1561     status = GdipGetDC(NULL, NULL);
1562     expect(InvalidParameter, status);
1563     status = GdipGetDC(graphics, NULL);
1564     expect(InvalidParameter, status);
1565     status = GdipGetDC(NULL, &retdc);
1566     expect(InvalidParameter, status);
1567
1568     status = GdipReleaseDC(NULL, NULL);
1569     expect(InvalidParameter, status);
1570     status = GdipReleaseDC(graphics, NULL);
1571     expect(InvalidParameter, status);
1572     status = GdipReleaseDC(NULL, (HDC)0xdeadbeef);
1573     expect(InvalidParameter, status);
1574
1575     /* Release without Get */
1576     status = GdipReleaseDC(graphics, hdc);
1577     expect(InvalidParameter, status);
1578
1579     retdc = NULL;
1580     status = GdipGetDC(graphics, &retdc);
1581     expect(Ok, status);
1582     ok(retdc == hdc, "Invalid HDC returned\n");
1583     /* call it once more */
1584     status = GdipGetDC(graphics, &retdc);
1585     expect(ObjectBusy, status);
1586
1587     /* try all Graphics calls here */
1588     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
1589     expect(ObjectBusy, status);
1590     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0.0, 0.0);
1591     expect(ObjectBusy, status);
1592     status = GdipDrawBezier(graphics, pen, 0.0, 10.0, 20.0, 15.0, 35.0, -10.0, 10.0, 10.0);
1593     expect(ObjectBusy, status);
1594     status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
1595     expect(ObjectBusy, status);
1596     status = GdipDrawBeziers(graphics, pen, ptf, 5);
1597     expect(ObjectBusy, status);
1598     status = GdipDrawBeziersI(graphics, pen, pt, 5);
1599     expect(ObjectBusy, status);
1600     status = GdipDrawClosedCurve(graphics, pen, ptf, 5);
1601     expect(ObjectBusy, status);
1602     status = GdipDrawClosedCurveI(graphics, pen, pt, 5);
1603     expect(ObjectBusy, status);
1604     status = GdipDrawClosedCurve2(graphics, pen, ptf, 5, 1.0);
1605     expect(ObjectBusy, status);
1606     status = GdipDrawClosedCurve2I(graphics, pen, pt, 5, 1.0);
1607     expect(ObjectBusy, status);
1608     status = GdipDrawCurve(graphics, pen, ptf, 5);
1609     expect(ObjectBusy, status);
1610     status = GdipDrawCurveI(graphics, pen, pt, 5);
1611     expect(ObjectBusy, status);
1612     status = GdipDrawCurve2(graphics, pen, ptf, 5, 1.0);
1613     expect(ObjectBusy, status);
1614     status = GdipDrawCurve2I(graphics, pen, pt, 5, 1.0);
1615     expect(ObjectBusy, status);
1616     status = GdipDrawEllipse(graphics, pen, 0.0, 0.0, 100.0, 50.0);
1617     expect(ObjectBusy, status);
1618     status = GdipDrawEllipseI(graphics, pen, 0, 0, 100, 50);
1619     expect(ObjectBusy, status);
1620     /* GdipDrawImage/GdipDrawImageI */
1621     /* GdipDrawImagePointsRect/GdipDrawImagePointsRectI */
1622     /* GdipDrawImageRectRect/GdipDrawImageRectRectI */
1623     /* GdipDrawImageRect/GdipDrawImageRectI */
1624     status = GdipDrawLine(graphics, pen, 0.0, 0.0, 100.0, 200.0);
1625     expect(ObjectBusy, status);
1626     status = GdipDrawLineI(graphics, pen, 0, 0, 100, 200);
1627     expect(ObjectBusy, status);
1628     status = GdipDrawLines(graphics, pen, ptf, 5);
1629     expect(ObjectBusy, status);
1630     status = GdipDrawLinesI(graphics, pen, pt, 5);
1631     expect(ObjectBusy, status);
1632     status = GdipDrawPath(graphics, pen, path);
1633     expect(ObjectBusy, status);
1634     status = GdipDrawPie(graphics, pen, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
1635     expect(ObjectBusy, status);
1636     status = GdipDrawPieI(graphics, pen, 0, 0, 100, 100, 0.0, 90.0);
1637     expect(ObjectBusy, status);
1638     status = GdipDrawRectangle(graphics, pen, 0.0, 0.0, 100.0, 300.0);
1639     expect(ObjectBusy, status);
1640     status = GdipDrawRectangleI(graphics, pen, 0, 0, 100, 300);
1641     expect(ObjectBusy, status);
1642     status = GdipDrawRectangles(graphics, pen, rectf, 2);
1643     expect(ObjectBusy, status);
1644     status = GdipDrawRectanglesI(graphics, pen, rect, 2);
1645     expect(ObjectBusy, status);
1646     /* GdipDrawString */
1647     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, ptf, 5, 1.0, FillModeAlternate);
1648     expect(ObjectBusy, status);
1649     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, pt, 5, 1.0, FillModeAlternate);
1650     expect(ObjectBusy, status);
1651     status = GdipFillClosedCurve(graphics, (GpBrush*)brush, ptf, 5);
1652     expect(ObjectBusy, status);
1653     status = GdipFillClosedCurveI(graphics, (GpBrush*)brush, pt, 5);
1654     expect(ObjectBusy, status);
1655     status = GdipFillEllipse(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
1656     expect(ObjectBusy, status);
1657     status = GdipFillEllipseI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
1658     expect(ObjectBusy, status);
1659     status = GdipFillPath(graphics, (GpBrush*)brush, path);
1660     expect(ObjectBusy, status);
1661     status = GdipFillPie(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0, 0.0, 15.0);
1662     expect(ObjectBusy, status);
1663     status = GdipFillPieI(graphics, (GpBrush*)brush, 0, 0, 100, 100, 0.0, 15.0);
1664     expect(ObjectBusy, status);
1665     status = GdipFillPolygon(graphics, (GpBrush*)brush, ptf, 5, FillModeAlternate);
1666     expect(ObjectBusy, status);
1667     status = GdipFillPolygonI(graphics, (GpBrush*)brush, pt, 5, FillModeAlternate);
1668     expect(ObjectBusy, status);
1669     status = GdipFillPolygon2(graphics, (GpBrush*)brush, ptf, 5);
1670     expect(ObjectBusy, status);
1671     status = GdipFillPolygon2I(graphics, (GpBrush*)brush, pt, 5);
1672     expect(ObjectBusy, status);
1673     status = GdipFillRectangle(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
1674     expect(ObjectBusy, status);
1675     status = GdipFillRectangleI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
1676     expect(ObjectBusy, status);
1677     status = GdipFillRectangles(graphics, (GpBrush*)brush, rectf, 2);
1678     expect(ObjectBusy, status);
1679     status = GdipFillRectanglesI(graphics, (GpBrush*)brush, rect, 2);
1680     expect(ObjectBusy, status);
1681     status = GdipFillRegion(graphics, (GpBrush*)brush, region);
1682     expect(ObjectBusy, status);
1683     status = GdipFlush(graphics, FlushIntentionFlush);
1684     expect(ObjectBusy, status);
1685     status = GdipGetClipBounds(graphics, rectf);
1686     expect(ObjectBusy, status);
1687     status = GdipGetClipBoundsI(graphics, rect);
1688     expect(ObjectBusy, status);
1689     status = GdipGetCompositingMode(graphics, &compmode);
1690     expect(ObjectBusy, status);
1691     status = GdipGetCompositingQuality(graphics, &quality);
1692     expect(ObjectBusy, status);
1693     status = GdipGetInterpolationMode(graphics, &intmode);
1694     expect(ObjectBusy, status);
1695     status = GdipGetNearestColor(graphics, &color);
1696     expect(ObjectBusy, status);
1697     status = GdipGetPageScale(graphics, &r);
1698     expect(ObjectBusy, status);
1699     status = GdipGetPageUnit(graphics, &unit);
1700     expect(ObjectBusy, status);
1701     status = GdipGetPixelOffsetMode(graphics, &offsetmode);
1702     expect(ObjectBusy, status);
1703     status = GdipGetSmoothingMode(graphics, &smoothmode);
1704     expect(ObjectBusy, status);
1705     status = GdipGetTextRenderingHint(graphics, &texthint);
1706     expect(ObjectBusy, status);
1707     status = GdipGetWorldTransform(graphics, m);
1708     expect(ObjectBusy, status);
1709     status = GdipGraphicsClear(graphics, 0xdeadbeef);
1710     expect(ObjectBusy, status);
1711     status = GdipIsVisiblePoint(graphics, 0.0, 0.0, &res);
1712     expect(ObjectBusy, status);
1713     status = GdipIsVisiblePointI(graphics, 0, 0, &res);
1714     expect(ObjectBusy, status);
1715     /* GdipMeasureCharacterRanges */
1716     /* GdipMeasureString */
1717     status = GdipResetClip(graphics);
1718     expect(ObjectBusy, status);
1719     status = GdipResetWorldTransform(graphics);
1720     expect(ObjectBusy, status);
1721     /* GdipRestoreGraphics */
1722     status = GdipRotateWorldTransform(graphics, 15.0, MatrixOrderPrepend);
1723     expect(ObjectBusy, status);
1724     /*  GdipSaveGraphics */
1725     status = GdipScaleWorldTransform(graphics, 1.0, 1.0, MatrixOrderPrepend);
1726     expect(ObjectBusy, status);
1727     status = GdipSetCompositingMode(graphics, CompositingModeSourceOver);
1728     expect(ObjectBusy, status);
1729     status = GdipSetCompositingQuality(graphics, CompositingQualityDefault);
1730     expect(ObjectBusy, status);
1731     status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
1732     expect(ObjectBusy, status);
1733     status = GdipSetPageScale(graphics, 1.0);
1734     expect(ObjectBusy, status);
1735     status = GdipSetPageUnit(graphics, UnitWorld);
1736     expect(ObjectBusy, status);
1737     status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeDefault);
1738     expect(ObjectBusy, status);
1739     status = GdipSetSmoothingMode(graphics, SmoothingModeDefault);
1740     expect(ObjectBusy, status);
1741     status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
1742     expect(ObjectBusy, status);
1743     status = GdipSetWorldTransform(graphics, m);
1744     expect(ObjectBusy, status);
1745     status = GdipTranslateWorldTransform(graphics, 0.0, 0.0, MatrixOrderPrepend);
1746     expect(ObjectBusy, status);
1747     status = GdipSetClipHrgn(graphics, hrgn, CombineModeReplace);
1748     expect(ObjectBusy, status);
1749     status = GdipSetClipPath(graphics, path, CombineModeReplace);
1750     expect(ObjectBusy, status);
1751     status = GdipSetClipRect(graphics, 0.0, 0.0, 10.0, 10.0, CombineModeReplace);
1752     expect(ObjectBusy, status);
1753     status = GdipSetClipRectI(graphics, 0, 0, 10, 10, CombineModeReplace);
1754     expect(ObjectBusy, status);
1755     status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
1756     expect(ObjectBusy, status);
1757     status = GdipTranslateClip(graphics, 0.0, 0.0);
1758     expect(ObjectBusy, status);
1759     status = GdipTranslateClipI(graphics, 0, 0);
1760     expect(ObjectBusy, status);
1761     status = GdipDrawPolygon(graphics, pen, ptf, 5);
1762     expect(ObjectBusy, status);
1763     status = GdipDrawPolygonI(graphics, pen, pt, 5);
1764     expect(ObjectBusy, status);
1765     status = GdipGetDpiX(graphics, &r);
1766     expect(ObjectBusy, status);
1767     status = GdipGetDpiY(graphics, &r);
1768     expect(ObjectBusy, status);
1769     status = GdipMultiplyWorldTransform(graphics, m, MatrixOrderPrepend);
1770     expect(ObjectBusy, status);
1771     status = GdipGetClip(graphics, region);
1772     expect(ObjectBusy, status);
1773     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 5);
1774     expect(ObjectBusy, status);
1775
1776     /* try to delete before release */
1777     status = GdipDeleteGraphics(graphics);
1778     expect(ObjectBusy, status);
1779
1780     status = GdipReleaseDC(graphics, retdc);
1781     expect(Ok, status);
1782
1783     GdipDeletePen(pen);
1784     GdipDeleteGraphics(graphics);
1785
1786     GdipDeleteRegion(clip);
1787     GdipDeletePath(path);
1788     GdipDeleteBrush((GpBrush*)brush);
1789     GdipDeleteRegion(region);
1790     GdipDeleteMatrix(m);
1791     DeleteObject(hrgn);
1792
1793     ReleaseDC(hwnd, hdc);
1794 }
1795
1796 static void test_transformpoints(void)
1797 {
1798     GpStatus status;
1799     GpGraphics *graphics = NULL;
1800     HDC hdc = GetDC( hwnd );
1801     GpPointF ptf[2];
1802     GpPoint pt[2];
1803
1804     status = GdipCreateFromHDC(hdc, &graphics);
1805     expect(Ok, status);
1806
1807     /* NULL arguments */
1808     status = GdipTransformPoints(NULL, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
1809     expect(InvalidParameter, status);
1810     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
1811     expect(InvalidParameter, status);
1812     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 0);
1813     expect(InvalidParameter, status);
1814     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, -1);
1815     expect(InvalidParameter, status);
1816
1817     ptf[0].X = 1.0;
1818     ptf[0].Y = 0.0;
1819     ptf[1].X = 0.0;
1820     ptf[1].Y = 1.0;
1821     status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, ptf, 2);
1822     expect(Ok, status);
1823     expectf(1.0, ptf[0].X);
1824     expectf(0.0, ptf[0].Y);
1825     expectf(0.0, ptf[1].X);
1826     expectf(1.0, ptf[1].Y);
1827
1828     status = GdipTranslateWorldTransform(graphics, 5.0, 5.0, MatrixOrderAppend);
1829     expect(Ok, status);
1830     status = GdipSetPageUnit(graphics, UnitPixel);
1831     expect(Ok, status);
1832     status = GdipSetPageScale(graphics, 3.0);
1833     expect(Ok, status);
1834
1835     ptf[0].X = 1.0;
1836     ptf[0].Y = 0.0;
1837     ptf[1].X = 0.0;
1838     ptf[1].Y = 1.0;
1839     status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, ptf, 2);
1840     expect(Ok, status);
1841     expectf(18.0, ptf[0].X);
1842     expectf(15.0, ptf[0].Y);
1843     expectf(15.0, ptf[1].X);
1844     expectf(18.0, ptf[1].Y);
1845
1846     ptf[0].X = 1.0;
1847     ptf[0].Y = 0.0;
1848     ptf[1].X = 0.0;
1849     ptf[1].Y = 1.0;
1850     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 2);
1851     expect(Ok, status);
1852     expectf(6.0, ptf[0].X);
1853     expectf(5.0, ptf[0].Y);
1854     expectf(5.0, ptf[1].X);
1855     expectf(6.0, ptf[1].Y);
1856
1857     ptf[0].X = 1.0;
1858     ptf[0].Y = 0.0;
1859     ptf[1].X = 0.0;
1860     ptf[1].Y = 1.0;
1861     status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpacePage, ptf, 2);
1862     expect(Ok, status);
1863     expectf(3.0, ptf[0].X);
1864     expectf(0.0, ptf[0].Y);
1865     expectf(0.0, ptf[1].X);
1866     expectf(3.0, ptf[1].Y);
1867
1868     ptf[0].X = 18.0;
1869     ptf[0].Y = 15.0;
1870     ptf[1].X = 15.0;
1871     ptf[1].Y = 18.0;
1872     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
1873     expect(Ok, status);
1874     expectf(1.0, ptf[0].X);
1875     expectf(0.0, ptf[0].Y);
1876     expectf(0.0, ptf[1].X);
1877     expectf(1.0, ptf[1].Y);
1878
1879     ptf[0].X = 6.0;
1880     ptf[0].Y = 5.0;
1881     ptf[1].X = 5.0;
1882     ptf[1].Y = 6.0;
1883     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpacePage, ptf, 2);
1884     expect(Ok, status);
1885     expectf(1.0, ptf[0].X);
1886     expectf(0.0, ptf[0].Y);
1887     expectf(0.0, ptf[1].X);
1888     expectf(1.0, ptf[1].Y);
1889
1890     ptf[0].X = 3.0;
1891     ptf[0].Y = 0.0;
1892     ptf[1].X = 0.0;
1893     ptf[1].Y = 3.0;
1894     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceDevice, ptf, 2);
1895     expect(Ok, status);
1896     expectf(1.0, ptf[0].X);
1897     expectf(0.0, ptf[0].Y);
1898     expectf(0.0, ptf[1].X);
1899     expectf(1.0, ptf[1].Y);
1900
1901     pt[0].X = 1;
1902     pt[0].Y = 0;
1903     pt[1].X = 0;
1904     pt[1].Y = 1;
1905     status = GdipTransformPointsI(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 2);
1906     expect(Ok, status);
1907     expect(18, pt[0].X);
1908     expect(15, pt[0].Y);
1909     expect(15, pt[1].X);
1910     expect(18, pt[1].Y);
1911
1912     GdipDeleteGraphics(graphics);
1913     ReleaseDC(hwnd, hdc);
1914 }
1915
1916 static void test_get_set_clip(void)
1917 {
1918     GpStatus status;
1919     GpGraphics *graphics = NULL;
1920     HDC hdc = GetDC( hwnd );
1921     GpRegion *clip;
1922     GpRectF rect;
1923     BOOL res;
1924
1925     status = GdipCreateFromHDC(hdc, &graphics);
1926     expect(Ok, status);
1927
1928     rect.X = rect.Y = 0.0;
1929     rect.Height = rect.Width = 100.0;
1930
1931     status = GdipCreateRegionRect(&rect, &clip);
1932     expect(Ok, status);
1933
1934     /* NULL arguments */
1935     status = GdipGetClip(NULL, NULL);
1936     expect(InvalidParameter, status);
1937     status = GdipGetClip(graphics, NULL);
1938     expect(InvalidParameter, status);
1939     status = GdipGetClip(NULL, clip);
1940     expect(InvalidParameter, status);
1941
1942     status = GdipSetClipRegion(NULL, NULL, CombineModeReplace);
1943     expect(InvalidParameter, status);
1944     status = GdipSetClipRegion(graphics, NULL, CombineModeReplace);
1945     expect(InvalidParameter, status);
1946
1947     status = GdipSetClipPath(NULL, NULL, CombineModeReplace);
1948     expect(InvalidParameter, status);
1949     status = GdipSetClipPath(graphics, NULL, CombineModeReplace);
1950     expect(InvalidParameter, status);
1951
1952     res = FALSE;
1953     status = GdipGetClip(graphics, clip);
1954     expect(Ok, status);
1955     status = GdipIsInfiniteRegion(clip, graphics, &res);
1956     expect(Ok, status);
1957     expect(TRUE, res);
1958
1959     /* remains infinite after reset */
1960     res = FALSE;
1961     status = GdipResetClip(graphics);
1962     expect(Ok, status);
1963     status = GdipGetClip(graphics, clip);
1964     expect(Ok, status);
1965     status = GdipIsInfiniteRegion(clip, graphics, &res);
1966     expect(Ok, status);
1967     expect(TRUE, res);
1968
1969     /* set to empty and then reset to infinite */
1970     status = GdipSetEmpty(clip);
1971     expect(Ok, status);
1972     status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
1973     expect(Ok, status);
1974
1975     status = GdipGetClip(graphics, clip);
1976     expect(Ok, status);
1977     res = FALSE;
1978     status = GdipIsEmptyRegion(clip, graphics, &res);
1979     expect(Ok, status);
1980     expect(TRUE, res);
1981     status = GdipResetClip(graphics);
1982     expect(Ok, status);
1983     status = GdipGetClip(graphics, clip);
1984     expect(Ok, status);
1985     res = FALSE;
1986     status = GdipIsInfiniteRegion(clip, graphics, &res);
1987     expect(Ok, status);
1988     expect(TRUE, res);
1989
1990     GdipDeleteRegion(clip);
1991
1992     GdipDeleteGraphics(graphics);
1993     ReleaseDC(hwnd, hdc);
1994 }
1995
1996 static void test_isempty(void)
1997 {
1998     GpStatus status;
1999     GpGraphics *graphics = NULL;
2000     HDC hdc = GetDC( hwnd );
2001     GpRegion *clip;
2002     BOOL res;
2003
2004     status = GdipCreateFromHDC(hdc, &graphics);
2005     expect(Ok, status);
2006
2007     status = GdipCreateRegion(&clip);
2008     expect(Ok, status);
2009
2010     /* NULL */
2011     status = GdipIsClipEmpty(NULL, NULL);
2012     expect(InvalidParameter, status);
2013     status = GdipIsClipEmpty(graphics, NULL);
2014     expect(InvalidParameter, status);
2015     status = GdipIsClipEmpty(NULL, &res);
2016     expect(InvalidParameter, status);
2017
2018     /* default is infinite */
2019     res = TRUE;
2020     status = GdipIsClipEmpty(graphics, &res);
2021     expect(Ok, status);
2022     expect(FALSE, res);
2023
2024     GdipDeleteRegion(clip);
2025
2026     GdipDeleteGraphics(graphics);
2027     ReleaseDC(hwnd, hdc);
2028 }
2029
2030 static void test_clear(void)
2031 {
2032     GpStatus status;
2033
2034     status = GdipGraphicsClear(NULL, 0xdeadbeef);
2035     expect(InvalidParameter, status);
2036 }
2037
2038 static void test_textcontrast(void)
2039 {
2040     GpStatus status;
2041     HDC hdc = GetDC( hwnd );
2042     GpGraphics *graphics;
2043     UINT contrast;
2044
2045     status = GdipGetTextContrast(NULL, NULL);
2046     expect(InvalidParameter, status);
2047
2048     status = GdipCreateFromHDC(hdc, &graphics);
2049     expect(Ok, status);
2050
2051     status = GdipGetTextContrast(graphics, NULL);
2052     expect(InvalidParameter, status);
2053     status = GdipGetTextContrast(graphics, &contrast);
2054     expect(Ok, status);
2055     expect(4, contrast);
2056
2057     GdipDeleteGraphics(graphics);
2058     ReleaseDC(hwnd, hdc);
2059 }
2060
2061 static void test_GdipDrawString(void)
2062 {
2063     GpStatus status;
2064     GpGraphics *graphics = NULL;
2065     GpFont *fnt = NULL;
2066     RectF  rect;
2067     GpStringFormat *format;
2068     GpBrush *brush;
2069     LOGFONTA logfont;
2070     HDC hdc = GetDC( hwnd );
2071     static const WCHAR string[] = {'T','e','s','t',0};
2072     static const PointF positions[4] = {{0,0}, {1,1}, {2,2}, {3,3}};
2073     GpMatrix *matrix;
2074
2075     memset(&logfont,0,sizeof(logfont));
2076     strcpy(logfont.lfFaceName,"Arial");
2077     logfont.lfHeight = 12;
2078     logfont.lfCharSet = DEFAULT_CHARSET;
2079
2080     status = GdipCreateFromHDC(hdc, &graphics);
2081     expect(Ok, status);
2082
2083     status = GdipCreateFontFromLogfontA(hdc, &logfont, &fnt);
2084     if (status == NotTrueTypeFont || status == FileNotFound)
2085     {
2086         skip("Arial not installed.\n");
2087         return;
2088     }
2089     expect(Ok, status);
2090
2091     status = GdipCreateSolidFill((ARGB)0xdeadbeef, (GpSolidFill**)&brush);
2092     expect(Ok, status);
2093
2094     status = GdipCreateStringFormat(0,0,&format);
2095     expect(Ok, status);
2096
2097     rect.X = 0;
2098     rect.Y = 0;
2099     rect.Width = 0;
2100     rect.Height = 12;
2101
2102     status = GdipDrawString(graphics, string, 4, fnt, &rect, format, brush);
2103     expect(Ok, status);
2104
2105     status = GdipCreateMatrix(&matrix);
2106     expect(Ok, status);
2107
2108     status = GdipDrawDriverString(NULL, string, 4, fnt, brush, positions, DriverStringOptionsCmapLookup, matrix);
2109     expect(InvalidParameter, status);
2110
2111     status = GdipDrawDriverString(graphics, NULL, 4, fnt, brush, positions, DriverStringOptionsCmapLookup, matrix);
2112     expect(InvalidParameter, status);
2113
2114     status = GdipDrawDriverString(graphics, string, 4, NULL, brush, positions, DriverStringOptionsCmapLookup, matrix);
2115     expect(InvalidParameter, status);
2116
2117     status = GdipDrawDriverString(graphics, string, 4, fnt, NULL, positions, DriverStringOptionsCmapLookup, matrix);
2118     expect(InvalidParameter, status);
2119
2120     status = GdipDrawDriverString(graphics, string, 4, fnt, brush, NULL, DriverStringOptionsCmapLookup, matrix);
2121     expect(InvalidParameter, status);
2122
2123     status = GdipDrawDriverString(graphics, string, 4, fnt, brush, positions, DriverStringOptionsCmapLookup|0x10, matrix);
2124     expect(Ok, status);
2125
2126     status = GdipDrawDriverString(graphics, string, 4, fnt, brush, positions, DriverStringOptionsCmapLookup, NULL);
2127     expect(Ok, status);
2128
2129     status = GdipDrawDriverString(graphics, string, 4, fnt, brush, positions, DriverStringOptionsCmapLookup, matrix);
2130     expect(Ok, status);
2131
2132     GdipDeleteMatrix(matrix);
2133     GdipDeleteGraphics(graphics);
2134     GdipDeleteBrush(brush);
2135     GdipDeleteFont(fnt);
2136     GdipDeleteStringFormat(format);
2137
2138     ReleaseDC(hwnd, hdc);
2139 }
2140
2141 static void test_GdipGetVisibleClipBounds_screen(void)
2142 {
2143     GpStatus status;
2144     GpGraphics *graphics = NULL;
2145     HDC hdc = GetDC(0);
2146     GpRectF rectf, exp, clipr;
2147     GpRect recti;
2148
2149     ok(hdc != NULL, "Expected HDC to be initialized\n");
2150
2151     status = GdipCreateFromHDC(hdc, &graphics);
2152     expect(Ok, status);
2153     ok(graphics != NULL, "Expected graphics to be initialized\n");
2154
2155     /* no clipping rect */
2156     exp.X = 0;
2157     exp.Y = 0;
2158     exp.Width = GetDeviceCaps(hdc, HORZRES);
2159     exp.Height = GetDeviceCaps(hdc, VERTRES);
2160
2161     status = GdipGetVisibleClipBounds(graphics, &rectf);
2162     expect(Ok, status);
2163     ok(rectf.X == exp.X &&
2164         rectf.Y == exp.Y &&
2165         rectf.Width == exp.Width &&
2166         rectf.Height == exp.Height,
2167         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2168         "the screen (%0.f, %0.f, %0.f, %0.f)\n",
2169         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2170         exp.X, exp.Y, exp.Width, exp.Height);
2171
2172     /* clipping rect entirely within window */
2173     exp.X = clipr.X = 10;
2174     exp.Y = clipr.Y = 12;
2175     exp.Width = clipr.Width = 14;
2176     exp.Height = clipr.Height = 16;
2177
2178     status = GdipSetClipRect(graphics, clipr.X, clipr.Y, clipr.Width, clipr.Height, CombineModeReplace);
2179     expect(Ok, status);
2180
2181     status = GdipGetVisibleClipBounds(graphics, &rectf);
2182     expect(Ok, status);
2183     ok(rectf.X == exp.X &&
2184         rectf.Y == exp.Y &&
2185         rectf.Width == exp.Width &&
2186         rectf.Height == exp.Height,
2187         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2188         "the clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2189         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2190         exp.X, exp.Y, exp.Width, exp.Height);
2191
2192     /* clipping rect partially outside of screen */
2193     clipr.X = -10;
2194     clipr.Y = -12;
2195     clipr.Width = 20;
2196     clipr.Height = 24;
2197
2198     status = GdipSetClipRect(graphics, clipr.X, clipr.Y, clipr.Width, clipr.Height, CombineModeReplace);
2199     expect(Ok, status);
2200
2201     exp.X = 0;
2202     exp.Y = 0;
2203     exp.Width = 10;
2204     exp.Height = 12;
2205
2206     status = GdipGetVisibleClipBounds(graphics, &rectf);
2207     expect(Ok, status);
2208     ok(rectf.X == exp.X &&
2209         rectf.Y == exp.Y &&
2210         rectf.Width == exp.Width &&
2211         rectf.Height == exp.Height,
2212         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2213         "the visible clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2214         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2215         exp.X, exp.Y, exp.Width, exp.Height);
2216
2217     status = GdipGetVisibleClipBoundsI(graphics, &recti);
2218     expect(Ok, status);
2219     ok(recti.X == exp.X &&
2220         recti.Y == exp.Y &&
2221         recti.Width == exp.Width &&
2222         recti.Height == exp.Height,
2223         "Expected clip bounds (%d, %d, %d, %d) to be the size of "
2224         "the visible clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2225         recti.X, recti.Y, recti.Width, recti.Height,
2226         exp.X, exp.Y, exp.Width, exp.Height);
2227
2228     GdipDeleteGraphics(graphics);
2229     ReleaseDC(0, hdc);
2230 }
2231
2232 static void test_GdipGetVisibleClipBounds_window(void)
2233 {
2234     GpStatus status;
2235     GpGraphics *graphics = NULL;
2236     GpRectF rectf, window, exp, clipr;
2237     GpRect recti;
2238     HDC hdc;
2239     PAINTSTRUCT ps;
2240     RECT wnd_rect;
2241
2242     /* get client area size */
2243     ok(GetClientRect(hwnd, &wnd_rect), "GetClientRect should have succeeded\n");
2244     window.X = wnd_rect.left;
2245     window.Y = wnd_rect.top;
2246     window.Width = wnd_rect.right - wnd_rect.left;
2247     window.Height = wnd_rect.bottom - wnd_rect.top;
2248
2249     hdc = BeginPaint(hwnd, &ps);
2250
2251     status = GdipCreateFromHDC(hdc, &graphics);
2252     expect(Ok, status);
2253     ok(graphics != NULL, "Expected graphics to be initialized\n");
2254
2255     status = GdipGetVisibleClipBounds(graphics, &rectf);
2256     expect(Ok, status);
2257     ok(rectf.X == window.X &&
2258         rectf.Y == window.Y &&
2259         rectf.Width == window.Width &&
2260         rectf.Height == window.Height,
2261         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2262         "the window (%0.f, %0.f, %0.f, %0.f)\n",
2263         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2264         window.X, window.Y, window.Width, window.Height);
2265
2266     /* clipping rect entirely within window */
2267     exp.X = clipr.X = 20;
2268     exp.Y = clipr.Y = 8;
2269     exp.Width = clipr.Width = 30;
2270     exp.Height = clipr.Height = 20;
2271
2272     status = GdipSetClipRect(graphics, clipr.X, clipr.Y, clipr.Width, clipr.Height, CombineModeReplace);
2273     expect(Ok, status);
2274
2275     status = GdipGetVisibleClipBounds(graphics, &rectf);
2276     expect(Ok, status);
2277     ok(rectf.X == exp.X &&
2278         rectf.Y == exp.Y &&
2279         rectf.Width == exp.Width &&
2280         rectf.Height == exp.Height,
2281         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2282         "the clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2283         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2284         exp.X, exp.Y, exp.Width, exp.Height);
2285
2286     /* clipping rect partially outside of window */
2287     clipr.X = window.Width - 10;
2288     clipr.Y = window.Height - 15;
2289     clipr.Width = 20;
2290     clipr.Height = 30;
2291
2292     status = GdipSetClipRect(graphics, clipr.X, clipr.Y, clipr.Width, clipr.Height, CombineModeReplace);
2293     expect(Ok, status);
2294
2295     exp.X = window.Width - 10;
2296     exp.Y = window.Height - 15;
2297     exp.Width = 10;
2298     exp.Height = 15;
2299
2300     status = GdipGetVisibleClipBounds(graphics, &rectf);
2301     expect(Ok, status);
2302     ok(rectf.X == exp.X &&
2303         rectf.Y == exp.Y &&
2304         rectf.Width == exp.Width &&
2305         rectf.Height == exp.Height,
2306         "Expected clip bounds (%0.f, %0.f, %0.f, %0.f) to be the size of "
2307         "the visible clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2308         rectf.X, rectf.Y, rectf.Width, rectf.Height,
2309         exp.X, exp.Y, exp.Width, exp.Height);
2310
2311     status = GdipGetVisibleClipBoundsI(graphics, &recti);
2312     expect(Ok, status);
2313     ok(recti.X == exp.X &&
2314         recti.Y == exp.Y &&
2315         recti.Width == exp.Width &&
2316         recti.Height == exp.Height,
2317         "Expected clip bounds (%d, %d, %d, %d) to be the size of "
2318         "the visible clipping rect (%0.f, %0.f, %0.f, %0.f)\n",
2319         recti.X, recti.Y, recti.Width, recti.Height,
2320         exp.X, exp.Y, exp.Width, exp.Height);
2321
2322     GdipDeleteGraphics(graphics);
2323     EndPaint(hwnd, &ps);
2324 }
2325
2326 static void test_GdipGetVisibleClipBounds(void)
2327 {
2328     GpGraphics* graphics = NULL;
2329     GpRectF rectf;
2330     GpRect rect;
2331     HDC hdc = GetDC( hwnd );
2332     GpStatus status;
2333
2334     status = GdipCreateFromHDC(hdc, &graphics);
2335     expect(Ok, status);
2336     ok(graphics != NULL, "Expected graphics to be initialized\n");
2337
2338     /* test null parameters */
2339     status = GdipGetVisibleClipBounds(graphics, NULL);
2340     expect(InvalidParameter, status);
2341
2342     status = GdipGetVisibleClipBounds(NULL, &rectf);
2343     expect(InvalidParameter, status);
2344
2345     status = GdipGetVisibleClipBoundsI(graphics, NULL);
2346     expect(InvalidParameter, status);
2347
2348     status = GdipGetVisibleClipBoundsI(NULL, &rect);
2349     expect(InvalidParameter, status);
2350
2351     GdipDeleteGraphics(graphics);
2352     ReleaseDC(hwnd, hdc);
2353
2354     test_GdipGetVisibleClipBounds_screen();
2355     test_GdipGetVisibleClipBounds_window();
2356 }
2357
2358 static void test_fromMemoryBitmap(void)
2359 {
2360     GpStatus status;
2361     GpGraphics *graphics = NULL;
2362     GpBitmap *bitmap = NULL;
2363     BYTE bits[48] = {0};
2364     HDC hdc=NULL;
2365     COLORREF color;
2366
2367     status = GdipCreateBitmapFromScan0(4, 4, 12, PixelFormat24bppRGB, bits, &bitmap);
2368     expect(Ok, status);
2369
2370     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2371     expect(Ok, status);
2372
2373     status = GdipGraphicsClear(graphics, 0xff686868);
2374     expect(Ok, status);
2375
2376     GdipDeleteGraphics(graphics);
2377
2378     /* drawing writes to the memory provided */
2379     expect(0x68, bits[10]);
2380
2381     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2382     expect(Ok, status);
2383
2384     status = GdipGetDC(graphics, &hdc);
2385     expect(Ok, status);
2386     ok(hdc != NULL, "got NULL hdc\n");
2387
2388     color = GetPixel(hdc, 0, 0);
2389     /* The HDC is write-only, and native fills with a solid color to figure out
2390      * which pixels have changed. */
2391     todo_wine expect(0x0c0b0d, color);
2392
2393     SetPixel(hdc, 0, 0, 0x797979);
2394     SetPixel(hdc, 1, 0, 0x0c0b0d);
2395
2396     status = GdipReleaseDC(graphics, hdc);
2397     expect(Ok, status);
2398
2399     GdipDeleteGraphics(graphics);
2400
2401     expect(0x79, bits[0]);
2402     todo_wine expect(0x68, bits[3]);
2403
2404     GdipDisposeImage((GpImage*)bitmap);
2405
2406     /* We get the same kind of write-only HDC for a "normal" bitmap */
2407     status = GdipCreateBitmapFromScan0(4, 4, 12, PixelFormat24bppRGB, NULL, &bitmap);
2408     expect(Ok, status);
2409
2410     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2411     expect(Ok, status);
2412
2413     status = GdipGetDC(graphics, &hdc);
2414     expect(Ok, status);
2415     ok(hdc != NULL, "got NULL hdc\n");
2416
2417     color = GetPixel(hdc, 0, 0);
2418     todo_wine expect(0x0c0b0d, color);
2419
2420     status = GdipReleaseDC(graphics, hdc);
2421     expect(Ok, status);
2422
2423     GdipDeleteGraphics(graphics);
2424
2425     GdipDisposeImage((GpImage*)bitmap);
2426 }
2427
2428 static void test_GdipIsVisiblePoint(void)
2429 {
2430     GpStatus status;
2431     GpGraphics *graphics = NULL;
2432     HDC hdc = GetDC( hwnd );
2433     REAL x, y;
2434     BOOL val;
2435
2436     ok(hdc != NULL, "Expected HDC to be initialized\n");
2437
2438     status = GdipCreateFromHDC(hdc, &graphics);
2439     expect(Ok, status);
2440     ok(graphics != NULL, "Expected graphics to be initialized\n");
2441
2442     /* null parameters */
2443     status = GdipIsVisiblePoint(NULL, 0, 0, &val);
2444     expect(InvalidParameter, status);
2445
2446     status = GdipIsVisiblePoint(graphics, 0, 0, NULL);
2447     expect(InvalidParameter, status);
2448
2449     status = GdipIsVisiblePointI(NULL, 0, 0, &val);
2450     expect(InvalidParameter, status);
2451
2452     status = GdipIsVisiblePointI(graphics, 0, 0, NULL);
2453     expect(InvalidParameter, status);
2454
2455     x = 0;
2456     y = 0;
2457     status = GdipIsVisiblePoint(graphics, x, y, &val);
2458     expect(Ok, status);
2459     ok(val == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
2460
2461     x = -10;
2462     y = 0;
2463     status = GdipIsVisiblePoint(graphics, x, y, &val);
2464     expect(Ok, status);
2465     ok(val == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
2466
2467     x = 0;
2468     y = -5;
2469     status = GdipIsVisiblePoint(graphics, x, y, &val);
2470     expect(Ok, status);
2471     ok(val == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
2472
2473     x = 1;
2474     y = 1;
2475     status = GdipIsVisiblePoint(graphics, x, y, &val);
2476     expect(Ok, status);
2477     ok(val == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
2478
2479     status = GdipSetClipRect(graphics, 10, 20, 30, 40, CombineModeReplace);
2480     expect(Ok, status);
2481
2482     x = 1;
2483     y = 1;
2484     status = GdipIsVisiblePoint(graphics, x, y, &val);
2485     expect(Ok, status);
2486     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2487
2488     x = 15.5;
2489     y = 40.5;
2490     status = GdipIsVisiblePoint(graphics, x, y, &val);
2491     expect(Ok, status);
2492     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2493
2494     /* translate into the center of the rect */
2495     GdipTranslateWorldTransform(graphics, 25, 40, MatrixOrderAppend);
2496
2497     x = 0;
2498     y = 0;
2499     status = GdipIsVisiblePoint(graphics, x, y, &val);
2500     expect(Ok, status);
2501     ok(val == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
2502
2503     x = 25;
2504     y = 40;
2505     status = GdipIsVisiblePoint(graphics, x, y, &val);
2506     expect(Ok, status);
2507     ok(val == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
2508
2509     GdipTranslateWorldTransform(graphics, -25, -40, MatrixOrderAppend);
2510
2511     /* corner cases */
2512     x = 9;
2513     y = 19;
2514     status = GdipIsVisiblePoint(graphics, x, y, &val);
2515     expect(Ok, status);
2516     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2517
2518     x = 9.25;
2519     y = 19.25;
2520     status = GdipIsVisiblePoint(graphics, x, y, &val);
2521     expect(Ok, status);
2522     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2523
2524     x = 9.5;
2525     y = 19.5;
2526     status = GdipIsVisiblePoint(graphics, x, y, &val);
2527     expect(Ok, status);
2528     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2529
2530     x = 9.75;
2531     y = 19.75;
2532     status = GdipIsVisiblePoint(graphics, x, y, &val);
2533     expect(Ok, status);
2534     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2535
2536     x = 10;
2537     y = 20;
2538     status = GdipIsVisiblePoint(graphics, x, y, &val);
2539     expect(Ok, status);
2540     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2541
2542     x = 40;
2543     y = 20;
2544     status = GdipIsVisiblePoint(graphics, x, y, &val);
2545     expect(Ok, status);
2546     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2547
2548     x = 39;
2549     y = 59;
2550     status = GdipIsVisiblePoint(graphics, x, y, &val);
2551     expect(Ok, status);
2552     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2553
2554     x = 39.25;
2555     y = 59.25;
2556     status = GdipIsVisiblePoint(graphics, x, y, &val);
2557     expect(Ok, status);
2558     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2559
2560     x = 39.5;
2561     y = 39.5;
2562     status = GdipIsVisiblePoint(graphics, x, y, &val);
2563     expect(Ok, status);
2564     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2565
2566     x = 39.75;
2567     y = 59.75;
2568     status = GdipIsVisiblePoint(graphics, x, y, &val);
2569     expect(Ok, status);
2570     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2571
2572     x = 40;
2573     y = 60;
2574     status = GdipIsVisiblePoint(graphics, x, y, &val);
2575     expect(Ok, status);
2576     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2577
2578     x = 40.15;
2579     y = 60.15;
2580     status = GdipIsVisiblePoint(graphics, x, y, &val);
2581     expect(Ok, status);
2582     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2583
2584     x = 10;
2585     y = 60;
2586     status = GdipIsVisiblePoint(graphics, x, y, &val);
2587     expect(Ok, status);
2588     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2589
2590     /* integer version */
2591     x = 25;
2592     y = 30;
2593     status = GdipIsVisiblePointI(graphics, (INT)x, (INT)y, &val);
2594     expect(Ok, status);
2595     ok(val == TRUE, "After clipping, expected (%.2f, %.2f) to be visible\n", x, y);
2596
2597     x = 50;
2598     y = 100;
2599     status = GdipIsVisiblePointI(graphics, (INT)x, (INT)y, &val);
2600     expect(Ok, status);
2601     ok(val == FALSE, "After clipping, expected (%.2f, %.2f) not to be visible\n", x, y);
2602
2603     GdipDeleteGraphics(graphics);
2604     ReleaseDC(hwnd, hdc);
2605 }
2606
2607 static void test_GdipIsVisibleRect(void)
2608 {
2609     GpStatus status;
2610     GpGraphics *graphics = NULL;
2611     HDC hdc = GetDC( hwnd );
2612     REAL x, y, width, height;
2613     BOOL val;
2614
2615     ok(hdc != NULL, "Expected HDC to be initialized\n");
2616
2617     status = GdipCreateFromHDC(hdc, &graphics);
2618     expect(Ok, status);
2619     ok(graphics != NULL, "Expected graphics to be initialized\n");
2620
2621     status = GdipIsVisibleRect(NULL, 0, 0, 0, 0, &val);
2622     expect(InvalidParameter, status);
2623
2624     status = GdipIsVisibleRect(graphics, 0, 0, 0, 0, NULL);
2625     expect(InvalidParameter, status);
2626
2627     status = GdipIsVisibleRectI(NULL, 0, 0, 0, 0, &val);
2628     expect(InvalidParameter, status);
2629
2630     status = GdipIsVisibleRectI(graphics, 0, 0, 0, 0, NULL);
2631     expect(InvalidParameter, status);
2632
2633     /* entirely within the visible region */
2634     x = 0; width = 10;
2635     y = 0; height = 10;
2636     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2637     expect(Ok, status);
2638     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2639
2640     /* partially outside */
2641     x = -10; width = 20;
2642     y = -10; height = 20;
2643     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2644     expect(Ok, status);
2645     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2646
2647     /* entirely outside */
2648     x = -10; width = 5;
2649     y = -10; height = 5;
2650     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2651     expect(Ok, status);
2652     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2653
2654     status = GdipSetClipRect(graphics, 10, 20, 30, 40, CombineModeReplace);
2655     expect(Ok, status);
2656
2657     /* entirely within the visible region */
2658     x = 12; width = 10;
2659     y = 22; height = 10;
2660     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2661     expect(Ok, status);
2662     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2663
2664     /* partially outside */
2665     x = 35; width = 10;
2666     y = 55; height = 10;
2667     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2668     expect(Ok, status);
2669     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2670
2671     /* entirely outside */
2672     x = 45; width = 5;
2673     y = 65; height = 5;
2674     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2675     expect(Ok, status);
2676     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2677
2678     /* translate into center of clipping rect */
2679     GdipTranslateWorldTransform(graphics, 25, 40, MatrixOrderAppend);
2680
2681     x = 0; width = 10;
2682     y = 0; height = 10;
2683     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2684     expect(Ok, status);
2685     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2686
2687     x = 25; width = 5;
2688     y = 40; height = 5;
2689     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2690     expect(Ok, status);
2691     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2692
2693     GdipTranslateWorldTransform(graphics, -25, -40, MatrixOrderAppend);
2694
2695     /* corners entirely outside, but some intersections */
2696     x = 0; width = 70;
2697     y = 0; height = 90;
2698     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2699     expect(Ok, status);
2700     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2701
2702     x = 0; width = 70;
2703     y = 0; height = 30;
2704     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2705     expect(Ok, status);
2706     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2707
2708     x = 0; width = 30;
2709     y = 0; height = 90;
2710     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2711     expect(Ok, status);
2712     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2713
2714     /* edge cases */
2715     x = 0; width = 10;
2716     y = 20; height = 40;
2717     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2718     expect(Ok, status);
2719     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2720
2721     x = 10; width = 30;
2722     y = 0; height = 20;
2723     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2724     expect(Ok, status);
2725     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2726
2727     x = 40; width = 10;
2728     y = 20; height = 40;
2729     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2730     expect(Ok, status);
2731     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2732
2733     x = 10; width = 30;
2734     y = 60; height = 10;
2735     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2736     expect(Ok, status);
2737     ok(val == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, width, height);
2738
2739     /* rounding tests */
2740     x = 0.4; width = 10.4;
2741     y = 20; height = 40;
2742     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2743     expect(Ok, status);
2744     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2745
2746     x = 10; width = 30;
2747     y = 0.4; height = 20.4;
2748     status = GdipIsVisibleRect(graphics, x, y, width, height, &val);
2749     expect(Ok, status);
2750     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2751
2752     /* integer version */
2753     x = 0; width = 30;
2754     y = 0; height = 90;
2755     status = GdipIsVisibleRectI(graphics, (INT)x, (INT)y, (INT)width, (INT)height, &val);
2756     expect(Ok, status);
2757     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2758
2759     x = 12; width = 10;
2760     y = 22; height = 10;
2761     status = GdipIsVisibleRectI(graphics, (INT)x, (INT)y, (INT)width, (INT)height, &val);
2762     expect(Ok, status);
2763     ok(val == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, width, height);
2764
2765     GdipDeleteGraphics(graphics);
2766     ReleaseDC(hwnd, hdc);
2767 }
2768
2769 static void test_GdipGetNearestColor(void)
2770 {
2771     GpStatus status;
2772     GpGraphics *graphics;
2773     GpBitmap *bitmap;
2774     ARGB color = 0xdeadbeef;
2775     HDC hdc = GetDC( hwnd );
2776
2777     /* create a graphics object */
2778     ok(hdc != NULL, "Expected HDC to be initialized\n");
2779
2780     status = GdipCreateFromHDC(hdc, &graphics);
2781     expect(Ok, status);
2782     ok(graphics != NULL, "Expected graphics to be initialized\n");
2783
2784     status = GdipGetNearestColor(graphics, NULL);
2785     expect(InvalidParameter, status);
2786
2787     status = GdipGetNearestColor(NULL, &color);
2788     expect(InvalidParameter, status);
2789     GdipDeleteGraphics(graphics);
2790
2791     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat1bppIndexed, NULL, &bitmap);
2792     expect(Ok, status);
2793     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2794     ok(broken(status == OutOfMemory) /* winver < Win7 */ || status == Ok, "status=%u\n", status);
2795     if (status == Ok)
2796     {
2797         status = GdipGetNearestColor(graphics, &color);
2798         expect(Ok, status);
2799         expect(0xdeadbeef, color);
2800         GdipDeleteGraphics(graphics);
2801     }
2802     GdipDisposeImage((GpImage*)bitmap);
2803
2804     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat4bppIndexed, NULL, &bitmap);
2805     expect(Ok, status);
2806     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2807     ok(broken(status == OutOfMemory) /* winver < Win7 */ || status == Ok, "status=%u\n", status);
2808     if (status == Ok)
2809     {
2810         status = GdipGetNearestColor(graphics, &color);
2811         expect(Ok, status);
2812         expect(0xdeadbeef, color);
2813         GdipDeleteGraphics(graphics);
2814     }
2815     GdipDisposeImage((GpImage*)bitmap);
2816
2817     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat8bppIndexed, NULL, &bitmap);
2818     expect(Ok, status);
2819     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2820     ok(broken(status == OutOfMemory) /* winver < Win7 */ || status == Ok, "status=%u\n", status);
2821     if (status == Ok)
2822     {
2823         status = GdipGetNearestColor(graphics, &color);
2824         expect(Ok, status);
2825         expect(0xdeadbeef, color);
2826         GdipDeleteGraphics(graphics);
2827     }
2828     GdipDisposeImage((GpImage*)bitmap);
2829
2830     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppGrayScale, NULL, &bitmap);
2831     expect(Ok, status);
2832     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2833     todo_wine expect(OutOfMemory, status);
2834     if (status == Ok)
2835         GdipDeleteGraphics(graphics);
2836     GdipDisposeImage((GpImage*)bitmap);
2837
2838     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, &bitmap);
2839     expect(Ok, status);
2840     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2841     expect(Ok, status);
2842     status = GdipGetNearestColor(graphics, &color);
2843     expect(Ok, status);
2844     expect(0xdeadbeef, color);
2845     GdipDeleteGraphics(graphics);
2846     GdipDisposeImage((GpImage*)bitmap);
2847
2848     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppRGB, NULL, &bitmap);
2849     expect(Ok, status);
2850     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2851     expect(Ok, status);
2852     status = GdipGetNearestColor(graphics, &color);
2853     expect(Ok, status);
2854     expect(0xdeadbeef, color);
2855     GdipDeleteGraphics(graphics);
2856     GdipDisposeImage((GpImage*)bitmap);
2857
2858     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppARGB, NULL, &bitmap);
2859     expect(Ok, status);
2860     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2861     expect(Ok, status);
2862     status = GdipGetNearestColor(graphics, &color);
2863     expect(Ok, status);
2864     expect(0xdeadbeef, color);
2865     GdipDeleteGraphics(graphics);
2866     GdipDisposeImage((GpImage*)bitmap);
2867
2868     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat48bppRGB, NULL, &bitmap);
2869     expect(Ok, status);
2870     if (status == Ok)
2871     {
2872         status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2873         expect(Ok, status);
2874         status = GdipGetNearestColor(graphics, &color);
2875         expect(Ok, status);
2876         expect(0xdeadbeef, color);
2877         GdipDeleteGraphics(graphics);
2878         GdipDisposeImage((GpImage*)bitmap);
2879     }
2880
2881     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppARGB, NULL, &bitmap);
2882     expect(Ok, status);
2883     if (status == Ok)
2884     {
2885         status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2886         expect(Ok, status);
2887         status = GdipGetNearestColor(graphics, &color);
2888         expect(Ok, status);
2889         expect(0xdeadbeef, color);
2890         GdipDeleteGraphics(graphics);
2891         GdipDisposeImage((GpImage*)bitmap);
2892     }
2893
2894     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppPARGB, NULL, &bitmap);
2895     expect(Ok, status);
2896     if (status == Ok)
2897     {
2898         status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2899         expect(Ok, status);
2900         status = GdipGetNearestColor(graphics, &color);
2901         expect(Ok, status);
2902         expect(0xdeadbeef, color);
2903         GdipDeleteGraphics(graphics);
2904         GdipDisposeImage((GpImage*)bitmap);
2905     }
2906
2907     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB565, NULL, &bitmap);
2908     expect(Ok, status);
2909     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2910     expect(Ok, status);
2911     status = GdipGetNearestColor(graphics, &color);
2912     expect(Ok, status);
2913     todo_wine expect(0xffa8bce8, color);
2914     GdipDeleteGraphics(graphics);
2915     GdipDisposeImage((GpImage*)bitmap);
2916
2917     status = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB555, NULL, &bitmap);
2918     expect(Ok, status);
2919     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2920     expect(Ok, status);
2921     status = GdipGetNearestColor(graphics, &color);
2922     expect(Ok, status);
2923     todo_wine
2924     ok(color == 0xffa8b8e8 ||
2925        broken(color == 0xffa0b8e0), /* Win98/WinMe */
2926        "Expected ffa8b8e8, got %.8x\n", color);
2927     GdipDeleteGraphics(graphics);
2928     GdipDisposeImage((GpImage*)bitmap);
2929
2930     ReleaseDC(hwnd, hdc);
2931 }
2932
2933 static void test_string_functions(void)
2934 {
2935     GpStatus status;
2936     GpGraphics *graphics;
2937     GpFontFamily *family;
2938     GpFont *font;
2939     RectF rc, char_bounds, bounds;
2940     GpBrush *brush;
2941     ARGB color = 0xff000000;
2942     HDC hdc = GetDC( hwnd );
2943     const WCHAR fontname[] = {'T','a','h','o','m','a',0};
2944     const WCHAR teststring[] = {'M','M',' ','M','\n','M',0};
2945     const WCHAR teststring2[] = {'j',0};
2946     REAL char_width, char_height;
2947     INT codepointsfitted, linesfilled;
2948     GpStringFormat *format;
2949     CharacterRange ranges[3] = {{0, 1}, {1, 3}, {5, 1}};
2950     GpRegion *regions[4];
2951     BOOL region_isempty[4];
2952     int i;
2953     PointF positions[8];
2954     GpMatrix *identity;
2955
2956     ok(hdc != NULL, "Expected HDC to be initialized\n");
2957     status = GdipCreateFromHDC(hdc, &graphics);
2958     expect(Ok, status);
2959     ok(graphics != NULL, "Expected graphics to be initialized\n");
2960
2961     status = GdipCreateFontFamilyFromName(fontname, NULL, &family);
2962     expect(Ok, status);
2963
2964     status = GdipCreateFont(family, 10.0, FontStyleRegular, UnitPixel, &font);
2965     expect(Ok, status);
2966
2967     status = GdipCreateSolidFill(color, (GpSolidFill**)&brush);
2968     expect(Ok, status);
2969
2970     status = GdipCreateStringFormat(0, LANG_NEUTRAL, &format);
2971     expect(Ok, status);
2972
2973     rc.X = 0;
2974     rc.Y = 0;
2975     rc.Width = 100.0;
2976     rc.Height = 100.0;
2977
2978     status = GdipDrawString(NULL, teststring, 6, font, &rc, NULL, brush);
2979     expect(InvalidParameter, status);
2980
2981     status = GdipDrawString(graphics, NULL, 6, font, &rc, NULL, brush);
2982     expect(InvalidParameter, status);
2983
2984     status = GdipDrawString(graphics, teststring, 6, NULL, &rc, NULL, brush);
2985     expect(InvalidParameter, status);
2986
2987     status = GdipDrawString(graphics, teststring, 6, font, NULL, NULL, brush);
2988     expect(InvalidParameter, status);
2989
2990     status = GdipDrawString(graphics, teststring, 6, font, &rc, NULL, NULL);
2991     expect(InvalidParameter, status);
2992
2993     status = GdipDrawString(graphics, teststring, 6, font, &rc, NULL, brush);
2994     expect(Ok, status);
2995
2996     status = GdipMeasureString(NULL, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
2997     expect(InvalidParameter, status);
2998
2999     status = GdipMeasureString(graphics, NULL, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3000     expect(InvalidParameter, status);
3001
3002     status = GdipMeasureString(graphics, teststring, 6, NULL, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3003     expect(InvalidParameter, status);
3004
3005     status = GdipMeasureString(graphics, teststring, 6, font, NULL, NULL, &bounds, &codepointsfitted, &linesfilled);
3006     expect(InvalidParameter, status);
3007
3008     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, NULL, &codepointsfitted, &linesfilled);
3009     expect(InvalidParameter, status);
3010
3011     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, NULL, &linesfilled);
3012     expect(Ok, status);
3013
3014     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, NULL);
3015     expect(Ok, status);
3016
3017     status = GdipMeasureString(graphics, teststring, 1, font, &rc, NULL, &char_bounds, &codepointsfitted, &linesfilled);
3018     expect(Ok, status);
3019     expectf(0.0, char_bounds.X);
3020     expectf(0.0, char_bounds.Y);
3021     ok(char_bounds.Width > 0, "got %0.2f\n", bounds.Width);
3022     ok(char_bounds.Height > 0, "got %0.2f\n", bounds.Height);
3023     expect(1, codepointsfitted);
3024     expect(1, linesfilled);
3025
3026     status = GdipMeasureString(graphics, teststring, 2, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3027     expect(Ok, status);
3028     expectf(0.0, bounds.X);
3029     expectf(0.0, bounds.Y);
3030     ok(bounds.Width > char_bounds.Width, "got %0.2f, expected at least %0.2f\n", bounds.Width, char_bounds.Width);
3031     expectf(char_bounds.Height, bounds.Height);
3032     expect(2, codepointsfitted);
3033     expect(1, linesfilled);
3034     char_width = bounds.Width - char_bounds.Width;
3035
3036     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3037     expect(Ok, status);
3038     expectf(0.0, bounds.X);
3039     expectf(0.0, bounds.Y);
3040     ok(bounds.Width > char_bounds.Width + char_width * 2, "got %0.2f, expected at least %0.2f\n",
3041        bounds.Width, char_bounds.Width + char_width * 2);
3042     ok(bounds.Height > char_bounds.Height, "got %0.2f, expected at least %0.2f\n", bounds.Height, char_bounds.Height);
3043     expect(6, codepointsfitted);
3044     expect(2, linesfilled);
3045     char_height = bounds.Height - char_bounds.Height;
3046
3047     /* Measure the first line. */
3048     status = GdipMeasureString(graphics, teststring, 4, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3049     expect(Ok, status);
3050     expectf(0.0, bounds.X);
3051     expectf(0.0, bounds.Y);
3052     expect(4, codepointsfitted);
3053     expect(1, linesfilled);
3054
3055     /* Give just enough space to fit the first line. */
3056     rc.Width = bounds.Width;
3057     status = GdipMeasureString(graphics, teststring, 5, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3058     expect(Ok, status);
3059     expectf(0.0, bounds.X);
3060     expectf(0.0, bounds.Y);
3061     todo_wine expect(5, codepointsfitted);
3062     todo_wine expect(1, linesfilled);
3063
3064     /* Cut off everything after the first space. */
3065     rc.Width = char_bounds.Width + char_width * 2.1;
3066
3067     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3068     expect(Ok, status);
3069     expectf(0.0, bounds.X);
3070     expectf(0.0, bounds.Y);
3071     expectf_(char_bounds.Width + char_width, bounds.Width, 0.01);
3072     expectf_(char_bounds.Height + char_height * 2, bounds.Height, 0.01);
3073     expect(6, codepointsfitted);
3074     expect(3, linesfilled);
3075
3076     /* Cut off everything including the first space. */
3077     rc.Width = char_bounds.Width + char_width * 1.7;
3078
3079     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3080     expect(Ok, status);
3081     expectf(0.0, bounds.X);
3082     expectf(0.0, bounds.Y);
3083     expectf_(char_bounds.Width + char_width, bounds.Width, 0.01);
3084     expectf_(char_bounds.Height + char_height * 2, bounds.Height, 0.01);
3085     expect(6, codepointsfitted);
3086     expect(3, linesfilled);
3087
3088     /* Cut off everything after the first character. */
3089     rc.Width = char_bounds.Width + char_width * 0.8;
3090
3091     status = GdipMeasureString(graphics, teststring, 6, font, &rc, NULL, &bounds, &codepointsfitted, &linesfilled);
3092     expect(Ok, status);
3093     expectf(0.0, bounds.X);
3094     expectf(0.0, bounds.Y);
3095     expectf_(char_bounds.Width, bounds.Width, 0.01);
3096     expectf_(char_bounds.Height + char_height * 3, bounds.Height, 0.05);
3097     expect(6, codepointsfitted);
3098     todo_wine expect(4, linesfilled);
3099
3100     for (i = 0; i < 4; i++)
3101         regions[i] = (GpRegion *)0xdeadbeef;
3102
3103     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 0, regions);
3104     expect(Ok, status);
3105
3106     for (i = 0; i < 4; i++)
3107         ok(regions[i] == (GpRegion *)0xdeadbeef, "expected 0xdeadbeef, got %p\n", regions[i]);
3108
3109     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 3, regions);
3110     expect(Ok, status);
3111
3112     for (i = 0; i < 4; i++)
3113         ok(regions[i] == (GpRegion *)0xdeadbeef, "expected 0xdeadbeef, got %p\n", regions[i]);
3114
3115     status = GdipSetStringFormatMeasurableCharacterRanges(format, 3, ranges);
3116     expect(Ok, status);
3117
3118     set_rect_empty(&rc);
3119
3120     for (i=0; i<4; i++)
3121     {
3122         status = GdipCreateRegion(&regions[i]);
3123         expect(Ok, status);
3124         status = GdipSetEmpty(regions[i]);
3125         expect(Ok, status);
3126     }
3127
3128     status = GdipMeasureCharacterRanges(NULL, teststring, 6, font, &rc, format, 3, regions);
3129     expect(InvalidParameter, status);
3130
3131     status = GdipMeasureCharacterRanges(graphics, NULL, 6, font, &rc, format, 3, regions);
3132     expect(InvalidParameter, status);
3133
3134     status = GdipMeasureCharacterRanges(graphics, teststring, 6, NULL, &rc, format, 3, regions);
3135     expect(InvalidParameter, status);
3136
3137     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, NULL, format, 3, regions);
3138     expect(InvalidParameter, status);
3139
3140     if (0)
3141     {
3142         /* Crashes on Windows XP */
3143         status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, NULL, 3, regions);
3144         expect(InvalidParameter, status);
3145     }
3146
3147     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 3, NULL);
3148     expect(InvalidParameter, status);
3149
3150     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 2, regions);
3151     expect(InvalidParameter, status);
3152
3153     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 3, regions);
3154     expect(Ok, status);
3155
3156     for (i = 0; i < 4; i++)
3157     {
3158         status = GdipIsEmptyRegion(regions[i], graphics, &region_isempty[i]);
3159         expect(Ok, status);
3160     }
3161
3162     ok(region_isempty[0], "region should be empty\n");
3163     ok(region_isempty[1], "region should be empty\n");
3164     ok(region_isempty[2], "region should be empty\n");
3165     ok(region_isempty[3], "region should be empty\n");
3166
3167     rc.Width = 100.0;
3168     rc.Height = 100.0;
3169
3170     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 4, regions);
3171     expect(Ok, status);
3172
3173     for (i=0; i<4; i++)
3174     {
3175         status = GdipIsEmptyRegion(regions[i], graphics, &region_isempty[i]);
3176         expect(Ok, status);
3177     }
3178
3179     ok(!region_isempty[0], "region shouldn't be empty\n");
3180     ok(!region_isempty[1], "region shouldn't be empty\n");
3181     ok(!region_isempty[2], "region shouldn't be empty\n");
3182     ok(region_isempty[3], "region should be empty\n");
3183
3184     /* Cut off everything after the first space, and the second line. */
3185     rc.Width = char_bounds.Width + char_width * 2.1;
3186     rc.Height = char_bounds.Height + char_height * 0.5;
3187
3188     status = GdipMeasureCharacterRanges(graphics, teststring, 6, font, &rc, format, 3, regions);
3189     expect(Ok, status);
3190
3191     for (i=0; i<4; i++)
3192     {
3193         status = GdipIsEmptyRegion(regions[i], graphics, &region_isempty[i]);
3194         expect(Ok, status);
3195     }
3196
3197     ok(!region_isempty[0], "region shouldn't be empty\n");
3198     ok(!region_isempty[1], "region shouldn't be empty\n");
3199     ok(region_isempty[2], "region should be empty\n");
3200     ok(region_isempty[3], "region should be empty\n");
3201
3202     for (i=0; i<4; i++)
3203         GdipDeleteRegion(regions[i]);
3204
3205     status = GdipCreateMatrix(&identity);
3206     expect(Ok, status);
3207
3208     rc.X = 0;
3209     rc.Y = 0;
3210     rc.Width = 0;
3211     rc.Height = 0;
3212     memset(positions, 0, sizeof(positions));
3213     status = GdipMeasureDriverString(NULL, teststring, 6, font, positions,
3214         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3215         identity, &rc);
3216     expect(InvalidParameter, status);
3217
3218     status = GdipMeasureDriverString(graphics, NULL, 6, font, positions,
3219         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3220         identity, &rc);
3221     expect(InvalidParameter, status);
3222
3223     status = GdipMeasureDriverString(graphics, teststring, 6, NULL, positions,
3224         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3225         identity, &rc);
3226     expect(InvalidParameter, status);
3227
3228     status = GdipMeasureDriverString(graphics, teststring, 6, font, NULL,
3229         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3230         identity, &rc);
3231     expect(InvalidParameter, status);
3232
3233     status = GdipMeasureDriverString(graphics, teststring, 6, font, positions,
3234         0x100, identity, &rc);
3235     expect(Ok, status);
3236
3237     status = GdipMeasureDriverString(graphics, teststring, 6, font, positions,
3238         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3239         NULL, &rc);
3240     expect(Ok, status);
3241
3242     status = GdipMeasureDriverString(graphics, teststring, 6, font, positions,
3243         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3244         identity, NULL);
3245     expect(InvalidParameter, status);
3246
3247     rc.X = 0;
3248     rc.Y = 0;
3249     rc.Width = 0;
3250     rc.Height = 0;
3251     status = GdipMeasureDriverString(graphics, teststring, 6, font, positions,
3252         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3253         identity, &rc);
3254     expect(Ok, status);
3255
3256     expectf(0.0, rc.X);
3257     ok(rc.Y < 0.0, "unexpected Y %0.2f\n", rc.Y);
3258     ok(rc.Width > 0.0, "unexpected Width %0.2f\n", rc.Width);
3259     ok(rc.Height > 0.0, "unexpected Y %0.2f\n", rc.Y);
3260
3261     char_width = rc.Width;
3262     char_height = rc.Height;
3263
3264     rc.X = 0;
3265     rc.Y = 0;
3266     rc.Width = 0;
3267     rc.Height = 0;
3268     status = GdipMeasureDriverString(graphics, teststring, 4, font, positions,
3269         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3270         identity, &rc);
3271     expect(Ok, status);
3272
3273     expectf(0.0, rc.X);
3274     ok(rc.Y < 0.0, "unexpected Y %0.2f\n", rc.Y);
3275     ok(rc.Width < char_width, "got Width %0.2f, expecting less than %0.2f\n", rc.Width, char_width);
3276     expectf(char_height, rc.Height);
3277
3278     rc.X = 0;
3279     rc.Y = 0;
3280     rc.Width = 0;
3281     rc.Height = 0;
3282     status = GdipMeasureDriverString(graphics, teststring2, 1, font, positions,
3283         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance,
3284         identity, &rc);
3285     expect(Ok, status);
3286
3287     expectf(rc.X, 0.0);
3288     ok(rc.Y < 0.0, "unexpected Y %0.2f\n", rc.Y);
3289     ok(rc.Width > 0, "unexpected Width %0.2f\n", rc.Width);
3290     expectf(rc.Height, char_height);
3291
3292     GdipDeleteMatrix(identity);
3293     GdipDeleteStringFormat(format);
3294     GdipDeleteBrush(brush);
3295     GdipDeleteFont(font);
3296     GdipDeleteFontFamily(family);
3297     GdipDeleteGraphics(graphics);
3298
3299     ReleaseDC(hwnd, hdc);
3300 }
3301
3302 static void test_get_set_interpolation(void)
3303 {
3304     GpGraphics *graphics;
3305     HDC hdc = GetDC( hwnd );
3306     GpStatus status;
3307     InterpolationMode mode;
3308
3309     ok(hdc != NULL, "Expected HDC to be initialized\n");
3310     status = GdipCreateFromHDC(hdc, &graphics);
3311     expect(Ok, status);
3312     ok(graphics != NULL, "Expected graphics to be initialized\n");
3313
3314     status = GdipGetInterpolationMode(NULL, &mode);
3315     expect(InvalidParameter, status);
3316
3317     if (0)
3318     {
3319         /* Crashes on Windows XP */
3320         status = GdipGetInterpolationMode(graphics, NULL);
3321         expect(InvalidParameter, status);
3322     }
3323
3324     status = GdipSetInterpolationMode(NULL, InterpolationModeNearestNeighbor);
3325     expect(InvalidParameter, status);
3326
3327     /* out of range */
3328     status = GdipSetInterpolationMode(graphics, InterpolationModeHighQualityBicubic+1);
3329     expect(InvalidParameter, status);
3330
3331     status = GdipSetInterpolationMode(graphics, InterpolationModeInvalid);
3332     expect(InvalidParameter, status);
3333
3334     status = GdipGetInterpolationMode(graphics, &mode);
3335     expect(Ok, status);
3336     expect(InterpolationModeBilinear, mode);
3337
3338     status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
3339     expect(Ok, status);
3340
3341     status = GdipGetInterpolationMode(graphics, &mode);
3342     expect(Ok, status);
3343     expect(InterpolationModeNearestNeighbor, mode);
3344
3345     status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
3346     expect(Ok, status);
3347
3348     status = GdipGetInterpolationMode(graphics, &mode);
3349     expect(Ok, status);
3350     expect(InterpolationModeBilinear, mode);
3351
3352     status = GdipSetInterpolationMode(graphics, InterpolationModeLowQuality);
3353     expect(Ok, status);
3354
3355     status = GdipGetInterpolationMode(graphics, &mode);
3356     expect(Ok, status);
3357     expect(InterpolationModeBilinear, mode);
3358
3359     status = GdipSetInterpolationMode(graphics, InterpolationModeHighQuality);
3360     expect(Ok, status);
3361
3362     status = GdipGetInterpolationMode(graphics, &mode);
3363     expect(Ok, status);
3364     expect(InterpolationModeHighQualityBicubic, mode);
3365
3366     GdipDeleteGraphics(graphics);
3367
3368     ReleaseDC(hwnd, hdc);
3369 }
3370
3371 static void test_get_set_textrenderinghint(void)
3372 {
3373     GpGraphics *graphics;
3374     HDC hdc = GetDC( hwnd );
3375     GpStatus status;
3376     TextRenderingHint hint;
3377
3378     ok(hdc != NULL, "Expected HDC to be initialized\n");
3379     status = GdipCreateFromHDC(hdc, &graphics);
3380     expect(Ok, status);
3381     ok(graphics != NULL, "Expected graphics to be initialized\n");
3382
3383     status = GdipGetTextRenderingHint(NULL, &hint);
3384     expect(InvalidParameter, status);
3385
3386     status = GdipGetTextRenderingHint(graphics, NULL);
3387     expect(InvalidParameter, status);
3388
3389     status = GdipSetTextRenderingHint(NULL, TextRenderingHintAntiAlias);
3390     expect(InvalidParameter, status);
3391
3392     /* out of range */
3393     status = GdipSetTextRenderingHint(graphics, TextRenderingHintClearTypeGridFit+1);
3394     expect(InvalidParameter, status);
3395
3396     status = GdipGetTextRenderingHint(graphics, &hint);
3397     expect(Ok, status);
3398     expect(TextRenderingHintSystemDefault, hint);
3399
3400     status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
3401     expect(Ok, status);
3402
3403     status = GdipGetTextRenderingHint(graphics, &hint);
3404     expect(Ok, status);
3405     expect(TextRenderingHintSystemDefault, hint);
3406
3407     status = GdipSetTextRenderingHint(graphics, TextRenderingHintAntiAliasGridFit);
3408     expect(Ok, status);
3409
3410     status = GdipGetTextRenderingHint(graphics, &hint);
3411     expect(Ok, status);
3412     expect(TextRenderingHintAntiAliasGridFit, hint);
3413
3414     GdipDeleteGraphics(graphics);
3415
3416     ReleaseDC(hwnd, hdc);
3417 }
3418
3419 static void test_getdc_scaled(void)
3420 {
3421     GpStatus status;
3422     GpGraphics *graphics = NULL;
3423     GpBitmap *bitmap = NULL;
3424     HDC hdc=NULL;
3425     HBRUSH hbrush, holdbrush;
3426     ARGB color;
3427
3428     status = GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB, NULL, &bitmap);
3429     expect(Ok, status);
3430
3431     status = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
3432     expect(Ok, status);
3433
3434     status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
3435     expect(Ok, status);
3436
3437     status = GdipGetDC(graphics, &hdc);
3438     expect(Ok, status);
3439     ok(hdc != NULL, "got NULL hdc\n");
3440
3441     hbrush = CreateSolidBrush(RGB(255, 0, 0));
3442
3443     holdbrush = SelectObject(hdc, hbrush);
3444
3445     Rectangle(hdc, 2, 2, 6, 6);
3446
3447     SelectObject(hdc, holdbrush);
3448
3449     DeleteObject(hbrush);
3450
3451     status = GdipReleaseDC(graphics, hdc);
3452     expect(Ok, status);
3453
3454     GdipDeleteGraphics(graphics);
3455
3456     status = GdipBitmapGetPixel(bitmap, 3, 3, &color);
3457     expect(Ok, status);
3458     expect(0xffff0000, color);
3459
3460     status = GdipBitmapGetPixel(bitmap, 8, 8, &color);
3461     expect(Ok, status);
3462     expect(0xff000000, color);
3463
3464     GdipDisposeImage((GpImage*)bitmap);
3465 }
3466
3467 static void test_GdipMeasureString(void)
3468 {
3469     static const struct test_data
3470     {
3471         REAL res_x, res_y, page_scale;
3472         GpUnit unit;
3473     } td[] =
3474     {
3475         { 200.0, 200.0, 1.0, UnitPixel }, /* base */
3476         { 200.0, 200.0, 2.0, UnitPixel },
3477         { 200.0, 200.0, 1.0, UnitDisplay },
3478         { 200.0, 200.0, 2.0, UnitDisplay },
3479         { 200.0, 200.0, 1.0, UnitInch },
3480         { 200.0, 200.0, 2.0, UnitInch },
3481         { 200.0, 600.0, 1.0, UnitPoint },
3482         { 200.0, 600.0, 2.0, UnitPoint },
3483         { 200.0, 600.0, 1.0, UnitDocument },
3484         { 200.0, 600.0, 2.0, UnitDocument },
3485         { 200.0, 600.0, 1.0, UnitMillimeter },
3486         { 200.0, 600.0, 2.0, UnitMillimeter },
3487         { 200.0, 600.0, 1.0, UnitDisplay },
3488         { 200.0, 600.0, 2.0, UnitDisplay },
3489         { 200.0, 600.0, 1.0, UnitPixel },
3490         { 200.0, 600.0, 2.0, UnitPixel },
3491     };
3492     static const WCHAR tahomaW[] = { 'T','a','h','o','m','a',0 };
3493     static const WCHAR string[] = { '1','2','3','4','5','6','7',0 };
3494     GpStatus status;
3495     GpGraphics *graphics;
3496     GpFontFamily *family;
3497     GpFont *font;
3498     GpStringFormat *format;
3499     RectF bounds, rc;
3500     REAL base_cx = 0, base_cy = 0, height;
3501     INT chars, lines;
3502     LOGFONTW lf;
3503     UINT i;
3504     REAL font_size;
3505     GpUnit font_unit, unit;
3506
3507     status = GdipCreateStringFormat(0, LANG_NEUTRAL, &format);
3508     expect(Ok, status);
3509     status = GdipCreateFontFamilyFromName(tahomaW, NULL, &family);
3510     expect(Ok, status);
3511
3512     /* font size in pixels */
3513     status = GdipCreateFont(family, 100.0, FontStyleRegular, UnitPixel, &font);
3514     expect(Ok, status);
3515     status = GdipGetFontSize(font, &font_size);
3516     expect(Ok, status);
3517     expectf(100.0, font_size);
3518     status = GdipGetFontUnit(font, &font_unit);
3519     expect(Ok, status);
3520     expect(UnitPixel, font_unit);
3521
3522     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3523     {
3524         GpImage *image;
3525
3526         graphics = create_graphics(td[i].res_x, td[i].res_y, td[i].unit, td[i].page_scale, &image);
3527
3528         lf.lfHeight = 0xdeadbeef;
3529         status = GdipGetLogFontW(font, graphics, &lf);
3530         expect(Ok, status);
3531         height = units_to_pixels(font_size, td[i].unit, td[i].res_y);
3532         if (td[i].unit != UnitDisplay)
3533             height *= td[i].page_scale;
3534         ok(-lf.lfHeight == (LONG)(height + 0.5), "%u: expected %d (%f), got %d\n",
3535            i, (LONG)(height + 0.5), height, lf.lfHeight);
3536
3537         height = font_size + 2.0 * font_size / 6.0;
3538
3539         set_rect_empty(&rc);
3540         set_rect_empty(&bounds);
3541         status = GdipMeasureString(graphics, string, -1, font, &rc, format, &bounds, &chars, &lines);
3542         expect(Ok, status);
3543
3544         if (i == 0)
3545         {
3546             base_cx = bounds.Width;
3547             base_cy = bounds.Height;
3548         }
3549
3550         expectf(0.0, bounds.X);
3551         expectf(0.0, bounds.Y);
3552 todo_wine
3553         expectf_(height, bounds.Height, height / 100.0);
3554         expectf_(bounds.Height / base_cy, bounds.Width / base_cx, 0.1);
3555         expect(7, chars);
3556         expect(1, lines);
3557
3558         /* make sure it really fits */
3559         bounds.Width += 1.0;
3560         bounds.Height += 1.0;
3561         rc = bounds;
3562         rc.X = 50.0;
3563         rc.Y = 50.0;
3564         set_rect_empty(&bounds);
3565         status = GdipMeasureString(graphics, string, -1, font, &rc, format, &bounds, &chars, &lines);
3566         expect(Ok, status);
3567         expectf(50.0, bounds.X);
3568         expectf(50.0, bounds.Y);
3569 todo_wine
3570         expectf_(height, bounds.Height, height / 100.0);
3571         expectf_(bounds.Height / base_cy, bounds.Width / base_cx, 0.1);
3572         expect(7, chars);
3573         expect(1, lines);
3574
3575         status = GdipDeleteGraphics(graphics);
3576         expect(Ok, status);
3577
3578         status = GdipDisposeImage(image);
3579         expect(Ok, status);
3580     }
3581
3582     GdipDeleteFont(font);
3583
3584     /* font size in logical units */
3585     /* UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
3586     for (unit = 3; unit <= 6; unit++)
3587     {
3588         /* create a font which final height is 100.0 pixels with 200 dpi device */
3589         /* height + 2 * (height/6) = 100 => height = 100 * 3 / 4 => 75 */
3590         height = pixels_to_units(75.0, unit, 200.0);
3591         status = GdipCreateFont(family, height, FontStyleRegular, unit, &font);
3592         expect(Ok, status);
3593         status = GdipGetFontSize(font, &font_size);
3594         expect(Ok, status);
3595         expectf(height, font_size);
3596         status = GdipGetFontUnit(font, &font_unit);
3597         expect(Ok, status);
3598         expect(unit, font_unit);
3599
3600         for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3601         {
3602             REAL unit_scale;
3603             GpImage *image;
3604
3605             graphics = create_graphics(td[i].res_x, td[i].res_y, td[i].unit, td[i].page_scale, &image);
3606
3607             lf.lfHeight = 0xdeadbeef;
3608             status = GdipGetLogFontW(font, graphics, &lf);
3609             expect(Ok, status);
3610             if (td[i].unit == UnitDisplay || td[i].unit == UnitPixel)
3611                 height = units_to_pixels(font_size, font_unit, td[i].res_x);
3612             else
3613                 height = units_to_pixels(font_size, font_unit, td[i].res_y);
3614             /*trace("%.1f font units = %f pixels with %.1f dpi, page_scale %.1f\n", font_size, height, td[i].res_y, td[i].page_scale);*/
3615             ok(-lf.lfHeight == (LONG)(height + 0.5), "%u: expected %d (%f), got %d\n",
3616                i, (LONG)(height + 0.5), height, lf.lfHeight);
3617
3618             if (td[i].unit == UnitDisplay || td[i].unit == UnitPixel)
3619                 unit_scale = units_scale(font_unit, td[i].unit, td[i].res_x);
3620             else
3621                 unit_scale = units_scale(font_unit, td[i].unit, td[i].res_y);
3622             /*trace("%u: %d to %d, %.1f dpi => unit_scale %f\n", i, font_unit, td[i].unit, td[i].res_y, unit_scale);*/
3623             height = (font_size + 2.0 * font_size / 6.0) * unit_scale;
3624             if (td[i].unit != UnitDisplay)
3625                 height /= td[i].page_scale;
3626             /*trace("%u: %.1f font units = %f units with %.1f dpi, page_scale %.1f\n", i, font_size, height, td[i].res_y, td[i].page_scale);*/
3627
3628             set_rect_empty(&rc);
3629             set_rect_empty(&bounds);
3630             status = GdipMeasureString(graphics, string, -1, font, &rc, format, &bounds, &chars, &lines);
3631             expect(Ok, status);
3632
3633             if (i == 0)
3634             {
3635                 base_cx = bounds.Width;
3636                 base_cy = bounds.Height;
3637             }
3638
3639             expectf(0.0, bounds.X);
3640             expectf(0.0, bounds.Y);
3641 todo_wine
3642             expectf_(height, bounds.Height, height / 85.0);
3643             expectf_(bounds.Height / base_cy, bounds.Width / base_cx, 0.1);
3644             expect(7, chars);
3645             expect(1, lines);
3646
3647             /* make sure it really fits */
3648             bounds.Width += 1.0;
3649             bounds.Height += 1.0;
3650             rc = bounds;
3651             rc.X = 50.0;
3652             rc.Y = 50.0;
3653             set_rect_empty(&bounds);
3654             status = GdipMeasureString(graphics, string, -1, font, &rc, format, &bounds, &chars, &lines);
3655             expect(Ok, status);
3656             expectf(50.0, bounds.X);
3657             expectf(50.0, bounds.Y);
3658 todo_wine
3659             expectf_(height, bounds.Height, height / 85.0);
3660             expectf_(bounds.Height / base_cy, bounds.Width / base_cx, 0.1);
3661             expect(7, chars);
3662             expect(1, lines);
3663
3664             /* verify the result */
3665             height = units_to_pixels(bounds.Height, td[i].unit, td[i].res_x);
3666             if (td[i].unit != UnitDisplay)
3667                 height *= td[i].page_scale;
3668             /*trace("%u: unit %u, %.1fx%.1f dpi, scale %.1f, height %f, pixels %f\n",
3669                   i, td[i].unit, td[i].res_x, td[i].res_y, td[i].page_scale, bounds.Height, height);*/
3670 todo_wine
3671             expectf_(100.0, height, 1.1);
3672
3673             status = GdipDeleteGraphics(graphics);
3674             expect(Ok, status);
3675
3676             status = GdipDisposeImage(image);
3677             expect(Ok, status);
3678         }
3679
3680         GdipDeleteFont(font);
3681     }
3682
3683     GdipDeleteFontFamily(family);
3684     GdipDeleteStringFormat(format);
3685 }
3686
3687 static void test_transform(void)
3688 {
3689     static const struct test_data
3690     {
3691         REAL res_x, res_y, scale;
3692         GpUnit unit;
3693         GpPointF in[2], out[2];
3694     } td[] =
3695     {
3696         { 96.0, 96.0, 1.0, UnitPixel,
3697           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 100.0, 0.0 }, { 0.0, 100.0 } } },
3698         { 96.0, 96.0, 1.0, UnitDisplay,
3699           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 100.0, 0.0 }, { 0.0, 100.0 } } },
3700         { 96.0, 96.0, 1.0, UnitInch,
3701           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 9600.0, 0.0 }, { 0.0, 9600.0 } } },
3702         { 123.0, 456.0, 1.0, UnitPoint,
3703           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 170.833313, 0.0 }, { 0.0, 633.333252 } } },
3704         { 123.0, 456.0, 1.0, UnitDocument,
3705           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 40.999996, 0.0 }, { 0.0, 151.999985 } } },
3706         { 123.0, 456.0, 2.0, UnitMillimeter,
3707           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 968.503845, 0.0 }, { 0.0, 3590.550781 } } },
3708         { 196.0, 296.0, 1.0, UnitDisplay,
3709           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 100.0, 0.0 }, { 0.0, 100.0 } } },
3710         { 196.0, 296.0, 1.0, UnitPixel,
3711           { { 100.0, 0.0 }, { 0.0, 100.0 } }, { { 100.0, 0.0 }, { 0.0, 100.0 } } },
3712     };
3713     GpStatus status;
3714     GpGraphics *graphics;
3715     GpImage *image;
3716     GpPointF ptf[2];
3717     UINT i;
3718
3719     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3720     {
3721         graphics = create_graphics(td[i].res_x, td[i].res_y, td[i].unit, td[i].scale, &image);
3722         ptf[0].X = td[i].in[0].X;
3723         ptf[0].Y = td[i].in[0].Y;
3724         ptf[1].X = td[i].in[1].X;
3725         ptf[1].Y = td[i].in[1].Y;
3726         status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, ptf, 2);
3727         expect(Ok, status);
3728         expectf(td[i].out[0].X, ptf[0].X);
3729         expectf(td[i].out[0].Y, ptf[0].Y);
3730         expectf(td[i].out[1].X, ptf[1].X);
3731         expectf(td[i].out[1].Y, ptf[1].Y);
3732         status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
3733         expect(Ok, status);
3734         expectf(td[i].in[0].X, ptf[0].X);
3735         expectf(td[i].in[0].Y, ptf[0].Y);
3736         expectf(td[i].in[1].X, ptf[1].X);
3737         expectf(td[i].in[1].Y, ptf[1].Y);
3738         status = GdipDeleteGraphics(graphics);
3739         expect(Ok, status);
3740         status = GdipDisposeImage(image);
3741         expect(Ok, status);
3742     }
3743 }
3744
3745 /* Many people on the net ask why there is so much difference in rendered
3746  * text height between gdiplus and gdi32, this test suggests an answer to
3747  * that question. Important: this test assumes that font dpi == device dpi.
3748  */
3749 static void test_font_height_scaling(void)
3750 {
3751     static const WCHAR tahomaW[] = { 'T','a','h','o','m','a',0 };
3752     static const WCHAR string[] = { '1','2','3','4','5','6','7',0 };
3753     HDC hdc;
3754     GpStringFormat *format;
3755     CharacterRange range = { 0, 7 };
3756     GpRegion *region;
3757     GpGraphics *graphics;
3758     GpFontFamily *family;
3759     GpFont *font;
3760     GpStatus status;
3761     RectF bounds, rect;
3762     REAL height, dpi, scale;
3763     PointF ptf;
3764     GpUnit gfx_unit, font_unit;
3765
3766     status = GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &format);
3767     expect(Ok, status);
3768     status = GdipSetStringFormatMeasurableCharacterRanges(format, 1, &range);
3769     expect(Ok, status);
3770     status = GdipCreateRegion(&region);
3771     expect(Ok, status);
3772
3773     status = GdipCreateFontFamilyFromName(tahomaW, NULL, &family);
3774     expect(Ok, status);
3775
3776     hdc = CreateCompatibleDC(0);
3777     status = GdipCreateFromHDC(hdc, &graphics);
3778     expect(Ok, status);
3779
3780     status = GdipGetDpiY(graphics, &dpi);
3781     expect(Ok, status);
3782
3783     /* First check if tested functionality works:
3784      * under XP if font and graphics units differ then GdipTransformPoints
3785      * followed by GdipSetPageUnit to change the graphics units breaks region
3786      * scaling in GdipMeasureCharacterRanges called later.
3787      */
3788     status = GdipSetPageUnit(graphics, UnitDocument);
3789     expect(Ok, status);
3790
3791     ptf.X = 0.0;
3792     ptf.Y = 0.0;
3793     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &ptf, 1);
3794     expect(Ok, status);
3795
3796     status = GdipSetPageUnit(graphics, UnitInch);
3797     expect(Ok, status);
3798
3799     status = GdipCreateFont(family, 720.0, FontStyleRegular, UnitPoint, &font);
3800     expect(Ok, status);
3801
3802     set_rect_empty(&rect);
3803     set_rect_empty(&bounds);
3804     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
3805     expect(Ok, status);
3806     trace("test bounds: %f,%f,%f,%f\n", bounds.X, bounds.Y, bounds.Width, bounds.Height);
3807
3808     set_rect_empty(&rect);
3809     rect.Width = 32000.0;
3810     rect.Height = 32000.0;
3811     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
3812     expect(Ok, status);
3813
3814     set_rect_empty(&rect);
3815     status = GdipGetRegionBounds(region, graphics, &rect);
3816     expect(Ok, status);
3817     trace("test region: %f,%f,%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
3818
3819     GdipDeleteFont(font);
3820
3821     scale = rect.Height / bounds.Height;
3822     if (fabs(scale - 1.0) > 0.1)
3823     {
3824         win_skip("GdipGetRegionBounds is broken, scale %f (should be near 1.0)\n", scale);
3825         goto cleanup;
3826     }
3827
3828     status = GdipScaleWorldTransform(graphics, 0.01, 0.01, MatrixOrderAppend);
3829     expect(Ok, status);
3830
3831     /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
3832     /* UnitPixel as a font base unit is not tested because it drastically
3833        differs in behaviour */
3834     for (font_unit = 3; font_unit <= 6; font_unit++)
3835     {
3836         /* create a font for the final text height of 100 pixels */
3837         /* height + 2 * (height/6) = 100 => height = 100 * 3 / 4 => 75 */
3838         status = GdipSetPageUnit(graphics, font_unit);
3839         expect(Ok, status);
3840         ptf.X = 0;
3841         ptf.Y = 75.0;
3842         status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &ptf, 1);
3843         expect(Ok, status);
3844         height = ptf.Y;
3845         /*trace("height %f units\n", height);*/
3846         status = GdipCreateFont(family, height, FontStyleRegular, font_unit, &font);
3847         expect(Ok, status);
3848
3849         /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
3850         for (gfx_unit = 2; gfx_unit <= 6; gfx_unit++)
3851         {
3852             static const WCHAR doubleW[2] = { 'W','W' };
3853             RectF bounds_1, bounds_2;
3854             REAL margin, margin_y, font_height;
3855             int match;
3856
3857             status = GdipSetPageUnit(graphics, gfx_unit);
3858             expect(Ok, status);
3859
3860             margin_y = units_to_pixels(height / 8.0, font_unit, dpi);
3861             margin_y = pixels_to_units(margin_y, gfx_unit, dpi);
3862
3863             status = GdipGetFontHeight(font, graphics, &font_height);
3864             expect(Ok, status);
3865
3866             set_rect_empty(&rect);
3867             set_rect_empty(&bounds);
3868             status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
3869             expect(Ok, status);
3870             /*trace("bounds: %f,%f,%f,%f\n", bounds.X, bounds.Y, bounds.Width, bounds.Height);*/
3871 todo_wine
3872             expectf_(font_height + margin_y, bounds.Height, 0.005);
3873
3874             ptf.X = 0;
3875             ptf.Y = bounds.Height;
3876             status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &ptf, 1);
3877             expect(Ok, status);
3878             match = fabs(100.0 - ptf.Y) <= 1.0;
3879 todo_wine
3880             ok(match, "Expected 100.0, got %f\n", ptf.Y);
3881
3882             /* verify the result */
3883             ptf.Y = units_to_pixels(bounds.Height, gfx_unit, dpi);
3884             ptf.Y /= 100.0;
3885             match = fabs(100.0 - ptf.Y) <= 1.0;
3886 todo_wine
3887             ok(match, "Expected 100.0, got %f\n", ptf.Y);
3888
3889             /* bounds.width of 1 glyph: [margin]+[width]+[margin] */
3890             set_rect_empty(&rect);
3891             set_rect_empty(&bounds_1);
3892             status = GdipMeasureString(graphics, doubleW, 1, font, &rect, format, &bounds_1, NULL, NULL);
3893             expect(Ok, status);
3894             /* bounds.width of 2 identical glyphs: [margin]+[width]+[width]+[margin] */
3895             set_rect_empty(&rect);
3896             set_rect_empty(&bounds_2);
3897             status = GdipMeasureString(graphics, doubleW, 2, font, &rect, format, &bounds_2, NULL, NULL);
3898             expect(Ok, status);
3899
3900             /* margin = [bounds.width of 1] - [bounds.width of 2] / 2*/
3901             margin = bounds_1.Width - bounds_2.Width / 2.0;
3902             /*trace("margin %f\n", margin);*/
3903             ok(margin > 0.0, "wrong margin %f\n", margin);
3904
3905             set_rect_empty(&rect);
3906             rect.Width = 320000.0;
3907             rect.Height = 320000.0;
3908             status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
3909             expect(Ok, status);
3910             set_rect_empty(&rect);
3911             status = GdipGetRegionBounds(region, graphics, &rect);
3912             expect(Ok, status);
3913             /*trace("region: %f,%f,%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);*/
3914             ok(rect.X > 0.0, "wrong rect.X %f\n", rect.X);
3915             expectf(0.0, rect.Y);
3916             match = fabs(1.0 - margin / rect.X) <= 0.05;
3917             ok(match, "Expected %f, got %f\n", margin, rect.X);
3918             match = fabs(1.0 - font_height / rect.Height) <= 0.1;
3919             ok(match, "Expected %f, got %f\n", font_height, rect.Height);
3920             match = fabs(1.0 - bounds.Width / (rect.Width + margin * 2.0)) <= 0.05;
3921             ok(match, "Expected %f, got %f\n", bounds.Width, rect.Width + margin * 2.0);
3922         }
3923
3924         GdipDeleteFont(font);
3925     }
3926
3927 cleanup:
3928     status = GdipDeleteGraphics(graphics);
3929     expect(Ok, status);
3930     DeleteDC(hdc);
3931
3932     GdipDeleteFontFamily(family);
3933     GdipDeleteRegion(region);
3934     GdipDeleteStringFormat(format);
3935 }
3936
3937 static void test_measure_string(void)
3938 {
3939     static const WCHAR tahomaW[] = { 'T','a','h','o','m','a',0 };
3940     static const WCHAR string[] = { 'A','0','1',0 };
3941     HDC hdc;
3942     GpStringFormat *format;
3943     CharacterRange range;
3944     GpRegion *region;
3945     GpGraphics *graphics;
3946     GpFontFamily *family;
3947     GpFont *font;
3948     GpStatus status;
3949     RectF bounds, rect;
3950     REAL width, height, width_1, width_2;
3951     REAL margin_x, margin_y, width_rgn, height_rgn;
3952     int lines, glyphs;
3953
3954     status = GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &format);
3955     expect(Ok, status);
3956     expect(Ok, status);
3957
3958     status = GdipCreateRegion(&region);
3959     expect(Ok, status);
3960
3961     status = GdipCreateFontFamilyFromName(tahomaW, NULL, &family);
3962     expect(Ok, status);
3963
3964     hdc = CreateCompatibleDC(0);
3965     status = GdipCreateFromHDC(hdc, &graphics);
3966
3967     status = GdipCreateFont(family, 20, FontStyleRegular, UnitPixel, &font);
3968     expect(Ok, status);
3969
3970     margin_x = 20.0 / 6.0;
3971     margin_y = 20.0 / 8.0;
3972
3973     set_rect_empty(&rect);
3974     set_rect_empty(&bounds);
3975     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
3976     expect(Ok, status);
3977     expect(3, glyphs);
3978     expect(1, lines);
3979     expectf(0.0, bounds.X);
3980     expectf(0.0, bounds.Y);
3981     width = bounds.Width;
3982     height = bounds.Height;
3983
3984     set_rect_empty(&rect);
3985     rect.Height = height / 2.0;
3986     set_rect_empty(&bounds);
3987     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
3988     expect(Ok, status);
3989     expect(3, glyphs);
3990     expect(1, lines);
3991     expectf(0.0, bounds.X);
3992     expectf(0.0, bounds.Y);
3993     expectf(width, bounds.Width);
3994 todo_wine
3995     expectf(height / 2.0, bounds.Height);
3996
3997     range.First = 0;
3998     range.Length = lstrlenW(string);
3999     status = GdipSetStringFormatMeasurableCharacterRanges(format, 1, &range);
4000     expect(Ok, status);
4001
4002     rect.X = 5.0;
4003     rect.Y = 5.0;
4004     rect.Width = 32000.0;
4005     rect.Height = 32000.0;
4006     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4007     expect(Ok, status);
4008     set_rect_empty(&bounds);
4009     status = GdipGetRegionBounds(region, graphics, &bounds);
4010     expect(Ok, status);
4011     expectf_(5.0 + margin_x, bounds.X, 1.0);
4012     expectf(5.0, bounds.Y);
4013     expectf_(width - margin_x*2.0, bounds.Width, 1.0);
4014 todo_wine
4015     expectf_(height - margin_y, bounds.Height, 1.0);
4016
4017     width_rgn = bounds.Width;
4018     height_rgn = bounds.Height;
4019
4020     range.First = 0;
4021     range.Length = 1;
4022     status = GdipSetStringFormatMeasurableCharacterRanges(format, 1, &range);
4023     expect(Ok, status);
4024
4025     set_rect_empty(&rect);
4026     rect.Width = 32000.0;
4027     rect.Height = 32000.0;
4028     status = GdipMeasureCharacterRanges(graphics, string, 1, font, &rect, format, 1, &region);
4029     expect(Ok, status);
4030     set_rect_empty(&bounds);
4031     status = GdipGetRegionBounds(region, graphics, &bounds);
4032     expect(Ok, status);
4033     expectf_(margin_x, bounds.X, 1.0);
4034     expectf(0.0, bounds.Y);
4035     ok(bounds.Width < width_rgn / 2.0, "width of 1 glyph is wrong\n");
4036     expectf(height_rgn, bounds.Height);
4037     width_1 = bounds.Width;
4038
4039     range.First = 0;
4040     range.Length = lstrlenW(string);
4041     status = GdipSetStringFormatMeasurableCharacterRanges(format, 1, &range);
4042     expect(Ok, status);
4043
4044     rect.X = 5.0;
4045     rect.Y = 5.0;
4046     rect.Width = 0.0;
4047     rect.Height = 0.0;
4048     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4049     expect(Ok, status);
4050     set_rect_empty(&bounds);
4051     status = GdipGetRegionBounds(region, graphics, &bounds);
4052     expect(Ok, status);
4053     expectf(0.0, bounds.X);
4054     expectf(0.0, bounds.Y);
4055     expectf(0.0, bounds.Width);
4056     expectf(0.0, bounds.Height);
4057
4058     rect.X = 5.0;
4059     rect.Y = 5.0;
4060     rect.Width = width_rgn / 2.0;
4061     rect.Height = 32000.0;
4062     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4063     expect(Ok, status);
4064     set_rect_empty(&bounds);
4065     status = GdipGetRegionBounds(region, graphics, &bounds);
4066     expect(Ok, status);
4067     expectf_(5.0 + margin_x, bounds.X, 1.0);
4068     expectf(5.0, bounds.Y);
4069     expectf_(width_1, bounds.Width, 1.0);
4070 todo_wine
4071     expectf_(height - margin_y, bounds.Height, 1.0);
4072
4073     status = GdipSetStringFormatFlags(format, StringFormatFlagsNoWrap | StringFormatFlagsNoClip);
4074
4075     rect.X = 5.0;
4076     rect.Y = 5.0;
4077     rect.Width = 0.0;
4078     rect.Height = 0.0;
4079     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4080     expect(Ok, status);
4081     set_rect_empty(&bounds);
4082     status = GdipGetRegionBounds(region, graphics, &bounds);
4083     expect(Ok, status);
4084     expectf_(5.0 + margin_x, bounds.X, 1.0);
4085     expectf(5.0, bounds.Y);
4086     expectf(width_rgn, bounds.Width);
4087     expectf(height_rgn, bounds.Height);
4088
4089     rect.X = 5.0;
4090     rect.Y = 5.0;
4091     rect.Width = width_rgn / 2.0;
4092     rect.Height = 32000.0;
4093     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4094     expect(Ok, status);
4095     set_rect_empty(&bounds);
4096     status = GdipGetRegionBounds(region, graphics, &bounds);
4097     expect(Ok, status);
4098     expectf_(5.0 + margin_x, bounds.X, 1.0);
4099     expectf(5.0, bounds.Y);
4100     expectf_(width_1, bounds.Width, 1.0);
4101     expectf(height_rgn, bounds.Height);
4102
4103     set_rect_empty(&rect);
4104     rect.Height = height / 2.0;
4105     set_rect_empty(&bounds);
4106     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4107     expect(Ok, status);
4108     expect(3, glyphs);
4109     expect(1, lines);
4110     expectf(0.0, bounds.X);
4111     expectf(0.0, bounds.Y);
4112     expectf_(width, bounds.Width, 0.01);
4113 todo_wine
4114     expectf(height, bounds.Height);
4115
4116     set_rect_empty(&rect);
4117     set_rect_empty(&bounds);
4118     status = GdipMeasureString(graphics, string, 1, font, &rect, format, &bounds, &glyphs, &lines);
4119     expect(Ok, status);
4120     expect(1, glyphs);
4121     expect(1, lines);
4122     expectf(0.0, bounds.X);
4123     expectf(0.0, bounds.Y);
4124     ok(bounds.Width < width / 2.0, "width of 1 glyph is wrong\n");
4125     expectf(height, bounds.Height);
4126     width_1 = bounds.Width;
4127
4128     set_rect_empty(&rect);
4129     set_rect_empty(&bounds);
4130     status = GdipMeasureString(graphics, string, 2, font, &rect, format, &bounds, &glyphs, &lines);
4131     expect(Ok, status);
4132     expect(2, glyphs);
4133     expect(1, lines);
4134     expectf(0.0, bounds.X);
4135     expectf(0.0, bounds.Y);
4136     ok(bounds.Width < width, "width of 2 glyphs is wrong\n");
4137     ok(bounds.Width > width_1, "width of 2 glyphs is wrong\n");
4138     expectf(height, bounds.Height);
4139     width_2 = bounds.Width;
4140
4141     set_rect_empty(&rect);
4142     rect.Width = width / 2.0;
4143     set_rect_empty(&bounds);
4144     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4145     expect(Ok, status);
4146     expect(1, glyphs);
4147     expect(1, lines);
4148     expectf(0.0, bounds.X);
4149     expectf(0.0, bounds.Y);
4150     expectf_(width_1, bounds.Width, 0.01);
4151     expectf(height, bounds.Height);
4152
4153     set_rect_empty(&rect);
4154     rect.Height = height;
4155     rect.Width = width - 0.05;
4156     set_rect_empty(&bounds);
4157     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4158     expect(Ok, status);
4159     expect(2, glyphs);
4160     expect(1, lines);
4161     expectf(0.0, bounds.X);
4162     expectf(0.0, bounds.Y);
4163     expectf_(width_2, bounds.Width, 0.01);
4164     expectf(height, bounds.Height);
4165
4166     set_rect_empty(&rect);
4167     rect.Height = height;
4168     rect.Width = width_2 - 0.05;
4169     set_rect_empty(&bounds);
4170     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4171     expect(Ok, status);
4172     expect(1, glyphs);
4173     expect(1, lines);
4174     expectf(0.0, bounds.X);
4175     expectf(0.0, bounds.Y);
4176     expectf_(width_1, bounds.Width, 0.01);
4177     expectf(height, bounds.Height);
4178
4179     /* Default (Near) alignment */
4180     rect.X = 5.0;
4181     rect.Y = 5.0;
4182     rect.Width = width * 2.0;
4183     rect.Height = height * 2.0;
4184     set_rect_empty(&bounds);
4185     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4186     expect(Ok, status);
4187     expect(3, glyphs);
4188     expect(1, lines);
4189     expectf(5.0, bounds.X);
4190     expectf(5.0, bounds.Y);
4191     expectf_(width, bounds.Width, 0.01);
4192     expectf(height, bounds.Height);
4193
4194     rect.X = 5.0;
4195     rect.Y = 5.0;
4196     rect.Width = 32000.0;
4197     rect.Height = 32000.0;
4198     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4199     expect(Ok, status);
4200     set_rect_empty(&bounds);
4201     status = GdipGetRegionBounds(region, graphics, &bounds);
4202     expect(Ok, status);
4203     expectf_(5.0 + margin_x, bounds.X, 1.0);
4204     expectf(5.0, bounds.Y);
4205     expectf_(width - margin_x*2.0, bounds.Width, 1.0);
4206 todo_wine
4207     expectf_(height - margin_y, bounds.Height, 1.0);
4208
4209     width_rgn = bounds.Width;
4210     height_rgn = bounds.Height;
4211
4212     /* Center alignment */
4213     GdipSetStringFormatAlign(format, StringAlignmentCenter);
4214     GdipSetStringFormatLineAlign(format, StringAlignmentCenter);
4215
4216     rect.X = 5.0;
4217     rect.Y = 5.0;
4218     rect.Width = width * 2.0;
4219     rect.Height = height * 2.0;
4220     set_rect_empty(&bounds);
4221     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4222     expect(Ok, status);
4223     expect(3, glyphs);
4224     expect(1, lines);
4225 todo_wine
4226     expectf_(5.0 + width/2.0, bounds.X, 0.01);
4227 todo_wine
4228     expectf(5.0 + height/2.0, bounds.Y);
4229     expectf_(width, bounds.Width, 0.01);
4230     expectf(height, bounds.Height);
4231
4232     rect.X = 5.0;
4233     rect.Y = 5.0;
4234     rect.Width = 0.0;
4235     rect.Height = 0.0;
4236     set_rect_empty(&bounds);
4237     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4238     expect(Ok, status);
4239     expect(3, glyphs);
4240     expect(1, lines);
4241 todo_wine
4242     expectf_(5.0 - width/2.0, bounds.X, 0.01);
4243 todo_wine
4244     expectf(5.0 - height/2.0, bounds.Y);
4245     expectf_(width, bounds.Width, 0.01);
4246     expectf(height, bounds.Height);
4247
4248     rect.X = 5.0;
4249     rect.Y = 5.0;
4250     rect.Width = width_rgn * 2.0;
4251     rect.Height = height_rgn * 2.0;
4252     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4253     expect(Ok, status);
4254     set_rect_empty(&bounds);
4255     status = GdipGetRegionBounds(region, graphics, &bounds);
4256     expect(Ok, status);
4257 todo_wine
4258     expectf_(5.0 + width_rgn/2.0, bounds.X, 1.0);
4259 todo_wine
4260     expectf_(5.0 + height_rgn/2.0, bounds.Y, 1.0);
4261     expectf_(width_rgn, bounds.Width, 1.0);
4262     expectf_(height_rgn, bounds.Height, 1.0);
4263
4264     rect.X = 5.0;
4265     rect.Y = 5.0;
4266     rect.Width = 0.0;
4267     rect.Height = 0.0;
4268     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4269     expect(Ok, status);
4270     set_rect_empty(&bounds);
4271     status = GdipGetRegionBounds(region, graphics, &bounds);
4272     expect(Ok, status);
4273 todo_wine
4274     expectf_(5.0 - width_rgn/2.0, bounds.X, 1.0);
4275 todo_wine
4276     expectf_(5.0 - height_rgn/2.0, bounds.Y, 1.0);
4277     expectf_(width_rgn, bounds.Width, 1.0);
4278     expectf_(height_rgn, bounds.Height, 1.0);
4279
4280     /* Far alignment */
4281     GdipSetStringFormatAlign(format, StringAlignmentFar);
4282     GdipSetStringFormatLineAlign(format, StringAlignmentFar);
4283
4284     rect.X = 5.0;
4285     rect.Y = 5.0;
4286     rect.Width = width * 2.0;
4287     rect.Height = height * 2.0;
4288     set_rect_empty(&bounds);
4289     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4290     expect(Ok, status);
4291     expect(3, glyphs);
4292     expect(1, lines);
4293 todo_wine
4294     expectf_(5.0 + width, bounds.X, 0.01);
4295 todo_wine
4296     expectf(5.0 + height, bounds.Y);
4297     expectf_(width, bounds.Width, 0.01);
4298     expectf(height, bounds.Height);
4299
4300     rect.X = 5.0;
4301     rect.Y = 5.0;
4302     rect.Width = 0.0;
4303     rect.Height = 0.0;
4304     set_rect_empty(&bounds);
4305     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, &glyphs, &lines);
4306     expect(Ok, status);
4307     expect(3, glyphs);
4308     expect(1, lines);
4309 todo_wine
4310     expectf_(5.0 - width, bounds.X, 0.01);
4311 todo_wine
4312     expectf(5.0 - height, bounds.Y);
4313     expectf_(width, bounds.Width, 0.01);
4314     expectf(height, bounds.Height);
4315
4316     rect.X = 5.0;
4317     rect.Y = 5.0;
4318     rect.Width = width_rgn * 2.0;
4319     rect.Height = height_rgn * 2.0;
4320     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4321     expect(Ok, status);
4322     set_rect_empty(&bounds);
4323     status = GdipGetRegionBounds(region, graphics, &bounds);
4324     expect(Ok, status);
4325 todo_wine
4326     expectf_(5.0 + width_rgn, bounds.X, 2.0);
4327 todo_wine
4328     expectf_(5.0 + height_rgn, bounds.Y, 1.0);
4329     expectf_(width_rgn, bounds.Width, 1.0);
4330     expectf_(height_rgn, bounds.Height, 1.0);
4331
4332     rect.X = 5.0;
4333     rect.Y = 5.0;
4334     rect.Width = 0.0;
4335     rect.Height = 0.0;
4336     status = GdipMeasureCharacterRanges(graphics, string, -1, font, &rect, format, 1, &region);
4337     expect(Ok, status);
4338     set_rect_empty(&bounds);
4339     status = GdipGetRegionBounds(region, graphics, &bounds);
4340     expect(Ok, status);
4341 todo_wine
4342     expectf_(5.0 - width_rgn, bounds.X, 2.0);
4343 todo_wine
4344     expectf_(5.0 - height_rgn, bounds.Y, 1.0);
4345     expectf_(width_rgn, bounds.Width, 1.0);
4346     expectf_(height_rgn, bounds.Height, 1.0);
4347
4348     status = GdipDeleteFont(font);
4349     expect(Ok, status);
4350
4351     status = GdipDeleteGraphics(graphics);
4352     expect(Ok, status);
4353     DeleteDC(hdc);
4354
4355     GdipDeleteFontFamily(family);
4356     GdipDeleteRegion(region);
4357     GdipDeleteStringFormat(format);
4358 }
4359
4360 static void test_measured_extra_space(void)
4361 {
4362     static const WCHAR tahomaW[] = { 'T','a','h','o','m','a',0 };
4363     static const WCHAR string[2] = { 'W','W' };
4364     GpStringFormat *format;
4365     HDC hdc;
4366     GpGraphics *graphics;
4367     GpFontFamily *family;
4368     GpFont *font;
4369     GpStatus status;
4370     GpUnit gfx_unit, font_unit;
4371     RectF bounds_1, bounds_2, rect;
4372     REAL margin, font_size, dpi;
4373
4374     status = GdipCreateStringFormat(0, LANG_NEUTRAL, &format);
4375     expect(Ok, status);
4376
4377     status = GdipCreateFontFamilyFromName(tahomaW, NULL, &family);
4378     expect(Ok, status);
4379     hdc = CreateCompatibleDC(0);
4380     status = GdipCreateFromHDC(hdc, &graphics);
4381     expect(Ok, status);
4382
4383     status = GdipGetDpiX(graphics, &dpi);
4384     expect(Ok, status);
4385
4386     /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
4387     /* UnitPixel as a font base unit is not tested because it differs in behaviour */
4388     for (font_unit = 3; font_unit <= 6; font_unit++)
4389     {
4390         status = GdipCreateFont(family, 1234.0, FontStyleRegular, font_unit, &font);
4391         expect(Ok, status);
4392
4393         status = GdipGetFontSize(font, &font_size);
4394         expect(Ok, status);
4395         font_size = units_to_pixels(font_size, font_unit, dpi);
4396         /*trace("font size/6 = %f pixels\n", font_size / 6.0);*/
4397
4398         /* UnitPixel = 2, UnitPoint = 3, UnitInch = 4, UnitDocument = 5, UnitMillimeter = 6 */
4399         for (gfx_unit = 2; gfx_unit <= 6; gfx_unit++)
4400         {
4401             status = GdipSetPageUnit(graphics, gfx_unit);
4402             expect(Ok, status);
4403
4404             /* bounds.width of 1 glyph: [margin]+[width]+[margin] */
4405             set_rect_empty(&rect);
4406             set_rect_empty(&bounds_1);
4407             status = GdipMeasureString(graphics, string, 1, font, &rect, format, &bounds_1, NULL, NULL);
4408             expect(Ok, status);
4409             /* bounds.width of 2 identical glyphs: [margin]+[width]+[width]+[margin] */
4410             set_rect_empty(&rect);
4411             set_rect_empty(&bounds_2);
4412             status = GdipMeasureString(graphics, string, 2, font, &rect, format, &bounds_2, NULL, NULL);
4413             expect(Ok, status);
4414
4415             /* margin = [bounds.width of 1] - [bounds.width of 2] / 2*/
4416             margin = units_to_pixels(bounds_1.Width - bounds_2.Width / 2.0, gfx_unit, dpi);
4417             /*trace("margin %f pixels\n", margin);*/
4418             expectf_(font_size / 6.0, margin, font_size / 100.0);
4419         }
4420
4421         GdipDeleteFont(font);
4422     }
4423
4424     GdipDeleteGraphics(graphics);
4425     DeleteDC(hdc);
4426     GdipDeleteFontFamily(family);
4427     GdipDeleteStringFormat(format);
4428 }
4429
4430 static void test_alpha_hdc(void)
4431 {
4432     GpStatus status;
4433     HDC hdc;
4434     HBITMAP hbm, old_hbm;
4435     GpGraphics *graphics;
4436     ULONG *bits;
4437     BITMAPINFO bmi;
4438     GpRectF bounds;
4439
4440     hdc = CreateCompatibleDC(0);
4441     ok(hdc != NULL, "CreateCompatibleDC failed\n");
4442     bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
4443     bmi.bmiHeader.biHeight = 5;
4444     bmi.bmiHeader.biWidth = 5;
4445     bmi.bmiHeader.biBitCount = 32;
4446     bmi.bmiHeader.biPlanes = 1;
4447     bmi.bmiHeader.biCompression = BI_RGB;
4448     bmi.bmiHeader.biClrUsed = 0;
4449
4450     hbm = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
4451     ok(hbm != NULL, "CreateDIBSection failed\n");
4452
4453     old_hbm = SelectObject(hdc, hbm);
4454
4455     status = GdipCreateFromHDC(hdc, &graphics);
4456     expect(Ok, status);
4457
4458     status = GdipGetVisibleClipBounds(graphics, &bounds);
4459     expect(Ok, status);
4460     expectf(0.0, bounds.X);
4461     expectf(0.0, bounds.Y);
4462     expectf(5.0, bounds.Width);
4463     expectf(5.0, bounds.Height);
4464
4465     bits[0] = 0xdeadbeef;
4466
4467     status = GdipGraphicsClear(graphics, 0xffaaaaaa);
4468     expect(Ok, status);
4469
4470     expect(0xffaaaaaa, bits[0]);
4471
4472     SelectObject(hdc, old_hbm);
4473
4474     bits[0] = 0xdeadbeef;
4475
4476     status = GdipGraphicsClear(graphics, 0xffbbbbbb);
4477     expect(Ok, status);
4478
4479     todo_wine expect(0xffbbbbbb, bits[0]);
4480
4481     GdipDeleteGraphics(graphics);
4482
4483     DeleteObject(hbm);
4484     DeleteDC(hdc);
4485 }
4486
4487 static void test_bitmapfromgraphics(void)
4488 {
4489     GpStatus stat;
4490     GpGraphics *graphics = NULL;
4491     HDC hdc = GetDC( hwnd );
4492     GpBitmap *bitmap = NULL;
4493     PixelFormat format;
4494     REAL imageres, graphicsres;
4495     UINT width, height;
4496
4497     stat = GdipCreateFromHDC(hdc, &graphics);
4498     expect(Ok, stat);
4499
4500     stat = GdipCreateBitmapFromGraphics(12, 13, NULL, &bitmap);
4501     expect(InvalidParameter, stat);
4502
4503     stat = GdipCreateBitmapFromGraphics(12, 13, graphics, NULL);
4504     expect(InvalidParameter, stat);
4505
4506     stat = GdipCreateBitmapFromGraphics(12, 13, graphics, &bitmap);
4507     expect(Ok, stat);
4508
4509     stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
4510     expect(Ok, stat);
4511     expect(PixelFormat32bppPARGB, format);
4512
4513     stat = GdipGetDpiX(graphics, &graphicsres);
4514     expect(Ok, stat);
4515
4516     stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &imageres);
4517     expect(Ok, stat);
4518     expectf(graphicsres, imageres);
4519
4520     stat = GdipGetDpiY(graphics, &graphicsres);
4521     expect(Ok, stat);
4522
4523     stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &imageres);
4524     expect(Ok, stat);
4525     expectf(graphicsres, imageres);
4526
4527     stat = GdipGetImageWidth((GpImage*)bitmap, &width);
4528     expect(Ok, stat);
4529     expect(12, width);
4530
4531     stat = GdipGetImageHeight((GpImage*)bitmap, &height);
4532     expect(Ok, stat);
4533     expect(13, height);
4534
4535     GdipDeleteGraphics(graphics);
4536     GdipDisposeImage((GpImage*)bitmap);
4537 }
4538
4539 static void test_clipping(void)
4540 {
4541     HDC hdc;
4542     GpStatus status;
4543     GpGraphics *graphics;
4544     GpRegion *region, *region100x100;
4545     GpMatrix *matrix;
4546     GpRectF rect;
4547     GpPointF ptf[4];
4548     GpUnit unit;
4549     HRGN hrgn;
4550     int ret;
4551     RECT rc;
4552
4553     hdc = CreateCompatibleDC(0);
4554     status = GdipCreateFromHDC(hdc, &graphics);
4555     expect(Ok, status);
4556
4557     status = GdipGetPageUnit(graphics, &unit);
4558     expect(Ok, status);
4559     expect(UnitDisplay, unit);
4560
4561     status = GdipCreateRegion(&region);
4562     expect(Ok, status);
4563     status = GdipSetEmpty(region);
4564     expect(Ok, status);
4565
4566     status = GdipCreateRegion(&region100x100);
4567     expect(Ok, status);
4568     status = GdipSetEmpty(region100x100);
4569     expect(Ok, status);
4570
4571     rect.X = rect.Y = 100.0;
4572     rect.Width = rect.Height = 100.0;
4573     status = GdipCombineRegionRect(region100x100, &rect, CombineModeUnion);
4574     expect(Ok, status);
4575     status = GdipSetClipRegion(graphics, region100x100, CombineModeReplace);
4576     expect(Ok, status);
4577
4578     status = GdipGetClipBounds(graphics, &rect);
4579     expect(Ok, status);
4580     ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
4581        "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4582
4583     status = GdipSetEmpty(region);
4584     expect(Ok, status);
4585     status = GdipGetClip(graphics, region);
4586     expect(Ok, status);
4587     status = GdipGetRegionBounds(region, graphics, &rect);
4588     expect(Ok, status);
4589     ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
4590        "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4591
4592     ptf[0].X = 100.0;
4593     ptf[0].Y = 100.0;
4594     ptf[1].X = 200.0;
4595     ptf[1].Y = 200.0;
4596     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4597     expect(Ok, status);
4598     ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
4599        "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4600
4601     status = GdipCreateMatrix(&matrix);
4602     expect(Ok, status);
4603     status = GdipScaleMatrix(matrix, 2.0, 4.0, MatrixOrderAppend);
4604     expect(Ok, status);
4605     status = GdipTranslateMatrix(matrix, 10.0, 20.0, MatrixOrderAppend);
4606     expect(Ok, status);
4607     status = GdipSetWorldTransform(graphics, matrix);
4608     expect(Ok, status);
4609
4610     status = GdipGetClipBounds(graphics, &rect);
4611     expect(Ok, status);
4612     ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
4613        "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4614
4615     status = GdipSetEmpty(region);
4616     expect(Ok, status);
4617     status = GdipGetClip(graphics, region);
4618     expect(Ok, status);
4619     status = GdipGetRegionBounds(region, graphics, &rect);
4620     expect(Ok, status);
4621     ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
4622        "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4623
4624     status = GdipGetRegionBounds(region100x100, graphics, &rect);
4625     expect(Ok, status);
4626     ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
4627        "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4628
4629     status = GdipGetRegionHRgn(region, NULL, &hrgn);
4630     expect(Ok, status);
4631     ret = GetRgnBox(hrgn, &rc);
4632     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4633     ok(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45,
4634        "expected 45,20-95,45, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4635     DeleteObject(hrgn);
4636
4637     status = GdipGetRegionHRgn(region, graphics, &hrgn);
4638     expect(Ok, status);
4639     ret = GetRgnBox(hrgn, &rc);
4640     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4641     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4642        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4643     DeleteObject(hrgn);
4644
4645     ptf[0].X = 100.0;
4646     ptf[0].Y = 100.0;
4647     ptf[1].X = 200.0;
4648     ptf[1].Y = 200.0;
4649     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4650     expect(Ok, status);
4651     ok(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0,
4652        "expected 45.0,20.0-95.0,45.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4653
4654     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
4655     expect(Ok, status);
4656     ret = GetRgnBox(hrgn, &rc);
4657     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4658     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4659        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4660     DeleteObject(hrgn);
4661
4662     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
4663     expect(Ok, status);
4664     ret = GetRgnBox(hrgn, &rc);
4665     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4666     ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
4667        "expected 210,420-410,820, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4668     DeleteObject(hrgn);
4669
4670     ptf[0].X = 210.0;
4671     ptf[0].Y = 420.0;
4672     ptf[1].X = 410.0;
4673     ptf[1].Y = 820.0;
4674     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4675     expect(Ok, status);
4676     ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
4677        "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4678
4679     status = GdipSetPageScale(graphics, 2.0);
4680     expect(Ok, status);
4681
4682     status = GdipGetClipBounds(graphics, &rect);
4683     expect(Ok, status);
4684     ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
4685        "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4686
4687     status = GdipSetEmpty(region);
4688     expect(Ok, status);
4689     status = GdipGetClip(graphics, region);
4690     expect(Ok, status);
4691     status = GdipGetRegionBounds(region, graphics, &rect);
4692     expect(Ok, status);
4693     ok(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0,
4694        "expected 45.0,20.0-50.0,25.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4695
4696     status = GdipGetRegionBounds(region100x100, graphics, &rect);
4697     expect(Ok, status);
4698     ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
4699        "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4700
4701     status = GdipGetRegionHRgn(region, NULL, &hrgn);
4702     expect(Ok, status);
4703     ret = GetRgnBox(hrgn, &rc);
4704     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4705     ok(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45,
4706        "expected 45,20-95,45, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4707     DeleteObject(hrgn);
4708
4709     status = GdipGetRegionHRgn(region, graphics, &hrgn);
4710     expect(Ok, status);
4711     ret = GetRgnBox(hrgn, &rc);
4712     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4713     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4714        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4715     DeleteObject(hrgn);
4716
4717     ptf[0].X = 100.0;
4718     ptf[0].Y = 100.0;
4719     ptf[1].X = 200.0;
4720     ptf[1].Y = 200.0;
4721     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4722     expect(Ok, status);
4723     ok(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0,
4724        "expected 45.0,20.0-95.0,45.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4725
4726     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
4727     expect(Ok, status);
4728     ret = GetRgnBox(hrgn, &rc);
4729     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4730     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4731        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4732     DeleteObject(hrgn);
4733
4734     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
4735     expect(Ok, status);
4736     ret = GetRgnBox(hrgn, &rc);
4737     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4738     ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
4739        "expected 210,420-410,820, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4740     DeleteObject(hrgn);
4741
4742     ptf[0].X = 210.0;
4743     ptf[0].Y = 420.0;
4744     ptf[1].X = 410.0;
4745     ptf[1].Y = 820.0;
4746     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4747     expect(Ok, status);
4748     ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
4749        "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4750
4751     GdipSetPageUnit(graphics, UnitPoint);
4752     expect(Ok, status);
4753
4754     status = GdipGetClipBounds(graphics, &rect);
4755     expect(Ok, status);
4756     ok((rect.X == 13.75 && rect.Y == 4.375 && rect.Width == 18.75 && rect.Height == 9.375) ||
4757        /* rounding under Wine is slightly different */
4758        (rect.X == 14.0 && rect.Y == 4.0 && rect.Width == 19.0 && rect.Height == 10.0) /* Wine */ ||
4759        broken(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0) /* before Win7 */,
4760        "expected 13.75,4.375-18.75,9.375, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4761
4762     status = GdipSetEmpty(region);
4763     expect(Ok, status);
4764     status = GdipGetClip(graphics, region);
4765     expect(Ok, status);
4766     status = GdipGetRegionBounds(region, graphics, &rect);
4767     expect(Ok, status);
4768     ok((rect.X == 13.75 && rect.Y == 4.375 && rect.Width == 18.75 && rect.Height == 9.375) ||
4769        /* rounding under Wine is slightly different */
4770        (rect.X == 14.0 && rect.Y == 4.0 && rect.Width == 19.0 && rect.Height == 10.0) /* Wine */ ||
4771        broken(rect.X == 45.0 && rect.Y == 20.0 && rect.Width == 50.0 && rect.Height == 25.0) /* before Win7 */,
4772        "expected 13.75,4.375-18.75,9.375, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4773
4774     status = GdipGetRegionBounds(region100x100, graphics, &rect);
4775     expect(Ok, status);
4776     ok(rect.X == 100.0 && rect.Y == 100.0 && rect.Width == 100.0 && rect.Height == 100.0,
4777        "expected 100.0,100.0-100.0,100.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4778
4779     status = GdipGetRegionHRgn(region, NULL, &hrgn);
4780     expect(Ok, status);
4781     ret = GetRgnBox(hrgn, &rc);
4782     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4783     ok((rc.left == 14 && rc.top == 5 && rc.right == 33 && rc.bottom == 14) ||
4784        /* rounding under Wine is slightly different */
4785        (rc.left == 14 && rc.top == 4 && rc.right == 33 && rc.bottom == 14) /* Wine */ ||
4786        broken(rc.left == 45 && rc.top == 20 && rc.right == 95 && rc.bottom == 45) /* before Win7 */,
4787        "expected 14,5-33,14, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4788     DeleteObject(hrgn);
4789
4790     status = GdipGetRegionHRgn(region, graphics, &hrgn);
4791     expect(Ok, status);
4792     ret = GetRgnBox(hrgn, &rc);
4793     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4794     ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
4795       broken(rc.left == 267 && rc.top == 267 && rc.right == 534 && rc.bottom == 534) /* before Win7 */,
4796        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4797     DeleteObject(hrgn);
4798
4799     ptf[0].X = 100.0;
4800     ptf[0].Y = 100.0;
4801     ptf[1].X = 200.0;
4802     ptf[1].Y = 200.0;
4803     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4804     expect(Ok, status);
4805     ok((ptf[0].X == 13.75 && ptf[0].Y == 4.375 && ptf[1].X == 32.5 && ptf[1].Y == 13.75) ||
4806        broken(ptf[0].X == 45.0 && ptf[0].Y == 20.0 && ptf[1].X == 95.0 && ptf[1].Y == 45.0) /* before Win7 */,
4807        "expected 13.75,4.375-32.5,13.75, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
4808
4809     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
4810     expect(Ok, status);
4811     ret = GetRgnBox(hrgn, &rc);
4812     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4813     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4814        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4815     DeleteObject(hrgn);
4816
4817     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
4818     expect(Ok, status);
4819     ret = GetRgnBox(hrgn, &rc);
4820     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4821     ok((rc.left == 560 && rc.top == 1120 && rc.right == 1094 && rc.bottom == 2187) ||
4822        /* rounding under Wine is slightly different */
4823        (rc.left == 560 && rc.top == 1120 && rc.right == 1093 && rc.bottom == 2187) /* Wine */,
4824        "expected 560,1120-1094,2187, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4825     DeleteObject(hrgn);
4826
4827     ptf[0].X = 560.0;
4828     ptf[0].Y = 1120.0;
4829     ptf[1].X = 1094.0;
4830     ptf[1].Y = 2187.0;
4831     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4832     expect(Ok, status);
4833     if (fabs(ptf[0].X - 100.0) < 0.001)
4834     {
4835         expectf(100.0, ptf[0].X);
4836         expectf(100.0, ptf[0].Y);
4837         expectf(200.125, ptf[1].X);
4838         expectf(200.03125, ptf[1].Y);
4839     }
4840     else /* before Win7 */
4841     {
4842         ok(broken(fabs(ptf[0].X - 275.0) < 0.001), "expected 275.0, got %f\n", ptf[0].X);
4843         ok(broken(fabs(ptf[0].Y - 275.0) < 0.001), "expected 275.0, got %f\n", ptf[0].Y);
4844         ok(broken(fabs(ptf[1].X - 542.0) < 0.001), "expected 542.0, got %f\n", ptf[1].X);
4845         ok(broken(fabs(ptf[1].Y - 541.75) < 0.001), "expected 541.75, got %f\n", ptf[1].Y);
4846     }
4847
4848     status = GdipTransformRegion(region100x100, matrix);
4849     expect(Ok, status);
4850
4851     status = GdipGetRegionBounds(region100x100, graphics, &rect);
4852     expect(Ok, status);
4853     ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
4854        "expected 210.0,420.0-200.0,400.0, got %.2f,%.2f-%.2f,%.2f\n", rect.X, rect.Y, rect.Width, rect.Height);
4855
4856     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
4857     expect(Ok, status);
4858     ret = GetRgnBox(hrgn, &rc);
4859     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4860     ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
4861        "expected 210,420-410,820, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4862     DeleteObject(hrgn);
4863
4864     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
4865     expect(Ok, status);
4866     ret = GetRgnBox(hrgn, &rc);
4867     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4868     ok((rc.left == 1147 && rc.top == 4534 && rc.right == 2214 && rc.bottom == 8800) ||
4869        /* rounding under Wine is slightly different */
4870        (rc.left == 1147 && rc.top == 4533 && rc.right == 2213 && rc.bottom == 8800) /* Wine */,
4871        "expected 1147,4534-2214,8800, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4872     DeleteObject(hrgn);
4873
4874     ptf[0].X = 1147.0;
4875     ptf[0].Y = 4534.0;
4876     ptf[1].X = 2214.0;
4877     ptf[1].Y = 8800.0;
4878     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
4879     expect(Ok, status);
4880     if (fabs(ptf[0].X - 210.0625) < 0.001)
4881     {
4882         expectf(210.0625, ptf[0].X);
4883         expectf(420.0625, ptf[0].Y);
4884         expectf(410.125, ptf[1].X);
4885         expectf(820.0, ptf[1].Y);
4886     }
4887     else /* before Win7 */
4888     {
4889         ok(broken(fabs(ptf[0].X - 568.5) < 0.001), "expected 568.5, got %f\n", ptf[0].X);
4890         ok(broken(fabs(ptf[0].Y - 1128.5) < 0.001), "expected 1128.5, got %f\n", ptf[0].Y);
4891         ok(broken(fabs(ptf[1].X - 1102.0) < 0.001), "expected 1102.0, got %f\n", ptf[1].X);
4892         ok(broken(fabs(ptf[1].Y - 2195.0) < 0.001), "expected 2195.0, got %f\n", ptf[1].Y);
4893     }
4894
4895     status = GdipRotateMatrix(matrix, 30.0, MatrixOrderAppend);
4896     expect(Ok, status);
4897     status = GdipSetWorldTransform(graphics, matrix);
4898     expect(Ok, status);
4899
4900     status = GdipGetClipBounds(graphics, &rect);
4901     expect(Ok, status);
4902     expectf_(20.612978, rect.X, 1.0);
4903     expectf_(-6.256012, rect.Y, 1.5);
4904     expectf_(25.612978, rect.Width, 1.0);
4905     expectf_(12.806489, rect.Height, 1.0);
4906
4907     status = GdipSetEmpty(region);
4908     expect(Ok, status);
4909     status = GdipGetClip(graphics, region);
4910     expect(Ok, status);
4911     status = GdipGetRegionBounds(region, graphics, &rect);
4912     expect(Ok, status);
4913    /* rounding under Wine is slightly different */
4914     expectf_(20.612978, rect.X, 1.0);
4915     expectf_(-6.256012, rect.Y, 1.5);
4916     expectf_(25.612978, rect.Width, 1.0);
4917     expectf_(12.806489, rect.Height, 1.0);
4918
4919     status = GdipGetRegionBounds(region100x100, graphics, &rect);
4920     expect(Ok, status);
4921     ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
4922        "expected 210.0,420.0-200.0,400.0, got %f,%f-%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
4923
4924     status = GdipGetRegionHRgn(region, NULL, &hrgn);
4925     expect(Ok, status);
4926     ret = GetRgnBox(hrgn, &rc);
4927     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
4928     ok((rc.left == 22 && rc.top == -6 && rc.right == 46 && rc.bottom == 7) ||
4929        /* rounding under Wine is slightly different */
4930        (rc.left == 21 && rc.top == -5 && rc.right == 46 && rc.bottom == 7) /* Wine */,
4931        "expected (22,-6)-(46,7), got (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
4932     DeleteObject(hrgn);
4933
4934     status = GdipGetRegionHRgn(region, graphics, &hrgn);
4935     expect(Ok, status);
4936     ret = GetRgnBox(hrgn, &rc);
4937     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4938     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
4939        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4940     DeleteObject(hrgn);
4941
4942     ptf[0].X = 100.0;
4943     ptf[0].Y = 100.0;
4944     ptf[1].X = 200.0;
4945     ptf[1].Y = 200.0;
4946     ptf[2].X = 200.0;
4947     ptf[2].Y = 100.0;
4948     ptf[3].X = 100.0;
4949     ptf[3].Y = 200.0;
4950     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
4951     expect(Ok, status);
4952     expectf(20.612978, ptf[0].X);
4953     expectf(-1.568512, ptf[0].Y);
4954     expectf(46.225956, ptf[1].X);
4955     expectf(1.862977, ptf[1].Y);
4956     expectf(36.850956, ptf[2].X);
4957     expectf(-6.256012, ptf[2].Y);
4958     expectf(29.987980, ptf[3].X);
4959     expectf(6.550478, ptf[3].Y);
4960
4961     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
4962     expect(Ok, status);
4963     ret = GetRgnBox(hrgn, &rc);
4964     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
4965     ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
4966        "expected 210,420-410,820, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
4967     DeleteObject(hrgn);
4968
4969     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
4970     expect(Ok, status);
4971     ret = GetRgnBox(hrgn, &rc);
4972     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
4973     ok((rc.left == -3406 && rc.top == 4500 && rc.right == -350 && rc.bottom == 8728) ||
4974        /* rounding under Wine is slightly different */
4975        (rc.left == -3407 && rc.top == 4500 && rc.right == -350 && rc.bottom == 8728) /* Wine */,
4976        "expected (-3406,4500)-(-350,8728), got (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
4977     DeleteObject(hrgn);
4978
4979     ptf[0].X = -3406.0;
4980     ptf[0].Y = 4500.0;
4981     ptf[1].X = -350.0;
4982     ptf[1].Y = 8728.0;
4983     ptf[2].X = -350.0;
4984     ptf[2].Y = 4500.0;
4985     ptf[3].X = -3406.0;
4986     ptf[3].Y = 8728.0;
4987     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
4988     expect(Ok, status);
4989     expectf(-136.190491, ptf[0].X);
4990     expectf(520.010742, ptf[0].Y);
4991     expectf(756.417175, ptf[1].X);
4992     expectf(720.031616, ptf[1].Y);
4993     expectf(360.042114, ptf[2].X);
4994     expectf(376.760742, ptf[2].Y);
4995     expectf(260.184570, ptf[3].X);
4996     expectf(863.281616, ptf[3].Y);
4997
4998     status = GdipRotateMatrix(matrix, -90.0, MatrixOrderAppend);
4999     expect(Ok, status);
5000     status = GdipSetWorldTransform(graphics, matrix);
5001     expect(Ok, status);
5002
5003     status = GdipGetClipBounds(graphics, &rect);
5004     expect(Ok, status);
5005     expectf_(-28.100956, rect.X, 1.0);
5006     expectf_(7.806488, rect.Y, 1.5);
5007     expectf_(25.612978, rect.Width, 1.0);
5008     expectf_(12.806489, rect.Height, 1.0);
5009
5010     status = GdipSetEmpty(region);
5011     expect(Ok, status);
5012     status = GdipGetClip(graphics, region);
5013     expect(Ok, status);
5014     status = GdipGetRegionBounds(region, graphics, &rect);
5015     expect(Ok, status);
5016    /* rounding under Wine is slightly different */
5017     expectf_(-28.100956, rect.X, 1.0);
5018     expectf_(7.806488, rect.Y, 1.5);
5019     expectf_(25.612978, rect.Width, 1.0);
5020     expectf_(12.806489, rect.Height, 1.0);
5021
5022     status = GdipGetRegionBounds(region100x100, graphics, &rect);
5023     expect(Ok, status);
5024     ok(rect.X == 210.0 && rect.Y == 420.0 && rect.Width == 200.0 && rect.Height == 400.0,
5025        "expected 210.0,420.0-200.0,400.0, got %f,%f-%f,%f\n", rect.X, rect.Y, rect.Width, rect.Height);
5026
5027     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5028     expect(Ok, status);
5029     ret = GetRgnBox(hrgn, &rc);
5030     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
5031     ok((rc.left == -27 && rc.top == 8 && rc.right == -2 && rc.bottom == 21) ||
5032        /* rounding under Wine is slightly different */
5033        (rc.left == -28 && rc.top == 9 && rc.right == -2 && rc.bottom == 21) /* Wine */,
5034        "expected (-27,8)-(-2,21), got (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
5035     DeleteObject(hrgn);
5036
5037     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5038     expect(Ok, status);
5039     ret = GetRgnBox(hrgn, &rc);
5040     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5041     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5042        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5043     DeleteObject(hrgn);
5044
5045     ptf[0].X = 100.0;
5046     ptf[0].Y = 100.0;
5047     ptf[1].X = 200.0;
5048     ptf[1].Y = 200.0;
5049     ptf[2].X = 200.0;
5050     ptf[2].Y = 100.0;
5051     ptf[3].X = 100.0;
5052     ptf[3].Y = 200.0;
5053     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
5054     expect(Ok, status);
5055     expectf(-11.862979, ptf[0].X);
5056     expectf(7.806488, ptf[0].Y);
5057     expectf(-18.725958, ptf[1].X);
5058     expectf(20.612976, ptf[1].Y);
5059     expectf(-2.487981, ptf[2].X);
5060     expectf(15.925477, ptf[2].Y);
5061     expectf(-28.100956, ptf[3].X);
5062     expectf(12.493987, ptf[3].Y);
5063
5064     status = GdipGetRegionHRgn(region100x100, NULL, &hrgn);
5065     expect(Ok, status);
5066     ret = GetRgnBox(hrgn, &rc);
5067     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5068     ok(rc.left == 210 && rc.top == 420 && rc.right == 410 && rc.bottom == 820,
5069        "expected 210,420-410,820, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5070     DeleteObject(hrgn);
5071
5072     status = GdipGetRegionHRgn(region100x100, graphics, &hrgn);
5073     expect(Ok, status);
5074     ret = GetRgnBox(hrgn, &rc);
5075     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
5076     ok((rc.left == 4500 && rc.top == 351 && rc.right == 8728 && rc.bottom == 3407) ||
5077        /* rounding under Wine is slightly different */
5078        (rc.left == 4499 && rc.top == 351 && rc.right == 8728 && rc.bottom == 3407) /* Wine */,
5079        "expected (4500,351)-(8728,3407), got (%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
5080     DeleteObject(hrgn);
5081
5082     ptf[0].X = -3406.0;
5083     ptf[0].Y = 4500.0;
5084     ptf[1].X = -350.0;
5085     ptf[1].Y = 8728.0;
5086     ptf[2].X = -350.0;
5087     ptf[2].Y = 4500.0;
5088     ptf[3].X = -3406.0;
5089     ptf[3].Y = 8728.0;
5090     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
5091     expect(Ok, status);
5092     expectf(-1055.021484, ptf[0].X);
5093     expectf(-70.595329, ptf[0].Y);
5094     expectf(-1455.063232, ptf[1].X);
5095     expectf(375.708435, ptf[1].Y);
5096     expectf(-768.521484, ptf[2].X);
5097     expectf(177.520981, ptf[2].Y);
5098     expectf(-1741.563110, ptf[3].X);
5099     expectf(127.592125, ptf[3].Y);
5100
5101     GdipDeleteMatrix(matrix);
5102     GdipDeleteRegion(region);
5103     GdipDeleteRegion(region100x100);
5104     GdipDeleteGraphics(graphics);
5105     DeleteDC(hdc);
5106 }
5107
5108 static void test_clipping_2(void)
5109 {
5110
5111     HDC hdc;
5112     GpStatus status;
5113     GpGraphics *graphics;
5114     GpRegion *region;
5115     GpMatrix *matrix;
5116     GpRectF rect;
5117     GpPointF ptf[4];
5118     GpUnit unit;
5119     HRGN hrgn;
5120     int ret;
5121     RECT rc;
5122
5123     hdc = CreateCompatibleDC(0);
5124     status = GdipCreateFromHDC(hdc, &graphics);
5125     expect(Ok, status);
5126
5127     status = GdipGetPageUnit(graphics, &unit);
5128     expect(Ok, status);
5129     expect(UnitDisplay, unit);
5130
5131     GdipSetPageUnit(graphics, UnitInch);
5132
5133     status = GdipCreateRegion(&region);
5134     expect(Ok, status);
5135     status = GdipSetEmpty(region);
5136     expect(Ok, status);
5137     rect.X = rect.Y = 100.0;
5138     rect.Width = rect.Height = 100.0;
5139     status = GdipCombineRegionRect(region, &rect, CombineModeUnion);
5140     expect(Ok, status);
5141     status = GdipSetClipRegion(graphics, region, CombineModeReplace);
5142     expect(Ok, status);
5143
5144     status = GdipGetClip(graphics, region);
5145     expect(Ok, status);
5146     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5147     expect(Ok, status);
5148     ret = GetRgnBox(hrgn, &rc);
5149     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5150     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5151        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5152     DeleteObject(hrgn);
5153     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5154     expect(Ok, status);
5155     ret = GetRgnBox(hrgn, &rc);
5156     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5157     ok(rc.left == 9600 && rc.top == 9600 && rc.right == 19200 && rc.bottom == 19200,
5158        "expected 9600,9600-19200,19200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5159     DeleteObject(hrgn);
5160
5161     ptf[0].X = 9600.0;
5162     ptf[0].Y = 9600.0;
5163     ptf[1].X = 19200.0;
5164     ptf[1].Y = 19200.0;
5165     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5166     expect(Ok, status);
5167     expectf(100.0, ptf[0].X);
5168     expectf(100.0, ptf[0].Y);
5169     expectf(200.0, ptf[1].X);
5170     expectf(200.0, ptf[1].X);
5171
5172     GdipSetPageUnit(graphics, UnitPoint);
5173
5174     status = GdipGetClip(graphics, region);
5175     expect(Ok, status);
5176     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5177     expect(Ok, status);
5178     ret = GetRgnBox(hrgn, &rc);
5179     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5180     ok((rc.left == 7200 && rc.top == 7200 && rc.right == 14400 && rc.bottom == 14400) ||
5181        broken(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) /* before Win7 */,
5182        "expected 7200,7200-14400,14400, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5183     DeleteObject(hrgn);
5184     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5185     expect(Ok, status);
5186     ret = GetRgnBox(hrgn, &rc);
5187     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5188     ok((rc.left == 9600 && rc.top == 9600 && rc.right == 19200 && rc.bottom == 19200) ||
5189        broken(rc.left == 134 && rc.top == 134 && rc.right == 267 && rc.bottom == 267) /* before Win7 */,
5190        "expected 9600,9600-19200,19200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5191     DeleteObject(hrgn);
5192
5193     ptf[0].X = 9600.0;
5194     ptf[0].Y = 9600.0;
5195     ptf[1].X = 19200.0;
5196     ptf[1].Y = 19200.0;
5197     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5198     expect(Ok, status);
5199     if (fabs(ptf[0].X - 7200.0) < 0.001)
5200         ok(ptf[0].X == 7200.0 && ptf[0].Y == 7200.0 && ptf[1].X == 14400.0 && ptf[1].Y == 14400.0,
5201            "expected 7200.0,7200.0-14400.0,14400.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
5202     else /* before Win7 */
5203     {
5204         ok(broken(fabs(ptf[0].X - 100.0) < 0.001), "expected 100.0, got %f\n", ptf[0].X);
5205         ok(broken(fabs(ptf[0].Y - 100.0) < 0.001), "expected 100.0, got %f\n", ptf[0].Y);
5206         ok(broken(fabs(ptf[1].X - 200.0) < 0.001), "expected 200.0, got %f\n", ptf[1].X);
5207         ok(broken(fabs(ptf[1].Y - 200.0) < 0.001), "expected 200.0, got %f\n", ptf[1].Y);
5208     }
5209
5210     GdipDeleteRegion(region);
5211
5212     GdipSetPageUnit(graphics, UnitPixel);
5213
5214     status = GdipCreateRegion(&region);
5215     expect(Ok, status);
5216     status = GdipSetEmpty(region);
5217     expect(Ok, status);
5218     rect.X = rect.Y = 100.0;
5219     rect.Width = rect.Height = 100.0;
5220     status = GdipCombineRegionRect(region, &rect, CombineModeUnion);
5221     expect(Ok, status);
5222     status = GdipSetClipRegion(graphics, region, CombineModeReplace);
5223     expect(Ok, status);
5224
5225     status = GdipGetClip(graphics, region);
5226     expect(Ok, status);
5227     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5228     expect(Ok, status);
5229     ret = GetRgnBox(hrgn, &rc);
5230     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5231     ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
5232        broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
5233        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5234     DeleteObject(hrgn);
5235     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5236     expect(Ok, status);
5237     ret = GetRgnBox(hrgn, &rc);
5238     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5239     ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
5240        broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
5241        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5242     DeleteObject(hrgn);
5243
5244     ptf[0].X = 100.0;
5245     ptf[0].Y = 100.0;
5246     ptf[1].X = 200.0;
5247     ptf[1].Y = 200.0;
5248     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5249     expect(Ok, status);
5250     if (fabs(ptf[0].X - 100.0) < 0.001)
5251         ok(ptf[0].X == 100.0 && ptf[0].Y == 100.0 && ptf[1].X == 200.0 && ptf[1].Y == 200.0,
5252            "expected 100.0,100.0-200.0,200.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
5253     else /* before Win7 */
5254     {
5255         ok(broken(fabs(ptf[0].X - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].X);
5256         ok(broken(fabs(ptf[0].Y - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].Y);
5257         ok(broken(fabs(ptf[1].X - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].X);
5258         ok(broken(fabs(ptf[1].Y - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].Y);
5259     }
5260
5261     GdipSetPageUnit(graphics, UnitPoint);
5262
5263     status = GdipGetClip(graphics, region);
5264     expect(Ok, status);
5265     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5266     expect(Ok, status);
5267     ret = GetRgnBox(hrgn, &rc);
5268     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5269     ok((rc.left == 75 && rc.top == 75 && rc.right == 150 && rc.bottom == 150) ||
5270        broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
5271        "expected 75,75-150,150, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5272     DeleteObject(hrgn);
5273     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5274     expect(Ok, status);
5275     ret = GetRgnBox(hrgn, &rc);
5276     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5277     ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
5278        broken(rc.left == 2 && rc.top == 2 && rc.right == 3 && rc.bottom == 3) /* before Win7 */,
5279        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5280     DeleteObject(hrgn);
5281
5282     ptf[0].X = 100.0;
5283     ptf[0].Y = 100.0;
5284     ptf[1].X = 200.0;
5285     ptf[1].Y = 200.0;
5286     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5287     expect(Ok, status);
5288     if (fabs(ptf[0].X - 75.0) < 0.001)
5289         ok(ptf[0].X == 75.0 && ptf[0].Y == 75.0 && ptf[1].X == 150.0 && ptf[1].Y == 150.0,
5290            "expected 75.0,75.0-150.0,150.0, got %f,%f-%f,%f\n", ptf[0].X, ptf[0].Y, ptf[1].X, ptf[1].Y);
5291     else /* before Win7 */
5292     {
5293         ok(broken(fabs(ptf[0].X - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].X);
5294         ok(broken(fabs(ptf[0].Y - 1.041667) < 0.001), "expected 1.041667, got %f\n", ptf[0].Y);
5295         ok(broken(fabs(ptf[1].X - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].X);
5296         ok(broken(fabs(ptf[1].Y - 2.083333) < 0.001), "expected 2.083333, got %f\n", ptf[1].Y);
5297     }
5298
5299     status = GdipCreateMatrix(&matrix);
5300     expect(Ok, status);
5301     status = GdipTranslateMatrix(matrix, 10.0, 10.0, MatrixOrderAppend);
5302     expect(Ok, status);
5303     status = GdipSetWorldTransform(graphics, matrix);
5304     expect(Ok, status);
5305     GdipDeleteMatrix(matrix);
5306
5307     status = GdipGetClip(graphics, region);
5308     expect(Ok, status);
5309     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5310     expect(Ok, status);
5311     ret = GetRgnBox(hrgn, &rc);
5312     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5313     ok(rc.left == 65 && rc.top == 65 && rc.right == 140 && rc.bottom == 140,
5314        "expected 65,65-140,140, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5315     DeleteObject(hrgn);
5316     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5317     expect(Ok, status);
5318     ret = GetRgnBox(hrgn, &rc);
5319     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5320     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5321        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5322     DeleteObject(hrgn);
5323
5324     ptf[0].X = 100.0;
5325     ptf[0].Y = 100.0;
5326     ptf[1].X = 200.0;
5327     ptf[1].Y = 200.0;
5328     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5329     expect(Ok, status);
5330     expectf(65.0, ptf[0].X);
5331     expectf(65.0, ptf[0].Y);
5332     expectf(140.0, ptf[1].X);
5333     expectf(140.0, ptf[1].X);
5334
5335     status = GdipCreateMatrix(&matrix);
5336     expect(Ok, status);
5337     status = GdipScaleMatrix(matrix, 0.25, 0.5, MatrixOrderAppend);
5338     expect(Ok, status);
5339     status = GdipSetWorldTransform(graphics, matrix);
5340     expect(Ok, status);
5341     GdipDeleteMatrix(matrix);
5342
5343     status = GdipGetClip(graphics, region);
5344     expect(Ok, status);
5345     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5346     expect(Ok, status);
5347     ret = GetRgnBox(hrgn, &rc);
5348     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5349     ok(rc.left == 300 && rc.top == 150 && rc.right == 600 && rc.bottom == 300,
5350        "expected 300,150-600,300, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5351     DeleteObject(hrgn);
5352     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5353     expect(Ok, status);
5354     ret = GetRgnBox(hrgn, &rc);
5355     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5356     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5357        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5358     DeleteObject(hrgn);
5359
5360     ptf[0].X = 100.0;
5361     ptf[0].Y = 100.0;
5362     ptf[1].X = 200.0;
5363     ptf[1].Y = 200.0;
5364     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5365     expect(Ok, status);
5366     expectf(300.0, ptf[0].X);
5367     expectf(150.0, ptf[0].Y);
5368     expectf(600.0, ptf[1].X);
5369     expectf(300.0, ptf[1].Y);
5370
5371     status = GdipSetPageScale(graphics, 2.0);
5372     expect(Ok, status);
5373
5374     status = GdipGetClip(graphics, region);
5375     expect(Ok, status);
5376     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5377     expect(Ok, status);
5378     ret = GetRgnBox(hrgn, &rc);
5379     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5380     ok((rc.left == 150 && rc.top == 75 && rc.right == 300 && rc.bottom == 150) ||
5381        broken(rc.left == 300 && rc.top == 150 && rc.right == 600 && rc.bottom == 300) /* before Win7 */,
5382        "expected 150,75-300,150, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5383     DeleteObject(hrgn);
5384     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5385     expect(Ok, status);
5386     ret = GetRgnBox(hrgn, &rc);
5387     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5388     ok((rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200) ||
5389        broken(rc.left == 200 && rc.top == 200 && rc.right == 400 && rc.bottom == 400) /* before Win7 */,
5390        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5391     DeleteObject(hrgn);
5392
5393     ptf[0].X = 100.0;
5394     ptf[0].Y = 100.0;
5395     ptf[1].X = 200.0;
5396     ptf[1].Y = 200.0;
5397     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
5398     expect(Ok, status);
5399     if (fabs(ptf[0].X - 150.0) < 0.001)
5400     {
5401         expectf(150.0, ptf[0].X);
5402         expectf(75.0, ptf[0].Y);
5403         expectf(300.0, ptf[1].X);
5404         expectf(150.0, ptf[1].Y);
5405     }
5406     else /* before Win7 */
5407     {
5408         ok(broken(fabs(ptf[0].X - 300.0) < 0.001), "expected 300.0, got %f\n", ptf[0].X);
5409         ok(broken(fabs(ptf[0].Y - 150.0) < 0.001), "expected 150.0, got %f\n", ptf[0].Y);
5410         ok(broken(fabs(ptf[1].X - 600.0) < 0.001), "expected 600.0, got %f\n", ptf[1].X);
5411         ok(broken(fabs(ptf[1].Y - 300.0) < 0.001), "expected 300.0, got %f\n", ptf[1].Y);
5412     }
5413
5414     status = GdipCreateMatrix(&matrix);
5415     expect(Ok, status);
5416     status = GdipRotateMatrix(matrix, 45.0, MatrixOrderAppend);
5417     expect(Ok, status);
5418     status = GdipSetWorldTransform(graphics, matrix);
5419     expect(Ok, status);
5420     GdipDeleteMatrix(matrix);
5421
5422     status = GdipGetClip(graphics, region);
5423     expect(Ok, status);
5424     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5425     expect(Ok, status);
5426     ret = GetRgnBox(hrgn, &rc);
5427     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
5428     ok((rc.left == 54 && rc.top == -26 && rc.right == 107 && rc.bottom == 27) ||
5429        /* rounding under Wine is slightly different */
5430        (rc.left == 53 && rc.top == -26 && rc.right == 106 && rc.bottom == 27) /* Wine */,
5431        "expected 54,-26-107,27, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5432     DeleteObject(hrgn);
5433     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5434     expect(Ok, status);
5435     ret = GetRgnBox(hrgn, &rc);
5436     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5437     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5438        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5439     DeleteObject(hrgn);
5440
5441     ptf[0].X = 100.0;
5442     ptf[0].Y = 100.0;
5443     ptf[1].X = 200.0;
5444     ptf[1].Y = 200.0;
5445     ptf[2].X = 200.0;
5446     ptf[2].Y = 100.0;
5447     ptf[3].X = 100.0;
5448     ptf[3].Y = 200.0;
5449     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
5450     expect(Ok, status);
5451     expectf(53.033016, ptf[0].X);
5452     expectf(0.0, ptf[0].Y);
5453     expectf(106.066032, ptf[1].X);
5454     expectf(0.0, ptf[1].Y);
5455     expectf(79.549522, ptf[2].X);
5456     expectf(-26.516510, ptf[2].Y);
5457     expectf(79.549522, ptf[3].X);
5458     expectf(26.516508, ptf[3].Y);
5459
5460     status = GdipCreateMatrix(&matrix);
5461     expect(Ok, status);
5462     status = GdipRotateMatrix(matrix, -45.0, MatrixOrderAppend);
5463     expect(Ok, status);
5464     status = GdipSetWorldTransform(graphics, matrix);
5465     expect(Ok, status);
5466     GdipDeleteMatrix(matrix);
5467
5468     status = GdipGetClip(graphics, region);
5469     expect(Ok, status);
5470     status = GdipGetRegionHRgn(region, NULL, &hrgn);
5471     expect(Ok, status);
5472     ret = GetRgnBox(hrgn, &rc);
5473     ok(ret == COMPLEXREGION, "expected COMPLEXREGION, got %d\n", ret);
5474     ok((rc.left == -26 && rc.top == 54 && rc.right == 27 && rc.bottom == 107) ||
5475        /* rounding under Wine is slightly different */
5476        (rc.left == -27 && rc.top == 54 && rc.right == 27 && rc.bottom == 106) /* Wine */,
5477        "expected -26,54-27,107, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5478     DeleteObject(hrgn);
5479     status = GdipGetRegionHRgn(region, graphics, &hrgn);
5480     expect(Ok, status);
5481     ret = GetRgnBox(hrgn, &rc);
5482     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
5483     ok(rc.left == 100 && rc.top == 100 && rc.right == 200 && rc.bottom == 200,
5484        "expected 100,100-200,200, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
5485     DeleteObject(hrgn);
5486
5487     ptf[0].X = 100.0;
5488     ptf[0].Y = 100.0;
5489     ptf[1].X = 200.0;
5490     ptf[1].Y = 200.0;
5491     ptf[2].X = 200.0;
5492     ptf[2].Y = 100.0;
5493     ptf[3].X = 100.0;
5494     ptf[3].Y = 200.0;
5495     status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 4);
5496     expect(Ok, status);
5497     expectf(0.0, ptf[0].X);
5498     expectf(53.033005, ptf[0].Y);
5499     expectf(0.0, ptf[1].X);
5500     expectf(106.066010, ptf[1].Y);
5501     expectf(26.516491, ptf[2].X);
5502     expectf(79.549507, ptf[2].Y);
5503     expectf(-26.516520, ptf[3].X);
5504     expectf(79.549500, ptf[3].Y);
5505
5506     GdipDeleteRegion(region);
5507     GdipDeleteGraphics(graphics);
5508     DeleteDC(hdc);
5509 }
5510
5511
5512 static void test_GdipFillRectangles(void)
5513 {
5514     GpStatus status;
5515     GpGraphics *graphics = NULL;
5516     GpBrush *brush = NULL;
5517     HDC hdc = GetDC( hwnd );
5518     GpRectF rects[2] = {{0,0,10,10}, {10,10,10,10}};
5519
5520     ok(hdc != NULL, "Expected HDC to be initialized\n");
5521
5522     status = GdipCreateFromHDC(hdc, &graphics);
5523     expect(Ok, status);
5524     ok(graphics != NULL, "Expected graphics to be initialized\n");
5525
5526     status = GdipCreateSolidFill((ARGB)0xffff00ff, (GpSolidFill**)&brush);
5527     expect(Ok, status);
5528     ok(brush != NULL, "Expected brush to be initialized\n");
5529
5530     status = GdipFillRectangles(NULL, brush, rects, 2);
5531     expect(InvalidParameter, status);
5532
5533     status = GdipFillRectangles(graphics, NULL, rects, 2);
5534     expect(InvalidParameter, status);
5535
5536     status = GdipFillRectangles(graphics, brush, NULL, 2);
5537     expect(InvalidParameter, status);
5538
5539     status = GdipFillRectangles(graphics, brush, rects, 0);
5540     expect(InvalidParameter, status);
5541
5542     status = GdipFillRectangles(graphics, brush, rects, -1);
5543     expect(InvalidParameter, status);
5544
5545     status = GdipFillRectangles(graphics, brush, rects, 1);
5546     expect(Ok, status);
5547
5548     status = GdipFillRectangles(graphics, brush, rects, 2);
5549     expect(Ok, status);
5550
5551     GdipDeleteBrush(brush);
5552     GdipDeleteGraphics(graphics);
5553
5554     ReleaseDC(hwnd, hdc);
5555 }
5556
5557 static void test_GdipGetVisibleClipBounds_memoryDC(void)
5558 {
5559     HDC hdc,dc;
5560     HBITMAP bmp;
5561     HGDIOBJ old;
5562     RECT rect;
5563     POINT pt;
5564     int width = 0;
5565     int height = 0;
5566     GpGraphics* graphics = NULL;
5567     GpRect boundRect;
5568     GpStatus status;
5569
5570     ok(GetClientRect(hwnd, &rect), "GetClientRect should have succeeded\n");
5571     width = rect.right - rect.left;
5572     height = rect.bottom - rect.top;
5573
5574     dc = GetDC(hwnd);
5575     hdc = CreateCompatibleDC ( dc );
5576     bmp = CreateCompatibleBitmap ( dc, width, height );
5577     old = SelectObject (hdc, bmp);
5578
5579     /*change the window origin is the key test point*/
5580     SetWindowOrgEx (hdc, rect.left+10, rect.top+10, &pt);
5581
5582     status = GdipCreateFromHDC(hdc, &graphics);
5583     expect(Ok, status);
5584
5585     status = GdipGetVisibleClipBoundsI(graphics, &boundRect);
5586     expect(Ok, status);
5587
5588     ok(boundRect.X==rect.left+10 &&
5589        boundRect.Y==rect.top+10 &&
5590        boundRect.Width==width &&
5591        boundRect.Height==height, "Expected GdipGetVisibleClipBoundsI ok\n");
5592
5593     status = GdipSetClipRectI(graphics, 0, 0, width, height, CombineModeReplace);
5594     expect(Ok, status);
5595
5596     status = GdipGetVisibleClipBoundsI(graphics, &boundRect);
5597     expect(Ok, status);
5598
5599     ok(boundRect.X==rect.left+10 &&
5600        boundRect.Y==rect.top+10 &&
5601        boundRect.Width==width-10 &&
5602        boundRect.Height==height-10, "Expected GdipGetVisibleClipBoundsI ok\n");
5603
5604     GdipDeleteGraphics(graphics);
5605
5606     SelectObject (hdc, old);
5607     DeleteObject (bmp);
5608     DeleteDC (hdc);
5609     ReleaseDC(hwnd, dc);
5610 }
5611
5612 START_TEST(graphics)
5613 {
5614     struct GdiplusStartupInput gdiplusStartupInput;
5615     ULONG_PTR gdiplusToken;
5616     WNDCLASSA class;
5617
5618     memset( &class, 0, sizeof(class) );
5619     class.lpszClassName = "gdiplus_test";
5620     class.style = CS_HREDRAW | CS_VREDRAW;
5621     class.lpfnWndProc = DefWindowProcA;
5622     class.hInstance = GetModuleHandleA(0);
5623     class.hIcon = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
5624     class.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
5625     class.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5626     RegisterClassA( &class );
5627     hwnd = CreateWindowA( "gdiplus_test", "graphics test", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5628                           CW_USEDEFAULT, CW_USEDEFAULT, 200, 200, 0, 0, GetModuleHandleA(0), 0 );
5629     ok(hwnd != NULL, "Expected window to be created\n");
5630
5631     gdiplusStartupInput.GdiplusVersion              = 1;
5632     gdiplusStartupInput.DebugEventCallback          = NULL;
5633     gdiplusStartupInput.SuppressBackgroundThread    = 0;
5634     gdiplusStartupInput.SuppressExternalCodecs      = 0;
5635
5636     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
5637
5638     test_clipping();
5639     test_clipping_2();
5640     test_measured_extra_space();
5641     test_measure_string();
5642     test_font_height_scaling();
5643     test_transform();
5644     test_GdipMeasureString();
5645     test_constructor_destructor();
5646     test_save_restore();
5647     test_GdipFillClosedCurve2();
5648     test_GdipFillClosedCurve2I();
5649     test_GdipDrawBezierI();
5650     test_GdipDrawArc();
5651     test_GdipDrawArcI();
5652     test_GdipDrawCurve();
5653     test_GdipDrawCurveI();
5654     test_GdipDrawCurve2();
5655     test_GdipDrawCurve2I();
5656     test_GdipDrawCurve3();
5657     test_GdipDrawCurve3I();
5658     test_GdipDrawLineI();
5659     test_GdipDrawLinesI();
5660     test_GdipDrawImagePointsRect();
5661     test_GdipFillClosedCurve();
5662     test_GdipFillClosedCurveI();
5663     test_GdipDrawString();
5664     test_GdipGetNearestColor();
5665     test_GdipGetVisibleClipBounds();
5666     test_GdipIsVisiblePoint();
5667     test_GdipIsVisibleRect();
5668     test_Get_Release_DC();
5669     test_BeginContainer2();
5670     test_transformpoints();
5671     test_get_set_clip();
5672     test_isempty();
5673     test_clear();
5674     test_textcontrast();
5675     test_fromMemoryBitmap();
5676     test_string_functions();
5677     test_get_set_interpolation();
5678     test_get_set_textrenderinghint();
5679     test_getdc_scaled();
5680     test_alpha_hdc();
5681     test_bitmapfromgraphics();
5682     test_GdipFillRectangles();
5683     test_GdipGetVisibleClipBounds_memoryDC();
5684
5685     GdiplusShutdown(gdiplusToken);
5686     DestroyWindow( hwnd );
5687 }