git.oblomov.eu Git - wine/blob - dlls/gdi32/tests/metafile.c

   1 /*
   2  * Unit tests for metafile functions
   3  *
   4  * Copyright (c) 2002 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <stdio.h>
  23 #include <math.h>
  24
  25 #include "wine/test.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "winerror.h"
  30
  31 static LOGFONTA orig_lf;
  32 static BOOL emr_processed = FALSE;
  33
  34 /* Arbitrarily chosen values for the second co-ordinate of a metafile line */
  35 #define LINE_X 55.0f
  36 #define LINE_Y 15.0f
  37
  38 static INT (WINAPI * pGetRelAbs)(HDC, DWORD);
  39 static INT (WINAPI * pSetRelAbs)(HDC, INT);
  40
  41 #define GDI_GET_PROC(func)                                     \
  42     p ## func = (void *)GetProcAddress(hGDI, #func);           \
  43     if(!p ## func)                                             \
  44         trace("GetProcAddress(hGDI, \"%s\") failed\n", #func); \
  45
  46 static void init_function_pointers(void)
  47 {
  48     HMODULE hGDI;
  49
  50     pGetRelAbs = NULL;
  51     pSetRelAbs = NULL;
  52
  53     hGDI = GetModuleHandleA("gdi32.dll");
  54     assert(hGDI);
  55     GDI_GET_PROC(GetRelAbs);
  56     GDI_GET_PROC(SetRelAbs);
  57 }
  58
  59 static int CALLBACK eto_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
  60     const ENHMETARECORD *emr, int n_objs, LPARAM param)
  61 {
  62     static int n_record;
  63     DWORD i;
  64     const INT *dx;
  65     INT *orig_dx = (INT *)param;
  66     LOGFONTA device_lf;
  67     INT ret;
  68
  69     trace("hdc %p, emr->iType %d, emr->nSize %d, param %p\n",
  70            hdc, emr->iType, emr->nSize, (void *)param);
  71
  72     if(!hdc) return 1;
  73
  74     PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
  75
  76     switch (emr->iType)
  77     {
  78     case EMR_HEADER:
  79         ok(GetTextAlign(hdc) == 0, "text align %08x\n", GetTextAlign(hdc));
  80         ok(GetBkColor(hdc) == RGB(0xff, 0xff, 0xff), "bk color %08x\n", GetBkColor(hdc));
  81         ok(GetTextColor(hdc) == RGB(0x0, 0x0, 0x0), "text color %08x\n", GetTextColor(hdc));
  82         ok(GetROP2(hdc) == R2_COPYPEN, "rop %d\n", GetROP2(hdc));
  83         ok(GetArcDirection(hdc) == AD_COUNTERCLOCKWISE, "arc dir %d\n", GetArcDirection(hdc));
  84         ok(GetPolyFillMode(hdc) == ALTERNATE, "poly fill %d\n", GetPolyFillMode(hdc));
  85         ok(GetStretchBltMode(hdc) == BLACKONWHITE, "stretchblt mode %d\n", GetStretchBltMode(hdc));
  86
  87         /* GetBkMode, GetRelAbs do not get reset to the default value */
  88         ok(GetBkMode(hdc) == OPAQUE, "bk mode %d\n", GetBkMode(hdc));
  89         if(pSetRelAbs && pGetRelAbs)
  90             ok(pGetRelAbs(hdc, 0) == RELATIVE, "relabs %d\n", pGetRelAbs(hdc, 0));
  91
  92         n_record = 0;
  93         break;
  94
  95     case EMR_EXTTEXTOUTA:
  96     {
  97         const EMREXTTEXTOUTA *emr_ExtTextOutA = (const EMREXTTEXTOUTA *)emr;
  98         dx = (const INT *)((const char *)emr + emr_ExtTextOutA->emrtext.offDx);
  99
 100         ret = GetObjectA(GetCurrentObject(hdc, OBJ_FONT), sizeof(device_lf), &device_lf);
 101         ok( ret == sizeof(device_lf), "GetObjectA error %d\n", GetLastError());
 102
 103         /* compare up to lfOutPrecision, other values are not interesting,
 104          * and in fact sometimes arbitrary adapted by Win9x.
 105          */
 106         ok(!memcmp(&orig_lf, &device_lf, FIELD_OFFSET(LOGFONTA, lfOutPrecision)), "fonts don't match\n");
 107         ok(!lstrcmpA(orig_lf.lfFaceName, device_lf.lfFaceName), "font names don't match\n");
 108
 109         for(i = 0; i < emr_ExtTextOutA->emrtext.nChars; i++)
 110         {
 111             ok(orig_dx[i] == dx[i], "pass %d: dx[%d] (%d) didn't match %d\n",
 112                                      n_record, i, dx[i], orig_dx[i]);
 113         }
 114         n_record++;
 115         emr_processed = TRUE;
 116         break;
 117     }
 118
 119     case EMR_EXTTEXTOUTW:
 120     {
 121         const EMREXTTEXTOUTW *emr_ExtTextOutW = (const EMREXTTEXTOUTW *)emr;
 122         dx = (const INT *)((const char *)emr + emr_ExtTextOutW->emrtext.offDx);
 123
 124         SetLastError(0xdeadbeef);
 125         ret = GetObjectA(GetCurrentObject(hdc, OBJ_FONT), sizeof(device_lf), &device_lf);
 126         ok( ret == sizeof(device_lf) ||
 127             broken(ret == (sizeof(device_lf) - LF_FACESIZE + strlen(device_lf.lfFaceName) + 1)), /* NT4 */
 128             "GetObjectA error %d\n", GetLastError());
 129
 130         /* compare up to lfOutPrecision, other values are not interesting,
 131          * and in fact sometimes arbitrary adapted by Win9x.
 132          */
 133         ok(!memcmp(&orig_lf, &device_lf, FIELD_OFFSET(LOGFONTA, lfOutPrecision)), "fonts don't match\n");
 134         ok(!lstrcmpA(orig_lf.lfFaceName, device_lf.lfFaceName), "font names don't match\n");
 135
 136         for(i = 0; i < emr_ExtTextOutW->emrtext.nChars; i++)
 137         {
 138             ok(orig_dx[i] == dx[i], "pass %d: dx[%d] (%d) didn't match %d\n",
 139                                      n_record, i, dx[i], orig_dx[i]);
 140         }
 141         n_record++;
 142         emr_processed = TRUE;
 143         break;
 144     }
 145
 146     default:
 147         break;
 148     }
 149
 150     return 1;
 151 }
 152
 153 static void test_ExtTextOut(void)
 154 {
 155     HWND hwnd;
 156     HDC hdcDisplay, hdcMetafile;
 157     HENHMETAFILE hMetafile;
 158     HFONT hFont;
 159     static const char text[] = "Simple text to test ExtTextOut on metafiles";
 160     INT i, len, dx[256];
 161     static const RECT rc = { 0, 0, 100, 100 };
 162     BOOL ret;
 163
 164     assert(sizeof(dx)/sizeof(dx[0]) >= lstrlenA(text));
 165
 166     /* Win9x doesn't play EMFs on invisible windows */
 167     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
 168                            0, 0, 200, 200, 0, 0, 0, NULL);
 169     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
 170
 171     hdcDisplay = GetDC(hwnd);
 172     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
 173
 174     trace("hdcDisplay %p\n", hdcDisplay);
 175
 176     SetMapMode(hdcDisplay, MM_TEXT);
 177
 178     memset(&orig_lf, 0, sizeof(orig_lf));
 179
 180     orig_lf.lfCharSet = ANSI_CHARSET;
 181     orig_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 182     orig_lf.lfWeight = FW_DONTCARE;
 183     orig_lf.lfHeight = 7;
 184     orig_lf.lfQuality = DEFAULT_QUALITY;
 185     lstrcpyA(orig_lf.lfFaceName, "Arial");
 186     hFont = CreateFontIndirectA(&orig_lf);
 187     ok(hFont != 0, "CreateFontIndirectA error %d\n", GetLastError());
 188
 189     hFont = SelectObject(hdcDisplay, hFont);
 190
 191     len = lstrlenA(text);
 192     for (i = 0; i < len; i++)
 193     {
 194         ret = GetCharWidthA(hdcDisplay, text[i], text[i], &dx[i]);
 195         ok( ret, "GetCharWidthA error %d\n", GetLastError());
 196     }
 197     hFont = SelectObject(hdcDisplay, hFont);
 198
 199     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
 200     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
 201
 202     trace("hdcMetafile %p\n", hdcMetafile);
 203
 204     ok(GetDeviceCaps(hdcMetafile, TECHNOLOGY) == DT_RASDISPLAY,
 205        "GetDeviceCaps(TECHNOLOGY) has to return DT_RASDISPLAY for a display based EMF\n");
 206
 207     hFont = SelectObject(hdcMetafile, hFont);
 208
 209     /* 1. pass NULL lpDx */
 210     ret = ExtTextOutA(hdcMetafile, 0, 0, 0, &rc, text, lstrlenA(text), NULL);
 211     ok( ret, "ExtTextOutA error %d\n", GetLastError());
 212
 213     /* 2. pass custom lpDx */
 214     ret = ExtTextOutA(hdcMetafile, 0, 20, 0, &rc, text, lstrlenA(text), dx);
 215     ok( ret, "ExtTextOutA error %d\n", GetLastError());
 216
 217     hFont = SelectObject(hdcMetafile, hFont);
 218     ret = DeleteObject(hFont);
 219     ok( ret, "DeleteObject error %d\n", GetLastError());
 220
 221     hMetafile = CloseEnhMetaFile(hdcMetafile);
 222     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
 223
 224     ok(!GetObjectType(hdcMetafile), "CloseEnhMetaFile has to destroy metafile hdc\n");
 225
 226     ret = PlayEnhMetaFile(hdcDisplay, hMetafile, &rc);
 227     ok( ret, "PlayEnhMetaFile error %d\n", GetLastError());
 228
 229     SetTextAlign(hdcDisplay, TA_UPDATECP | TA_CENTER | TA_BASELINE | TA_RTLREADING );
 230     SetBkColor(hdcDisplay, RGB(0xff, 0, 0));
 231     SetTextColor(hdcDisplay, RGB(0, 0xff, 0));
 232     SetROP2(hdcDisplay, R2_NOT);
 233     SetArcDirection(hdcDisplay, AD_CLOCKWISE);
 234     SetPolyFillMode(hdcDisplay, WINDING);
 235     SetStretchBltMode(hdcDisplay, HALFTONE);
 236
 237     if(pSetRelAbs) pSetRelAbs(hdcDisplay, RELATIVE);
 238     SetBkMode(hdcDisplay, OPAQUE);
 239
 240     ret = EnumEnhMetaFile(hdcDisplay, hMetafile, eto_emf_enum_proc, dx, &rc);
 241     ok( ret, "EnumEnhMetaFile error %d\n", GetLastError());
 242
 243     ok( GetTextAlign(hdcDisplay) == (TA_UPDATECP | TA_CENTER | TA_BASELINE | TA_RTLREADING),
 244         "text align %08x\n", GetTextAlign(hdcDisplay));
 245     ok( GetBkColor(hdcDisplay) == RGB(0xff, 0, 0), "bk color %08x\n", GetBkColor(hdcDisplay));
 246     ok( GetTextColor(hdcDisplay) == RGB(0, 0xff, 0), "text color %08x\n", GetTextColor(hdcDisplay));
 247     ok( GetROP2(hdcDisplay) == R2_NOT, "rop2 %d\n", GetROP2(hdcDisplay));
 248     ok( GetArcDirection(hdcDisplay) == AD_CLOCKWISE, "arc dir  %d\n", GetArcDirection(hdcDisplay));
 249     ok( GetPolyFillMode(hdcDisplay) == WINDING, "poly fill %d\n", GetPolyFillMode(hdcDisplay));
 250     ok( GetStretchBltMode(hdcDisplay) == HALFTONE, "stretchblt mode %d\n", GetStretchBltMode(hdcDisplay));
 251
 252     ok(emr_processed, "EnumEnhMetaFile couldn't find EMR_EXTTEXTOUTA or EMR_EXTTEXTOUTW record\n");
 253
 254     ok(!EnumEnhMetaFile(hdcDisplay, hMetafile, eto_emf_enum_proc, dx, NULL),
 255        "A valid hdc has to require a valid rc\n");
 256
 257     ok(EnumEnhMetaFile(NULL, hMetafile, eto_emf_enum_proc, dx, NULL),
 258        "A null hdc does not require a valid rc\n");
 259
 260     ret = DeleteEnhMetaFile(hMetafile);
 261     ok( ret, "DeleteEnhMetaFile error %d\n", GetLastError());
 262     ret = ReleaseDC(hwnd, hdcDisplay);
 263     ok( ret, "ReleaseDC error %d\n", GetLastError());
 264     DestroyWindow(hwnd);
 265 }
 266
 267 static void check_dc_state(HDC hdc, int restore_no,
 268                            int wnd_org_x, int wnd_org_y, int wnd_ext_x, int wnd_ext_y,
 269                            int vp_org_x, int vp_org_y, int vp_ext_x, int vp_ext_y)
 270 {
 271     BOOL ret;
 272     XFORM xform;
 273     POINT vp_org, win_org;
 274     SIZE vp_size, win_size;
 275     FLOAT xscale, yscale, edx, edy;
 276
 277     SetLastError(0xdeadbeef);
 278     ret = GetWorldTransform(hdc, &xform);
 279     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) goto win9x_here;
 280     ok(ret, "GetWorldTransform error %u\n", GetLastError());
 281
 282     trace("%d: eM11 %f, eM22 %f, eDx %f, eDy %f\n", restore_no, xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 283
 284     ok(xform.eM12 == 0.0, "%d: expected eM12 0.0, got %f\n", restore_no, xform.eM12);
 285     ok(xform.eM21 == 0.0, "%d: expected eM21 0.0, got %f\n", restore_no, xform.eM21);
 286
 287     xscale = (FLOAT)vp_ext_x / (FLOAT)wnd_ext_x;
 288     trace("x scale %f\n", xscale);
 289     ok(fabs(xscale - xform.eM11) < 0.01, "%d: vp_ext_x %d, wnd_ext_cx %d, eM11 %f\n",
 290        restore_no, vp_ext_x, wnd_ext_x, xform.eM11);
 291
 292     yscale = (FLOAT)vp_ext_y / (FLOAT)wnd_ext_y;
 293     trace("y scale %f\n", yscale);
 294     ok(fabs(yscale - xform.eM22) < 0.01, "%d: vp_ext_y %d, wnd_ext_y %d, eM22 %f\n",
 295        restore_no, vp_ext_y, wnd_ext_y, xform.eM22);
 296
 297     edx = (FLOAT)vp_org_x - xform.eM11 * (FLOAT)wnd_org_x;
 298     ok(fabs(edx - xform.eDx) < 0.01, "%d: edx %f != eDx %f\n", restore_no, edx, xform.eDx);
 299     edy = (FLOAT)vp_org_y - xform.eM22 * (FLOAT)wnd_org_y;
 300     ok(fabs(edy - xform.eDy) < 0.01, "%d: edy %f != eDy %f\n", restore_no, edy, xform.eDy);
 301
 302     return;
 303
 304 win9x_here:
 305
 306     GetWindowOrgEx(hdc, &win_org);
 307     GetViewportOrgEx(hdc, &vp_org);
 308     GetWindowExtEx(hdc, &win_size);
 309     GetViewportExtEx(hdc, &vp_size);
 310
 311     ok(wnd_org_x == win_org.x, "%d: wnd_org_x: %d != %d\n", restore_no, wnd_org_x, win_org.x);
 312     ok(wnd_org_y == win_org.y, "%d: wnd_org_y: %d != %d\n", restore_no, wnd_org_y, win_org.y);
 313
 314     ok(vp_org_x == vp_org.x, "%d: vport_org_x: %d != %d\n", restore_no, vp_org_x, vp_org.x);
 315     ok(vp_org_y == vp_org.y, "%d: vport_org_y: %d != %d\n", restore_no, vp_org_y, vp_org.y);
 316
 317     ok(wnd_ext_x == win_size.cx, "%d: wnd_ext_x: %d != %d\n", restore_no, wnd_ext_x, win_size.cx);
 318     ok(wnd_ext_y == win_size.cy, "%d: wnd_ext_y: %d != %d\n", restore_no, wnd_ext_y, win_size.cy);
 319
 320     ok(vp_ext_x == vp_size.cx, "%d: vport_ext_x: %d != %d\n", restore_no, vp_ext_x, vp_size.cx);
 321     ok(vp_ext_y == vp_size.cy, "%d: vport_ext_y: %d != %d\n", restore_no, vp_ext_y, vp_size.cy);
 322 }
 323
 324 static int CALLBACK savedc_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
 325                                          const ENHMETARECORD *emr, int n_objs, LPARAM param)
 326 {
 327     BOOL ret;
 328     XFORM xform;
 329     POINT pt;
 330     SIZE size;
 331     static int save_state;
 332     static int restore_no;
 333
 334     trace("hdc %p, emr->iType %d, emr->nSize %d, param %p\n",
 335            hdc, emr->iType, emr->nSize, (void *)param);
 336
 337     trace("BEFORE:\n");
 338     SetLastError(0xdeadbeef);
 339     ret = GetWorldTransform(hdc, &xform);
 340     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 341     {
 342         ok(GetWindowOrgEx(hdc, &pt), "GetWindowOrgEx error %u\n", GetLastError());
 343         trace("window org (%d,%d)\n", pt.x, pt.y);
 344         ok(GetViewportOrgEx(hdc, &pt), "GetViewportOrgEx error %u\n", GetLastError());
 345         trace("vport org (%d,%d)\n", pt.x, pt.y);
 346         ok(GetWindowExtEx(hdc, &size), "GetWindowExtEx error %u\n", GetLastError());
 347         trace("window ext (%d,%d)\n", size.cx, size.cy);
 348         ok(GetViewportExtEx(hdc, &size), "GetViewportExtEx error %u\n", GetLastError());
 349         trace("vport ext (%d,%d)\n", size.cx, size.cy);
 350     }
 351     else
 352     {
 353         ok(ret, "GetWorldTransform error %u\n", GetLastError());
 354         trace("eM11 %f, eM22 %f, eDx %f, eDy %f\n", xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 355     }
 356
 357     PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
 358
 359     switch (emr->iType)
 360     {
 361     case EMR_HEADER:
 362     {
 363         static RECT exp_bounds = { 0, 0, 150, 150 };
 364         RECT bounds;
 365         const ENHMETAHEADER *emf = (const ENHMETAHEADER *)emr;
 366
 367         trace("bounds %d,%d-%d,%d, frame %d,%d-%d,%d\n",
 368                emf->rclBounds.left, emf->rclBounds.top, emf->rclBounds.right, emf->rclBounds.bottom,
 369                emf->rclFrame.left, emf->rclFrame.top, emf->rclFrame.right, emf->rclFrame.bottom);
 370         trace("mm %d x %d, device %d x %d\n", emf->szlMillimeters.cx, emf->szlMillimeters.cy,
 371                emf->szlDevice.cx, emf->szlDevice.cy);
 372
 373         SetRect(&bounds, emf->rclBounds.left, emf->rclBounds.top, emf->rclBounds.right, emf->rclBounds.bottom);
 374         ok(EqualRect(&bounds, &exp_bounds), "wrong bounds\n");
 375
 376         save_state = 0;
 377         restore_no = 0;
 378         check_dc_state(hdc, restore_no, 0, 0, 1, 1, 0, 0, 1, 1);
 379         break;
 380     }
 381
 382     case EMR_LINETO:
 383         {
 384             const EMRLINETO *line = (const EMRLINETO *)emr;
 385             trace("EMR_LINETO %d,%d\n", line->ptl.x, line->ptl.x);
 386             break;
 387         }
 388     case EMR_SETWINDOWORGEX:
 389         {
 390             const EMRSETWINDOWORGEX *org = (const EMRSETWINDOWORGEX *)emr;
 391             trace("EMR_SETWINDOWORGEX: %d,%d\n", org->ptlOrigin.x, org->ptlOrigin.y);
 392             break;
 393         }
 394     case EMR_SETWINDOWEXTEX:
 395         {
 396             const EMRSETWINDOWEXTEX *ext = (const EMRSETWINDOWEXTEX *)emr;
 397             trace("EMR_SETWINDOWEXTEX: %d,%d\n", ext->szlExtent.cx, ext->szlExtent.cy);
 398             break;
 399         }
 400     case EMR_SETVIEWPORTORGEX:
 401         {
 402             const EMRSETVIEWPORTORGEX *org = (const EMRSETVIEWPORTORGEX *)emr;
 403             trace("EMR_SETVIEWPORTORGEX: %d,%d\n", org->ptlOrigin.x, org->ptlOrigin.y);
 404             break;
 405         }
 406     case EMR_SETVIEWPORTEXTEX:
 407         {
 408             const EMRSETVIEWPORTEXTEX *ext = (const EMRSETVIEWPORTEXTEX *)emr;
 409             trace("EMR_SETVIEWPORTEXTEX: %d,%d\n", ext->szlExtent.cx, ext->szlExtent.cy);
 410             break;
 411         }
 412     case EMR_SAVEDC:
 413         save_state++;
 414         trace("EMR_SAVEDC\n");
 415         break;
 416
 417     case EMR_RESTOREDC:
 418         {
 419             const EMRRESTOREDC *restoredc = (const EMRRESTOREDC *)emr;
 420             trace("EMR_RESTOREDC: %d\n", restoredc->iRelative);
 421
 422             switch(++restore_no)
 423             {
 424             case 1:
 425                 ok(restoredc->iRelative == -1, "first restore %d\n", restoredc->iRelative);
 426                 check_dc_state(hdc, restore_no, -2, -2, 8192, 8192, 20, 20, 20479, 20478);
 427                 break;
 428             case 2:
 429                 ok(restoredc->iRelative == -3, "second restore %d\n", restoredc->iRelative);
 430                 check_dc_state(hdc, restore_no, 0, 0, 16384, 16384, 0, 0, 17873, 17872);
 431                 break;
 432             case 3:
 433                 ok(restoredc->iRelative == -2, "third restore %d\n", restoredc->iRelative);
 434                 check_dc_state(hdc, restore_no, -4, -4, 32767, 32767, 40, 40, 3276, 3276);
 435                 break;
 436             }
 437             ok(restore_no <= 3, "restore_no %d\n", restore_no);
 438             save_state += restoredc->iRelative;
 439             break;
 440         }
 441     case EMR_EOF:
 442         ok(save_state == 0, "EOF save_state %d\n", save_state);
 443         break;
 444     }
 445
 446     trace("AFTER:\n");
 447     SetLastError(0xdeadbeef);
 448     ret = GetWorldTransform(hdc, &xform);
 449     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 450     {
 451         ok(GetWindowOrgEx(hdc, &pt), "GetWindowOrgEx error %u\n", GetLastError());
 452         trace("window org (%d,%d)\n", pt.x, pt.y);
 453         ok(GetViewportOrgEx(hdc, &pt), "GetViewportOrgEx error %u\n", GetLastError());
 454         trace("vport org (%d,%d)\n", pt.x, pt.y);
 455         ok(GetWindowExtEx(hdc, &size), "GetWindowExtEx error %u\n", GetLastError());
 456         trace("window ext (%d,%d)\n", size.cx, size.cy);
 457         ok(GetViewportExtEx(hdc, &size), "GetViewportExtEx error %u\n", GetLastError());
 458         trace("vport ext (%d,%d)\n", size.cx, size.cy);
 459     }
 460     else
 461     {
 462         ok(ret, "GetWorldTransform error %u\n", GetLastError());
 463         trace("eM11 %f, eM22 %f, eDx %f, eDy %f\n", xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 464     }
 465
 466     return 1;
 467 }
 468
 469 static void test_SaveDC(void)
 470 {
 471     HDC hdcMetafile, hdcDisplay;
 472     HENHMETAFILE hMetafile;
 473     HWND hwnd;
 474     int ret;
 475     static const RECT rc = { 0, 0, 150, 150 };
 476
 477     /* Win9x doesn't play EMFs on invisible windows */
 478     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
 479                            0, 0, 200, 200, 0, 0, 0, NULL);
 480     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
 481
 482     hdcDisplay = GetDC(hwnd);
 483     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
 484
 485     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
 486     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
 487
 488     SetMapMode(hdcMetafile, MM_ANISOTROPIC);
 489
 490     /* Need to write something to the emf, otherwise Windows won't play it back */
 491     LineTo(hdcMetafile, 150, 150);
 492
 493     SetWindowOrgEx(hdcMetafile, 0, 0, NULL);
 494     SetViewportOrgEx(hdcMetafile, 0, 0, NULL);
 495     SetWindowExtEx(hdcMetafile, 110, 110, NULL );
 496     SetViewportExtEx(hdcMetafile, 120, 120, NULL );
 497
 498     /* Force Win9x to update DC state */
 499     SetPixelV(hdcMetafile, 50, 50, 0);
 500
 501     ret = SaveDC(hdcMetafile);
 502     ok(ret == 1, "ret = %d\n", ret);
 503
 504     SetWindowOrgEx(hdcMetafile, -1, -1, NULL);
 505     SetViewportOrgEx(hdcMetafile, 10, 10, NULL);
 506     SetWindowExtEx(hdcMetafile, 150, 150, NULL );
 507     SetViewportExtEx(hdcMetafile, 200, 200, NULL );
 508
 509     /* Force Win9x to update DC state */
 510     SetPixelV(hdcMetafile, 50, 50, 0);
 511
 512     ret = SaveDC(hdcMetafile);
 513     ok(ret == 2, "ret = %d\n", ret);
 514
 515     SetWindowOrgEx(hdcMetafile, -2, -2, NULL);
 516     SetViewportOrgEx(hdcMetafile, 20, 20, NULL);
 517     SetWindowExtEx(hdcMetafile, 120, 120, NULL );
 518     SetViewportExtEx(hdcMetafile, 300, 300, NULL );
 519
 520     /* Force Win9x to update DC state */
 521     SetPixelV(hdcMetafile, 50, 50, 0);
 522
 523     ret = SaveDC(hdcMetafile);
 524     ok(ret == 3, "ret = %d\n", ret);
 525
 526     SetWindowOrgEx(hdcMetafile, -3, -3, NULL);
 527     SetViewportOrgEx(hdcMetafile, 30, 30, NULL);
 528     SetWindowExtEx(hdcMetafile, 200, 200, NULL );
 529     SetViewportExtEx(hdcMetafile, 400, 400, NULL );
 530
 531     /* Force Win9x to update DC state */
 532     SetPixelV(hdcMetafile, 50, 50, 0);
 533
 534     ret = RestoreDC(hdcMetafile, -1);
 535     ok(ret, "ret = %d\n", ret);
 536
 537     ret = SaveDC(hdcMetafile);
 538     ok(ret == 3, "ret = %d\n", ret);
 539
 540     ret = RestoreDC(hdcMetafile, 1);
 541     ok(ret, "ret = %d\n", ret);
 542
 543     SetWindowOrgEx(hdcMetafile, -4, -4, NULL);
 544     SetViewportOrgEx(hdcMetafile, 40, 40, NULL);
 545     SetWindowExtEx(hdcMetafile, 500, 500, NULL );
 546     SetViewportExtEx(hdcMetafile, 50, 50, NULL );
 547
 548     /* Force Win9x to update DC state */
 549     SetPixelV(hdcMetafile, 50, 50, 0);
 550
 551     ret = SaveDC(hdcMetafile);
 552     ok(ret == 1, "ret = %d\n", ret);
 553
 554     ret = SaveDC(hdcMetafile);
 555     ok(ret == 2, "ret = %d\n", ret);
 556
 557     hMetafile = CloseEnhMetaFile(hdcMetafile);
 558     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
 559
 560     ret = EnumEnhMetaFile(hdcDisplay, hMetafile, savedc_emf_enum_proc, 0, &rc);
 561     ok( ret == 1, "EnumEnhMetaFile rets %d\n", ret);
 562
 563     ret = DeleteEnhMetaFile(hMetafile);
 564     ok( ret, "DeleteEnhMetaFile error %d\n", GetLastError());
 565     ret = ReleaseDC(hwnd, hdcDisplay);
 566     ok( ret, "ReleaseDC error %d\n", GetLastError());
 567     DestroyWindow(hwnd);
 568 }
 569
 570 /* Win-format metafile (mfdrv) tests */
 571 /* These tests compare the generated metafiles byte-by-byte */
 572 /* with the nominal results. */
 573
 574 /* Maximum size of sample metafiles in bytes. */
 575 #define MF_BUFSIZE 512
 576
 577 /* 8x8 bitmap data for a pattern brush */
 578 static const unsigned char SAMPLE_PATTERN_BRUSH[] = {
 579     0x01, 0x00, 0x02, 0x00,
 580     0x03, 0x00, 0x04, 0x00,
 581     0x05, 0x00, 0x06, 0x00,
 582     0x07, 0x00, 0x08, 0x00
 583 };
 584
 585 /* Sample metafiles to be compared to the outputs of the
 586  * test functions.
 587  */
 588
 589 static const unsigned char MF_BLANK_BITS[] = {
 590     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x0c, 0x00,
 591     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 592     0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
 593 };
 594
 595 static const unsigned char MF_GRAPHICS_BITS[] = {
 596     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x22, 0x00,
 597     0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
 598     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x02,
 599     0x01, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00,
 600     0x13, 0x02, 0x02, 0x00, 0x02, 0x00, 0x05, 0x00,
 601     0x00, 0x00, 0x14, 0x02, 0x01, 0x00, 0x01, 0x00,
 602     0x07, 0x00, 0x00, 0x00, 0x18, 0x04, 0x02, 0x00,
 603     0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
 604     0x00, 0x00, 0x00, 0x00
 605 };
 606
 607 static const unsigned char MF_PATTERN_BRUSH_BITS[] = {
 608     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x3d, 0x00,
 609     0x00, 0x00, 0x01, 0x00, 0x2d, 0x00, 0x00, 0x00,
 610     0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x42, 0x01,
 611     0x03, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
 612     0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 613     0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 614     0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 615     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 616     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 617     0xff, 0xff, 0xff, 0x00, 0x08, 0x00, 0x00, 0x00,
 618     0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
 619     0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
 620     0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 621     0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
 622     0x2d, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 623     0x00, 0x00
 624 };
 625
 626 static const unsigned char MF_TEXTOUT_ON_PATH_BITS[] =
 627 {
 628     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x19, 0x00,
 629     0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
 630     0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x0a,
 631     0x16, 0x00, 0x0b, 0x00, 0x04, 0x00, 0x00, 0x00,
 632     0x54, 0x65, 0x73, 0x74, 0x03, 0x00, 0x05, 0x00,
 633     0x08, 0x00, 0x0c, 0x00, 0x03, 0x00, 0x00, 0x00,
 634     0x00, 0x00
 635 };
 636
 637 static const unsigned char EMF_TEXTOUT_ON_PATH_BITS[] =
 638 {
 639     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 640     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 641     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 642     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 643     0xe7, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff, 0xff,
 644     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 645     0xf4, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 646     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 647     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 648     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 649     0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
 650     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 651     0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
 652     0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
 653     0x08, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
 654     0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 655     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 656     0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
 657     0x00, 0x00, 0xc8, 0x41, 0x00, 0x80, 0xbb, 0x41,
 658     0x0b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
 659     0x04, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
 660     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 661     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 662     0xff, 0xff, 0xff, 0xff, 0x54, 0x00, 0x00, 0x00,
 663     0x54, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00,
 664     0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 665     0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 666     0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 667     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 668     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 669     0x14, 0x00, 0x00, 0x00
 670 };
 671
 672 static const unsigned char MF_LINETO_BITS[] = {
 673     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
 674     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 675     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
 676     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
 677     0x00, 0x00
 678 };
 679
 680 static const unsigned char EMF_LINETO_BITS[] = {
 681     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 682     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 683     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
 684     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 685     0x61, 0x06, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00,
 686     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 687     0x38, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
 688     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 689     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 690     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 691     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
 692     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 693     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
 694     0xe0, 0x93, 0x04, 0x00, 0x46, 0x00, 0x00, 0x00,
 695     0x48, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
 696     0x47, 0x44, 0x49, 0x43, 0x01, 0x00, 0x00, 0x80,
 697     0x00, 0x03, 0x00, 0x00, 0x60, 0xe5, 0xf4, 0x73,
 698     0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
 699     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
 700     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 701     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
 702     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
 703     0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
 704     0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 705     0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 706     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 707     0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 708     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 709     0x36, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 710     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
 711     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 712     0x07, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x00,
 713     0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 714     0x30, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 715     0x0f, 0x00, 0x00, 0x80, 0x4b, 0x00, 0x00, 0x00,
 716     0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 717     0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
 718     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 719     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
 720 };
 721
 722 static const unsigned char EMF_LINETO_MM_ANISOTROPIC_BITS[] = {
 723     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 724     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 725     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
 726     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 727     0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
 728     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 729     0x38, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
 730     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 731     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 732     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 733     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
 734     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 735     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
 736     0xe0, 0x93, 0x04, 0x00, 0x46, 0x00, 0x00, 0x00,
 737     0x48, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
 738     0x47, 0x44, 0x49, 0x43, 0x01, 0x00, 0x00, 0x80,
 739     0x00, 0x03, 0x00, 0x00, 0xa4, 0xfe, 0xf4, 0x73,
 740     0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
 741     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
 742     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 743     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
 744     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
 745     0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
 746     0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 747     0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 748     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 749     0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 750     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
 751     0x36, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 752     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
 753     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 754     0x07, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x00,
 755     0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 756     0x30, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 757     0x0f, 0x00, 0x00, 0x80, 0x4b, 0x00, 0x00, 0x00,
 758     0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 759     0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
 760     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 761     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
 762 };
 763
 764 static const unsigned char EMF_LINETO_MM_TEXT_BITS[] = {
 765     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 766     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 767     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
 768     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 769     0x61, 0x06, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00,
 770     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 771     0xe4, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
 772     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 773     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 774     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 775     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
 776     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 777     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
 778     0xe0, 0x93, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00,
 779     0x10, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
 780     0x00, 0x04, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
 781     0x10, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
 782     0x00, 0x04, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
 783     0x10, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
 784     0x0f, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
 785     0x0c, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80,
 786     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 787     0x00, 0x00, 0x00, 0x80, 0x30, 0x00, 0x00, 0x00,
 788     0x0c, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x80,
 789     0x4b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 790     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 791     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 792     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 793     0x14, 0x00, 0x00, 0x00
 794 };
 795
 796 /* For debugging or dumping the raw metafiles produced by
 797  * new test functions.
 798  */
 799 static INT CALLBACK mf_enum_proc(HDC hdc, HANDLETABLE *ht, METARECORD *mr,
 800                                  INT nobj, LPARAM param)
 801 {
 802     trace("hdc %p, mr->rdFunction %04x, mr->rdSize %u, param %p\n",
 803            hdc, mr->rdFunction, mr->rdSize, (void *)param);
 804     return TRUE;
 805 }
 806
 807 /* For debugging or dumping the raw metafiles produced by
 808  * new test functions.
 809  */
 810
 811 static void dump_mf_bits (const HMETAFILE mf, const char *desc)
 812 {
 813     BYTE buf[MF_BUFSIZE];
 814     UINT mfsize, i;
 815
 816     if (!winetest_debug) return;
 817
 818     mfsize = GetMetaFileBitsEx (mf, MF_BUFSIZE, buf);
 819     ok (mfsize > 0, "%s: GetMetaFileBitsEx failed.\n", desc);
 820
 821     printf ("MetaFile %s has bits:\n{\n    ", desc);
 822     for (i=0; i<mfsize; i++)
 823     {
 824         printf ("0x%02x", buf[i]);
 825         if (i == mfsize-1)
 826             printf ("\n");
 827         else if (i % 8 == 7)
 828             printf (",\n    ");
 829         else
 830             printf (", ");
 831     }
 832     printf ("};\n");
 833 }
 834
 835 /* Compare the metafile produced by a test function with the
 836  * expected raw metafile data in "bits".
 837  * Return value is 0 for a perfect match,
 838  * -1 if lengths aren't equal,
 839  * otherwise returns the number of non-matching bytes.
 840  */
 841
 842 static int compare_mf_bits (const HMETAFILE mf, const unsigned char *bits, UINT bsize,
 843     const char *desc)
 844 {
 845     unsigned char buf[MF_BUFSIZE];
 846     UINT mfsize, i;
 847     int diff;
 848
 849     mfsize = GetMetaFileBitsEx (mf, MF_BUFSIZE, buf);
 850     ok (mfsize > 0, "%s: GetMetaFileBitsEx failed.\n", desc);
 851     if (mfsize < MF_BUFSIZE)
 852         ok (mfsize == bsize, "%s: mfsize=%d, bsize=%d.\n",
 853             desc, mfsize, bsize);
 854     else
 855         ok (bsize >= MF_BUFSIZE, "%s: mfsize > bufsize (%d bytes), bsize=%d.\n",
 856             desc, mfsize, bsize);
 857     if (mfsize != bsize)
 858         return -1;
 859
 860     diff = 0;
 861     for (i=0; i<bsize; i++)
 862     {
 863        if (buf[i] !=  bits[i])
 864            diff++;
 865     }
 866     ok (diff == 0, "%s: mfsize=%d, bsize=%d, diff=%d\n",
 867         desc, mfsize, bsize, diff);
 868
 869     return diff;
 870 }
 871
 872 static int compare_mf_disk_bits(LPCSTR name, const BYTE *bits, UINT bsize, const char *desc)
 873 {
 874     unsigned char buf[MF_BUFSIZE];
 875     DWORD mfsize, rd_size, i;
 876     int diff;
 877     HANDLE hfile;
 878     BOOL ret;
 879
 880     hfile = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 881     assert(hfile != INVALID_HANDLE_VALUE);
 882
 883     mfsize = GetFileSize(hfile, NULL);
 884     assert(mfsize <= MF_BUFSIZE);
 885
 886     ret = ReadFile(hfile, buf, sizeof(buf), &rd_size, NULL);
 887     ok( ret && rd_size == mfsize, "ReadFile: error %d\n", GetLastError());
 888
 889     CloseHandle(hfile);
 890
 891     ok(mfsize == bsize, "%s: mfsize=%d, bsize=%d.\n", desc, mfsize, bsize);
 892
 893     if (mfsize != bsize)
 894         return -1;
 895
 896     diff = 0;
 897     for (i=0; i<bsize; i++)
 898     {
 899         if (buf[i] != bits[i])
 900             diff++;
 901     }
 902     ok(diff == 0, "%s: mfsize=%d, bsize=%d, diff=%d\n",
 903         desc, mfsize, bsize, diff);
 904
 905     return diff;
 906 }
 907
 908 /* For debugging or dumping the raw EMFs produced by
 909  * new test functions.
 910  */
 911 static void dump_emf_bits(const HENHMETAFILE mf, const char *desc)
 912 {
 913     BYTE buf[MF_BUFSIZE];
 914     UINT mfsize, i;
 915
 916     if (!winetest_debug) return;
 917
 918     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
 919     ok (mfsize > 0, "%s: GetEnhMetaFileBits failed\n", desc);
 920
 921     printf("EMF %s has bits:\n{\n    ", desc);
 922     for (i = 0; i < mfsize; i++)
 923     {
 924         printf ("0x%02x", buf[i]);
 925         if (i == mfsize-1)
 926             printf ("\n");
 927         else if (i % 8 == 7)
 928             printf (",\n    ");
 929         else
 930             printf (", ");
 931     }
 932     printf ("};\n");
 933 }
 934
 935 static void dump_emf_records(const HENHMETAFILE mf, const char *desc)
 936 {
 937     BYTE *emf;
 938     BYTE buf[MF_BUFSIZE];
 939     UINT mfsize, offset;
 940
 941     if (!winetest_debug) return;
 942
 943     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
 944     ok (mfsize > 0, "%s: GetEnhMetaFileBits error %d\n", desc, GetLastError());
 945
 946     printf("EMF %s has records:\n", desc);
 947
 948     emf = buf;
 949     offset = 0;
 950     while(offset < mfsize)
 951     {
 952         EMR *emr = (EMR *)(emf + offset);
 953         printf("emr->iType %d, emr->nSize %u\n", emr->iType, emr->nSize);
 954         /*trace("emr->iType 0x%04lx, emr->nSize 0x%04lx\n", emr->iType, emr->nSize);*/
 955         offset += emr->nSize;
 956     }
 957 }
 958
 959 static void dump_emf_record(const ENHMETARECORD *emr, const char *desc)
 960 {
 961     const BYTE *buf;
 962     DWORD i;
 963
 964     if (!winetest_debug) return;
 965
 966     printf ("%s: EMF record %u has bits:\n{\n", desc, emr->iType);
 967     buf = (const BYTE *)emr;
 968     for (i = 0; i < emr->nSize; i++)
 969     {
 970         printf ("0x%02x", buf[i]);
 971         if (i == emr->nSize - 1)
 972             printf ("\n");
 973         else if (i % 8 == 7)
 974             printf (",\n");
 975         else
 976             printf (", ");
 977     }
 978     printf ("};\n");
 979 }
 980
 981 static void dump_EMREXTTEXTOUT(const EMREXTTEXTOUTW *eto)
 982 {
 983     trace("rclBounds %d,%d - %d,%d\n", eto->rclBounds.left, eto->rclBounds.top,
 984           eto->rclBounds.right, eto->rclBounds.bottom);
 985     trace("iGraphicsMode %u\n", eto->iGraphicsMode);
 986     trace("exScale: %f\n", eto->exScale);
 987     trace("eyScale: %f\n", eto->eyScale);
 988     trace("emrtext.ptlReference %d,%d\n", eto->emrtext.ptlReference.x, eto->emrtext.ptlReference.y);
 989     trace("emrtext.nChars %u\n", eto->emrtext.nChars);
 990     trace("emrtext.offString %#x\n", eto->emrtext.offString);
 991     trace("emrtext.fOptions %#x\n", eto->emrtext.fOptions);
 992     trace("emrtext.rcl %d,%d - %d,%d\n", eto->emrtext.rcl.left, eto->emrtext.rcl.top,
 993           eto->emrtext.rcl.right, eto->emrtext.rcl.bottom);
 994     trace("emrtext.offDx %#x\n", eto->emrtext.offDx);
 995 }
 996
 997 static BOOL match_emf_record(const ENHMETARECORD *emr1, const ENHMETARECORD *emr2,
 998                              const char *desc, BOOL ignore_scaling)
 999 {
1000     int diff;
1001
1002     ok(emr1->iType == emr2->iType, "%s: emr->iType %u != %u\n",
1003        desc, emr1->iType, emr2->iType);
1004
1005     ok(emr1->nSize == emr2->nSize, "%s: emr->nSize %u != %u\n",
1006        desc, emr1->nSize, emr2->nSize);
1007
1008     /* iType and nSize mismatches are fatal */
1009     if (emr1->iType != emr2->iType || emr1->nSize != emr2->nSize) return FALSE;
1010
1011     /* contents of EMR_GDICOMMENT are not interesting */
1012     if (emr1->iType == EMR_GDICOMMENT) return TRUE;
1013
1014     /* different Windows versions setup DC scaling differently when
1015      * converting an old style metafile to an EMF.
1016      */
1017     if (ignore_scaling && (emr1->iType == EMR_SETWINDOWEXTEX ||
1018                            emr1->iType == EMR_SETVIEWPORTEXTEX))
1019         return TRUE;
1020
1021     if (emr1->iType == EMR_EXTTEXTOUTW || emr1->iType == EMR_EXTTEXTOUTA)
1022     {
1023         EMREXTTEXTOUTW *eto1, *eto2;
1024
1025         eto1 = HeapAlloc(GetProcessHeap(), 0, emr1->nSize);
1026         memcpy(eto1, emr1, emr1->nSize);
1027         eto2 = HeapAlloc(GetProcessHeap(), 0, emr2->nSize);
1028         memcpy(eto2, emr2, emr2->nSize);
1029
1030         /* different Windows versions setup DC scaling differently */
1031         eto1->exScale = eto1->eyScale = 0.0;
1032         eto2->exScale = eto2->eyScale = 0.0;
1033
1034         diff = memcmp(eto1, eto2, emr1->nSize);
1035         if (diff)
1036         {
1037             dump_EMREXTTEXTOUT(eto1);
1038             dump_EMREXTTEXTOUT(eto2);
1039         }
1040         HeapFree(GetProcessHeap(), 0, eto1);
1041         HeapFree(GetProcessHeap(), 0, eto2);
1042     }
1043     else
1044         diff = memcmp(emr1, emr2, emr1->nSize);
1045
1046     ok(diff == 0, "%s: contents of record %u don't match\n", desc, emr1->iType);
1047
1048     if (diff)
1049     {
1050         dump_emf_record(emr1, "expected bits");
1051         dump_emf_record(emr2, "actual bits");
1052     }
1053
1054     return diff == 0; /* report all non-fatal record mismatches */
1055 }
1056
1057 /* Compare the EMF produced by a test function with the
1058  * expected raw EMF data in "bits".
1059  * Return value is 0 for a perfect match,
1060  * -1 if lengths aren't equal,
1061  * otherwise returns the number of non-matching bytes.
1062  */
1063 static int compare_emf_bits(const HENHMETAFILE mf, const unsigned char *bits,
1064                             UINT bsize, const char *desc,
1065                             BOOL ignore_scaling)
1066 {
1067     unsigned char buf[MF_BUFSIZE];
1068     UINT mfsize, offset;
1069     const ENHMETAHEADER *emh1, *emh2;
1070
1071     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
1072     ok (mfsize > 0, "%s: GetEnhMetaFileBits error %d\n", desc, GetLastError());
1073
1074     if (mfsize < MF_BUFSIZE)
1075     {
1076         ok(mfsize == bsize, "%s: mfsize=%d, bsize=%d\n", desc, mfsize, bsize);
1077     }
1078     else
1079         ok(bsize >= MF_BUFSIZE, "%s: mfsize > bufsize (%d bytes), bsize=%d\n",
1080            desc, mfsize, bsize);
1081
1082     /* basic things must match */
1083     emh1 = (const ENHMETAHEADER *)bits;
1084     emh2 = (const ENHMETAHEADER *)buf;
1085     ok(emh1->iType == EMR_HEADER, "expected EMR_HEADER, got %u\n", emh1->iType);
1086     ok(emh1->nSize == sizeof(ENHMETAHEADER), "expected sizeof(ENHMETAHEADER), got %u\n", emh1->nSize);
1087     ok(emh2->nBytes == mfsize, "expected emh->nBytes %u, got %u\n", mfsize, emh2->nBytes);
1088     ok(emh1->dSignature == ENHMETA_SIGNATURE, "expected ENHMETA_SIGNATURE, got %u\n", emh1->dSignature);
1089
1090     ok(emh1->iType == emh2->iType, "expected EMR_HEADER, got %u\n", emh2->iType);
1091     ok(emh1->nSize == emh2->nSize, "expected nSize %u, got %u\n", emh1->nSize, emh2->nSize);
1092     ok(emh1->dSignature == emh2->dSignature, "expected dSignature %u, got %u\n", emh1->dSignature, emh2->dSignature);
1093     ok(emh1->nBytes == emh2->nBytes, "expected nBytes %u, got %u\n", emh1->nBytes, emh2->nBytes);
1094     ok(emh1->nRecords == emh2->nRecords, "expected nBytes %u, got %u\n", emh1->nRecords, emh2->nRecords);
1095
1096     offset = emh1->nSize;
1097     while (offset < emh1->nBytes)
1098     {
1099         const ENHMETARECORD *emr1 = (const ENHMETARECORD *)(bits + offset);
1100         const ENHMETARECORD *emr2 = (const ENHMETARECORD *)(buf + offset);
1101
1102         trace("EMF record %u, size %u/record %u, size %u\n",
1103               emr1->iType, emr1->nSize, emr2->iType, emr2->nSize);
1104
1105         if (!match_emf_record(emr1, emr2, desc, ignore_scaling)) return -1;
1106
1107         offset += emr1->nSize;
1108     }
1109     return 0;
1110 }
1111
1112 /* Test a blank metafile.  May be used as a template for new tests. */
1113
1114 static void test_mf_Blank(void)
1115 {
1116     HDC hdcMetafile;
1117     HMETAFILE hMetafile;
1118     INT caps;
1119     BOOL ret;
1120     INT type;
1121
1122     hdcMetafile = CreateMetaFileA(NULL);
1123     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1124     trace("hdcMetafile %p\n", hdcMetafile);
1125
1126 /* Tests on metafile initialization */
1127     caps = GetDeviceCaps (hdcMetafile, TECHNOLOGY);
1128     ok (caps == DT_METAFILE,
1129         "GetDeviceCaps: TECHNOLOGY=%d != DT_METAFILE.\n", caps);
1130
1131     hMetafile = CloseMetaFile(hdcMetafile);
1132     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1133     type = GetObjectType(hMetafile);
1134     ok(type == OBJ_METAFILE, "CloseMetaFile created object with type %d\n", type);
1135     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
1136
1137     if (compare_mf_bits (hMetafile, MF_BLANK_BITS, sizeof(MF_BLANK_BITS),
1138         "mf_blank") != 0)
1139     {
1140         dump_mf_bits(hMetafile, "mf_Blank");
1141         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1142     }
1143
1144     ret = DeleteMetaFile(hMetafile);
1145     ok( ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
1146 }
1147
1148 static void test_CopyMetaFile(void)
1149 {
1150     HDC hdcMetafile;
1151     HMETAFILE hMetafile, hmf_copy;
1152     BOOL ret;
1153     char temp_path[MAX_PATH];
1154     char mf_name[MAX_PATH];
1155     INT type;
1156
1157     hdcMetafile = CreateMetaFileA(NULL);
1158     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1159     trace("hdcMetafile %p\n", hdcMetafile);
1160
1161     hMetafile = CloseMetaFile(hdcMetafile);
1162     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1163     type = GetObjectType(hMetafile);
1164     ok(type == OBJ_METAFILE, "CloseMetaFile created object with type %d\n", type);
1165
1166     if (compare_mf_bits (hMetafile, MF_BLANK_BITS, sizeof(MF_BLANK_BITS),
1167         "mf_blank") != 0)
1168     {
1169         dump_mf_bits(hMetafile, "mf_Blank");
1170         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1171     }
1172
1173     GetTempPathA(MAX_PATH, temp_path);
1174     GetTempFileNameA(temp_path, "wmf", 0, mf_name);
1175
1176     hmf_copy = CopyMetaFileA(hMetafile, mf_name);
1177     ok(hmf_copy != 0, "CopyMetaFile error %d\n", GetLastError());
1178
1179     type = GetObjectType(hmf_copy);
1180     ok(type == OBJ_METAFILE, "CopyMetaFile created object with type %d\n", type);
1181
1182     ret = DeleteMetaFile(hMetafile);
1183     ok( ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
1184
1185     if (compare_mf_disk_bits(mf_name, MF_BLANK_BITS, sizeof(MF_BLANK_BITS), "mf_blank") != 0)
1186     {
1187         dump_mf_bits(hMetafile, "mf_Blank");
1188         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1189     }
1190
1191     ret = DeleteMetaFile(hmf_copy);
1192     ok( ret, "DeleteMetaFile(%p) error %d\n", hmf_copy, GetLastError());
1193
1194     DeleteFileA(mf_name);
1195 }
1196
1197 static void test_SetMetaFileBits(void)
1198 {
1199     HMETAFILE hmf;
1200     INT type;
1201     BOOL ret;
1202     BYTE buf[256];
1203     METAHEADER *mh;
1204
1205     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), MF_GRAPHICS_BITS);
1206     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
1207     type = GetObjectType(hmf);
1208     ok(type == OBJ_METAFILE, "SetMetaFileBitsEx created object with type %d\n", type);
1209
1210     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
1211     {
1212         dump_mf_bits(hmf, "mf_Graphics");
1213         EnumMetaFile(0, hmf, mf_enum_proc, 0);
1214     }
1215
1216     ret = DeleteMetaFile(hmf);
1217     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
1218
1219     /* NULL data crashes XP SP1 */
1220     /*hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), NULL);*/
1221
1222     /* Now with not zero size */
1223     SetLastError(0xdeadbeef);
1224     hmf = SetMetaFileBitsEx(0, MF_GRAPHICS_BITS);
1225     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1226     ok(GetLastError() == ERROR_INVALID_DATA, "wrong error %d\n", GetLastError());
1227
1228     /* Now with not even size */
1229     SetLastError(0xdeadbeef);
1230     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS) - 1, MF_GRAPHICS_BITS);
1231     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1232     ok(GetLastError() == 0xdeadbeef /* XP SP1 */, "wrong error %d\n", GetLastError());
1233
1234     /* Now with zeroed out or faked some header fields */
1235     assert(sizeof(buf) >= sizeof(MF_GRAPHICS_BITS));
1236     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
1237     mh = (METAHEADER *)buf;
1238     /* corruption of any of the below fields leads to a failure */
1239     mh->mtType = 0;
1240     mh->mtVersion = 0;
1241     mh->mtHeaderSize = 0;
1242     SetLastError(0xdeadbeef);
1243     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
1244     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1245     ok(GetLastError() == ERROR_INVALID_DATA, "wrong error %d\n", GetLastError());
1246
1247     /* Now with corrupted mtSize field */
1248     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
1249     mh = (METAHEADER *)buf;
1250     /* corruption of mtSize doesn't lead to a failure */
1251     mh->mtSize *= 2;
1252     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
1253     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
1254
1255     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
1256     {
1257         dump_mf_bits(hmf, "mf_Graphics");
1258         EnumMetaFile(0, hmf, mf_enum_proc, 0);
1259     }
1260
1261     ret = DeleteMetaFile(hmf);
1262     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
1263
1264     /* Now with zeroed out mtSize field */
1265     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
1266     mh = (METAHEADER *)buf;
1267     /* zeroing mtSize doesn't lead to a failure */
1268     mh->mtSize = 0;
1269     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
1270     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
1271
1272     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
1273     {
1274         dump_mf_bits(hmf, "mf_Graphics");
1275         EnumMetaFile(0, hmf, mf_enum_proc, 0);
1276     }
1277
1278     ret = DeleteMetaFile(hmf);
1279     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
1280 }
1281
1282 /* Simple APIs from mfdrv/graphics.c
1283  */
1284
1285 static void test_mf_Graphics(void)
1286 {
1287     HDC hdcMetafile;
1288     HMETAFILE hMetafile;
1289     POINT oldpoint;
1290     BOOL ret;
1291
1292     hdcMetafile = CreateMetaFileA(NULL);
1293     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1294     trace("hdcMetafile %p\n", hdcMetafile);
1295
1296     ret = MoveToEx(hdcMetafile, 1, 1, NULL);
1297     ok( ret, "MoveToEx error %d.\n", GetLastError());
1298     ret = LineTo(hdcMetafile, 2, 2);
1299     ok( ret, "LineTo error %d.\n", GetLastError());
1300     ret = MoveToEx(hdcMetafile, 1, 1, &oldpoint);
1301     ok( ret, "MoveToEx error %d.\n", GetLastError());
1302
1303 /* oldpoint gets garbage under Win XP, so the following test would
1304  * work under Wine but fails under Windows:
1305  *
1306  *   ok((oldpoint.x == 2) && (oldpoint.y == 2),
1307  *       "MoveToEx: (x, y) = (%ld, %ld), should be (2, 2).\n",
1308  *       oldpoint.x, oldpoint.y);
1309  */
1310
1311     ret = Ellipse(hdcMetafile, 0, 0, 2, 2);
1312     ok( ret, "Ellipse error %d.\n", GetLastError());
1313
1314     hMetafile = CloseMetaFile(hdcMetafile);
1315     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1316     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
1317
1318     if (compare_mf_bits (hMetafile, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS),
1319         "mf_Graphics") != 0)
1320     {
1321         dump_mf_bits(hMetafile, "mf_Graphics");
1322         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1323     }
1324
1325     ret = DeleteMetaFile(hMetafile);
1326     ok( ret, "DeleteMetaFile(%p) error %d\n",
1327         hMetafile, GetLastError());
1328 }
1329
1330 static void test_mf_PatternBrush(void)
1331 {
1332     HDC hdcMetafile;
1333     HMETAFILE hMetafile;
1334     LOGBRUSH *orig_lb;
1335     HBRUSH hBrush;
1336     BOOL ret;
1337
1338     orig_lb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LOGBRUSH));
1339
1340     orig_lb->lbStyle = BS_PATTERN;
1341     orig_lb->lbColor = RGB(0, 0, 0);
1342     orig_lb->lbHatch = (ULONG_PTR)CreateBitmap (8, 8, 1, 1, SAMPLE_PATTERN_BRUSH);
1343     ok((HBITMAP)orig_lb->lbHatch != NULL, "CreateBitmap error %d.\n", GetLastError());
1344
1345     hBrush = CreateBrushIndirect (orig_lb);
1346     ok(hBrush != 0, "CreateBrushIndirect error %d\n", GetLastError());
1347
1348     hdcMetafile = CreateMetaFileA(NULL);
1349     ok(hdcMetafile != 0, "CreateMetaFileA error %d\n", GetLastError());
1350     trace("hdcMetafile %p\n", hdcMetafile);
1351
1352     hBrush = SelectObject(hdcMetafile, hBrush);
1353     ok(hBrush != 0, "SelectObject error %d.\n", GetLastError());
1354
1355     hMetafile = CloseMetaFile(hdcMetafile);
1356     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1357     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
1358
1359     if (compare_mf_bits (hMetafile, MF_PATTERN_BRUSH_BITS, sizeof(MF_PATTERN_BRUSH_BITS),
1360         "mf_Pattern_Brush") != 0)
1361     {
1362         dump_mf_bits(hMetafile, "mf_Pattern_Brush");
1363         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1364     }
1365
1366     ret = DeleteMetaFile(hMetafile);
1367     ok( ret, "DeleteMetaFile error %d\n", GetLastError());
1368     ret = DeleteObject(hBrush);
1369     ok( ret, "DeleteObject(HBRUSH) error %d\n", GetLastError());
1370     ret = DeleteObject((HBITMAP)orig_lb->lbHatch);
1371     ok( ret, "DeleteObject(HBITMAP) error %d\n",
1372         GetLastError());
1373     HeapFree (GetProcessHeap(), 0, orig_lb);
1374 }
1375
1376 static void test_mf_ExtTextOut_on_path(void)
1377 {
1378     HDC hdcMetafile;
1379     HMETAFILE hMetafile;
1380     BOOL ret;
1381     static const INT dx[4] = { 3, 5, 8, 12 };
1382
1383     hdcMetafile = CreateMetaFileA(NULL);
1384     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1385     trace("hdcMetafile %p\n", hdcMetafile);
1386
1387     ret = BeginPath(hdcMetafile);
1388     ok(!ret, "BeginPath on metafile DC should fail\n");
1389
1390     ret = ExtTextOutA(hdcMetafile, 11, 22, 0, NULL, "Test", 4, dx);
1391     ok(ret, "ExtTextOut error %d\n", GetLastError());
1392
1393     ret = EndPath(hdcMetafile);
1394     ok(!ret, "EndPath on metafile DC should fail\n");
1395
1396     hMetafile = CloseMetaFile(hdcMetafile);
1397     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1398
1399     if (compare_mf_bits(hMetafile, MF_TEXTOUT_ON_PATH_BITS, sizeof(MF_TEXTOUT_ON_PATH_BITS),
1400         "mf_TextOut_on_path") != 0)
1401     {
1402         dump_mf_bits(hMetafile, "mf_TextOut_on_path");
1403         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1404     }
1405
1406     ret = DeleteMetaFile(hMetafile);
1407     ok(ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
1408 }
1409
1410 static void test_emf_ExtTextOut_on_path(void)
1411 {
1412     HWND hwnd;
1413     HDC hdcDisplay, hdcMetafile;
1414     HENHMETAFILE hMetafile;
1415     BOOL ret;
1416     static const INT dx[4] = { 3, 5, 8, 12 };
1417
1418     /* Win9x doesn't play EMFs on invisible windows */
1419     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
1420                            0, 0, 200, 200, 0, 0, 0, NULL);
1421     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
1422
1423     hdcDisplay = GetDC(hwnd);
1424     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
1425
1426     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
1427     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
1428
1429     ret = BeginPath(hdcMetafile);
1430     ok(ret, "BeginPath error %d\n", GetLastError());
1431
1432     ret = ExtTextOutA(hdcMetafile, 11, 22, 0, NULL, "Test", 4, dx);
1433     ok(ret, "ExtTextOut error %d\n", GetLastError());
1434
1435     ret = EndPath(hdcMetafile);
1436     ok(ret, "EndPath error %d\n", GetLastError());
1437
1438     hMetafile = CloseEnhMetaFile(hdcMetafile);
1439     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
1440
1441     /* this doesn't succeed yet: EMF has correct size, all EMF records
1442      * are there, but their contents don't match for different reasons.
1443      */
1444     if (compare_emf_bits(hMetafile, EMF_TEXTOUT_ON_PATH_BITS, sizeof(EMF_TEXTOUT_ON_PATH_BITS),
1445         "emf_TextOut_on_path", FALSE) != 0)
1446     {
1447         dump_emf_bits(hMetafile, "emf_TextOut_on_path");
1448         dump_emf_records(hMetafile, "emf_TextOut_on_path");
1449     }
1450
1451     ret = DeleteEnhMetaFile(hMetafile);
1452     ok(ret, "DeleteEnhMetaFile error %d\n", GetLastError());
1453     ret = ReleaseDC(hwnd, hdcDisplay);
1454     ok(ret, "ReleaseDC error %d\n", GetLastError());
1455     DestroyWindow(hwnd);
1456 }
1457
1458 static const unsigned char EMF_CLIPPING[] =
1459 {
1460     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1461     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1462     0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1463     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1464     0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
1465     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1466     0xd0, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1467     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1468     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1469     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1470     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
1471     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1472     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
1473     0xe0, 0x93, 0x04, 0x00, 0x36, 0x00, 0x00, 0x00,
1474     0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1475     0x01, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00,
1476     0x40, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
1477     0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
1478     0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1479     0x10, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
1480     0x64, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1481     0x00, 0x04, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
1482     0x64, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1483     0x00, 0x04, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
1484     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1485     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
1486 };
1487
1488 static void translate( POINT *pt, UINT count, const XFORM *xform )
1489 {
1490     while (count--)
1491     {
1492         FLOAT x = (FLOAT)pt->x;
1493         FLOAT y = (FLOAT)pt->y;
1494         pt->x = (LONG)floor( x * xform->eM11 + y * xform->eM21 + xform->eDx + 0.5 );
1495         pt->y = (LONG)floor( x * xform->eM12 + y * xform->eM22 + xform->eDy + 0.5 );
1496         pt++;
1497     }
1498 }
1499
1500 /* Compare rectangles allowing rounding errors */
1501 static BOOL is_equal_rect(const RECT *rc1, const RECT *rc2)
1502 {
1503     return abs(rc1->left - rc2->left) <= 1 &&
1504            abs(rc1->top - rc2->top) <= 1 &&
1505            abs(rc1->right - rc2->right) <= 1 &&
1506            abs(rc1->bottom - rc2->bottom) <= 1;
1507 }
1508
1509 static int CALLBACK clip_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
1510                                        const ENHMETARECORD *emr, int n_objs, LPARAM param)
1511 {
1512     if (emr->iType == EMR_EXTSELECTCLIPRGN)
1513     {
1514         const EMREXTSELECTCLIPRGN *clip = (const EMREXTSELECTCLIPRGN *)emr;
1515         union _rgn
1516         {
1517             RGNDATA data;
1518             char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
1519         };
1520         const union _rgn *rgn1;
1521         union _rgn rgn2;
1522         RECT rect, rc_transformed;
1523         const RECT *rc = (const RECT *)param;
1524         HRGN hrgn;
1525         XFORM xform;
1526         INT ret;
1527         BOOL is_win9x;
1528
1529         trace("EMR_EXTSELECTCLIPRGN: cbRgnData %#x, iMode %u\n",
1530                clip->cbRgnData, clip->iMode);
1531
1532         ok(clip->iMode == RGN_COPY, "expected RGN_COPY, got %u\n", clip->iMode);
1533         ok(clip->cbRgnData >= sizeof(RGNDATAHEADER) + sizeof(RECT),
1534            "too small data block: %u bytes\n", clip->cbRgnData);
1535         if (clip->cbRgnData < sizeof(RGNDATAHEADER) + sizeof(RECT))
1536             return 0;
1537
1538         rgn1 = (const union _rgn *)clip->RgnData;
1539
1540         trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
1541               rgn1->data.rdh.dwSize, rgn1->data.rdh.iType,
1542               rgn1->data.rdh.nCount, rgn1->data.rdh.nRgnSize,
1543               rgn1->data.rdh.rcBound.left, rgn1->data.rdh.rcBound.top,
1544               rgn1->data.rdh.rcBound.right, rgn1->data.rdh.rcBound.bottom);
1545
1546         ok(EqualRect(&rgn1->data.rdh.rcBound, rc), "rects don't match\n");
1547
1548         rect = *(const RECT *)rgn1->data.Buffer;
1549         trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
1550         ok(EqualRect(&rect, rc), "rects don't match\n");
1551
1552         ok(rgn1->data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn1->data.rdh.dwSize);
1553         ok(rgn1->data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn1->data.rdh.iType);
1554         ok(rgn1->data.rdh.nCount == 1, "expected 1, got %u\n", rgn1->data.rdh.nCount);
1555         ok(rgn1->data.rdh.nRgnSize == sizeof(RECT),  "expected sizeof(RECT), got %u\n", rgn1->data.rdh.nRgnSize);
1556
1557         hrgn = CreateRectRgn(0, 0, 0, 0);
1558
1559         memset(&xform, 0, sizeof(xform));
1560         SetLastError(0xdeadbeef);
1561         ret = GetWorldTransform(hdc, &xform);
1562         is_win9x = !ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED;
1563         if (!is_win9x)
1564             ok(ret, "GetWorldTransform error %u\n", GetLastError());
1565
1566         trace("xform.eM11 %f, xform.eM22 %f\n", xform.eM11, xform.eM22);
1567
1568         ret = GetClipRgn(hdc, hrgn);
1569         ok(ret == 0, "GetClipRgn returned %d, expected 0\n", ret);
1570
1571         PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
1572
1573         ret = GetClipRgn(hdc, hrgn);
1574         ok(ret == 1, "GetClipRgn returned %d, expected 0\n", ret);
1575
1576         /* Win9x returns empty clipping region */
1577         if (is_win9x) return 1;
1578
1579         ret = GetRegionData(hrgn, 0, NULL);
1580         ok(ret == sizeof(rgn2.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
1581
1582         ret = GetRegionData(hrgn, sizeof(rgn2), &rgn2.data);
1583
1584         trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
1585               rgn2.data.rdh.dwSize, rgn2.data.rdh.iType,
1586               rgn2.data.rdh.nCount, rgn2.data.rdh.nRgnSize,
1587               rgn2.data.rdh.rcBound.left, rgn2.data.rdh.rcBound.top,
1588               rgn2.data.rdh.rcBound.right, rgn2.data.rdh.rcBound.bottom);
1589
1590         rect = rgn2.data.rdh.rcBound;
1591         rc_transformed = *rc;
1592         translate((POINT *)&rc_transformed, 2, &xform);
1593         trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
1594               rc_transformed.right, rc_transformed.bottom);
1595         ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
1596
1597         rect = *(const RECT *)rgn2.data.Buffer;
1598         trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
1599         rc_transformed = *rc;
1600         translate((POINT *)&rc_transformed, 2, &xform);
1601         trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
1602               rc_transformed.right, rc_transformed.bottom);
1603         ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
1604
1605         ok(rgn2.data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn2.data.rdh.dwSize);
1606         ok(rgn2.data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn2.data.rdh.iType);
1607         ok(rgn2.data.rdh.nCount == 1, "expected 1, got %u\n", rgn2.data.rdh.nCount);
1608         ok(rgn2.data.rdh.nRgnSize == sizeof(RECT),  "expected sizeof(RECT), got %u\n", rgn2.data.rdh.nRgnSize);
1609
1610         DeleteObject(hrgn);
1611     }
1612     return 1;
1613 }
1614
1615 static void test_emf_clipping(void)
1616 {
1617     static const RECT rc = { 0, 0, 100, 100 };
1618     RECT rc_clip = { 100, 100, 1024, 1024 };
1619     HWND hwnd;
1620     HDC hdc;
1621     HENHMETAFILE hemf;
1622     HRGN hrgn;
1623     INT ret;
1624
1625     SetLastError(0xdeadbeef);
1626     hdc = CreateEnhMetaFileA(0, NULL, NULL, NULL);
1627     ok(hdc != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
1628
1629     /* Need to write something to the emf, otherwise Windows won't play it back */
1630     LineTo(hdc, 1, 1);
1631
1632     hrgn = CreateRectRgn(rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom);
1633     ret = SelectClipRgn(hdc, hrgn);
1634     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
1635
1636     SetLastError(0xdeadbeef);
1637     hemf = CloseEnhMetaFile(hdc);
1638     ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
1639
1640     if (compare_emf_bits(hemf, EMF_CLIPPING, sizeof(EMF_CLIPPING),
1641         "emf_clipping", FALSE) != 0)
1642     {
1643         dump_emf_bits(hemf, "emf_clipping");
1644         dump_emf_records(hemf, "emf_clipping");
1645     }
1646
1647     DeleteObject(hrgn);
1648
1649     /* Win9x doesn't play EMFs on invisible windows */
1650     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
1651                            0, 0, 200, 200, 0, 0, 0, NULL);
1652     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
1653
1654     hdc = GetDC(hwnd);
1655
1656     ret = EnumEnhMetaFile(hdc, hemf, clip_emf_enum_proc, &rc_clip, &rc);
1657     ok(ret, "EnumEnhMetaFile error %d\n", GetLastError());
1658
1659     DeleteEnhMetaFile(hemf);
1660     ReleaseDC(hwnd, hdc);
1661     DestroyWindow(hwnd);
1662 }
1663
1664 static INT CALLBACK EmfEnumProc(HDC hdc, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR, INT nObj, LPARAM lpData)
1665 {
1666     LPMETAFILEPICT lpMFP = (LPMETAFILEPICT)lpData;
1667     POINT mapping[2] = { { 0, 0 }, { 10, 10 } };
1668     /* When using MM_TEXT Win9x does not update the mapping mode
1669      * until a record is played which actually outputs something */
1670     PlayEnhMetaFileRecord(hdc, lpHTable, lpEMFR, nObj);
1671     LPtoDP(hdc, mapping, 2);
1672     trace("EMF record: iType %d, nSize %d, (%d,%d)-(%d,%d)\n",
1673            lpEMFR->iType, lpEMFR->nSize,
1674            mapping[0].x, mapping[0].y, mapping[1].x, mapping[1].y);
1675
1676     if (lpEMFR->iType == EMR_LINETO)
1677     {
1678         INT x0, y0, x1, y1;
1679         if (!lpMFP || lpMFP->mm == MM_TEXT)
1680         {
1681             x0 = 0;
1682             y0 = 0;
1683             x1 = (INT)floor(10 * 100.0 / LINE_X + 0.5);
1684             y1 = (INT)floor(10 * 100.0 / LINE_Y + 0.5);
1685         }
1686         else
1687         {
1688             ok(lpMFP->mm == MM_ANISOTROPIC, "mm=%d\n", lpMFP->mm);
1689
1690             x0 = MulDiv(0, GetDeviceCaps(hdc, HORZSIZE) * 100, GetDeviceCaps(hdc, HORZRES));
1691             y0 = MulDiv(0, GetDeviceCaps(hdc, VERTSIZE) * 100, GetDeviceCaps(hdc, VERTRES));
1692             x1 = MulDiv(10, GetDeviceCaps(hdc, HORZSIZE) * 100, GetDeviceCaps(hdc, HORZRES));
1693             y1 = MulDiv(10, GetDeviceCaps(hdc, VERTSIZE) * 100, GetDeviceCaps(hdc, VERTRES));
1694         }
1695         ok(mapping[0].x == x0 && mapping[0].y == y0 && mapping[1].x == x1 && mapping[1].y == y1,
1696             "(%d,%d)->(%d,%d), expected (%d,%d)->(%d,%d)\n",
1697             mapping[0].x, mapping[0].y, mapping[1].x, mapping[1].y,
1698             x0, y0, x1, y1);
1699     }
1700     return TRUE;
1701 }
1702
1703 static HENHMETAFILE create_converted_emf(const METAFILEPICT *mfp)
1704 {
1705     HDC hdcMf;
1706     HMETAFILE hmf;
1707     HENHMETAFILE hemf;
1708     BOOL ret;
1709     UINT size;
1710     LPBYTE pBits;
1711
1712     hdcMf = CreateMetaFile(NULL);
1713     ok(hdcMf != NULL, "CreateMetaFile failed with error %d\n", GetLastError());
1714     ret = LineTo(hdcMf, (INT)LINE_X, (INT)LINE_Y);
1715     ok(ret, "LineTo failed with error %d\n", GetLastError());
1716     hmf = CloseMetaFile(hdcMf);
1717     ok(hmf != NULL, "CloseMetaFile failed with error %d\n", GetLastError());
1718
1719     if (compare_mf_bits (hmf, MF_LINETO_BITS, sizeof(MF_LINETO_BITS), "mf_LineTo") != 0)
1720     {
1721         dump_mf_bits(hmf, "mf_LineTo");
1722         EnumMetaFile(0, hmf, mf_enum_proc, 0);
1723     }
1724
1725     size = GetMetaFileBitsEx(hmf, 0, NULL);
1726     ok(size, "GetMetaFileBitsEx failed with error %d\n", GetLastError());
1727     pBits = HeapAlloc(GetProcessHeap(), 0, size);
1728     GetMetaFileBitsEx(hmf, size, pBits);
1729     DeleteMetaFile(hmf);
1730     hemf = SetWinMetaFileBits(size, pBits, NULL, mfp);
1731     HeapFree(GetProcessHeap(), 0, pBits);
1732     return hemf;
1733 }
1734
1735 static void test_mf_conversions(void)
1736 {
1737     trace("Testing MF->EMF conversion (MM_ANISOTROPIC)\n");
1738     {
1739         HDC hdcOffscreen = CreateCompatibleDC(NULL);
1740         HENHMETAFILE hemf;
1741         METAFILEPICT mfp;
1742         RECT rect = { 0, 0, 100, 100 };
1743         mfp.mm = MM_ANISOTROPIC;
1744         mfp.xExt = 100;
1745         mfp.yExt = 100;
1746         mfp.hMF = NULL;
1747         hemf = create_converted_emf(&mfp);
1748
1749         if (compare_emf_bits(hemf, EMF_LINETO_MM_ANISOTROPIC_BITS, sizeof(EMF_LINETO_MM_ANISOTROPIC_BITS),
1750                              "emf_LineTo MM_ANISOTROPIC", TRUE) != 0)
1751         {
1752             dump_emf_bits(hemf, "emf_LineTo MM_ANISOTROPIC");
1753             dump_emf_records(hemf, "emf_LineTo MM_ANISOTROPIC");
1754         }
1755
1756         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, &mfp, &rect);
1757
1758         DeleteEnhMetaFile(hemf);
1759         DeleteDC(hdcOffscreen);
1760     }
1761
1762     trace("Testing MF->EMF conversion (MM_TEXT)\n");
1763     {
1764         HDC hdcOffscreen = CreateCompatibleDC(NULL);
1765         HENHMETAFILE hemf;
1766         METAFILEPICT mfp;
1767         RECT rect = { 0, 0, 100, 100 };
1768         mfp.mm = MM_TEXT;
1769         mfp.xExt = 0;
1770         mfp.yExt = 0;
1771         mfp.hMF = NULL;
1772         hemf = create_converted_emf(&mfp);
1773
1774         if (compare_emf_bits(hemf, EMF_LINETO_MM_TEXT_BITS, sizeof(EMF_LINETO_MM_TEXT_BITS),
1775                              "emf_LineTo MM_TEXT", TRUE) != 0)
1776         {
1777             dump_emf_bits(hemf, "emf_LineTo MM_TEXT");
1778             dump_emf_records(hemf, "emf_LineTo MM_TEXT");
1779         }
1780
1781         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, &mfp, &rect);
1782
1783         DeleteEnhMetaFile(hemf);
1784         DeleteDC(hdcOffscreen);
1785     }
1786
1787     trace("Testing MF->EMF conversion (NULL mfp)\n");
1788     {
1789         HDC hdcOffscreen = CreateCompatibleDC(NULL);
1790         HENHMETAFILE hemf;
1791         RECT rect = { 0, 0, 100, 100 };
1792         hemf = create_converted_emf(NULL);
1793
1794         if (compare_emf_bits(hemf, EMF_LINETO_BITS, sizeof(EMF_LINETO_BITS),
1795                              "emf_LineTo NULL", TRUE) != 0)
1796         {
1797             dump_emf_bits(hemf, "emf_LineTo NULL");
1798             dump_emf_records(hemf, "emf_LineTo NULL");
1799         }
1800
1801         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, NULL, &rect);
1802
1803         DeleteEnhMetaFile(hemf);
1804         DeleteDC(hdcOffscreen);
1805     }
1806 }
1807
1808 static BOOL getConvertedFrameAndBounds(UINT buffer_size, BYTE * buffer, BOOL mfpIsNull,
1809                                        LONG mm, LONG xExt, LONG yExt,
1810                                        RECTL * rclBounds, RECTL * rclFrame)
1811 {
1812   METAFILEPICT mfp;
1813   METAFILEPICT * mfpPtr = NULL;
1814   HENHMETAFILE emf;
1815   ENHMETAHEADER header;
1816   UINT res;
1817
1818   if (!mfpIsNull)
1819   {
1820     mfp.mm = mm;
1821     mfp.xExt = xExt;
1822     mfp.yExt = yExt;
1823     mfpPtr = &mfp;
1824   }
1825
1826   emf = SetWinMetaFileBits(buffer_size, buffer, NULL, mfpPtr);
1827   ok(emf != NULL, "SetWinMetaFileBits failed\n");
1828   if (!emf) return FALSE;
1829   res = GetEnhMetaFileHeader(emf, sizeof(header), &header);
1830   ok(res != 0, "GetEnhMetaHeader failed\n");
1831   DeleteEnhMetaFile(emf);
1832   if (!res) return FALSE;
1833
1834   *rclBounds = header.rclBounds;
1835   *rclFrame = header.rclFrame;
1836   return TRUE;
1837 }
1838
1839 static void checkConvertedFrameAndBounds(UINT buffer_size, BYTE * buffer, BOOL mfpIsNull,
1840                                          LONG mm, LONG xExt, LONG yExt,
1841                                          RECTL * rclBoundsExpected, RECTL * rclFrameExpected)
1842 {
1843   RECTL rclBounds, rclFrame;
1844
1845   if (getConvertedFrameAndBounds(buffer_size, buffer, mfpIsNull, mm, xExt, yExt, &rclBounds, &rclFrame))
1846   {
1847     const char * msg;
1848     char buf[64];
1849
1850     if (mfpIsNull)
1851     {
1852        msg = "mfp == NULL";
1853     }
1854     else
1855     {
1856       const char * mm_str;
1857       switch (mm)
1858       {
1859          case MM_ANISOTROPIC: mm_str = "MM_ANISOTROPIC"; break;
1860          case MM_ISOTROPIC:   mm_str = "MM_ISOTROPIC"; break;
1861          default:             mm_str = "Unexpected";
1862       }
1863       sprintf(buf, "mm=%s, xExt=%d, yExt=%d", mm_str, xExt, yExt);
1864       msg = buf;
1865     }
1866
1867     ok(rclBounds.left == rclBoundsExpected->left, "rclBounds.left: Expected %d, got %d (%s)\n", rclBoundsExpected->left, rclBounds.left, msg);
1868     ok(rclBounds.top == rclBoundsExpected->top, "rclBounds.top: Expected %d, got %d (%s)\n", rclBoundsExpected->top, rclBounds.top, msg);
1869     ok(rclBounds.right == rclBoundsExpected->right, "rclBounds.right: Expected %d, got %d (%s)\n", rclBoundsExpected->right, rclBounds.right, msg);
1870     ok(rclBounds.bottom == rclBoundsExpected->bottom, "rclBounds.bottom: Expected %d, got %d (%s)\n", rclBoundsExpected->bottom, rclBounds.bottom, msg);
1871     ok(rclFrame.left == rclFrameExpected->left, "rclFrame.left: Expected %d, got %d (%s)\n", rclFrameExpected->left, rclFrame.left, msg);
1872     ok(rclFrame.top == rclFrameExpected->top, "rclFrame.top: Expected %d, got %d (%s)\n", rclFrameExpected->top, rclFrame.top, msg);
1873     ok(rclFrame.right == rclFrameExpected->right, "rclFrame.right: Expected %d, got %d (%s)\n", rclFrameExpected->right, rclFrame.right, msg);
1874     ok(rclFrame.bottom == rclFrameExpected->bottom, "rclFrame.bottom: Expected %d, got %d (%s)\n", rclFrameExpected->bottom, rclFrame.bottom, msg);
1875   }
1876 }
1877
1878 static void test_SetWinMetaFileBits(void)
1879 {
1880   HMETAFILE wmf;
1881   HDC wmfDC;
1882   BYTE * buffer;
1883   UINT buffer_size;
1884   RECT rect;
1885   UINT res;
1886   RECTL rclBoundsAnisotropic, rclFrameAnisotropic;
1887   RECTL rclBoundsIsotropic, rclFrameIsotropic;
1888   RECTL rclBounds, rclFrame;
1889   HDC dc;
1890   LONG diffx, diffy;
1891
1892   wmfDC = CreateMetaFile(NULL);
1893   ok(wmfDC != NULL, "CreateMetaFile failed\n");
1894   if (!wmfDC) return;
1895
1896   SetWindowExtEx(wmfDC, 100, 100, NULL);
1897   rect.left = rect.top = 0;
1898   rect.right = rect.bottom = 50;
1899   FillRect(wmfDC, &rect, GetStockObject(BLACK_BRUSH));
1900   wmf = CloseMetaFile(wmfDC);
1901   ok(wmf != NULL, "Metafile creation failed\n");
1902   if (!wmf) return;
1903
1904   buffer_size = GetMetaFileBitsEx(wmf, 0, NULL);
1905   ok(buffer_size != 0, "GetMetaFileBitsEx failed\n");
1906   if (buffer_size == 0)
1907   {
1908     DeleteMetaFile(wmf);
1909     return;
1910   }
1911
1912   buffer = HeapAlloc(GetProcessHeap(), 0, buffer_size);
1913   ok(buffer != NULL, "HeapAlloc failed\n");
1914   if (!buffer)
1915   {
1916     DeleteMetaFile(wmf);
1917     return;
1918   }
1919
1920   res = GetMetaFileBitsEx(wmf, buffer_size, buffer);
1921   ok(res == buffer_size, "GetMetaFileBitsEx failed\n");
1922   DeleteMetaFile(wmf);
1923   if (res != buffer_size)
1924   {
1925      HeapFree(GetProcessHeap(), 0, buffer);
1926      return;
1927   }
1928
1929   /* Get the reference bounds and frame */
1930   getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1931   getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, 0,  &rclBoundsIsotropic, &rclFrameIsotropic);
1932
1933   ok(rclBoundsAnisotropic.left == 0 && rclBoundsAnisotropic.top == 0 &&
1934      rclBoundsIsotropic.left == 0 && rclBoundsIsotropic.top == 0,
1935      "SetWinMetaFileBits: Reference bounds: Left and top bound must be zero\n");
1936
1937   ok(rclBoundsAnisotropic.right >= rclBoundsIsotropic.right, "SetWinMetaFileBits: Reference bounds: Invalid right bound\n");
1938   ok(rclBoundsAnisotropic.bottom >= rclBoundsIsotropic.bottom, "SetWinMetaFileBits: Reference bounds: Invalid bottom bound\n");
1939   diffx = rclBoundsIsotropic.right - rclBoundsIsotropic.bottom;
1940   if (diffx < 0) diffx = -diffx;
1941   ok(diffx <= 1, "SetWinMetaFileBits (MM_ISOTROPIC): Reference bounds are not isotropic\n");
1942
1943   dc = CreateCompatibleDC(NULL);
1944
1945   /* Allow 1 mm difference (rounding errors) */
1946   diffx = rclBoundsAnisotropic.right - GetDeviceCaps(dc, HORZRES) / 2;
1947   diffy = rclBoundsAnisotropic.bottom - GetDeviceCaps(dc, VERTRES) / 2;
1948   if (diffx < 0) diffx = -diffx;
1949   if (diffy < 0) diffy = -diffy;
1950   todo_wine
1951   {
1952   ok(diffx <= 1 && diffy <= 1,
1953      "SetWinMetaFileBits (MM_ANISOTROPIC): Reference bounds: The whole device surface must be used (%dx%d), but got (%dx%d)\n",
1954      GetDeviceCaps(dc, HORZRES) / 2, GetDeviceCaps(dc, VERTRES) / 2, rclBoundsAnisotropic.right, rclBoundsAnisotropic.bottom);
1955   }
1956
1957   /* Allow 1 mm difference (rounding errors) */
1958   diffx = rclFrameAnisotropic.right / 100 - GetDeviceCaps(dc, HORZSIZE) / 2;
1959   diffy = rclFrameAnisotropic.bottom / 100 - GetDeviceCaps(dc, VERTSIZE) / 2;
1960   if (diffx < 0) diffx = -diffx;
1961   if (diffy < 0) diffy = -diffy;
1962   todo_wine
1963   {
1964   ok(diffx <= 1 && diffy <= 1,
1965      "SetWinMetaFileBits (MM_ANISOTROPIC): Reference frame: The whole device surface must be used (%dx%d), but got (%dx%d)\n",
1966      GetDeviceCaps(dc, HORZSIZE) / 2, GetDeviceCaps(dc, VERTSIZE) / 2, rclFrameAnisotropic.right / 100, rclFrameAnisotropic.bottom / 100);
1967   }
1968   DeleteDC(dc);
1969
1970   /* If the METAFILEPICT pointer is NULL, the MM_ANISOTROPIC mapping mode and the whole device surface are used */
1971   checkConvertedFrameAndBounds(buffer_size, buffer, TRUE, 0, 0, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1972
1973   /* If xExt or yExt is zero or negative, the whole device surface is used */
1974   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 10000, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1975   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 10000, 0, &rclBoundsIsotropic, &rclFrameIsotropic);
1976   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, 10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1977   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, 10000, &rclBoundsIsotropic, &rclFrameIsotropic);
1978   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -10000, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1979   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -10000, 0, &rclBoundsIsotropic, &rclFrameIsotropic);
1980   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, -10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1981   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, -10000, &rclBoundsIsotropic, &rclFrameIsotropic);
1982   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -10000, 10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1983   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -10000, 10000, &rclBoundsIsotropic, &rclFrameIsotropic);
1984   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 10000, -10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1985   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 10000, -10000, &rclBoundsIsotropic, &rclFrameIsotropic);
1986
1987   /* MSDN says that negative xExt and yExt values specify a ratio.
1988      Check that this is wrong and the whole device surface is used */
1989   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -1000, -100, &rclBoundsAnisotropic, &rclFrameAnisotropic);
1990   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -1000, -100, &rclBoundsIsotropic, &rclFrameIsotropic);
1991
1992   /* Ordinary conversions */
1993
1994   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 30000, 20000, &rclBounds, &rclFrame))
1995   {
1996     ok(rclFrame.left == 0 && rclFrame.top == 0 && rclFrame.right == 30000 && rclFrame.bottom == 20000,
1997        "SetWinMetaFileBits (MM_ANISOTROPIC): rclFrame contains invalid values\n");
1998     ok(rclBounds.left == 0 && rclBounds.top == 0 && rclBounds.right > rclBounds.bottom,
1999        "SetWinMetaFileBits (MM_ANISOTROPIC): rclBounds contains invalid values\n");
2000   }
2001
2002   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 30000, 20000, &rclBounds, &rclFrame))
2003   {
2004     ok(rclFrame.left == 0 && rclFrame.top == 0 && rclFrame.right == 30000 && rclFrame.bottom == 20000,
2005        "SetWinMetaFileBits (MM_ISOTROPIC): rclFrame contains invalid values\n");
2006     ok(rclBounds.left == 0 && rclBounds.top == 0,
2007        "SetWinMetaFileBits (MM_ISOTROPIC): rclBounds contains invalid values\n");
2008
2009     /* Wine has a rounding error */
2010     diffx = rclBounds.right - rclBounds.bottom;
2011     if (diffx < 0) diffx = -diffx;
2012     ok(diffx <= 1, "SetWinMetaFileBits (MM_ISOTROPIC): rclBounds is not isotropic\n");
2013   }
2014
2015   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_HIMETRIC, 30000, 20000, &rclBounds, &rclFrame))
2016   {
2017     ok(rclFrame.right - rclFrame.left != 30000 && rclFrame.bottom - rclFrame.top != 20000,
2018        "SetWinMetaFileBits: xExt and yExt must be ignored for mapping modes other than MM_ANISOTROPIC and MM_ISOTROPIC\n");
2019   }
2020
2021   HeapFree(GetProcessHeap(), 0, buffer);
2022 }
2023
2024 static BOOL (WINAPI *pGdiIsMetaPrintDC)(HDC);
2025 static BOOL (WINAPI *pGdiIsMetaFileDC)(HDC);
2026 static BOOL (WINAPI *pGdiIsPlayMetafileDC)(HDC);
2027
2028 static void test_gdiis(void)
2029 {
2030     RECT rect = {0,0,100,100};
2031     HDC hdc, hemfDC, hmfDC;
2032     HENHMETAFILE hemf;
2033     HMODULE hgdi32;
2034
2035     /* resolve all the functions */
2036     hgdi32 = GetModuleHandle("gdi32");
2037     pGdiIsMetaPrintDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaPrintDC");
2038     pGdiIsMetaFileDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaFileDC");
2039     pGdiIsPlayMetafileDC = (void*) GetProcAddress(hgdi32, "GdiIsPlayMetafileDC");
2040
2041     if(!pGdiIsMetaPrintDC || !pGdiIsMetaFileDC || !pGdiIsPlayMetafileDC)
2042     {
2043         win_skip("Needed GdiIs* functions are not available\n");
2044         return;
2045     }
2046
2047     /* try with nothing */
2048     ok(!pGdiIsMetaPrintDC(NULL), "ismetaprint with NULL parameter\n");
2049     ok(!pGdiIsMetaFileDC(NULL), "ismetafile with NULL parameter\n");
2050     ok(!pGdiIsPlayMetafileDC(NULL), "isplaymetafile with NULL parameter\n");
2051
2052     /* try with a metafile */
2053     hmfDC = CreateMetaFile(NULL);
2054     ok(!pGdiIsMetaPrintDC(hmfDC), "ismetaprint on metafile\n");
2055     ok(pGdiIsMetaFileDC(hmfDC), "ismetafile on metafile\n");
2056     ok(!pGdiIsPlayMetafileDC(hmfDC), "isplaymetafile on metafile\n");
2057     DeleteMetaFile(CloseMetaFile(hmfDC));
2058
2059     /* try with an enhanced metafile */
2060     hdc = GetDC(NULL);
2061     hemfDC = CreateEnhMetaFileW(hdc, NULL, &rect, NULL);
2062     ok(hemfDC != NULL, "failed to create emf\n");
2063
2064     ok(!pGdiIsMetaPrintDC(hemfDC), "ismetaprint on emf\n");
2065     ok(pGdiIsMetaFileDC(hemfDC), "ismetafile on emf\n");
2066     ok(!pGdiIsPlayMetafileDC(hemfDC), "isplaymetafile on emf\n");
2067
2068     hemf = CloseEnhMetaFile(hemfDC);
2069     ok(hemf != NULL, "failed to close EMF\n");
2070     DeleteEnhMetaFile(hemf);
2071     ReleaseDC(NULL,hdc);
2072 }
2073
2074 static void test_SetEnhMetaFileBits(void)
2075 {
2076     BYTE data[256];
2077     HENHMETAFILE hemf;
2078     ENHMETAHEADER *emh;
2079
2080     memset(data, 0xAA, sizeof(data));
2081     SetLastError(0xdeadbeef);
2082     hemf = SetEnhMetaFileBits(sizeof(data), data);
2083     ok(!hemf, "SetEnhMetaFileBits should fail\n");
2084     ok(GetLastError() == ERROR_INVALID_DATA ||
2085        GetLastError() == ERROR_INVALID_PARAMETER, /* Win9x, WinMe */
2086        "expected ERROR_INVALID_DATA or ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
2087
2088     emh = (ENHMETAHEADER *)data;
2089     memset(emh, 0, sizeof(*emh));
2090
2091     emh->iType = EMR_HEADER;
2092     emh->nSize = sizeof(*emh);
2093     emh->dSignature = ENHMETA_SIGNATURE;
2094     /* emh->nVersion  = 0x10000; XP doesn't care about version */
2095     emh->nBytes = sizeof(*emh);
2096     /* emh->nRecords = 1; XP doesn't care about records */
2097     emh->nHandles = 1; /* XP refuses to load a EMF if nHandles == 0 */
2098
2099     SetLastError(0xdeadbeef);
2100     hemf = SetEnhMetaFileBits(emh->nBytes, data);
2101     ok(hemf != 0, "SetEnhMetaFileBits error %u\n", GetLastError());
2102     DeleteEnhMetaFile(hemf);
2103
2104     /* XP refuses to load unaligned EMF */
2105     emh->nBytes++;
2106     SetLastError(0xdeadbeef);
2107     hemf = SetEnhMetaFileBits(emh->nBytes, data);
2108     ok(!hemf ||
2109        broken(hemf != NULL), /* Win9x, WinMe */
2110        "SetEnhMetaFileBits should fail\n");
2111     todo_wine
2112     ok(GetLastError() == 0xdeadbeef, "Expected deadbeef, got %u\n", GetLastError());
2113     DeleteEnhMetaFile(hemf);
2114
2115     emh->dSignature = 0;
2116     emh->nBytes--;
2117     SetLastError(0xdeadbeef);
2118     hemf = SetEnhMetaFileBits(emh->nBytes, data);
2119     ok(!hemf ||
2120        broken(hemf != NULL), /* Win9x, WinMe */
2121        "SetEnhMetaFileBits should fail\n");
2122     todo_wine
2123     ok(GetLastError() == 0xdeadbeef, "Expected deadbeef, got %u\n", GetLastError());
2124     DeleteEnhMetaFile(hemf);
2125 }
2126
2127 START_TEST(metafile)
2128 {
2129     init_function_pointers();
2130
2131     /* For enhanced metafiles (enhmfdrv) */
2132     test_ExtTextOut();
2133     test_SaveDC();
2134
2135     /* For win-format metafiles (mfdrv) */
2136     test_mf_Blank();
2137     test_mf_Graphics();
2138     test_mf_PatternBrush();
2139     test_CopyMetaFile();
2140     test_SetMetaFileBits();
2141     test_mf_ExtTextOut_on_path();
2142     test_emf_ExtTextOut_on_path();
2143     test_emf_clipping();
2144
2145     /* For metafile conversions */
2146     test_mf_conversions();
2147     test_SetWinMetaFileBits();
2148
2149     test_gdiis();
2150     test_SetEnhMetaFileBits();
2151 }