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 static COLORREF (WINAPI *pSetDCBrushColor)(HDC,COLORREF);
  41 static COLORREF (WINAPI *pSetDCPenColor)(HDC,COLORREF);
  42
  43 #define GDI_GET_PROC(func)                                     \
  44     p ## func = (void *)GetProcAddress(hGDI, #func);           \
  45     if(!p ## func)                                             \
  46         trace("GetProcAddress(hGDI, \"%s\") failed\n", #func); \
  47
  48 static void init_function_pointers(void)
  49 {
  50     HMODULE hGDI;
  51
  52     pGetRelAbs = NULL;
  53     pSetRelAbs = NULL;
  54
  55     hGDI = GetModuleHandleA("gdi32.dll");
  56     assert(hGDI);
  57     GDI_GET_PROC(GetRelAbs);
  58     GDI_GET_PROC(SetRelAbs);
  59     GDI_GET_PROC(SetDCBrushColor);
  60     GDI_GET_PROC(SetDCPenColor);
  61 }
  62
  63 static int CALLBACK eto_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
  64     const ENHMETARECORD *emr, int n_objs, LPARAM param)
  65 {
  66     static int n_record;
  67     DWORD i;
  68     const INT *dx;
  69     INT *orig_dx = (INT *)param;
  70     LOGFONTA device_lf;
  71     INT ret;
  72
  73     trace("hdc %p, emr->iType %d, emr->nSize %d, param %p\n",
  74            hdc, emr->iType, emr->nSize, (void *)param);
  75
  76     if(!hdc) return 1;
  77
  78     PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
  79
  80     switch (emr->iType)
  81     {
  82     case EMR_HEADER:
  83         ok(GetTextAlign(hdc) == 0, "text align %08x\n", GetTextAlign(hdc));
  84         ok(GetBkColor(hdc) == RGB(0xff, 0xff, 0xff), "bk color %08x\n", GetBkColor(hdc));
  85         ok(GetTextColor(hdc) == RGB(0x0, 0x0, 0x0), "text color %08x\n", GetTextColor(hdc));
  86         ok(GetROP2(hdc) == R2_COPYPEN, "rop %d\n", GetROP2(hdc));
  87         ok(GetArcDirection(hdc) == AD_COUNTERCLOCKWISE, "arc dir %d\n", GetArcDirection(hdc));
  88         ok(GetPolyFillMode(hdc) == ALTERNATE, "poly fill %d\n", GetPolyFillMode(hdc));
  89         ok(GetStretchBltMode(hdc) == BLACKONWHITE, "stretchblt mode %d\n", GetStretchBltMode(hdc));
  90
  91         /* GetBkMode, GetRelAbs do not get reset to the default value */
  92         ok(GetBkMode(hdc) == OPAQUE, "bk mode %d\n", GetBkMode(hdc));
  93         if(pSetRelAbs && pGetRelAbs)
  94             ok(pGetRelAbs(hdc, 0) == RELATIVE, "relabs %d\n", pGetRelAbs(hdc, 0));
  95
  96         n_record = 0;
  97         break;
  98
  99     case EMR_EXTTEXTOUTA:
 100     {
 101         const EMREXTTEXTOUTA *emr_ExtTextOutA = (const EMREXTTEXTOUTA *)emr;
 102         dx = (const INT *)((const char *)emr + emr_ExtTextOutA->emrtext.offDx);
 103
 104         ret = GetObjectA(GetCurrentObject(hdc, OBJ_FONT), sizeof(device_lf), &device_lf);
 105         ok( ret == sizeof(device_lf), "GetObjectA error %d\n", GetLastError());
 106
 107         /* compare up to lfOutPrecision, other values are not interesting,
 108          * and in fact sometimes arbitrary adapted by Win9x.
 109          */
 110         ok(!memcmp(&orig_lf, &device_lf, FIELD_OFFSET(LOGFONTA, lfOutPrecision)), "fonts don't match\n");
 111         ok(!lstrcmpA(orig_lf.lfFaceName, device_lf.lfFaceName), "font names don't match\n");
 112
 113         for(i = 0; i < emr_ExtTextOutA->emrtext.nChars; i++)
 114         {
 115             ok(orig_dx[i] == dx[i], "pass %d: dx[%d] (%d) didn't match %d\n",
 116                                      n_record, i, dx[i], orig_dx[i]);
 117         }
 118         n_record++;
 119         emr_processed = TRUE;
 120         break;
 121     }
 122
 123     case EMR_EXTTEXTOUTW:
 124     {
 125         const EMREXTTEXTOUTW *emr_ExtTextOutW = (const EMREXTTEXTOUTW *)emr;
 126         dx = (const INT *)((const char *)emr + emr_ExtTextOutW->emrtext.offDx);
 127
 128         SetLastError(0xdeadbeef);
 129         ret = GetObjectA(GetCurrentObject(hdc, OBJ_FONT), sizeof(device_lf), &device_lf);
 130         ok( ret == sizeof(device_lf) ||
 131             broken(ret == (sizeof(device_lf) - LF_FACESIZE + strlen(device_lf.lfFaceName) + 1)), /* NT4 */
 132             "GetObjectA error %d\n", GetLastError());
 133
 134         /* compare up to lfOutPrecision, other values are not interesting,
 135          * and in fact sometimes arbitrary adapted by Win9x.
 136          */
 137         ok(!memcmp(&orig_lf, &device_lf, FIELD_OFFSET(LOGFONTA, lfOutPrecision)), "fonts don't match\n");
 138         ok(!lstrcmpA(orig_lf.lfFaceName, device_lf.lfFaceName), "font names don't match\n");
 139
 140         for(i = 0; i < emr_ExtTextOutW->emrtext.nChars; i++)
 141         {
 142             ok(orig_dx[i] == dx[i], "pass %d: dx[%d] (%d) didn't match %d\n",
 143                                      n_record, i, dx[i], orig_dx[i]);
 144         }
 145         n_record++;
 146         emr_processed = TRUE;
 147         break;
 148     }
 149
 150     default:
 151         break;
 152     }
 153
 154     return 1;
 155 }
 156
 157 static void test_ExtTextOut(void)
 158 {
 159     HWND hwnd;
 160     HDC hdcDisplay, hdcMetafile;
 161     HENHMETAFILE hMetafile;
 162     HFONT hFont;
 163     static const char text[] = "Simple text to test ExtTextOut on metafiles";
 164     INT i, len, dx[256];
 165     static const RECT rc = { 0, 0, 100, 100 };
 166     BOOL ret;
 167
 168     assert(sizeof(dx)/sizeof(dx[0]) >= lstrlenA(text));
 169
 170     /* Win9x doesn't play EMFs on invisible windows */
 171     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
 172                            0, 0, 200, 200, 0, 0, 0, NULL);
 173     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
 174
 175     hdcDisplay = GetDC(hwnd);
 176     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
 177
 178     trace("hdcDisplay %p\n", hdcDisplay);
 179
 180     SetMapMode(hdcDisplay, MM_TEXT);
 181
 182     memset(&orig_lf, 0, sizeof(orig_lf));
 183
 184     orig_lf.lfCharSet = ANSI_CHARSET;
 185     orig_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 186     orig_lf.lfWeight = FW_DONTCARE;
 187     orig_lf.lfHeight = 7;
 188     orig_lf.lfQuality = DEFAULT_QUALITY;
 189     lstrcpyA(orig_lf.lfFaceName, "Arial");
 190     hFont = CreateFontIndirectA(&orig_lf);
 191     ok(hFont != 0, "CreateFontIndirectA error %d\n", GetLastError());
 192
 193     hFont = SelectObject(hdcDisplay, hFont);
 194
 195     len = lstrlenA(text);
 196     for (i = 0; i < len; i++)
 197     {
 198         ret = GetCharWidthA(hdcDisplay, text[i], text[i], &dx[i]);
 199         ok( ret, "GetCharWidthA error %d\n", GetLastError());
 200     }
 201     hFont = SelectObject(hdcDisplay, hFont);
 202
 203     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
 204     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
 205
 206     trace("hdcMetafile %p\n", hdcMetafile);
 207
 208     ok(GetDeviceCaps(hdcMetafile, TECHNOLOGY) == DT_RASDISPLAY,
 209        "GetDeviceCaps(TECHNOLOGY) has to return DT_RASDISPLAY for a display based EMF\n");
 210
 211     hFont = SelectObject(hdcMetafile, hFont);
 212
 213     /* 1. pass NULL lpDx */
 214     ret = ExtTextOutA(hdcMetafile, 0, 0, 0, &rc, text, lstrlenA(text), NULL);
 215     ok( ret, "ExtTextOutA error %d\n", GetLastError());
 216
 217     /* 2. pass custom lpDx */
 218     ret = ExtTextOutA(hdcMetafile, 0, 20, 0, &rc, text, lstrlenA(text), dx);
 219     ok( ret, "ExtTextOutA error %d\n", GetLastError());
 220
 221     hFont = SelectObject(hdcMetafile, hFont);
 222     ret = DeleteObject(hFont);
 223     ok( ret, "DeleteObject error %d\n", GetLastError());
 224
 225     hMetafile = CloseEnhMetaFile(hdcMetafile);
 226     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
 227
 228     ok(!GetObjectType(hdcMetafile), "CloseEnhMetaFile has to destroy metafile hdc\n");
 229
 230     ret = PlayEnhMetaFile(hdcDisplay, hMetafile, &rc);
 231     ok( ret, "PlayEnhMetaFile error %d\n", GetLastError());
 232
 233     SetTextAlign(hdcDisplay, TA_UPDATECP | TA_CENTER | TA_BASELINE | TA_RTLREADING );
 234     SetBkColor(hdcDisplay, RGB(0xff, 0, 0));
 235     SetTextColor(hdcDisplay, RGB(0, 0xff, 0));
 236     SetROP2(hdcDisplay, R2_NOT);
 237     SetArcDirection(hdcDisplay, AD_CLOCKWISE);
 238     SetPolyFillMode(hdcDisplay, WINDING);
 239     SetStretchBltMode(hdcDisplay, HALFTONE);
 240
 241     if(pSetRelAbs) pSetRelAbs(hdcDisplay, RELATIVE);
 242     SetBkMode(hdcDisplay, OPAQUE);
 243
 244     ret = EnumEnhMetaFile(hdcDisplay, hMetafile, eto_emf_enum_proc, dx, &rc);
 245     ok( ret, "EnumEnhMetaFile error %d\n", GetLastError());
 246
 247     ok( GetTextAlign(hdcDisplay) == (TA_UPDATECP | TA_CENTER | TA_BASELINE | TA_RTLREADING),
 248         "text align %08x\n", GetTextAlign(hdcDisplay));
 249     ok( GetBkColor(hdcDisplay) == RGB(0xff, 0, 0), "bk color %08x\n", GetBkColor(hdcDisplay));
 250     ok( GetTextColor(hdcDisplay) == RGB(0, 0xff, 0), "text color %08x\n", GetTextColor(hdcDisplay));
 251     ok( GetROP2(hdcDisplay) == R2_NOT, "rop2 %d\n", GetROP2(hdcDisplay));
 252     ok( GetArcDirection(hdcDisplay) == AD_CLOCKWISE, "arc dir  %d\n", GetArcDirection(hdcDisplay));
 253     ok( GetPolyFillMode(hdcDisplay) == WINDING, "poly fill %d\n", GetPolyFillMode(hdcDisplay));
 254     ok( GetStretchBltMode(hdcDisplay) == HALFTONE, "stretchblt mode %d\n", GetStretchBltMode(hdcDisplay));
 255
 256     ok(emr_processed, "EnumEnhMetaFile couldn't find EMR_EXTTEXTOUTA or EMR_EXTTEXTOUTW record\n");
 257
 258     ok(!EnumEnhMetaFile(hdcDisplay, hMetafile, eto_emf_enum_proc, dx, NULL),
 259        "A valid hdc has to require a valid rc\n");
 260
 261     ok(EnumEnhMetaFile(NULL, hMetafile, eto_emf_enum_proc, dx, NULL),
 262        "A null hdc does not require a valid rc\n");
 263
 264     ret = DeleteEnhMetaFile(hMetafile);
 265     ok( ret, "DeleteEnhMetaFile error %d\n", GetLastError());
 266     ret = ReleaseDC(hwnd, hdcDisplay);
 267     ok( ret, "ReleaseDC error %d\n", GetLastError());
 268     DestroyWindow(hwnd);
 269 }
 270
 271 struct eto_scale_test_record
 272 {
 273     INT graphics_mode;
 274     INT map_mode;
 275     double ex_scale;
 276     double ey_scale;
 277     BOOL processed;
 278 };
 279
 280 static int CALLBACK eto_scale_enum_proc(HDC hdc, HANDLETABLE *handle_table,
 281     const ENHMETARECORD *emr, int n_objs, LPARAM param)
 282 {
 283     struct eto_scale_test_record *test = (struct eto_scale_test_record*)param;
 284
 285     if (emr->iType == EMR_EXTTEXTOUTW)
 286     {
 287         const EMREXTTEXTOUTW *pExtTextOutW = (const EMREXTTEXTOUTW *)emr;
 288         trace("gm %d, mm %d, scale %f, %f, expected %f, %f\n",
 289               test->graphics_mode, test->map_mode,
 290               pExtTextOutW->exScale, pExtTextOutW->eyScale,
 291               test->ex_scale, test->ey_scale);
 292         ok(fabs(test->ex_scale - pExtTextOutW->exScale) < 0.001,
 293            "Got exScale %f, expected %f\n", pExtTextOutW->exScale, test->ex_scale);
 294         ok(fabs(test->ey_scale - pExtTextOutW->eyScale) < 0.001,
 295            "Got eyScale %f, expected %f\n", pExtTextOutW->eyScale, test->ey_scale);
 296         test->processed = TRUE;
 297     }
 298
 299     return 1;
 300 }
 301
 302 static void test_ExtTextOutScale(void)
 303 {
 304     const RECT rc = { 0, 0, 100, 100 };
 305     const WCHAR str[] = {'a',0 };
 306     struct eto_scale_test_record test;
 307     HDC hdcDisplay, hdcMetafile;
 308     HENHMETAFILE hMetafile;
 309     HWND hwnd;
 310     SIZE wndext, vportext;
 311     int horzSize, vertSize, horzRes, vertRes;
 312     int ret;
 313     int i;
 314
 315     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
 316                            0, 0, 200, 200, 0, 0, 0, NULL);
 317     ok(hwnd != 0, "CreateWindowExA failed\n");
 318
 319     hdcDisplay = GetDC(hwnd);
 320     ok(hdcDisplay != 0, "GetDC failed\n");
 321
 322     horzSize = GetDeviceCaps(hdcDisplay, HORZSIZE);
 323     horzRes  = GetDeviceCaps(hdcDisplay, HORZRES);
 324     vertSize = GetDeviceCaps(hdcDisplay, VERTSIZE);
 325     vertRes  = GetDeviceCaps(hdcDisplay, VERTRES);
 326     ok(horzSize && horzRes && vertSize && vertRes, "GetDeviceCaps failed\n");
 327
 328     for (i = 0; i < 16; i++)
 329     {
 330         test.graphics_mode = i / 8 + 1;
 331         test.map_mode      = i % 8 + 1;
 332
 333         ret = SetGraphicsMode(hdcDisplay, test.graphics_mode);
 334         ok(ret, "SetGraphicsMode failed\n");
 335         ret = SetMapMode(hdcDisplay, test.map_mode);
 336         ok(ret, "SetMapMode failed\n");
 337
 338         if ((test.map_mode == MM_ISOTROPIC) || (test.map_mode == MM_ANISOTROPIC))
 339         {
 340             ret = SetWindowExtEx(hdcDisplay, 1, 1, NULL);
 341             ok(ret, "SetWindowExtEx failed\n");
 342             ret = SetViewportExtEx(hdcDisplay, -20, -10, NULL);
 343             ok(ret, "SetViewportExtEx failed\n");
 344         }
 345
 346         ret = GetViewportExtEx(hdcDisplay, &vportext);
 347         ok(ret, "GetViewportExtEx failed\n");
 348         ret = GetWindowExtEx(hdcDisplay, &wndext);
 349         ok(ret, "GetWindowExtEx failed\n");
 350
 351         trace("gm %d, mm %d, wnd %d,%d, vp %d,%d horz %d,%d vert %d,%d\n",
 352                test.graphics_mode, test.map_mode,
 353                wndext.cx, wndext.cy, vportext.cx, vportext.cy,
 354                horzSize, horzRes, vertSize, vertRes);
 355
 356         if (test.graphics_mode == GM_COMPATIBLE)
 357         {
 358             test.ex_scale = 100.0 * ((FLOAT)horzSize  / (FLOAT)horzRes) /
 359                                     ((FLOAT)wndext.cx / (FLOAT)vportext.cx);
 360             test.ey_scale = 100.0 * ((FLOAT)vertSize  / (FLOAT)vertRes) /
 361                                     ((FLOAT)wndext.cy / (FLOAT)vportext.cy);
 362         }
 363         else
 364         {
 365             test.ex_scale = 0.0;
 366             test.ey_scale = 0.0;
 367         }
 368
 369         hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
 370         ok(hdcMetafile != 0, "CreateEnhMetaFileA failed\n");
 371
 372         ret = SetGraphicsMode(hdcMetafile, test.graphics_mode);
 373         ok(ret, "SetGraphicsMode failed\n");
 374         ret = SetMapMode(hdcMetafile, test.map_mode);
 375         ok(ret, "SetMapMode failed\n");
 376
 377         if ((test.map_mode == MM_ISOTROPIC) || (test.map_mode == MM_ANISOTROPIC))
 378         {
 379             ret = SetWindowExtEx(hdcMetafile, 1, 1, NULL);
 380             ok(ret, "SetWindowExtEx failed\n");
 381             ret = SetViewportExtEx(hdcMetafile, -20, -10, NULL);
 382             ok(ret, "SetViewportExtEx failed\n");
 383         }
 384
 385         ret = ExtTextOutW(hdcMetafile, 0, 0, 0, 0, str, 1, NULL);
 386         ok(ret, "ExtTextOutW failed\n");
 387
 388         hMetafile = CloseEnhMetaFile(hdcMetafile);
 389         ok(hMetafile != 0, "CloseEnhMetaFile failed\n");
 390
 391         test.processed = 0;
 392         ret = EnumEnhMetaFile(hdcDisplay, hMetafile, eto_scale_enum_proc, &test, &rc);
 393         ok(ret, "EnumEnhMetaFile failed\n");
 394         ok(test.processed, "EnumEnhMetaFile couldn't find EMR_EXTTEXTOUTW record\n");
 395
 396         ret = DeleteEnhMetaFile(hMetafile);
 397         ok(ret, "DeleteEnhMetaFile failed\n");
 398     }
 399
 400     ret = ReleaseDC(hwnd, hdcDisplay);
 401     ok(ret, "ReleaseDC failed\n");
 402     DestroyWindow(hwnd);
 403 }
 404
 405
 406 static void check_dc_state(HDC hdc, int restore_no,
 407                            int wnd_org_x, int wnd_org_y, int wnd_ext_x, int wnd_ext_y,
 408                            int vp_org_x, int vp_org_y, int vp_ext_x, int vp_ext_y)
 409 {
 410     BOOL ret;
 411     XFORM xform;
 412     POINT vp_org, win_org;
 413     SIZE vp_size, win_size;
 414     FLOAT xscale, yscale, edx, edy;
 415
 416     SetLastError(0xdeadbeef);
 417     ret = GetWorldTransform(hdc, &xform);
 418     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) goto win9x_here;
 419     ok(ret, "GetWorldTransform error %u\n", GetLastError());
 420
 421     trace("%d: eM11 %f, eM22 %f, eDx %f, eDy %f\n", restore_no, xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 422
 423     ok(xform.eM12 == 0.0, "%d: expected eM12 0.0, got %f\n", restore_no, xform.eM12);
 424     ok(xform.eM21 == 0.0, "%d: expected eM21 0.0, got %f\n", restore_no, xform.eM21);
 425
 426     xscale = (FLOAT)vp_ext_x / (FLOAT)wnd_ext_x;
 427     trace("x scale %f\n", xscale);
 428     ok(fabs(xscale - xform.eM11) < 0.01, "%d: vp_ext_x %d, wnd_ext_cx %d, eM11 %f\n",
 429        restore_no, vp_ext_x, wnd_ext_x, xform.eM11);
 430
 431     yscale = (FLOAT)vp_ext_y / (FLOAT)wnd_ext_y;
 432     trace("y scale %f\n", yscale);
 433     ok(fabs(yscale - xform.eM22) < 0.01, "%d: vp_ext_y %d, wnd_ext_y %d, eM22 %f\n",
 434        restore_no, vp_ext_y, wnd_ext_y, xform.eM22);
 435
 436     edx = (FLOAT)vp_org_x - xform.eM11 * (FLOAT)wnd_org_x;
 437     ok(fabs(edx - xform.eDx) < 0.01, "%d: edx %f != eDx %f\n", restore_no, edx, xform.eDx);
 438     edy = (FLOAT)vp_org_y - xform.eM22 * (FLOAT)wnd_org_y;
 439     ok(fabs(edy - xform.eDy) < 0.01, "%d: edy %f != eDy %f\n", restore_no, edy, xform.eDy);
 440
 441     return;
 442
 443 win9x_here:
 444
 445     GetWindowOrgEx(hdc, &win_org);
 446     GetViewportOrgEx(hdc, &vp_org);
 447     GetWindowExtEx(hdc, &win_size);
 448     GetViewportExtEx(hdc, &vp_size);
 449
 450     ok(wnd_org_x == win_org.x, "%d: wnd_org_x: %d != %d\n", restore_no, wnd_org_x, win_org.x);
 451     ok(wnd_org_y == win_org.y, "%d: wnd_org_y: %d != %d\n", restore_no, wnd_org_y, win_org.y);
 452
 453     ok(vp_org_x == vp_org.x, "%d: vport_org_x: %d != %d\n", restore_no, vp_org_x, vp_org.x);
 454     ok(vp_org_y == vp_org.y, "%d: vport_org_y: %d != %d\n", restore_no, vp_org_y, vp_org.y);
 455
 456     ok(wnd_ext_x == win_size.cx, "%d: wnd_ext_x: %d != %d\n", restore_no, wnd_ext_x, win_size.cx);
 457     ok(wnd_ext_y == win_size.cy, "%d: wnd_ext_y: %d != %d\n", restore_no, wnd_ext_y, win_size.cy);
 458
 459     ok(vp_ext_x == vp_size.cx, "%d: vport_ext_x: %d != %d\n", restore_no, vp_ext_x, vp_size.cx);
 460     ok(vp_ext_y == vp_size.cy, "%d: vport_ext_y: %d != %d\n", restore_no, vp_ext_y, vp_size.cy);
 461 }
 462
 463 static int CALLBACK savedc_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
 464                                          const ENHMETARECORD *emr, int n_objs, LPARAM param)
 465 {
 466     BOOL ret;
 467     XFORM xform;
 468     POINT pt;
 469     SIZE size;
 470     static int save_state;
 471     static int restore_no;
 472     static int select_no;
 473
 474     trace("hdc %p, emr->iType %d, emr->nSize %d, param %p\n",
 475            hdc, emr->iType, emr->nSize, (void *)param);
 476
 477     trace("BEFORE:\n");
 478     SetLastError(0xdeadbeef);
 479     ret = GetWorldTransform(hdc, &xform);
 480     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 481     {
 482         ret = GetWindowOrgEx(hdc, &pt);
 483         ok(ret, "GetWindowOrgEx error %u\n", GetLastError());
 484         trace("window org (%d,%d)\n", pt.x, pt.y);
 485         ret = GetViewportOrgEx(hdc, &pt);
 486         ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 487         trace("vport org (%d,%d)\n", pt.x, pt.y);
 488         ret = GetWindowExtEx(hdc, &size);
 489         ok(ret, "GetWindowExtEx error %u\n", GetLastError());
 490         trace("window ext (%d,%d)\n", size.cx, size.cy);
 491         ret = GetViewportExtEx(hdc, &size);
 492         ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 493         trace("vport ext (%d,%d)\n", size.cx, size.cy);
 494     }
 495     else
 496     {
 497         ok(ret, "GetWorldTransform error %u\n", GetLastError());
 498         trace("eM11 %f, eM22 %f, eDx %f, eDy %f\n", xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 499     }
 500
 501     PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
 502
 503     switch (emr->iType)
 504     {
 505     case EMR_HEADER:
 506     {
 507         static RECT exp_bounds = { 0, 0, 150, 150 };
 508         RECT bounds;
 509         const ENHMETAHEADER *emf = (const ENHMETAHEADER *)emr;
 510
 511         trace("bounds %d,%d-%d,%d, frame %d,%d-%d,%d\n",
 512                emf->rclBounds.left, emf->rclBounds.top, emf->rclBounds.right, emf->rclBounds.bottom,
 513                emf->rclFrame.left, emf->rclFrame.top, emf->rclFrame.right, emf->rclFrame.bottom);
 514         trace("mm %d x %d, device %d x %d\n", emf->szlMillimeters.cx, emf->szlMillimeters.cy,
 515                emf->szlDevice.cx, emf->szlDevice.cy);
 516
 517         SetRect(&bounds, emf->rclBounds.left, emf->rclBounds.top, emf->rclBounds.right, emf->rclBounds.bottom);
 518         ok(EqualRect(&bounds, &exp_bounds), "wrong bounds\n");
 519
 520         save_state = 0;
 521         restore_no = 0;
 522         select_no = 0;
 523         check_dc_state(hdc, restore_no, 0, 0, 1, 1, 0, 0, 1, 1);
 524         break;
 525     }
 526
 527     case EMR_LINETO:
 528         {
 529             const EMRLINETO *line = (const EMRLINETO *)emr;
 530             trace("EMR_LINETO %d,%d\n", line->ptl.x, line->ptl.x);
 531             break;
 532         }
 533     case EMR_SETWINDOWORGEX:
 534         {
 535             const EMRSETWINDOWORGEX *org = (const EMRSETWINDOWORGEX *)emr;
 536             trace("EMR_SETWINDOWORGEX: %d,%d\n", org->ptlOrigin.x, org->ptlOrigin.y);
 537             break;
 538         }
 539     case EMR_SETWINDOWEXTEX:
 540         {
 541             const EMRSETWINDOWEXTEX *ext = (const EMRSETWINDOWEXTEX *)emr;
 542             trace("EMR_SETWINDOWEXTEX: %d,%d\n", ext->szlExtent.cx, ext->szlExtent.cy);
 543             break;
 544         }
 545     case EMR_SETVIEWPORTORGEX:
 546         {
 547             const EMRSETVIEWPORTORGEX *org = (const EMRSETVIEWPORTORGEX *)emr;
 548             trace("EMR_SETVIEWPORTORGEX: %d,%d\n", org->ptlOrigin.x, org->ptlOrigin.y);
 549             break;
 550         }
 551     case EMR_SETVIEWPORTEXTEX:
 552         {
 553             const EMRSETVIEWPORTEXTEX *ext = (const EMRSETVIEWPORTEXTEX *)emr;
 554             trace("EMR_SETVIEWPORTEXTEX: %d,%d\n", ext->szlExtent.cx, ext->szlExtent.cy);
 555             break;
 556         }
 557     case EMR_SAVEDC:
 558         save_state++;
 559         trace("EMR_SAVEDC\n");
 560         break;
 561
 562     case EMR_RESTOREDC:
 563         {
 564             const EMRRESTOREDC *restoredc = (const EMRRESTOREDC *)emr;
 565             trace("EMR_RESTOREDC: %d\n", restoredc->iRelative);
 566
 567             switch(++restore_no)
 568             {
 569             case 1:
 570                 ok(restoredc->iRelative == -1, "first restore %d\n", restoredc->iRelative);
 571                 check_dc_state(hdc, restore_no, -2, -2, 8192, 8192, 20, 20, 20479, 20478);
 572                 break;
 573             case 2:
 574                 ok(restoredc->iRelative == -3, "second restore %d\n", restoredc->iRelative);
 575                 check_dc_state(hdc, restore_no, 0, 0, 16384, 16384, 0, 0, 17873, 17872);
 576                 break;
 577             case 3:
 578                 ok(restoredc->iRelative == -2, "third restore %d\n", restoredc->iRelative);
 579                 check_dc_state(hdc, restore_no, -4, -4, 32767, 32767, 40, 40, 3276, 3276);
 580                 break;
 581             }
 582             ok(restore_no <= 3, "restore_no %d\n", restore_no);
 583             save_state += restoredc->iRelative;
 584             break;
 585         }
 586     case EMR_SELECTOBJECT:
 587         {
 588             const EMRSELECTOBJECT *selectobj = (const EMRSELECTOBJECT*)emr;
 589             trace("EMR_SELECTOBJECT: %x\n",selectobj->ihObject);
 590             select_no ++;
 591             break;
 592         }
 593     case EMR_EOF:
 594         ok(save_state == 0, "EOF save_state %d\n", save_state);
 595         ok(select_no == 3, "Too many/few selects  %i\n",select_no);
 596         break;
 597     }
 598
 599     trace("AFTER:\n");
 600     SetLastError(0xdeadbeef);
 601     ret = GetWorldTransform(hdc, &xform);
 602     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 603     {
 604         ret = GetWindowOrgEx(hdc, &pt);
 605         ok(ret, "GetWindowOrgEx error %u\n", GetLastError());
 606         trace("window org (%d,%d)\n", pt.x, pt.y);
 607         ret = GetViewportOrgEx(hdc, &pt);
 608         ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 609         trace("vport org (%d,%d)\n", pt.x, pt.y);
 610         ret = GetWindowExtEx(hdc, &size);
 611         ok(ret, "GetWindowExtEx error %u\n", GetLastError());
 612         trace("window ext (%d,%d)\n", size.cx, size.cy);
 613         ret = GetViewportExtEx(hdc, &size);
 614         ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 615         trace("vport ext (%d,%d)\n", size.cx, size.cy);
 616     }
 617     else
 618     {
 619         ok(ret, "GetWorldTransform error %u\n", GetLastError());
 620         trace("eM11 %f, eM22 %f, eDx %f, eDy %f\n", xform.eM11, xform.eM22, xform.eDx, xform.eDy);
 621     }
 622
 623     return 1;
 624 }
 625
 626 static void test_SaveDC(void)
 627 {
 628     HDC hdcMetafile, hdcDisplay;
 629     HENHMETAFILE hMetafile;
 630     HWND hwnd;
 631     int ret;
 632     POINT pt;
 633     SIZE size;
 634     HFONT hFont,hFont2,hFontOld,hFontCheck;
 635     static const RECT rc = { 0, 0, 150, 150 };
 636
 637     /* Win9x doesn't play EMFs on invisible windows */
 638     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
 639                            0, 0, 200, 200, 0, 0, 0, NULL);
 640     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
 641
 642     hdcDisplay = GetDC(hwnd);
 643     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
 644
 645     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
 646     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
 647
 648     SetMapMode(hdcMetafile, MM_ANISOTROPIC);
 649
 650     /* Need to write something to the emf, otherwise Windows won't play it back */
 651     LineTo(hdcMetafile, 150, 150);
 652
 653     SetWindowOrgEx(hdcMetafile, 0, 0, NULL);
 654     SetViewportOrgEx(hdcMetafile, 0, 0, NULL);
 655     SetWindowExtEx(hdcMetafile, 110, 110, NULL );
 656     SetViewportExtEx(hdcMetafile, 120, 120, NULL );
 657
 658     /* Force Win9x to update DC state */
 659     SetPixelV(hdcMetafile, 50, 50, 0);
 660
 661     ret = GetViewportOrgEx(hdcMetafile, &pt);
 662     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 663     ok(pt.x == 0,"Expecting ViewportOrg x of 0, got %i\n",pt.x);
 664     ret = GetViewportExtEx(hdcMetafile, &size);
 665     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 666     ok(size.cx == 120,"Expecting ViewportExt cx of 120, got %i\n",size.cx);
 667     ret = SaveDC(hdcMetafile);
 668     ok(ret == 1, "ret = %d\n", ret);
 669
 670     SetWindowOrgEx(hdcMetafile, -1, -1, NULL);
 671     SetViewportOrgEx(hdcMetafile, 10, 10, NULL);
 672     SetWindowExtEx(hdcMetafile, 150, 150, NULL );
 673     SetViewportExtEx(hdcMetafile, 200, 200, NULL );
 674
 675     /* Force Win9x to update DC state */
 676     SetPixelV(hdcMetafile, 50, 50, 0);
 677
 678     ret = GetViewportOrgEx(hdcMetafile, &pt);
 679     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 680     ok(pt.x == 10,"Expecting ViewportOrg x of 10, got %i\n",pt.x);
 681     ret = GetViewportExtEx(hdcMetafile, &size);
 682     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 683     ok(size.cx == 200,"Expecting ViewportExt cx of 200, got %i\n",size.cx);
 684     ret = SaveDC(hdcMetafile);
 685     ok(ret == 2, "ret = %d\n", ret);
 686
 687     SetWindowOrgEx(hdcMetafile, -2, -2, NULL);
 688     SetViewportOrgEx(hdcMetafile, 20, 20, NULL);
 689     SetWindowExtEx(hdcMetafile, 120, 120, NULL );
 690     SetViewportExtEx(hdcMetafile, 300, 300, NULL );
 691     SetPolyFillMode( hdcMetafile, ALTERNATE );
 692     SetBkColor( hdcMetafile, 0 );
 693
 694     /* Force Win9x to update DC state */
 695     SetPixelV(hdcMetafile, 50, 50, 0);
 696
 697     ret = GetViewportOrgEx(hdcMetafile, &pt);
 698     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 699     ok(pt.x == 20,"Expecting ViewportOrg x of 20, got %i\n",pt.x);
 700     ret = GetViewportExtEx(hdcMetafile, &size);
 701     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 702     ok(size.cx == 300,"Expecting ViewportExt cx of 300, got %i\n",size.cx);
 703     ret = SaveDC(hdcMetafile);
 704     ok(ret == 3, "ret = %d\n", ret);
 705
 706     SetWindowOrgEx(hdcMetafile, -3, -3, NULL);
 707     SetViewportOrgEx(hdcMetafile, 30, 30, NULL);
 708     SetWindowExtEx(hdcMetafile, 200, 200, NULL );
 709     SetViewportExtEx(hdcMetafile, 400, 400, NULL );
 710
 711     SetPolyFillMode( hdcMetafile, WINDING );
 712     SetBkColor( hdcMetafile, 0x123456 );
 713     ok( GetPolyFillMode( hdcMetafile ) == WINDING, "PolyFillMode not restored\n" );
 714     ok( GetBkColor( hdcMetafile ) == 0x123456, "Background color not restored\n" );
 715
 716     /* Force Win9x to update DC state */
 717     SetPixelV(hdcMetafile, 50, 50, 0);
 718
 719     ret = GetViewportOrgEx(hdcMetafile, &pt);
 720     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 721     ok(pt.x == 30,"Expecting ViewportOrg x of 30, got %i\n",pt.x);
 722     ret = GetViewportExtEx(hdcMetafile, &size);
 723     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 724     ok(size.cx == 400,"Expecting ViewportExt cx of 400, got %i\n",size.cx);
 725     ret = RestoreDC(hdcMetafile, -1);
 726     ok(ret, "ret = %d\n", ret);
 727
 728     ret = GetViewportOrgEx(hdcMetafile, &pt);
 729     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 730     ok(pt.x == 20,"Expecting ViewportOrg x of 20, got %i\n",pt.x);
 731     ret = GetViewportExtEx(hdcMetafile, &size);
 732     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 733     ok(size.cx == 300,"Expecting ViewportExt cx of 300, got %i\n",size.cx);
 734     ok( GetPolyFillMode( hdcMetafile ) == ALTERNATE, "PolyFillMode not restored\n" );
 735     ok( GetBkColor( hdcMetafile ) == 0, "Background color not restored\n" );
 736     ret = SaveDC(hdcMetafile);
 737     ok(ret == 3, "ret = %d\n", ret);
 738
 739     ret = GetViewportOrgEx(hdcMetafile, &pt);
 740     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 741     ok(pt.x == 20,"Expecting ViewportOrg x of 20, got %i\n",pt.x);
 742     ret = GetViewportExtEx(hdcMetafile, &size);
 743     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 744     ok(size.cx == 300,"Expecting ViewportExt cx of 300, got %i\n",size.cx);
 745     ret = RestoreDC(hdcMetafile, 1);
 746     ok(ret, "ret = %d\n", ret);
 747     ret = GetViewportOrgEx(hdcMetafile, &pt);
 748     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 749     ok(pt.x == 0,"Expecting ViewportOrg x of 0, got %i\n",pt.x);
 750     ret = GetViewportExtEx(hdcMetafile, &size);
 751     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 752     ok(size.cx == 120,"Expecting ViewportExt cx of 120, got %i\n",size.cx);
 753
 754     SetWindowOrgEx(hdcMetafile, -4, -4, NULL);
 755     SetViewportOrgEx(hdcMetafile, 40, 40, NULL);
 756     SetWindowExtEx(hdcMetafile, 500, 500, NULL );
 757     SetViewportExtEx(hdcMetafile, 50, 50, NULL );
 758
 759     /* Force Win9x to update DC state */
 760     SetPixelV(hdcMetafile, 50, 50, 0);
 761
 762     ret = GetViewportOrgEx(hdcMetafile, &pt);
 763     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 764     ok(pt.x == 40,"Expecting ViewportOrg x of 40, got %i\n",pt.x);
 765     ret = GetViewportExtEx(hdcMetafile, &size);
 766     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 767     ok(size.cx == 50,"Expecting ViewportExt cx of 50, got %i\n",size.cx);
 768     ret = SaveDC(hdcMetafile);
 769     ok(ret == 1, "ret = %d\n", ret);
 770
 771     ret = GetViewportOrgEx(hdcMetafile, &pt);
 772     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 773     ok(pt.x == 40,"Expecting ViewportOrg x of 40, got %i\n",pt.x);
 774     ret = GetViewportExtEx(hdcMetafile, &size);
 775     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 776     ok(size.cx == 50,"Expecting ViewportExt cx of 50, got %i\n",size.cx);
 777     ret = SaveDC(hdcMetafile);
 778     ok(ret == 2, "ret = %d\n", ret);
 779
 780     memset(&orig_lf, 0, sizeof(orig_lf));
 781     orig_lf.lfCharSet = ANSI_CHARSET;
 782     orig_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 783     orig_lf.lfWeight = FW_DONTCARE;
 784     orig_lf.lfHeight = 7;
 785     orig_lf.lfQuality = DEFAULT_QUALITY;
 786     lstrcpyA(orig_lf.lfFaceName, "Arial");
 787     hFont = CreateFontIndirectA(&orig_lf);
 788     ok(hFont != 0, "CreateFontIndirectA error %d\n", GetLastError());
 789
 790     hFontOld = SelectObject(hdcMetafile, hFont);
 791
 792     hFont2 = CreateFontIndirectA(&orig_lf);
 793     ok(hFont2 != 0, "CreateFontIndirectA error %d\n", GetLastError());
 794     hFontCheck = SelectObject(hdcMetafile, hFont2);
 795     ok(hFontCheck == hFont, "Font not selected\n");
 796
 797     /* Force Win9x to update DC state */
 798     SetPixelV(hdcMetafile, 50, 50, 0);
 799
 800     ret = RestoreDC(hdcMetafile, 1);
 801     ok(ret, "ret = %d\n", ret);
 802     ret = GetViewportOrgEx(hdcMetafile, &pt);
 803     ok(ret, "GetViewportOrgEx error %u\n", GetLastError());
 804     ok(pt.x == 40,"Expecting ViewportOrg x of 40, got %i\n",pt.x);
 805     ret = GetViewportExtEx(hdcMetafile, &size);
 806     ok(ret, "GetViewportExtEx error %u\n", GetLastError());
 807     ok(size.cx == 50,"Expecting ViewportExt cx of 50, got %i\n",size.cx);
 808
 809     hFontCheck = SelectObject(hdcMetafile, hFontOld);
 810     ok(hFontOld == hFontCheck && hFontCheck != hFont && hFontCheck != hFont2,
 811        "Font not reverted with DC Restore\n");
 812
 813     ret = RestoreDC(hdcMetafile, -20);
 814     ok(!ret, "ret = %d\n", ret);
 815     ret = RestoreDC(hdcMetafile, 20);
 816     ok(!ret, "ret = %d\n", ret);
 817
 818     hMetafile = CloseEnhMetaFile(hdcMetafile);
 819     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
 820
 821     ret = EnumEnhMetaFile(hdcDisplay, hMetafile, savedc_emf_enum_proc, 0, &rc);
 822     ok( ret == 1, "EnumEnhMetaFile rets %d\n", ret);
 823
 824     ret = DeleteObject(hFont);
 825     ok( ret, "DeleteObject error %d\n", GetLastError());
 826     ret = DeleteObject(hFont2);
 827     ok( ret, "DeleteObject error %d\n", GetLastError());
 828     ret = DeleteEnhMetaFile(hMetafile);
 829     ok( ret, "DeleteEnhMetaFile error %d\n", GetLastError());
 830     ret = ReleaseDC(hwnd, hdcDisplay);
 831     ok( ret, "ReleaseDC error %d\n", GetLastError());
 832     DestroyWindow(hwnd);
 833 }
 834
 835 static void test_mf_SaveDC(void)
 836 {
 837     HDC hdcMetafile;
 838     HMETAFILE hMetafile;
 839     int ret;
 840     POINT pt;
 841     SIZE size;
 842     HFONT hFont,hFont2,hFontOld,hFontCheck;
 843
 844     hdcMetafile = CreateMetaFileA(NULL);
 845     ok(hdcMetafile != 0, "CreateMetaFileA error %d\n", GetLastError());
 846
 847     ret = SetMapMode(hdcMetafile, MM_ANISOTROPIC);
 848     ok (ret, "SetMapMode should not fail\n");
 849
 850     /* Need to write something to the emf, otherwise Windows won't play it back */
 851     LineTo(hdcMetafile, 150, 150);
 852
 853     pt.x = pt.y = 5555;
 854     SetWindowOrgEx(hdcMetafile, 0, 0, &pt);
 855     ok( pt.x == 5555 && pt.y == 5555, "wrong origin %d,%d\n", pt.x, pt.y);
 856     pt.x = pt.y = 5555;
 857     SetViewportOrgEx(hdcMetafile, 0, 0, &pt);
 858     ok( pt.x == 5555 && pt.y == 5555, "wrong origin %d,%d\n", pt.x, pt.y);
 859     size.cx = size.cy = 5555;
 860     SetWindowExtEx(hdcMetafile, 110, 110, &size );
 861     ok( size.cx == 5555 && size.cy == 5555, "wrong size %d,%d\n", size.cx, size.cy );
 862     size.cx = size.cy = 5555;
 863     SetViewportExtEx(hdcMetafile, 120, 120, &size );
 864     ok( size.cx == 5555 && size.cy == 5555, "wrong size %d,%d\n", size.cx, size.cy );
 865
 866     /* Force Win9x to update DC state */
 867     SetPixelV(hdcMetafile, 50, 50, 0);
 868
 869     ret = GetViewportOrgEx(hdcMetafile, &pt);
 870     todo_wine ok (!ret, "GetViewportOrgEx should fail\n");
 871     ret = GetViewportExtEx(hdcMetafile, &size);
 872     todo_wine ok (!ret, "GetViewportExtEx should fail\n");
 873     ret = SaveDC(hdcMetafile);
 874     ok(ret == 1, "ret = %d\n", ret);
 875
 876     SetWindowOrgEx(hdcMetafile, -1, -1, NULL);
 877     SetViewportOrgEx(hdcMetafile, 10, 10, NULL);
 878     SetWindowExtEx(hdcMetafile, 150, 150, NULL );
 879     SetViewportExtEx(hdcMetafile, 200, 200, NULL );
 880
 881     /* Force Win9x to update DC state */
 882     SetPixelV(hdcMetafile, 50, 50, 0);
 883
 884     ret = SaveDC(hdcMetafile);
 885     ok(ret == 1, "ret = %d\n", ret);
 886
 887     SetWindowOrgEx(hdcMetafile, -2, -2, NULL);
 888     SetViewportOrgEx(hdcMetafile, 20, 20, NULL);
 889     SetWindowExtEx(hdcMetafile, 120, 120, NULL );
 890     SetViewportExtEx(hdcMetafile, 300, 300, NULL );
 891
 892     /* Force Win9x to update DC state */
 893     SetPixelV(hdcMetafile, 50, 50, 0);
 894     SetPolyFillMode( hdcMetafile, ALTERNATE );
 895     SetBkColor( hdcMetafile, 0 );
 896
 897     ret = SaveDC(hdcMetafile);
 898     ok(ret == 1, "ret = %d\n", ret);
 899
 900     SetWindowOrgEx(hdcMetafile, -3, -3, NULL);
 901     SetViewportOrgEx(hdcMetafile, 30, 30, NULL);
 902     SetWindowExtEx(hdcMetafile, 200, 200, NULL );
 903     SetViewportExtEx(hdcMetafile, 400, 400, NULL );
 904
 905     SetPolyFillMode( hdcMetafile, WINDING );
 906     SetBkColor( hdcMetafile, 0x123456 );
 907     todo_wine ok( !GetPolyFillMode( hdcMetafile ), "GetPolyFillMode succeeded\n" );
 908     todo_wine ok( GetBkColor( hdcMetafile ) == CLR_INVALID, "GetBkColor succeeded\n" );
 909
 910     /* Force Win9x to update DC state */
 911     SetPixelV(hdcMetafile, 50, 50, 0);
 912
 913     ret = RestoreDC(hdcMetafile, -1);
 914     ok(ret, "ret = %d\n", ret);
 915
 916     ret = SaveDC(hdcMetafile);
 917     ok(ret == 1, "ret = %d\n", ret);
 918
 919     ret = RestoreDC(hdcMetafile, 1);
 920     ok(ret, "ret = %d\n", ret);
 921
 922     SetWindowOrgEx(hdcMetafile, -4, -4, NULL);
 923     SetViewportOrgEx(hdcMetafile, 40, 40, NULL);
 924     SetWindowExtEx(hdcMetafile, 500, 500, NULL );
 925     SetViewportExtEx(hdcMetafile, 50, 50, NULL );
 926
 927     /* Force Win9x to update DC state */
 928     SetPixelV(hdcMetafile, 50, 50, 0);
 929
 930     ret = SaveDC(hdcMetafile);
 931     ok(ret == 1, "ret = %d\n", ret);
 932
 933     ret = SaveDC(hdcMetafile);
 934     ok(ret == 1, "ret = %d\n", ret);
 935
 936     memset(&orig_lf, 0, sizeof(orig_lf));
 937     orig_lf.lfCharSet = ANSI_CHARSET;
 938     orig_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 939     orig_lf.lfWeight = FW_DONTCARE;
 940     orig_lf.lfHeight = 7;
 941     orig_lf.lfQuality = DEFAULT_QUALITY;
 942     lstrcpyA(orig_lf.lfFaceName, "Arial");
 943     hFont = CreateFontIndirectA(&orig_lf);
 944     ok(hFont != 0, "CreateFontIndirectA error %d\n", GetLastError());
 945
 946     hFontOld = SelectObject(hdcMetafile, hFont);
 947
 948     hFont2 = CreateFontIndirectA(&orig_lf);
 949     ok(hFont2 != 0, "CreateFontIndirectA error %d\n", GetLastError());
 950     hFontCheck = SelectObject(hdcMetafile, hFont2);
 951     ok(hFontCheck == hFont, "Font not selected\n");
 952
 953     /* Force Win9x to update DC state */
 954     SetPixelV(hdcMetafile, 50, 50, 0);
 955
 956     ret = RestoreDC(hdcMetafile, 1);
 957     ok(ret, "ret = %d\n", ret);
 958
 959     hFontCheck = SelectObject(hdcMetafile, hFontOld);
 960     ok(hFontOld != hFontCheck && hFontCheck == hFont2, "Font incorrectly reverted with DC Restore\n");
 961
 962     /* restore level is ignored */
 963     ret = RestoreDC(hdcMetafile, -20);
 964     ok(ret, "ret = %d\n", ret);
 965     ret = RestoreDC(hdcMetafile, 20);
 966     ok(ret, "ret = %d\n", ret);
 967     ret = RestoreDC(hdcMetafile, 0);
 968     ok(ret, "ret = %d\n", ret);
 969
 970     hMetafile = CloseMetaFile(hdcMetafile);
 971     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
 972
 973     ret = DeleteMetaFile(hMetafile);
 974     ok( ret, "DeleteMetaFile error %d\n", GetLastError());
 975     ret = DeleteObject(hFont);
 976     ok( ret, "DeleteObject error %d\n", GetLastError());
 977     ret = DeleteObject(hFont2);
 978     ok( ret, "DeleteObject error %d\n", GetLastError());
 979 }
 980
 981
 982 /* Win-format metafile (mfdrv) tests */
 983 /* These tests compare the generated metafiles byte-by-byte */
 984 /* with the nominal results. */
 985
 986 /* Maximum size of sample metafiles in bytes. */
 987 #define MF_BUFSIZE 512
 988
 989 /* 8x8 bitmap data for a pattern brush */
 990 static const unsigned char SAMPLE_PATTERN_BRUSH[] = {
 991     0x01, 0x00, 0x02, 0x00,
 992     0x03, 0x00, 0x04, 0x00,
 993     0x05, 0x00, 0x06, 0x00,
 994     0x07, 0x00, 0x08, 0x00
 995 };
 996
 997 /* Sample metafiles to be compared to the outputs of the
 998  * test functions.
 999  */
1000
1001 static const unsigned char MF_BLANK_BITS[] = {
1002     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x0c, 0x00,
1003     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1004     0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
1005 };
1006
1007 static const unsigned char MF_GRAPHICS_BITS[] = {
1008     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x22, 0x00,
1009     0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
1010     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x02,
1011     0x01, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00,
1012     0x13, 0x02, 0x02, 0x00, 0x02, 0x00, 0x05, 0x00,
1013     0x00, 0x00, 0x14, 0x02, 0x01, 0x00, 0x01, 0x00,
1014     0x07, 0x00, 0x00, 0x00, 0x18, 0x04, 0x02, 0x00,
1015     0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
1016     0x00, 0x00, 0x00, 0x00
1017 };
1018
1019 static const unsigned char MF_PATTERN_BRUSH_BITS[] = {
1020     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x3d, 0x00,
1021     0x00, 0x00, 0x01, 0x00, 0x2d, 0x00, 0x00, 0x00,
1022     0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x42, 0x01,
1023     0x03, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
1024     0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1025     0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
1026     0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1027     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1028     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1029     0xff, 0xff, 0xff, 0x00, 0x08, 0x00, 0x00, 0x00,
1030     0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
1031     0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1032     0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
1033     0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1034     0x2d, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1035     0x00, 0x00
1036 };
1037
1038 static const unsigned char MF_DCBRUSH_BITS[] =
1039 {
1040     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x2a, 0x00,
1041     0x00, 0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0x00,
1042     0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xfc, 0x02,
1043     0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
1044     0x04, 0x00, 0x00, 0x00, 0x2d, 0x01, 0x00, 0x00,
1045     0x08, 0x00, 0x00, 0x00, 0xfa, 0x02, 0x00, 0x00,
1046     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1047     0x04, 0x00, 0x00, 0x00, 0x2d, 0x01, 0x01, 0x00,
1048     0x07, 0x00, 0x00, 0x00, 0x1b, 0x04, 0x14, 0x00,
1049     0x14, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x03, 0x00,
1050     0x00, 0x00, 0x00, 0x00
1051 };
1052
1053 static const unsigned char MF_TEXTOUT_ON_PATH_BITS[] =
1054 {
1055     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x19, 0x00,
1056     0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
1057     0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x0a,
1058     0x16, 0x00, 0x0b, 0x00, 0x04, 0x00, 0x00, 0x00,
1059     0x54, 0x65, 0x73, 0x74, 0x03, 0x00, 0x05, 0x00,
1060     0x08, 0x00, 0x0c, 0x00, 0x03, 0x00, 0x00, 0x00,
1061     0x00, 0x00
1062 };
1063
1064 static const unsigned char EMF_TEXTOUT_ON_PATH_BITS[] =
1065 {
1066     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1067     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1068     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1069     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1070     0xe7, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff, 0xff,
1071     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1072     0xf4, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1073     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1074     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1075     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1076     0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
1077     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1078     0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
1079     0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
1080     0x08, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
1081     0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1082     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
1083     0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
1084     0x00, 0x00, 0xc8, 0x41, 0x00, 0x80, 0xbb, 0x41,
1085     0x0b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
1086     0x04, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
1087     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1088     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
1089     0xff, 0xff, 0xff, 0xff, 0x54, 0x00, 0x00, 0x00,
1090     0x54, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00,
1091     0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1092     0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1093     0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1094     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1095     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1096     0x14, 0x00, 0x00, 0x00
1097 };
1098
1099 static const unsigned char MF_LINETO_BITS[] = {
1100     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
1101     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1102     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
1103     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
1104     0x00, 0x00
1105 };
1106
1107 static const unsigned char EMF_LINETO_BITS[] = {
1108     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1109     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1110     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1111     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1112     0x61, 0x06, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00,
1113     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1114     0x38, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
1115     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1116     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1117     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1118     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
1119     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1120     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
1121     0xe0, 0x93, 0x04, 0x00, 0x46, 0x00, 0x00, 0x00,
1122     0x48, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
1123     0x47, 0x44, 0x49, 0x43, 0x01, 0x00, 0x00, 0x80,
1124     0x00, 0x03, 0x00, 0x00, 0x60, 0xe5, 0xf4, 0x73,
1125     0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
1126     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
1127     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1128     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
1129     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
1130     0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
1131     0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1132     0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1133     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1134     0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1135     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1136     0x36, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1137     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1138     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1139     0x07, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x00,
1140     0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1141     0x30, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1142     0x0f, 0x00, 0x00, 0x80, 0x4b, 0x00, 0x00, 0x00,
1143     0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1144     0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
1145     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1146     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
1147 };
1148
1149 static const unsigned char EMF_LINETO_MM_ANISOTROPIC_BITS[] = {
1150     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1151     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1152     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1153     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1154     0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
1155     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1156     0x38, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
1157     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1158     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1159     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1160     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
1161     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1162     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
1163     0xe0, 0x93, 0x04, 0x00, 0x46, 0x00, 0x00, 0x00,
1164     0x48, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
1165     0x47, 0x44, 0x49, 0x43, 0x01, 0x00, 0x00, 0x80,
1166     0x00, 0x03, 0x00, 0x00, 0xa4, 0xfe, 0xf4, 0x73,
1167     0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
1168     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x11, 0x00,
1169     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1170     0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
1171     0x0f, 0x00, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00,
1172     0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
1173     0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1174     0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1175     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1176     0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1177     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1178     0x36, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1179     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1180     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1181     0x07, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x00,
1182     0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1183     0x30, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1184     0x0f, 0x00, 0x00, 0x80, 0x4b, 0x00, 0x00, 0x00,
1185     0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1186     0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
1187     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1188     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
1189 };
1190
1191 static const unsigned char EMF_LINETO_MM_TEXT_BITS[] = {
1192     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1193     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1194     0x37, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1195     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1196     0x61, 0x06, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00,
1197     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1198     0xe4, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
1199     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1200     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1201     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1202     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
1203     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1204     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
1205     0xe0, 0x93, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00,
1206     0x10, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
1207     0x00, 0x04, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
1208     0x10, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
1209     0x00, 0x04, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
1210     0x10, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
1211     0x0f, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
1212     0x0c, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80,
1213     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1214     0x00, 0x00, 0x00, 0x80, 0x30, 0x00, 0x00, 0x00,
1215     0x0c, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x80,
1216     0x4b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1217     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1218     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1219     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1220     0x14, 0x00, 0x00, 0x00
1221 };
1222
1223 static const unsigned char EMF_BITBLT[] =
1224 {
1225     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1226     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1227     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1228     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1229     0x6a, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00,
1230     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1231     0xa0, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1232     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1233     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1234     0x23, 0x04, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00,
1235     0x75, 0x01, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00,
1236     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1237     0x00, 0x00, 0x00, 0x00, 0x08, 0xb1, 0x05, 0x00,
1238     0x28, 0x11, 0x03, 0x00, 0x4c, 0x00, 0x00, 0x00,
1239     0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1240     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1241     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1242     0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1243     0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0xcc, 0x00,
1244     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1245     0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00,
1246     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
1247     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1248     0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
1249     0x64, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
1250     0x8c, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
1251     0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1252     0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00,
1253     0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
1254     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1255     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1256     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1257     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1258     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1259     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1260     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1261     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1262     0x4c, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
1263     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1264     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1265     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1266     0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1267     0x62, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
1268     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
1269     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1270     0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00,
1271     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1272     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1273     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1274     0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
1275     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1276     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
1277 };
1278
1279 static const unsigned char EMF_DCBRUSH_BITS[] =
1280 {
1281     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1282     0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
1283     0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
1284     0x39, 0x01, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00,
1285     0x52, 0x02, 0x00, 0x00, 0x52, 0x02, 0x00, 0x00,
1286     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1287     0x44, 0x01, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
1288     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1289     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1290     0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
1291     0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
1292     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1293     0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
1294     0x80, 0xa9, 0x03, 0x00, 0x25, 0x00, 0x00, 0x00,
1295     0x0c, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x80,
1296     0x25, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1297     0x13, 0x00, 0x00, 0x80, 0x27, 0x00, 0x00, 0x00,
1298     0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1299     0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x55, 0x00,
1300     0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
1301     0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1302     0x26, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
1303     0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1304     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1305     0x33, 0x44, 0x55, 0x00, 0x25, 0x00, 0x00, 0x00,
1306     0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
1307     0x2b, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
1308     0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
1309     0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
1310     0x28, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1311     0x01, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
1312     0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1313     0x00, 0x00, 0x00, 0x00, 0x12, 0x34, 0x56, 0x00,
1314     0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
1315     0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1316     0x28, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
1317     0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
1318     0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
1319     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1320     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1321     0x14, 0x00, 0x00, 0x00
1322 };
1323
1324 static const unsigned char EMF_BEZIER_BITS[] =
1325 {
1326     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
1327     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1328     0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
1329     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1330     0x1a, 0x2a, 0x0d, 0x00, 0x1a, 0x2f, 0x0d, 0x00,
1331     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
1332     0x44, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
1333     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1334     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1335     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
1336     0x51, 0x01, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00,
1337     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1338     0x00, 0x00, 0x00, 0x00, 0x68, 0x24, 0x05, 0x00,
1339     0xb0, 0x1e, 0x04, 0x00, 0x58, 0x00, 0x00, 0x00,
1340     0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1341     0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1342     0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1343     0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x14, 0x00,
1344     0x0f, 0x00, 0x0f, 0x00, 0x55, 0x00, 0x00, 0x00,
1345     0x2c, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
1346     0x0a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
1347     0x19, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1348     0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x14, 0x00,
1349     0x0f, 0x00, 0x0f, 0x00, 0x19, 0x00, 0x19, 0x00,
1350     0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
1351     0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1352     0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
1353     0x04, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
1354     0x01, 0x80, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1355     0x14, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1356     0x0f, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
1357     0x19, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1358     0x34, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1359     0x0f, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
1360     0x01, 0x80, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1361     0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
1362     0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1363     0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
1364     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
1365     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
1366     0x14, 0x00, 0x00, 0x00
1367 };
1368
1369 /* For debugging or dumping the raw metafiles produced by
1370  * new test functions.
1371  */
1372 static INT CALLBACK mf_enum_proc(HDC hdc, HANDLETABLE *ht, METARECORD *mr,
1373                                  INT nobj, LPARAM param)
1374 {
1375     trace("hdc %p, mr->rdFunction %04x, mr->rdSize %u, param %p\n",
1376            hdc, mr->rdFunction, mr->rdSize, (void *)param);
1377     return TRUE;
1378 }
1379
1380 /* For debugging or dumping the raw metafiles produced by
1381  * new test functions.
1382  */
1383
1384 static void dump_mf_bits (const HMETAFILE mf, const char *desc)
1385 {
1386     BYTE buf[MF_BUFSIZE];
1387     UINT mfsize, i;
1388
1389     if (!winetest_debug) return;
1390
1391     mfsize = GetMetaFileBitsEx (mf, MF_BUFSIZE, buf);
1392     ok (mfsize > 0, "%s: GetMetaFileBitsEx failed.\n", desc);
1393
1394     printf ("MetaFile %s has bits:\n{\n    ", desc);
1395     for (i=0; i<mfsize; i++)
1396     {
1397         printf ("0x%02x", buf[i]);
1398         if (i == mfsize-1)
1399             printf ("\n");
1400         else if (i % 8 == 7)
1401             printf (",\n    ");
1402         else
1403             printf (", ");
1404     }
1405     printf ("};\n");
1406 }
1407
1408 /* Compare the metafile produced by a test function with the
1409  * expected raw metafile data in "bits".
1410  * Return value is 0 for a perfect match,
1411  * -1 if lengths aren't equal,
1412  * otherwise returns the number of non-matching bytes.
1413  */
1414
1415 static int compare_mf_bits (const HMETAFILE mf, const unsigned char *bits, UINT bsize,
1416     const char *desc)
1417 {
1418     unsigned char buf[MF_BUFSIZE];
1419     UINT mfsize, i;
1420     int diff;
1421
1422     mfsize = GetMetaFileBitsEx (mf, MF_BUFSIZE, buf);
1423     ok (mfsize > 0, "%s: GetMetaFileBitsEx failed.\n", desc);
1424     if (mfsize < MF_BUFSIZE)
1425         ok (mfsize == bsize, "%s: mfsize=%d, bsize=%d.\n",
1426             desc, mfsize, bsize);
1427     else
1428         ok (bsize >= MF_BUFSIZE, "%s: mfsize > bufsize (%d bytes), bsize=%d.\n",
1429             desc, mfsize, bsize);
1430     if (mfsize != bsize)
1431         return -1;
1432
1433     diff = 0;
1434     for (i=0; i<bsize; i++)
1435     {
1436        if (buf[i] !=  bits[i])
1437            diff++;
1438     }
1439     ok (diff == 0, "%s: mfsize=%d, bsize=%d, diff=%d\n",
1440         desc, mfsize, bsize, diff);
1441
1442     return diff;
1443 }
1444
1445 static int compare_mf_disk_bits(LPCSTR name, const BYTE *bits, UINT bsize, const char *desc)
1446 {
1447     unsigned char buf[MF_BUFSIZE];
1448     DWORD mfsize, rd_size, i;
1449     int diff;
1450     HANDLE hfile;
1451     BOOL ret;
1452
1453     hfile = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
1454     assert(hfile != INVALID_HANDLE_VALUE);
1455
1456     mfsize = GetFileSize(hfile, NULL);
1457     assert(mfsize <= MF_BUFSIZE);
1458
1459     ret = ReadFile(hfile, buf, sizeof(buf), &rd_size, NULL);
1460     ok( ret && rd_size == mfsize, "ReadFile: error %d\n", GetLastError());
1461
1462     CloseHandle(hfile);
1463
1464     ok(mfsize == bsize, "%s: mfsize=%d, bsize=%d.\n", desc, mfsize, bsize);
1465
1466     if (mfsize != bsize)
1467         return -1;
1468
1469     diff = 0;
1470     for (i=0; i<bsize; i++)
1471     {
1472         if (buf[i] != bits[i])
1473             diff++;
1474     }
1475     ok(diff == 0, "%s: mfsize=%d, bsize=%d, diff=%d\n",
1476         desc, mfsize, bsize, diff);
1477
1478     return diff;
1479 }
1480
1481 /* For debugging or dumping the raw EMFs produced by
1482  * new test functions.
1483  */
1484 static void dump_emf_bits(const HENHMETAFILE mf, const char *desc)
1485 {
1486     BYTE buf[MF_BUFSIZE];
1487     UINT mfsize, i;
1488
1489     if (!winetest_debug) return;
1490
1491     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
1492     ok (mfsize > 0, "%s: GetEnhMetaFileBits failed\n", desc);
1493
1494     printf("EMF %s has bits:\n{\n    ", desc);
1495     for (i = 0; i < mfsize; i++)
1496     {
1497         printf ("0x%02x", buf[i]);
1498         if (i == mfsize-1)
1499             printf ("\n");
1500         else if (i % 8 == 7)
1501             printf (",\n    ");
1502         else
1503             printf (", ");
1504     }
1505     printf ("};\n");
1506 }
1507
1508 static void dump_emf_records(const HENHMETAFILE mf, const char *desc)
1509 {
1510     BYTE *emf;
1511     BYTE buf[MF_BUFSIZE];
1512     UINT mfsize, offset;
1513
1514     if (!winetest_debug) return;
1515
1516     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
1517     ok (mfsize > 0, "%s: GetEnhMetaFileBits error %d\n", desc, GetLastError());
1518
1519     printf("EMF %s has records:\n", desc);
1520
1521     emf = buf;
1522     offset = 0;
1523     while(offset < mfsize)
1524     {
1525         EMR *emr = (EMR *)(emf + offset);
1526         printf("emr->iType %d, emr->nSize %u\n", emr->iType, emr->nSize);
1527         /*trace("emr->iType 0x%04lx, emr->nSize 0x%04lx\n", emr->iType, emr->nSize);*/
1528         offset += emr->nSize;
1529     }
1530 }
1531
1532 static void dump_emf_record(const ENHMETARECORD *emr, const char *desc)
1533 {
1534     const BYTE *buf;
1535     DWORD i;
1536
1537     if (!winetest_debug) return;
1538
1539     printf ("%s: EMF record %u has bits:\n{\n", desc, emr->iType);
1540     buf = (const BYTE *)emr;
1541     for (i = 0; i < emr->nSize; i++)
1542     {
1543         printf ("0x%02x", buf[i]);
1544         if (i == emr->nSize - 1)
1545             printf ("\n");
1546         else if (i % 8 == 7)
1547             printf (",\n");
1548         else
1549             printf (", ");
1550     }
1551     printf ("};\n");
1552 }
1553
1554 static void dump_EMREXTTEXTOUT(const EMREXTTEXTOUTW *eto)
1555 {
1556     trace("rclBounds %d,%d - %d,%d\n", eto->rclBounds.left, eto->rclBounds.top,
1557           eto->rclBounds.right, eto->rclBounds.bottom);
1558     trace("iGraphicsMode %u\n", eto->iGraphicsMode);
1559     trace("exScale: %f\n", eto->exScale);
1560     trace("eyScale: %f\n", eto->eyScale);
1561     trace("emrtext.ptlReference %d,%d\n", eto->emrtext.ptlReference.x, eto->emrtext.ptlReference.y);
1562     trace("emrtext.nChars %u\n", eto->emrtext.nChars);
1563     trace("emrtext.offString %#x\n", eto->emrtext.offString);
1564     trace("emrtext.fOptions %#x\n", eto->emrtext.fOptions);
1565     trace("emrtext.rcl %d,%d - %d,%d\n", eto->emrtext.rcl.left, eto->emrtext.rcl.top,
1566           eto->emrtext.rcl.right, eto->emrtext.rcl.bottom);
1567     trace("emrtext.offDx %#x\n", eto->emrtext.offDx);
1568 }
1569
1570 static BOOL match_emf_record(const ENHMETARECORD *emr1, const ENHMETARECORD *emr2,
1571                              const char *desc, BOOL ignore_scaling)
1572 {
1573     int diff;
1574
1575     ok(emr1->iType == emr2->iType, "%s: emr->iType %u != %u\n",
1576        desc, emr1->iType, emr2->iType);
1577
1578     ok(emr1->nSize == emr2->nSize, "%s: emr->nSize %u != %u\n",
1579        desc, emr1->nSize, emr2->nSize);
1580
1581     /* iType and nSize mismatches are fatal */
1582     if (emr1->iType != emr2->iType || emr1->nSize != emr2->nSize) return FALSE;
1583
1584     /* contents of EMR_GDICOMMENT are not interesting */
1585     if (emr1->iType == EMR_GDICOMMENT) return TRUE;
1586
1587     /* different Windows versions setup DC scaling differently when
1588      * converting an old style metafile to an EMF.
1589      */
1590     if (ignore_scaling && (emr1->iType == EMR_SETWINDOWEXTEX ||
1591                            emr1->iType == EMR_SETVIEWPORTEXTEX))
1592         return TRUE;
1593
1594     if (emr1->iType == EMR_EXTTEXTOUTW || emr1->iType == EMR_EXTTEXTOUTA)
1595     {
1596         EMREXTTEXTOUTW *eto1, *eto2;
1597
1598         eto1 = HeapAlloc(GetProcessHeap(), 0, emr1->nSize);
1599         memcpy(eto1, emr1, emr1->nSize);
1600         eto2 = HeapAlloc(GetProcessHeap(), 0, emr2->nSize);
1601         memcpy(eto2, emr2, emr2->nSize);
1602
1603         /* different Windows versions setup DC scaling differently */
1604         eto1->exScale = eto1->eyScale = 0.0;
1605         eto2->exScale = eto2->eyScale = 0.0;
1606
1607         diff = memcmp(eto1, eto2, emr1->nSize);
1608         if (diff)
1609         {
1610             dump_EMREXTTEXTOUT(eto1);
1611             dump_EMREXTTEXTOUT(eto2);
1612         }
1613         HeapFree(GetProcessHeap(), 0, eto1);
1614         HeapFree(GetProcessHeap(), 0, eto2);
1615     }
1616     else if (emr1->iType == EMR_EXTSELECTCLIPRGN && !lstrcmpA(desc, "emf_clipping"))
1617     {
1618         /* We have to take care of NT4 differences here */
1619         diff = memcmp(emr1, emr2, emr1->nSize);
1620         if (diff)
1621         {
1622             ENHMETARECORD *emr_nt4;
1623
1624             emr_nt4 = HeapAlloc(GetProcessHeap(), 0, emr2->nSize);
1625             memcpy(emr_nt4, emr2, emr2->nSize);
1626             /* Correct the nRgnSize field */
1627             emr_nt4->dParm[5] = sizeof(RECT);
1628
1629             diff = memcmp(emr1, emr_nt4, emr1->nSize);
1630             if (!diff)
1631                 win_skip("Catered for NT4 differences\n");
1632
1633             HeapFree(GetProcessHeap(), 0, emr_nt4);
1634         }
1635     }
1636     else if (emr1->iType == EMR_POLYBEZIERTO16 || emr1->iType == EMR_POLYBEZIER16)
1637     {
1638         EMRPOLYBEZIER16 *eto1, *eto2;
1639
1640         eto1 = (EMRPOLYBEZIER16*)emr1;
1641         eto2 = (EMRPOLYBEZIER16*)emr2;
1642
1643         diff = eto1->cpts != eto2->cpts;
1644         if(!diff)
1645             diff = memcmp(eto1->apts, eto2->apts, eto1->cpts * sizeof(POINTS));
1646     }
1647     else if (emr1->iType == EMR_POLYBEZIERTO || emr1->iType == EMR_POLYBEZIER)
1648     {
1649         EMRPOLYBEZIER *eto1, *eto2;
1650
1651         eto1 = (EMRPOLYBEZIER*)emr1;
1652         eto2 = (EMRPOLYBEZIER*)emr2;
1653
1654         diff = eto1->cptl != eto2->cptl;
1655         if(!diff)
1656             diff = memcmp(eto1->aptl, eto2->aptl, eto1->cptl * sizeof(POINTL));
1657     }
1658     else
1659         diff = memcmp(emr1, emr2, emr1->nSize);
1660
1661     ok(diff == 0, "%s: contents of record %u don't match\n", desc, emr1->iType);
1662
1663     if (diff)
1664     {
1665         dump_emf_record(emr1, "expected bits");
1666         dump_emf_record(emr2, "actual bits");
1667     }
1668
1669     return diff == 0; /* report all non-fatal record mismatches */
1670 }
1671
1672 /* Compare the EMF produced by a test function with the
1673  * expected raw EMF data in "bits".
1674  * Return value is 0 for a perfect match,
1675  * -1 if lengths aren't equal,
1676  * otherwise returns the number of non-matching bytes.
1677  */
1678 static int compare_emf_bits(const HENHMETAFILE mf, const unsigned char *bits,
1679                             UINT bsize, const char *desc,
1680                             BOOL ignore_scaling)
1681 {
1682     unsigned char buf[MF_BUFSIZE];
1683     UINT mfsize, offset1, offset2, diff_nt4, diff_9x;
1684     const ENHMETAHEADER *emh1, *emh2;
1685
1686     mfsize = GetEnhMetaFileBits(mf, MF_BUFSIZE, buf);
1687     ok (mfsize > 0, "%s: GetEnhMetaFileBits error %d\n", desc, GetLastError());
1688
1689     /* ENHMETAHEADER size could differ, depending on platform */
1690     diff_nt4 = sizeof(SIZEL);
1691     diff_9x = sizeof(SIZEL) + 3 * sizeof(DWORD);
1692
1693     if (mfsize < MF_BUFSIZE)
1694     {
1695         ok(mfsize == bsize ||
1696            broken(mfsize == bsize - diff_nt4) ||  /* NT4 */
1697            broken(mfsize == bsize - diff_9x), /* Win9x/WinME */
1698            "%s: mfsize=%d, bsize=%d\n", desc, mfsize, bsize);
1699     }
1700     else
1701         ok(bsize >= MF_BUFSIZE, "%s: mfsize > bufsize (%d bytes), bsize=%d\n",
1702            desc, mfsize, bsize);
1703
1704     /* basic things must match */
1705     emh1 = (const ENHMETAHEADER *)bits;
1706     emh2 = (const ENHMETAHEADER *)buf;
1707     ok(emh1->iType == EMR_HEADER, "expected EMR_HEADER, got %u\n", emh1->iType);
1708     ok(emh1->nSize == sizeof(ENHMETAHEADER), "expected sizeof(ENHMETAHEADER), got %u\n", emh1->nSize);
1709     ok(emh2->nBytes == mfsize, "expected emh->nBytes %u, got %u\n", mfsize, emh2->nBytes);
1710     ok(emh1->dSignature == ENHMETA_SIGNATURE, "expected ENHMETA_SIGNATURE, got %u\n", emh1->dSignature);
1711
1712     ok(emh1->iType == emh2->iType, "expected EMR_HEADER, got %u\n", emh2->iType);
1713     ok(emh1->nSize == emh2->nSize ||
1714        broken(emh1->nSize - diff_nt4 == emh2->nSize) ||
1715        broken(emh1->nSize - diff_9x == emh2->nSize),
1716        "expected nSize %u, got %u\n", emh1->nSize, emh2->nSize);
1717     ok(emh1->dSignature == emh2->dSignature, "expected dSignature %u, got %u\n", emh1->dSignature, emh2->dSignature);
1718     ok(emh1->nBytes == emh2->nBytes ||
1719        broken(emh1->nBytes - diff_nt4 == emh2->nBytes) ||
1720        broken(emh1->nBytes - diff_9x == emh2->nBytes),
1721        "expected nBytes %u, got %u\n", emh1->nBytes, emh2->nBytes);
1722     ok(emh1->nRecords == emh2->nRecords, "expected nRecords %u, got %u\n", emh1->nRecords, emh2->nRecords);
1723
1724     offset1 = emh1->nSize;
1725     offset2 = emh2->nSize; /* Needed for Win9x/WinME/NT4 */
1726     while (offset1 < emh1->nBytes)
1727     {
1728         const ENHMETARECORD *emr1 = (const ENHMETARECORD *)(bits + offset1);
1729         const ENHMETARECORD *emr2 = (const ENHMETARECORD *)(buf + offset2);
1730
1731         trace("%s: EMF record %u, size %u/record %u, size %u\n",
1732               desc, emr1->iType, emr1->nSize, emr2->iType, emr2->nSize);
1733
1734         if (!match_emf_record(emr1, emr2, desc, ignore_scaling)) return -1;
1735
1736         /* We have already bailed out if iType or nSize don't match */
1737         offset1 += emr1->nSize;
1738         offset2 += emr2->nSize;
1739     }
1740     return 0;
1741 }
1742
1743
1744 /* tests blitting to an EMF */
1745 static void test_emf_BitBlt(void)
1746 {
1747     HDC hdcDisplay, hdcMetafile, hdcBitmap;
1748     HBITMAP hBitmap, hOldBitmap;
1749     HENHMETAFILE hMetafile;
1750 #define BMP_DIM 4
1751     BITMAPINFOHEADER bmih =
1752     {
1753         sizeof(BITMAPINFOHEADER),
1754         BMP_DIM,/* biWidth */
1755         BMP_DIM,/* biHeight */
1756         1,      /* biPlanes */
1757         24,     /* biBitCount */
1758         BI_RGB, /* biCompression */
1759         0,      /* biXPelsPerMeter */
1760         0,      /* biYPelsPerMeter */
1761         0,      /* biClrUsed */
1762         0,      /* biClrImportant */
1763     };
1764     void *bits;
1765     BOOL ret;
1766
1767     hdcDisplay = CreateDCA("DISPLAY", NULL, NULL, NULL);
1768     ok( hdcDisplay != 0, "CreateDCA error %d\n", GetLastError() );
1769
1770     hdcBitmap = CreateCompatibleDC(hdcDisplay);
1771     ok( hdcBitmap != 0, "CreateCompatibleDC failed\n" );
1772     bmih.biXPelsPerMeter = MulDiv(GetDeviceCaps(hdcDisplay, LOGPIXELSX), 100, 3937);
1773     bmih.biYPelsPerMeter = MulDiv(GetDeviceCaps(hdcDisplay, LOGPIXELSY), 100, 3937);
1774     hBitmap = CreateDIBSection(hdcDisplay, (const BITMAPINFO *)&bmih,
1775                                DIB_RGB_COLORS, &bits, NULL, 0);
1776     hOldBitmap = SelectObject(hdcBitmap, hBitmap);
1777
1778     hdcMetafile = CreateEnhMetaFileA(hdcBitmap, NULL, NULL, NULL);
1779     ok( hdcMetafile != 0, "CreateEnhMetaFileA failed\n" );
1780
1781     /* First fill the bitmap DC with something recognizable, like BLACKNESS */
1782     ret = BitBlt(hdcBitmap, 0, 0, BMP_DIM, BMP_DIM, 0, 0, 0, BLACKNESS);
1783     ok( ret, "BitBlt(BLACKNESS) failed\n" );
1784
1785     ret = BitBlt(hdcMetafile, 0, 0, BMP_DIM, BMP_DIM, hdcBitmap, 0, 0, SRCCOPY);
1786     ok( ret, "BitBlt(SRCCOPY) failed\n" );
1787     ret = BitBlt(hdcMetafile, 0, 0, BMP_DIM, BMP_DIM, 0, 0, 0, WHITENESS);
1788     ok( ret, "BitBlt(WHITENESS) failed\n" );
1789
1790     hMetafile = CloseEnhMetaFile(hdcMetafile);
1791     ok( hMetafile != 0, "CloseEnhMetaFile failed\n" );
1792
1793     if(compare_emf_bits(hMetafile, EMF_BITBLT, sizeof(EMF_BITBLT),
1794         "emf_BitBlt", FALSE) != 0)
1795     {
1796         dump_emf_bits(hMetafile, "emf_BitBlt");
1797         dump_emf_records(hMetafile, "emf_BitBlt");
1798     }
1799
1800     SelectObject(hdcBitmap, hOldBitmap);
1801     DeleteObject(hBitmap);
1802     DeleteDC(hdcBitmap);
1803     DeleteDC(hdcDisplay);
1804 #undef BMP_DIM
1805 }
1806
1807 static void test_emf_DCBrush(void)
1808 {
1809     HDC hdcMetafile;
1810     HENHMETAFILE hMetafile;
1811     HBRUSH hBrush;
1812     HPEN hPen;
1813     BOOL ret;
1814     COLORREF color;
1815
1816     if (!pSetDCBrushColor || !pSetDCPenColor)
1817     {
1818         win_skip( "SetDCBrush/PenColor not supported\n" );
1819         return;
1820     }
1821
1822     hdcMetafile = CreateEnhMetaFileA(GetDC(0), NULL, NULL, NULL);
1823     ok( hdcMetafile != 0, "CreateEnhMetaFileA failed\n" );
1824
1825     hBrush = SelectObject(hdcMetafile, GetStockObject(DC_BRUSH));
1826     ok(hBrush != 0, "SelectObject error %d.\n", GetLastError());
1827
1828     hPen = SelectObject(hdcMetafile, GetStockObject(DC_PEN));
1829     ok(hPen != 0, "SelectObject error %d.\n", GetLastError());
1830
1831     color = pSetDCBrushColor( hdcMetafile, RGB(0x55,0x55,0x55) );
1832     ok( color == 0xffffff, "SetDCBrushColor returned %x\n", color );
1833
1834     color = pSetDCPenColor( hdcMetafile, RGB(0x33,0x44,0x55) );
1835     ok( color == 0, "SetDCPenColor returned %x\n", color );
1836
1837     Rectangle( hdcMetafile, 10, 10, 20, 20 );
1838
1839     color = pSetDCBrushColor( hdcMetafile, RGB(0x12,0x34,0x56) );
1840     ok( color == 0x555555, "SetDCBrushColor returned %x\n", color );
1841
1842     hMetafile = CloseEnhMetaFile(hdcMetafile);
1843     ok( hMetafile != 0, "CloseEnhMetaFile failed\n" );
1844
1845     if (compare_emf_bits (hMetafile, EMF_DCBRUSH_BITS, sizeof(EMF_DCBRUSH_BITS),
1846                           "emf_DC_Brush", FALSE ) != 0)
1847     {
1848         dump_emf_bits(hMetafile, "emf_DC_Brush");
1849         dump_emf_records(hMetafile, "emf_DC_Brush");
1850     }
1851     ret = DeleteEnhMetaFile(hMetafile);
1852     ok( ret, "DeleteEnhMetaFile error %d\n", GetLastError());
1853     ret = DeleteObject(hBrush);
1854     ok( ret, "DeleteObject(HBRUSH) error %d\n", GetLastError());
1855     ret = DeleteObject(hPen);
1856     ok( ret, "DeleteObject(HPEN) error %d\n", GetLastError());
1857 }
1858
1859 /* Test a blank metafile.  May be used as a template for new tests. */
1860
1861 static void test_mf_Blank(void)
1862 {
1863     HDC hdcMetafile;
1864     HMETAFILE hMetafile;
1865     INT caps;
1866     BOOL ret;
1867     INT type;
1868
1869     hdcMetafile = CreateMetaFileA(NULL);
1870     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1871     trace("hdcMetafile %p\n", hdcMetafile);
1872
1873 /* Tests on metafile initialization */
1874     caps = GetDeviceCaps (hdcMetafile, TECHNOLOGY);
1875     ok (caps == DT_METAFILE,
1876         "GetDeviceCaps: TECHNOLOGY=%d != DT_METAFILE.\n", caps);
1877
1878     hMetafile = CloseMetaFile(hdcMetafile);
1879     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1880     type = GetObjectType(hMetafile);
1881     ok(type == OBJ_METAFILE, "CloseMetaFile created object with type %d\n", type);
1882     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
1883
1884     if (compare_mf_bits (hMetafile, MF_BLANK_BITS, sizeof(MF_BLANK_BITS),
1885         "mf_blank") != 0)
1886     {
1887         dump_mf_bits(hMetafile, "mf_Blank");
1888         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1889     }
1890
1891     ret = DeleteMetaFile(hMetafile);
1892     ok( ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
1893 }
1894
1895 static void test_CopyMetaFile(void)
1896 {
1897     HDC hdcMetafile;
1898     HMETAFILE hMetafile, hmf_copy;
1899     BOOL ret;
1900     char temp_path[MAX_PATH];
1901     char mf_name[MAX_PATH];
1902     INT type;
1903
1904     hdcMetafile = CreateMetaFileA(NULL);
1905     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
1906     trace("hdcMetafile %p\n", hdcMetafile);
1907
1908     hMetafile = CloseMetaFile(hdcMetafile);
1909     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
1910     type = GetObjectType(hMetafile);
1911     ok(type == OBJ_METAFILE, "CloseMetaFile created object with type %d\n", type);
1912
1913     if (compare_mf_bits (hMetafile, MF_BLANK_BITS, sizeof(MF_BLANK_BITS),
1914         "mf_blank") != 0)
1915     {
1916         dump_mf_bits(hMetafile, "mf_Blank");
1917         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
1918     }
1919
1920     GetTempPathA(MAX_PATH, temp_path);
1921     GetTempFileNameA(temp_path, "wmf", 0, mf_name);
1922
1923     hmf_copy = CopyMetaFileA(hMetafile, mf_name);
1924     ok(hmf_copy != 0, "CopyMetaFile error %d\n", GetLastError());
1925
1926     type = GetObjectType(hmf_copy);
1927     ok(type == OBJ_METAFILE, "CopyMetaFile created object with type %d\n", type);
1928
1929     ret = DeleteMetaFile(hMetafile);
1930     ok( ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
1931
1932     if (compare_mf_disk_bits(mf_name, MF_BLANK_BITS, sizeof(MF_BLANK_BITS), "mf_blank") != 0)
1933     {
1934         dump_mf_bits(hmf_copy, "mf_Blank");
1935         EnumMetaFile(0, hmf_copy, mf_enum_proc, 0);
1936     }
1937
1938     ret = DeleteMetaFile(hmf_copy);
1939     ok( ret, "DeleteMetaFile(%p) error %d\n", hmf_copy, GetLastError());
1940
1941     DeleteFileA(mf_name);
1942 }
1943
1944 static void test_SetMetaFileBits(void)
1945 {
1946     HMETAFILE hmf;
1947     INT type;
1948     BOOL ret;
1949     BYTE buf[256];
1950     METAHEADER *mh;
1951
1952     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), MF_GRAPHICS_BITS);
1953     trace("hmf %p\n", hmf);
1954     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
1955     type = GetObjectType(hmf);
1956     ok(type == OBJ_METAFILE, "SetMetaFileBitsEx created object with type %d\n", type);
1957
1958     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
1959     {
1960         dump_mf_bits(hmf, "mf_Graphics");
1961         EnumMetaFile(0, hmf, mf_enum_proc, 0);
1962     }
1963
1964     ret = DeleteMetaFile(hmf);
1965     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
1966
1967     /* NULL data crashes XP SP1 */
1968     /*hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), NULL);*/
1969
1970     /* Now with zero size */
1971     SetLastError(0xdeadbeef);
1972     hmf = SetMetaFileBitsEx(0, MF_GRAPHICS_BITS);
1973     trace("hmf %p\n", hmf);
1974     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1975     ok(GetLastError() == ERROR_INVALID_DATA ||
1976        broken(GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
1977        "wrong error %d\n", GetLastError());
1978
1979     /* Now with odd size */
1980     SetLastError(0xdeadbeef);
1981     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS) - 1, MF_GRAPHICS_BITS);
1982     trace("hmf %p\n", hmf);
1983     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1984     ok(GetLastError() == 0xdeadbeef /* XP SP1 */, "wrong error %d\n", GetLastError());
1985
1986     /* Now with zeroed out header fields */
1987     assert(sizeof(buf) >= sizeof(MF_GRAPHICS_BITS));
1988     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
1989     mh = (METAHEADER *)buf;
1990     /* corruption of any of the below fields leads to a failure */
1991     mh->mtType = 0;
1992     mh->mtVersion = 0;
1993     mh->mtHeaderSize = 0;
1994     SetLastError(0xdeadbeef);
1995     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
1996     trace("hmf %p\n", hmf);
1997     ok(!hmf, "SetMetaFileBitsEx should fail\n");
1998     ok(GetLastError() == ERROR_INVALID_DATA ||
1999        broken(GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
2000        "wrong error %d\n", GetLastError());
2001
2002     /* Now with corrupted mtSize field */
2003     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
2004     mh = (METAHEADER *)buf;
2005     /* corruption of mtSize doesn't lead to a failure */
2006     mh->mtSize *= 2;
2007     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
2008     trace("hmf %p\n", hmf);
2009     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
2010
2011     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
2012     {
2013         dump_mf_bits(hmf, "mf_Graphics");
2014         EnumMetaFile(0, hmf, mf_enum_proc, 0);
2015     }
2016
2017     ret = DeleteMetaFile(hmf);
2018     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
2019
2020 #ifndef _WIN64 /* Generates access violation on XP x64 and Win2003 x64 */
2021     /* Now with zeroed out mtSize field */
2022     memcpy(buf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS));
2023     mh = (METAHEADER *)buf;
2024     /* zeroing mtSize doesn't lead to a failure */
2025     mh->mtSize = 0;
2026     hmf = SetMetaFileBitsEx(sizeof(MF_GRAPHICS_BITS), buf);
2027     trace("hmf %p\n", hmf);
2028     ok(hmf != 0, "SetMetaFileBitsEx error %d\n", GetLastError());
2029
2030     if (compare_mf_bits(hmf, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS), "mf_Graphics") != 0)
2031     {
2032         dump_mf_bits(hmf, "mf_Graphics");
2033         EnumMetaFile(0, hmf, mf_enum_proc, 0);
2034     }
2035
2036     ret = DeleteMetaFile(hmf);
2037     ok(ret, "DeleteMetaFile(%p) error %d\n", hmf, GetLastError());
2038 #endif
2039 }
2040
2041 /* Simple APIs from mfdrv/graphics.c
2042  */
2043
2044 static void test_mf_Graphics(void)
2045 {
2046     HDC hdcMetafile;
2047     HMETAFILE hMetafile;
2048     POINT oldpoint;
2049     BOOL ret;
2050
2051     hdcMetafile = CreateMetaFileA(NULL);
2052     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
2053     trace("hdcMetafile %p\n", hdcMetafile);
2054
2055     ret = MoveToEx(hdcMetafile, 1, 1, NULL);
2056     ok( ret, "MoveToEx error %d.\n", GetLastError());
2057     ret = LineTo(hdcMetafile, 2, 2);
2058     ok( ret, "LineTo error %d.\n", GetLastError());
2059     ret = MoveToEx(hdcMetafile, 1, 1, &oldpoint);
2060     ok( ret, "MoveToEx error %d.\n", GetLastError());
2061
2062 /* oldpoint gets garbage under Win XP, so the following test would
2063  * work under Wine but fails under Windows:
2064  *
2065  *   ok((oldpoint.x == 2) && (oldpoint.y == 2),
2066  *       "MoveToEx: (x, y) = (%ld, %ld), should be (2, 2).\n",
2067  *       oldpoint.x, oldpoint.y);
2068  */
2069
2070     ret = Ellipse(hdcMetafile, 0, 0, 2, 2);
2071     ok( ret, "Ellipse error %d.\n", GetLastError());
2072
2073     hMetafile = CloseMetaFile(hdcMetafile);
2074     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
2075     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
2076
2077     if (compare_mf_bits (hMetafile, MF_GRAPHICS_BITS, sizeof(MF_GRAPHICS_BITS),
2078         "mf_Graphics") != 0)
2079     {
2080         dump_mf_bits(hMetafile, "mf_Graphics");
2081         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
2082     }
2083
2084     ret = DeleteMetaFile(hMetafile);
2085     ok( ret, "DeleteMetaFile(%p) error %d\n",
2086         hMetafile, GetLastError());
2087 }
2088
2089 static void test_mf_PatternBrush(void)
2090 {
2091     HDC hdcMetafile;
2092     HMETAFILE hMetafile;
2093     LOGBRUSH *orig_lb;
2094     HBRUSH hBrush;
2095     BOOL ret;
2096
2097     orig_lb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LOGBRUSH));
2098
2099     orig_lb->lbStyle = BS_PATTERN;
2100     orig_lb->lbColor = RGB(0, 0, 0);
2101     orig_lb->lbHatch = (ULONG_PTR)CreateBitmap (8, 8, 1, 1, SAMPLE_PATTERN_BRUSH);
2102     ok((HBITMAP)orig_lb->lbHatch != NULL, "CreateBitmap error %d.\n", GetLastError());
2103
2104     hBrush = CreateBrushIndirect (orig_lb);
2105     ok(hBrush != 0, "CreateBrushIndirect error %d\n", GetLastError());
2106
2107     hdcMetafile = CreateMetaFileA(NULL);
2108     ok(hdcMetafile != 0, "CreateMetaFileA error %d\n", GetLastError());
2109     trace("hdcMetafile %p\n", hdcMetafile);
2110
2111     hBrush = SelectObject(hdcMetafile, hBrush);
2112     ok(hBrush != 0, "SelectObject error %d.\n", GetLastError());
2113
2114     hMetafile = CloseMetaFile(hdcMetafile);
2115     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
2116     ok(!GetObjectType(hdcMetafile), "CloseMetaFile has to destroy metafile hdc\n");
2117
2118     if (compare_mf_bits (hMetafile, MF_PATTERN_BRUSH_BITS, sizeof(MF_PATTERN_BRUSH_BITS),
2119         "mf_Pattern_Brush") != 0)
2120     {
2121         dump_mf_bits(hMetafile, "mf_Pattern_Brush");
2122         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
2123     }
2124
2125     ret = DeleteMetaFile(hMetafile);
2126     ok( ret, "DeleteMetaFile error %d\n", GetLastError());
2127     ret = DeleteObject(hBrush);
2128     ok( ret, "DeleteObject(HBRUSH) error %d\n", GetLastError());
2129     ret = DeleteObject((HBITMAP)orig_lb->lbHatch);
2130     ok( ret, "DeleteObject(HBITMAP) error %d\n",
2131         GetLastError());
2132     HeapFree (GetProcessHeap(), 0, orig_lb);
2133 }
2134
2135 static void test_mf_DCBrush(void)
2136 {
2137     HDC hdcMetafile;
2138     HMETAFILE hMetafile;
2139     HBRUSH hBrush;
2140     HPEN hPen;
2141     BOOL ret;
2142     COLORREF color;
2143
2144     if (!pSetDCBrushColor || !pSetDCPenColor)
2145     {
2146         win_skip( "SetDCBrush/PenColor not supported\n" );
2147         return;
2148     }
2149
2150     hdcMetafile = CreateMetaFileA(NULL);
2151     ok( hdcMetafile != 0, "CreateMetaFileA failed\n" );
2152
2153     hBrush = SelectObject(hdcMetafile, GetStockObject(DC_BRUSH));
2154     ok(hBrush != 0, "SelectObject error %d.\n", GetLastError());
2155
2156     hPen = SelectObject(hdcMetafile, GetStockObject(DC_PEN));
2157     ok(hPen != 0, "SelectObject error %d.\n", GetLastError());
2158
2159     color = pSetDCBrushColor( hdcMetafile, RGB(0x55,0x55,0x55) );
2160     ok( color == CLR_INVALID, "SetDCBrushColor returned %x\n", color );
2161
2162     color = pSetDCPenColor( hdcMetafile, RGB(0x33,0x44,0x55) );
2163     ok( color == CLR_INVALID, "SetDCPenColor returned %x\n", color );
2164
2165     Rectangle( hdcMetafile, 10, 10, 20, 20 );
2166
2167     color = pSetDCBrushColor( hdcMetafile, RGB(0x12,0x34,0x56) );
2168     ok( color == CLR_INVALID, "SetDCBrushColor returned %x\n", color );
2169
2170     hMetafile = CloseMetaFile(hdcMetafile);
2171     ok( hMetafile != 0, "CloseMetaFile failed\n" );
2172
2173     if (compare_mf_bits(hMetafile, MF_DCBRUSH_BITS, sizeof(MF_DCBRUSH_BITS), "mf_DCBrush") != 0)
2174     {
2175         dump_mf_bits(hMetafile, "mf_DCBrush");
2176         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
2177     }
2178     ret = DeleteMetaFile(hMetafile);
2179     ok(ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
2180 }
2181
2182 static void test_mf_ExtTextOut_on_path(void)
2183 {
2184     HDC hdcMetafile;
2185     HMETAFILE hMetafile;
2186     BOOL ret;
2187     static const INT dx[4] = { 3, 5, 8, 12 };
2188
2189     hdcMetafile = CreateMetaFileA(NULL);
2190     ok(hdcMetafile != 0, "CreateMetaFileA(NULL) error %d\n", GetLastError());
2191     trace("hdcMetafile %p\n", hdcMetafile);
2192
2193     ret = BeginPath(hdcMetafile);
2194     ok(!ret, "BeginPath on metafile DC should fail\n");
2195
2196     ret = ExtTextOutA(hdcMetafile, 11, 22, 0, NULL, "Test", 4, dx);
2197     ok(ret, "ExtTextOut error %d\n", GetLastError());
2198
2199     ret = EndPath(hdcMetafile);
2200     ok(!ret, "EndPath on metafile DC should fail\n");
2201
2202     hMetafile = CloseMetaFile(hdcMetafile);
2203     ok(hMetafile != 0, "CloseMetaFile error %d\n", GetLastError());
2204
2205     if (compare_mf_bits(hMetafile, MF_TEXTOUT_ON_PATH_BITS, sizeof(MF_TEXTOUT_ON_PATH_BITS),
2206         "mf_TextOut_on_path") != 0)
2207     {
2208         dump_mf_bits(hMetafile, "mf_TextOut_on_path");
2209         EnumMetaFile(0, hMetafile, mf_enum_proc, 0);
2210     }
2211
2212     ret = DeleteMetaFile(hMetafile);
2213     ok(ret, "DeleteMetaFile(%p) error %d\n", hMetafile, GetLastError());
2214 }
2215
2216 static void test_emf_ExtTextOut_on_path(void)
2217 {
2218     HWND hwnd;
2219     HDC hdcDisplay, hdcMetafile;
2220     HENHMETAFILE hMetafile;
2221     BOOL ret;
2222     static const INT dx[4] = { 3, 5, 8, 12 };
2223
2224     /* Win9x doesn't play EMFs on invisible windows */
2225     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
2226                            0, 0, 200, 200, 0, 0, 0, NULL);
2227     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
2228
2229     hdcDisplay = GetDC(hwnd);
2230     ok(hdcDisplay != 0, "GetDC error %d\n", GetLastError());
2231
2232     hdcMetafile = CreateEnhMetaFileA(hdcDisplay, NULL, NULL, NULL);
2233     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
2234
2235     ret = BeginPath(hdcMetafile);
2236     ok(ret, "BeginPath error %d\n", GetLastError());
2237
2238     ret = ExtTextOutA(hdcMetafile, 11, 22, 0, NULL, "Test", 4, dx);
2239     ok(ret, "ExtTextOut error %d\n", GetLastError());
2240
2241     ret = EndPath(hdcMetafile);
2242     ok(ret, "EndPath error %d\n", GetLastError());
2243
2244     hMetafile = CloseEnhMetaFile(hdcMetafile);
2245     ok(hMetafile != 0, "CloseEnhMetaFile error %d\n", GetLastError());
2246
2247     /* this doesn't succeed yet: EMF has correct size, all EMF records
2248      * are there, but their contents don't match for different reasons.
2249      */
2250     if (compare_emf_bits(hMetafile, EMF_TEXTOUT_ON_PATH_BITS, sizeof(EMF_TEXTOUT_ON_PATH_BITS),
2251         "emf_TextOut_on_path", FALSE) != 0)
2252     {
2253         dump_emf_bits(hMetafile, "emf_TextOut_on_path");
2254         dump_emf_records(hMetafile, "emf_TextOut_on_path");
2255     }
2256
2257     ret = DeleteEnhMetaFile(hMetafile);
2258     ok(ret, "DeleteEnhMetaFile error %d\n", GetLastError());
2259     ret = ReleaseDC(hwnd, hdcDisplay);
2260     ok(ret, "ReleaseDC error %d\n", GetLastError());
2261     DestroyWindow(hwnd);
2262 }
2263
2264 static const unsigned char EMF_CLIPPING[] =
2265 {
2266     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
2267     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2268     0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
2269     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2270     0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
2271     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
2272     0xd0, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
2273     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2274     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2275     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
2276     0x7c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
2277     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2278     0x00, 0x00, 0x00, 0x00, 0x60, 0xcc, 0x05, 0x00,
2279     0xe0, 0x93, 0x04, 0x00, 0x36, 0x00, 0x00, 0x00,
2280     0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
2281     0x01, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00,
2282     0x40, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
2283     0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
2284     0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
2285     0x10, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
2286     0x64, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
2287     0x00, 0x04, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
2288     0x64, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
2289     0x00, 0x04, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
2290     0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2291     0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
2292 };
2293
2294 static void translate( POINT *pt, UINT count, const XFORM *xform )
2295 {
2296     while (count--)
2297     {
2298         FLOAT x = (FLOAT)pt->x;
2299         FLOAT y = (FLOAT)pt->y;
2300         pt->x = (LONG)floor( x * xform->eM11 + y * xform->eM21 + xform->eDx + 0.5 );
2301         pt->y = (LONG)floor( x * xform->eM12 + y * xform->eM22 + xform->eDy + 0.5 );
2302         pt++;
2303     }
2304 }
2305
2306 /* Compare rectangles allowing rounding errors */
2307 static BOOL is_equal_rect(const RECT *rc1, const RECT *rc2)
2308 {
2309     return abs(rc1->left - rc2->left) <= 1 &&
2310            abs(rc1->top - rc2->top) <= 1 &&
2311            abs(rc1->right - rc2->right) <= 1 &&
2312            abs(rc1->bottom - rc2->bottom) <= 1;
2313 }
2314
2315 static int CALLBACK clip_emf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
2316                                        const ENHMETARECORD *emr, int n_objs, LPARAM param)
2317 {
2318     if (emr->iType == EMR_EXTSELECTCLIPRGN)
2319     {
2320         const EMREXTSELECTCLIPRGN *clip = (const EMREXTSELECTCLIPRGN *)emr;
2321         union _rgn
2322         {
2323             RGNDATA data;
2324             char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
2325         };
2326         const union _rgn *rgn1;
2327         union _rgn rgn2;
2328         RECT rect, rc_transformed;
2329         const RECT *rc = (const RECT *)param;
2330         HRGN hrgn;
2331         XFORM xform;
2332         INT ret;
2333         BOOL is_win9x;
2334
2335         trace("EMR_EXTSELECTCLIPRGN: cbRgnData %#x, iMode %u\n",
2336                clip->cbRgnData, clip->iMode);
2337
2338         ok(clip->iMode == RGN_COPY, "expected RGN_COPY, got %u\n", clip->iMode);
2339         ok(clip->cbRgnData >= sizeof(RGNDATAHEADER) + sizeof(RECT),
2340            "too small data block: %u bytes\n", clip->cbRgnData);
2341         if (clip->cbRgnData < sizeof(RGNDATAHEADER) + sizeof(RECT))
2342             return 0;
2343
2344         rgn1 = (const union _rgn *)clip->RgnData;
2345
2346         trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
2347               rgn1->data.rdh.dwSize, rgn1->data.rdh.iType,
2348               rgn1->data.rdh.nCount, rgn1->data.rdh.nRgnSize,
2349               rgn1->data.rdh.rcBound.left, rgn1->data.rdh.rcBound.top,
2350               rgn1->data.rdh.rcBound.right, rgn1->data.rdh.rcBound.bottom);
2351
2352         ok(EqualRect(&rgn1->data.rdh.rcBound, rc), "rects don't match\n");
2353
2354         rect = *(const RECT *)rgn1->data.Buffer;
2355         trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
2356         ok(EqualRect(&rect, rc), "rects don't match\n");
2357
2358         ok(rgn1->data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn1->data.rdh.dwSize);
2359         ok(rgn1->data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn1->data.rdh.iType);
2360         ok(rgn1->data.rdh.nCount == 1, "expected 1, got %u\n", rgn1->data.rdh.nCount);
2361         ok(rgn1->data.rdh.nRgnSize == sizeof(RECT) ||
2362            broken(rgn1->data.rdh.nRgnSize == 168), /* NT4 */
2363            "expected sizeof(RECT), got %u\n", rgn1->data.rdh.nRgnSize);
2364
2365         hrgn = CreateRectRgn(0, 0, 0, 0);
2366
2367         memset(&xform, 0, sizeof(xform));
2368         SetLastError(0xdeadbeef);
2369         ret = GetWorldTransform(hdc, &xform);
2370         is_win9x = !ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED;
2371         if (!is_win9x)
2372             ok(ret, "GetWorldTransform error %u\n", GetLastError());
2373
2374         trace("xform.eM11 %f, xform.eM22 %f\n", xform.eM11, xform.eM22);
2375
2376         ret = GetClipRgn(hdc, hrgn);
2377         ok(ret == 0, "GetClipRgn returned %d, expected 0\n", ret);
2378
2379         PlayEnhMetaFileRecord(hdc, handle_table, emr, n_objs);
2380
2381         ret = GetClipRgn(hdc, hrgn);
2382         ok(ret == 1, "GetClipRgn returned %d, expected 1\n", ret);
2383
2384         /* Win9x returns empty clipping region */
2385         if (is_win9x) return 1;
2386
2387         ret = GetRegionData(hrgn, 0, NULL);
2388         ok(ret == sizeof(rgn2.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
2389
2390         ret = GetRegionData(hrgn, sizeof(rgn2), &rgn2.data);
2391         ok(ret == sizeof(rgn2), "expected sizeof(rgn2), got %u\n", ret);
2392
2393         trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
2394               rgn2.data.rdh.dwSize, rgn2.data.rdh.iType,
2395               rgn2.data.rdh.nCount, rgn2.data.rdh.nRgnSize,
2396               rgn2.data.rdh.rcBound.left, rgn2.data.rdh.rcBound.top,
2397               rgn2.data.rdh.rcBound.right, rgn2.data.rdh.rcBound.bottom);
2398
2399         rect = rgn2.data.rdh.rcBound;
2400         rc_transformed = *rc;
2401         translate((POINT *)&rc_transformed, 2, &xform);
2402         trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
2403               rc_transformed.right, rc_transformed.bottom);
2404         ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
2405
2406         rect = *(const RECT *)rgn2.data.Buffer;
2407         trace("rect (%d,%d-%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
2408         rc_transformed = *rc;
2409         translate((POINT *)&rc_transformed, 2, &xform);
2410         trace("transformed (%d,%d-%d,%d)\n", rc_transformed.left, rc_transformed.top,
2411               rc_transformed.right, rc_transformed.bottom);
2412         ok(is_equal_rect(&rect, &rc_transformed), "rects don't match\n");
2413
2414         ok(rgn2.data.rdh.dwSize == sizeof(rgn1->data.rdh), "expected sizeof(rdh), got %u\n", rgn2.data.rdh.dwSize);
2415         ok(rgn2.data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn2.data.rdh.iType);
2416         ok(rgn2.data.rdh.nCount == 1, "expected 1, got %u\n", rgn2.data.rdh.nCount);
2417         ok(rgn2.data.rdh.nRgnSize == sizeof(RECT) ||
2418            broken(rgn2.data.rdh.nRgnSize == 168), /* NT4 */
2419            "expected sizeof(RECT), got %u\n", rgn2.data.rdh.nRgnSize);
2420
2421         DeleteObject(hrgn);
2422     }
2423     return 1;
2424 }
2425
2426 static void test_emf_clipping(void)
2427 {
2428     static const RECT rc = { 0, 0, 100, 100 };
2429     RECT rc_clip = { 100, 100, 1024, 1024 };
2430     HWND hwnd;
2431     HDC hdc;
2432     HENHMETAFILE hemf;
2433     HRGN hrgn;
2434     INT ret;
2435     RECT rc_res, rc_sclip;
2436
2437     SetLastError(0xdeadbeef);
2438     hdc = CreateEnhMetaFileA(0, NULL, NULL, NULL);
2439     ok(hdc != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
2440
2441     /* Need to write something to the emf, otherwise Windows won't play it back */
2442     LineTo(hdc, 1, 1);
2443
2444     hrgn = CreateRectRgn(rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom);
2445     ret = SelectClipRgn(hdc, hrgn);
2446     ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
2447
2448     SetLastError(0xdeadbeef);
2449     hemf = CloseEnhMetaFile(hdc);
2450     ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
2451
2452     if (compare_emf_bits(hemf, EMF_CLIPPING, sizeof(EMF_CLIPPING),
2453         "emf_clipping", FALSE) != 0)
2454     {
2455         dump_emf_bits(hemf, "emf_clipping");
2456         dump_emf_records(hemf, "emf_clipping");
2457     }
2458
2459     DeleteObject(hrgn);
2460
2461     /* Win9x doesn't play EMFs on invisible windows */
2462     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
2463                            0, 0, 200, 200, 0, 0, 0, NULL);
2464     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
2465
2466     hdc = GetDC(hwnd);
2467
2468     ret = EnumEnhMetaFile(hdc, hemf, clip_emf_enum_proc, &rc_clip, &rc);
2469     ok(ret, "EnumEnhMetaFile error %d\n", GetLastError());
2470
2471     DeleteEnhMetaFile(hemf);
2472     ReleaseDC(hwnd, hdc);
2473     DestroyWindow(hwnd);
2474
2475     hdc = CreateEnhMetaFileA(0, NULL, NULL, NULL);
2476
2477     SetRect(&rc_sclip, 100, 100, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2478     hrgn = CreateRectRgn(rc_sclip.left, rc_sclip.top, rc_sclip.right, rc_sclip.bottom);
2479     SelectClipRgn(hdc, hrgn);
2480     ret = GetClipBox(hdc, &rc_res);
2481 todo_wine
2482     ok(ret == SIMPLEREGION, "got %d\n", ret);
2483     if(ret == SIMPLEREGION)
2484         ok(EqualRect(&rc_res, &rc_sclip),
2485                  "expected rc_res (%d, %d) - (%d, %d), got (%d, %d) - (%d, %d)\n",
2486                  rc_sclip.left, rc_sclip.top, rc_sclip.right, rc_sclip.bottom,
2487                  rc_res.left, rc_res.top, rc_res.right, rc_res.bottom);
2488
2489     hemf = CloseEnhMetaFile(hdc);
2490     DeleteEnhMetaFile(hemf);
2491     DeleteObject(hrgn);
2492     DeleteDC(hdc);
2493 }
2494
2495 static const unsigned char MF_CLIP_BITS[] = {
2496     /* METAHEADER */
2497     0x01, 0x00,             /* mtType */
2498     0x09, 0x00,             /* mtHeaderSize */
2499     0x00, 0x03,             /* mtVersion */
2500     0x32, 0x00, 0x00, 0x00, /* mtSize */
2501     0x01, 0x00,             /* mtNoObjects */
2502     0x14, 0x00, 0x00, 0x00, /* mtMaxRecord (size in words of longest record) */
2503     0x00, 0x00,             /* reserved */
2504
2505     /* METARECORD for CreateRectRgn(0x11, 0x22, 0x33, 0x44) */
2506     0x14, 0x00, 0x00, 0x00, /* rdSize in words */
2507     0xff, 0x06,             /* META_CREATEREGION */
2508     0x00, 0x00, 0x06, 0x00, 0xf6, 0x02, 0x00, 0x00,
2509     0x24, 0x00, 0x01, 0x00, 0x02, 0x00, 0x11, 0x00,
2510     0x22, 0x00, 0x33, 0x00, 0x44, 0x00, 0x02, 0x00,
2511     0x22, 0x00, 0x44, 0x00, 0x11, 0x00, 0x33, 0x00,
2512     0x02, 0x00,
2513
2514     /* METARECORD for SelectObject */
2515     0x04, 0x00, 0x00, 0x00,
2516     0x2d, 0x01,             /* META_SELECTOBJECT (not META_SELECTCLIPREGION?!) */
2517     0x00, 0x00,
2518
2519     /* METARECORD */
2520     0x04, 0x00, 0x00, 0x00,
2521     0xf0, 0x01,             /* META_DELETEOBJECT */
2522     0x00, 0x00,
2523
2524     /* METARECORD for MoveTo(1,0x30) */
2525     0x05, 0x00, 0x00, 0x00, /* rdSize in words */
2526     0x14, 0x02,             /* META_MOVETO */
2527     0x30, 0x00,             /* y */
2528     0x01, 0x00,             /* x */
2529
2530     /* METARECORD for LineTo(0x20, 0x30) */
2531     0x05, 0x00, 0x00, 0x00, /* rdSize in words */
2532     0x13, 0x02,             /* META_LINETO */
2533     0x30, 0x00,             /* y */
2534     0x20, 0x00,             /* x */
2535
2536     /* EOF */
2537     0x03, 0x00, 0x00, 0x00,
2538     0x00, 0x00
2539 };
2540
2541 static int clip_mf_enum_proc_seen_selectclipregion;
2542 static int clip_mf_enum_proc_seen_selectobject;
2543
2544 static int CALLBACK clip_mf_enum_proc(HDC hdc, HANDLETABLE *handle_table,
2545                                        METARECORD *mr, int n_objs, LPARAM param)
2546 {
2547     switch (mr->rdFunction) {
2548     case META_SELECTCLIPREGION:
2549         clip_mf_enum_proc_seen_selectclipregion++;
2550         break;
2551     case META_SELECTOBJECT:
2552         clip_mf_enum_proc_seen_selectobject++;
2553         break;
2554     }
2555     return 1;
2556 }
2557
2558 static void test_mf_clipping(void)
2559 {
2560                           /* left top right bottom */
2561     static RECT rc_clip = { 0x11, 0x22, 0x33, 0x44 };
2562     HWND hwnd;
2563     HDC hdc;
2564     HMETAFILE hmf;
2565     HRGN hrgn;
2566     INT ret;
2567
2568     SetLastError(0xdeadbeef);
2569     hdc = CreateMetaFileA(NULL);
2570     ok(hdc != 0, "CreateMetaFileA error %d\n", GetLastError());
2571
2572     hrgn = CreateRectRgn(rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom);
2573     ret = SelectClipRgn(hdc, hrgn);
2574     /* Seems like it should be SIMPLEREGION, but windows returns NULLREGION? */
2575     ok(ret == NULLREGION, "expected NULLREGION, got %d\n", ret);
2576
2577     /* Draw a line that starts off left of the clip region and ends inside it */
2578     MoveToEx(hdc, 0x1, 0x30, NULL);
2579     LineTo(hdc,  0x20, 0x30);
2580
2581     SetLastError(0xdeadbeef);
2582     hmf = CloseMetaFile(hdc);
2583     ok(hmf != 0, "CloseMetaFile error %d\n", GetLastError());
2584
2585     if (compare_mf_bits(hmf, MF_CLIP_BITS, sizeof(MF_CLIP_BITS),
2586         "mf_clipping") != 0)
2587     {
2588         dump_mf_bits(hmf, "mf_clipping");
2589     }
2590
2591     DeleteObject(hrgn);
2592
2593     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
2594                            0, 0, 200, 200, 0, 0, 0, NULL);
2595     ok(hwnd != 0, "CreateWindowExA error %d\n", GetLastError());
2596
2597     hdc = GetDC(hwnd);
2598
2599     ret = EnumMetaFile(hdc, hmf, clip_mf_enum_proc, (LPARAM)&rc_clip);
2600     ok(ret, "EnumMetaFile error %d\n", GetLastError());
2601
2602     /* Oddly, windows doesn't seem to use META_SELECTCLIPREGION */
2603     ok(clip_mf_enum_proc_seen_selectclipregion == 0,
2604        "expected 0 selectclipregion, saw %d\n", clip_mf_enum_proc_seen_selectclipregion);
2605     ok(clip_mf_enum_proc_seen_selectobject == 1,
2606        "expected 1 selectobject, saw %d\n", clip_mf_enum_proc_seen_selectobject);
2607
2608     DeleteMetaFile(hmf);
2609     ReleaseDC(hwnd, hdc);
2610     DestroyWindow(hwnd);
2611 }
2612
2613 static INT CALLBACK EmfEnumProc(HDC hdc, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR, INT nObj, LPARAM lpData)
2614 {
2615     LPMETAFILEPICT lpMFP = (LPMETAFILEPICT)lpData;
2616     POINT mapping[2] = { { 0, 0 }, { 10, 10 } };
2617     /* When using MM_TEXT Win9x does not update the mapping mode
2618      * until a record is played which actually outputs something */
2619     PlayEnhMetaFileRecord(hdc, lpHTable, lpEMFR, nObj);
2620     LPtoDP(hdc, mapping, 2);
2621     trace("EMF record: iType %d, nSize %d, (%d,%d)-(%d,%d)\n",
2622            lpEMFR->iType, lpEMFR->nSize,
2623            mapping[0].x, mapping[0].y, mapping[1].x, mapping[1].y);
2624
2625     if (lpEMFR->iType == EMR_LINETO)
2626     {
2627         INT x0, y0, x1, y1;
2628         if (!lpMFP || lpMFP->mm == MM_TEXT)
2629         {
2630             x0 = 0;
2631             y0 = 0;
2632             x1 = (INT)floor(10 * 100.0 / LINE_X + 0.5);
2633             y1 = (INT)floor(10 * 100.0 / LINE_Y + 0.5);
2634         }
2635         else
2636         {
2637             ok(lpMFP->mm == MM_ANISOTROPIC, "mm=%d\n", lpMFP->mm);
2638
2639             x0 = MulDiv(0, GetDeviceCaps(hdc, HORZSIZE) * 100, GetDeviceCaps(hdc, HORZRES));
2640             y0 = MulDiv(0, GetDeviceCaps(hdc, VERTSIZE) * 100, GetDeviceCaps(hdc, VERTRES));
2641             x1 = MulDiv(10, GetDeviceCaps(hdc, HORZSIZE) * 100, GetDeviceCaps(hdc, HORZRES));
2642             y1 = MulDiv(10, GetDeviceCaps(hdc, VERTSIZE) * 100, GetDeviceCaps(hdc, VERTRES));
2643         }
2644         ok(mapping[0].x == x0 && mapping[0].y == y0 && mapping[1].x == x1 && mapping[1].y == y1,
2645             "(%d,%d)->(%d,%d), expected (%d,%d)->(%d,%d)\n",
2646             mapping[0].x, mapping[0].y, mapping[1].x, mapping[1].y,
2647             x0, y0, x1, y1);
2648     }
2649     return TRUE;
2650 }
2651
2652 static HENHMETAFILE create_converted_emf(const METAFILEPICT *mfp)
2653 {
2654     HDC hdcMf;
2655     HMETAFILE hmf;
2656     HENHMETAFILE hemf;
2657     BOOL ret;
2658     UINT size;
2659     LPBYTE pBits;
2660
2661     hdcMf = CreateMetaFile(NULL);
2662     ok(hdcMf != NULL, "CreateMetaFile failed with error %d\n", GetLastError());
2663     ret = LineTo(hdcMf, (INT)LINE_X, (INT)LINE_Y);
2664     ok(ret, "LineTo failed with error %d\n", GetLastError());
2665     hmf = CloseMetaFile(hdcMf);
2666     ok(hmf != NULL, "CloseMetaFile failed with error %d\n", GetLastError());
2667
2668     if (compare_mf_bits (hmf, MF_LINETO_BITS, sizeof(MF_LINETO_BITS), "mf_LineTo") != 0)
2669     {
2670         dump_mf_bits(hmf, "mf_LineTo");
2671         EnumMetaFile(0, hmf, mf_enum_proc, 0);
2672     }
2673
2674     size = GetMetaFileBitsEx(hmf, 0, NULL);
2675     ok(size, "GetMetaFileBitsEx failed with error %d\n", GetLastError());
2676     pBits = HeapAlloc(GetProcessHeap(), 0, size);
2677     GetMetaFileBitsEx(hmf, size, pBits);
2678     DeleteMetaFile(hmf);
2679     hemf = SetWinMetaFileBits(size, pBits, NULL, mfp);
2680     HeapFree(GetProcessHeap(), 0, pBits);
2681     return hemf;
2682 }
2683
2684 static void test_mf_conversions(void)
2685 {
2686     trace("Testing MF->EMF conversion (MM_ANISOTROPIC)\n");
2687     {
2688         HDC hdcOffscreen = CreateCompatibleDC(NULL);
2689         HENHMETAFILE hemf;
2690         METAFILEPICT mfp;
2691         RECT rect = { 0, 0, 100, 100 };
2692         mfp.mm = MM_ANISOTROPIC;
2693         mfp.xExt = 100;
2694         mfp.yExt = 100;
2695         mfp.hMF = NULL;
2696         hemf = create_converted_emf(&mfp);
2697
2698         if (compare_emf_bits(hemf, EMF_LINETO_MM_ANISOTROPIC_BITS, sizeof(EMF_LINETO_MM_ANISOTROPIC_BITS),
2699                              "emf_LineTo MM_ANISOTROPIC", TRUE) != 0)
2700         {
2701             dump_emf_bits(hemf, "emf_LineTo MM_ANISOTROPIC");
2702             dump_emf_records(hemf, "emf_LineTo MM_ANISOTROPIC");
2703         }
2704
2705         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, &mfp, &rect);
2706
2707         DeleteEnhMetaFile(hemf);
2708         DeleteDC(hdcOffscreen);
2709     }
2710
2711     trace("Testing MF->EMF conversion (MM_TEXT)\n");
2712     {
2713         HDC hdcOffscreen = CreateCompatibleDC(NULL);
2714         HENHMETAFILE hemf;
2715         METAFILEPICT mfp;
2716         RECT rect = { 0, 0, 100, 100 };
2717         mfp.mm = MM_TEXT;
2718         mfp.xExt = 0;
2719         mfp.yExt = 0;
2720         mfp.hMF = NULL;
2721         hemf = create_converted_emf(&mfp);
2722
2723         if (compare_emf_bits(hemf, EMF_LINETO_MM_TEXT_BITS, sizeof(EMF_LINETO_MM_TEXT_BITS),
2724                              "emf_LineTo MM_TEXT", TRUE) != 0)
2725         {
2726             dump_emf_bits(hemf, "emf_LineTo MM_TEXT");
2727             dump_emf_records(hemf, "emf_LineTo MM_TEXT");
2728         }
2729
2730         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, &mfp, &rect);
2731
2732         DeleteEnhMetaFile(hemf);
2733         DeleteDC(hdcOffscreen);
2734     }
2735
2736     trace("Testing MF->EMF conversion (NULL mfp)\n");
2737     {
2738         HDC hdcOffscreen = CreateCompatibleDC(NULL);
2739         HENHMETAFILE hemf;
2740         RECT rect = { 0, 0, 100, 100 };
2741         hemf = create_converted_emf(NULL);
2742
2743         if (compare_emf_bits(hemf, EMF_LINETO_BITS, sizeof(EMF_LINETO_BITS),
2744                              "emf_LineTo NULL", TRUE) != 0)
2745         {
2746             dump_emf_bits(hemf, "emf_LineTo NULL");
2747             dump_emf_records(hemf, "emf_LineTo NULL");
2748         }
2749
2750         EnumEnhMetaFile(hdcOffscreen, hemf, EmfEnumProc, NULL, &rect);
2751
2752         DeleteEnhMetaFile(hemf);
2753         DeleteDC(hdcOffscreen);
2754     }
2755 }
2756
2757 static BOOL getConvertedFrameAndBounds(UINT buffer_size, BYTE * buffer, BOOL mfpIsNull,
2758                                        LONG mm, LONG xExt, LONG yExt,
2759                                        RECTL * rclBounds, RECTL * rclFrame)
2760 {
2761   METAFILEPICT mfp;
2762   METAFILEPICT * mfpPtr = NULL;
2763   HENHMETAFILE emf;
2764   ENHMETAHEADER header;
2765   UINT res;
2766
2767   if (!mfpIsNull)
2768   {
2769     mfp.mm = mm;
2770     mfp.xExt = xExt;
2771     mfp.yExt = yExt;
2772     mfpPtr = &mfp;
2773   }
2774
2775   emf = SetWinMetaFileBits(buffer_size, buffer, NULL, mfpPtr);
2776   ok(emf != NULL, "SetWinMetaFileBits failed\n");
2777   if (!emf) return FALSE;
2778   res = GetEnhMetaFileHeader(emf, sizeof(header), &header);
2779   ok(res != 0, "GetEnhMetaHeader failed\n");
2780   DeleteEnhMetaFile(emf);
2781   if (!res) return FALSE;
2782
2783   *rclBounds = header.rclBounds;
2784   *rclFrame = header.rclFrame;
2785   return TRUE;
2786 }
2787
2788 static void checkConvertedFrameAndBounds(UINT buffer_size, BYTE * buffer, BOOL mfpIsNull,
2789                                          LONG mm, LONG xExt, LONG yExt,
2790                                          RECTL * rclBoundsExpected, RECTL * rclFrameExpected)
2791 {
2792   RECTL rclBounds, rclFrame;
2793
2794   if (getConvertedFrameAndBounds(buffer_size, buffer, mfpIsNull, mm, xExt, yExt, &rclBounds, &rclFrame))
2795   {
2796     const char * msg;
2797     char buf[64];
2798
2799     if (mfpIsNull)
2800     {
2801        msg = "mfp == NULL";
2802     }
2803     else
2804     {
2805       const char * mm_str;
2806       switch (mm)
2807       {
2808          case MM_ANISOTROPIC: mm_str = "MM_ANISOTROPIC"; break;
2809          case MM_ISOTROPIC:   mm_str = "MM_ISOTROPIC"; break;
2810          default:             mm_str = "Unexpected";
2811       }
2812       sprintf(buf, "mm=%s, xExt=%d, yExt=%d", mm_str, xExt, yExt);
2813       msg = buf;
2814     }
2815
2816     ok(rclBounds.left == rclBoundsExpected->left, "rclBounds.left: Expected %d, got %d (%s)\n", rclBoundsExpected->left, rclBounds.left, msg);
2817     ok(rclBounds.top == rclBoundsExpected->top, "rclBounds.top: Expected %d, got %d (%s)\n", rclBoundsExpected->top, rclBounds.top, msg);
2818     ok(rclBounds.right == rclBoundsExpected->right, "rclBounds.right: Expected %d, got %d (%s)\n", rclBoundsExpected->right, rclBounds.right, msg);
2819     ok(rclBounds.bottom == rclBoundsExpected->bottom, "rclBounds.bottom: Expected %d, got %d (%s)\n", rclBoundsExpected->bottom, rclBounds.bottom, msg);
2820     ok(rclFrame.left == rclFrameExpected->left, "rclFrame.left: Expected %d, got %d (%s)\n", rclFrameExpected->left, rclFrame.left, msg);
2821     ok(rclFrame.top == rclFrameExpected->top, "rclFrame.top: Expected %d, got %d (%s)\n", rclFrameExpected->top, rclFrame.top, msg);
2822     ok(rclFrame.right == rclFrameExpected->right, "rclFrame.right: Expected %d, got %d (%s)\n", rclFrameExpected->right, rclFrame.right, msg);
2823     ok(rclFrame.bottom == rclFrameExpected->bottom, "rclFrame.bottom: Expected %d, got %d (%s)\n", rclFrameExpected->bottom, rclFrame.bottom, msg);
2824   }
2825 }
2826
2827 static void test_SetWinMetaFileBits(void)
2828 {
2829   HMETAFILE wmf;
2830   HDC wmfDC;
2831   BYTE * buffer;
2832   UINT buffer_size;
2833   RECT rect;
2834   UINT res;
2835   RECTL rclBoundsAnisotropic, rclFrameAnisotropic;
2836   RECTL rclBoundsIsotropic, rclFrameIsotropic;
2837   RECTL rclBounds, rclFrame;
2838   HDC dc;
2839   LONG diffx, diffy;
2840
2841   wmfDC = CreateMetaFile(NULL);
2842   ok(wmfDC != NULL, "CreateMetaFile failed\n");
2843   if (!wmfDC) return;
2844
2845   SetWindowExtEx(wmfDC, 100, 100, NULL);
2846   rect.left = rect.top = 0;
2847   rect.right = rect.bottom = 50;
2848   FillRect(wmfDC, &rect, GetStockObject(BLACK_BRUSH));
2849   wmf = CloseMetaFile(wmfDC);
2850   ok(wmf != NULL, "Metafile creation failed\n");
2851   if (!wmf) return;
2852
2853   buffer_size = GetMetaFileBitsEx(wmf, 0, NULL);
2854   ok(buffer_size != 0, "GetMetaFileBitsEx failed\n");
2855   if (buffer_size == 0)
2856   {
2857     DeleteMetaFile(wmf);
2858     return;
2859   }
2860
2861   buffer = HeapAlloc(GetProcessHeap(), 0, buffer_size);
2862   ok(buffer != NULL, "HeapAlloc failed\n");
2863   if (!buffer)
2864   {
2865     DeleteMetaFile(wmf);
2866     return;
2867   }
2868
2869   res = GetMetaFileBitsEx(wmf, buffer_size, buffer);
2870   ok(res == buffer_size, "GetMetaFileBitsEx failed\n");
2871   DeleteMetaFile(wmf);
2872   if (res != buffer_size)
2873   {
2874      HeapFree(GetProcessHeap(), 0, buffer);
2875      return;
2876   }
2877
2878   /* Get the reference bounds and frame */
2879   getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2880   getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, 0,  &rclBoundsIsotropic, &rclFrameIsotropic);
2881
2882   ok(rclBoundsAnisotropic.left == 0 && rclBoundsAnisotropic.top == 0 &&
2883      rclBoundsIsotropic.left == 0 && rclBoundsIsotropic.top == 0,
2884      "SetWinMetaFileBits: Reference bounds: Left and top bound must be zero\n");
2885
2886   ok(rclBoundsAnisotropic.right >= rclBoundsIsotropic.right, "SetWinMetaFileBits: Reference bounds: Invalid right bound\n");
2887   ok(rclBoundsAnisotropic.bottom >= rclBoundsIsotropic.bottom, "SetWinMetaFileBits: Reference bounds: Invalid bottom bound\n");
2888   diffx = rclBoundsIsotropic.right - rclBoundsIsotropic.bottom;
2889   if (diffx < 0) diffx = -diffx;
2890   ok(diffx <= 1, "SetWinMetaFileBits (MM_ISOTROPIC): Reference bounds are not isotropic\n");
2891
2892   dc = CreateCompatibleDC(NULL);
2893
2894   /* Allow 1 mm difference (rounding errors) */
2895   diffx = rclBoundsAnisotropic.right - GetDeviceCaps(dc, HORZRES) / 2;
2896   diffy = rclBoundsAnisotropic.bottom - GetDeviceCaps(dc, VERTRES) / 2;
2897   if (diffx < 0) diffx = -diffx;
2898   if (diffy < 0) diffy = -diffy;
2899   todo_wine
2900   {
2901   ok(diffx <= 1 && diffy <= 1,
2902      "SetWinMetaFileBits (MM_ANISOTROPIC): Reference bounds: The whole device surface must be used (%dx%d), but got (%dx%d)\n",
2903      GetDeviceCaps(dc, HORZRES) / 2, GetDeviceCaps(dc, VERTRES) / 2, rclBoundsAnisotropic.right, rclBoundsAnisotropic.bottom);
2904   }
2905
2906   /* Allow 1 mm difference (rounding errors) */
2907   diffx = rclFrameAnisotropic.right / 100 - GetDeviceCaps(dc, HORZSIZE) / 2;
2908   diffy = rclFrameAnisotropic.bottom / 100 - GetDeviceCaps(dc, VERTSIZE) / 2;
2909   if (diffx < 0) diffx = -diffx;
2910   if (diffy < 0) diffy = -diffy;
2911   todo_wine
2912   {
2913   ok(diffx <= 1 && diffy <= 1,
2914      "SetWinMetaFileBits (MM_ANISOTROPIC): Reference frame: The whole device surface must be used (%dx%d), but got (%dx%d)\n",
2915      GetDeviceCaps(dc, HORZSIZE) / 2, GetDeviceCaps(dc, VERTSIZE) / 2, rclFrameAnisotropic.right / 100, rclFrameAnisotropic.bottom / 100);
2916   }
2917   DeleteDC(dc);
2918
2919   /* If the METAFILEPICT pointer is NULL, the MM_ANISOTROPIC mapping mode and the whole device surface are used */
2920   checkConvertedFrameAndBounds(buffer_size, buffer, TRUE, 0, 0, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2921
2922   /* If xExt or yExt is zero or negative, the whole device surface is used */
2923   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 10000, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2924   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 10000, 0, &rclBoundsIsotropic, &rclFrameIsotropic);
2925   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, 10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2926   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, 10000, &rclBoundsIsotropic, &rclFrameIsotropic);
2927   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -10000, 0, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2928   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -10000, 0, &rclBoundsIsotropic, &rclFrameIsotropic);
2929   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 0, -10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2930   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 0, -10000, &rclBoundsIsotropic, &rclFrameIsotropic);
2931   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -10000, 10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2932   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -10000, 10000, &rclBoundsIsotropic, &rclFrameIsotropic);
2933   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 10000, -10000, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2934   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 10000, -10000, &rclBoundsIsotropic, &rclFrameIsotropic);
2935
2936   /* MSDN says that negative xExt and yExt values specify a ratio.
2937      Check that this is wrong and the whole device surface is used */
2938   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, -1000, -100, &rclBoundsAnisotropic, &rclFrameAnisotropic);
2939   checkConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, -1000, -100, &rclBoundsIsotropic, &rclFrameIsotropic);
2940
2941   /* Ordinary conversions */
2942
2943   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ANISOTROPIC, 30000, 20000, &rclBounds, &rclFrame))
2944   {
2945     ok(rclFrame.left == 0 && rclFrame.top == 0 && rclFrame.right == 30000 && rclFrame.bottom == 20000,
2946        "SetWinMetaFileBits (MM_ANISOTROPIC): rclFrame contains invalid values\n");
2947     ok(rclBounds.left == 0 && rclBounds.top == 0 && rclBounds.right > rclBounds.bottom,
2948        "SetWinMetaFileBits (MM_ANISOTROPIC): rclBounds contains invalid values\n");
2949   }
2950
2951   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_ISOTROPIC, 30000, 20000, &rclBounds, &rclFrame))
2952   {
2953     ok(rclFrame.left == 0 && rclFrame.top == 0 && rclFrame.right == 30000 && rclFrame.bottom == 20000,
2954        "SetWinMetaFileBits (MM_ISOTROPIC): rclFrame contains invalid values\n");
2955     ok(rclBounds.left == 0 && rclBounds.top == 0,
2956        "SetWinMetaFileBits (MM_ISOTROPIC): rclBounds contains invalid values\n");
2957
2958     /* Wine has a rounding error */
2959     diffx = rclBounds.right - rclBounds.bottom;
2960     if (diffx < 0) diffx = -diffx;
2961     ok(diffx <= 1, "SetWinMetaFileBits (MM_ISOTROPIC): rclBounds is not isotropic\n");
2962   }
2963
2964   if (getConvertedFrameAndBounds(buffer_size, buffer, FALSE, MM_HIMETRIC, 30000, 20000, &rclBounds, &rclFrame))
2965   {
2966     ok(rclFrame.right - rclFrame.left != 30000 && rclFrame.bottom - rclFrame.top != 20000,
2967        "SetWinMetaFileBits: xExt and yExt must be ignored for mapping modes other than MM_ANISOTROPIC and MM_ISOTROPIC\n");
2968   }
2969
2970   HeapFree(GetProcessHeap(), 0, buffer);
2971 }
2972
2973 static BOOL near_match(int x, int y)
2974 {
2975     int epsilon = min(abs(x), abs(y));
2976
2977     epsilon = max(epsilon/100, 2);
2978
2979     if(x < y - epsilon || x > y + epsilon) return FALSE;
2980     return TRUE;
2981 }
2982
2983 static void getwinmetafilebits(UINT mode, int scale, RECT *rc)
2984 {
2985     HENHMETAFILE emf;
2986     HDC display_dc, emf_dc;
2987     ENHMETAHEADER *enh_header;
2988     UINT size, emf_size, i;
2989     WORD check = 0;
2990     DWORD rec_num = 0;
2991     METAHEADER *mh = NULL;
2992     METARECORD *rec;
2993     INT horz_res, vert_res, horz_size, vert_size;
2994     INT curve_caps, line_caps, poly_caps;
2995
2996     display_dc = GetDC(NULL);
2997     ok(display_dc != NULL, "display_dc is NULL\n");
2998
2999     horz_res = GetDeviceCaps(display_dc, HORZRES);
3000     vert_res = GetDeviceCaps(display_dc, VERTRES);
3001     horz_size = GetDeviceCaps(display_dc, HORZSIZE);
3002     vert_size = GetDeviceCaps(display_dc, VERTSIZE);
3003
3004     emf_dc = CreateEnhMetaFileA(display_dc, NULL, rc, NULL);
3005     ok(emf_dc != NULL, "emf_dc is NULL\n");
3006
3007     curve_caps = GetDeviceCaps(emf_dc, CURVECAPS);
3008     ok(curve_caps == 511, "expect 511 got %d\n", curve_caps);
3009
3010     line_caps = GetDeviceCaps(emf_dc, LINECAPS);
3011     ok(line_caps == 254, "expect 254 got %d\n", line_caps);
3012
3013     poly_caps = GetDeviceCaps(emf_dc, POLYGONALCAPS);
3014     ok(poly_caps == 255, "expect 511 got %d\n", poly_caps);
3015
3016     for(i = 0; i < 3000; i++) /* This is enough to take emf_size > 0xffff */
3017         Rectangle(emf_dc, 0, 0, 1000, 20);
3018     emf = CloseEnhMetaFile(emf_dc);
3019     ok(emf != NULL, "emf is NULL\n");
3020
3021     emf_size = GetEnhMetaFileBits(emf, 0, NULL);
3022     enh_header = HeapAlloc(GetProcessHeap(), 0, emf_size);
3023     emf_size = GetEnhMetaFileBits(emf, emf_size, (BYTE*)enh_header);
3024     DeleteEnhMetaFile(emf);
3025     /* multiply szlDevice.cx by scale, when scale != 1 the recording and playback dcs
3026        have different resolutions */
3027     enh_header->szlDevice.cx *= scale;
3028     emf = SetEnhMetaFileBits(emf_size, (BYTE*)enh_header);
3029     ok(emf != NULL, "emf is NULL\n");
3030     ok(EqualRect((RECT*)&enh_header->rclFrame, rc), "Frame rectangles differ\n");
3031
3032     size = GetWinMetaFileBits(emf, 0, NULL, mode, display_dc);
3033     ok(size ||
3034        broken(size == 0), /* some versions of winxp fail for some reason */
3035        "GetWinMetaFileBits returns 0\n");
3036     if(!size) goto end;
3037     mh = HeapAlloc(GetProcessHeap(), 0, size);
3038     GetWinMetaFileBits(emf, size, (BYTE*)mh, mode, display_dc);
3039
3040     for(i = 0; i < size / 2; i++) check += ((WORD*)mh)[i];
3041     ok(check == 0, "check %04x\n", check);
3042
3043     rec = (METARECORD*)(mh + 1);
3044
3045     while(rec->rdSize && rec->rdFunction)
3046     {
3047         const DWORD chunk_size = 0x2000;
3048         DWORD mfcomment_chunks = (emf_size + chunk_size - 1) / chunk_size;
3049
3050         if(rec_num < mfcomment_chunks)
3051         {
3052             DWORD this_chunk_size = chunk_size;
3053
3054             if(rec_num == mfcomment_chunks - 1)
3055                 this_chunk_size = emf_size - rec_num * chunk_size;
3056
3057             ok(rec->rdSize == (this_chunk_size + 44) / 2, "%04x: got %04x expected %04x\n", rec_num, rec->rdSize, (this_chunk_size + 44) / 2);
3058             ok(rec->rdFunction == META_ESCAPE, "%04x: got %04x\n", rec_num, rec->rdFunction);
3059             if(rec->rdSize < (this_chunk_size + 44) / 2) break;
3060             ok(rec->rdParm[0] == MFCOMMENT, "got %04x\n", rec->rdParm[0]);
3061             ok(rec->rdParm[1] == this_chunk_size + 34, "got %04x %x\n", rec->rdParm[1], emf_size + 34);
3062             ok(rec->rdParm[2] == 0x4d57, "got %04x\n", rec->rdParm[2]); /* WMFC */
3063             ok(rec->rdParm[3] == 0x4346, "got %04x\n", rec->rdParm[3]); /*  "   */
3064             ok(rec->rdParm[4] == 1, "got %04x\n", rec->rdParm[4]);
3065             ok(rec->rdParm[5] == 0, "got %04x\n", rec->rdParm[5]);
3066             ok(rec->rdParm[6] == 0, "got %04x\n", rec->rdParm[6]);
3067             ok(rec->rdParm[7] == 1, "got %04x\n", rec->rdParm[7]);
3068             /* parm[8] is the checksum, tested above */
3069             if(rec_num > 0) ok(rec->rdParm[8] == 0, "got %04x\n", rec->rdParm[8]);
3070             ok(rec->rdParm[9] == 0, "got %04x\n", rec->rdParm[9]);
3071             ok(rec->rdParm[10] == 0, "got %04x\n", rec->rdParm[10]);
3072             ok(rec->rdParm[11] == mfcomment_chunks, "got %04x\n", rec->rdParm[11]); /* num chunks */
3073             ok(rec->rdParm[12] == 0, "got %04x\n", rec->rdParm[12]);
3074             ok(rec->rdParm[13] == this_chunk_size, "got %04x expected %04x\n", rec->rdParm[13], this_chunk_size);
3075             ok(rec->rdParm[14] == 0, "got %04x\n", rec->rdParm[14]);
3076             ok(*(DWORD*)(rec->rdParm + 15) == emf_size - this_chunk_size - rec_num * chunk_size, "got %08x\n", *(DWORD*)(rec->rdParm + 15));  /* DWORD size remaining after current chunk */
3077             ok(*(DWORD*)(rec->rdParm + 17) == emf_size, "got %08x emf_size %08x\n", *(DWORD*)(rec->rdParm + 17), emf_size);
3078             ok(!memcmp(rec->rdParm + 19, (char*)enh_header + rec_num * chunk_size, this_chunk_size), "bits mismatch\n");
3079         }
3080
3081         else if(rec_num == mfcomment_chunks)
3082         {
3083             ok(rec->rdFunction == META_SETMAPMODE, "got %04x\n", rec->rdFunction);
3084             ok(rec->rdParm[0] == mode, "got %04x\n", rec->rdParm[0]);
3085         }
3086         else if(rec_num == mfcomment_chunks + 1)
3087         {
3088             POINT pt;
3089             ok(rec->rdFunction == META_SETWINDOWORG, "got %04x\n", rec->rdFunction);
3090             switch(mode)
3091             {
3092             case MM_TEXT:
3093             case MM_ISOTROPIC:
3094             case MM_ANISOTROPIC:
3095                 pt.y = MulDiv(rc->top, vert_res, vert_size * 100) + 1;
3096                 pt.x = MulDiv(rc->left, horz_res, horz_size * 100);
3097                 break;
3098             case MM_LOMETRIC:
3099                 pt.y = MulDiv(-rc->top, 1, 10) + 1;
3100                 pt.x = MulDiv( rc->left, 1, 10);
3101                 break;
3102             case MM_HIMETRIC:
3103                 pt.y = -rc->top + 1;
3104                 pt.x = (rc->left >= 0) ? rc->left : rc->left + 1; /* strange but true */
3105                 break;
3106             case MM_LOENGLISH:
3107                 pt.y = MulDiv(-rc->top, 10, 254) + 1;
3108                 pt.x = MulDiv( rc->left, 10, 254);
3109                 break;
3110             case MM_HIENGLISH:
3111                 pt.y = MulDiv(-rc->top, 100, 254) + 1;
3112                 pt.x = MulDiv( rc->left, 100, 254);
3113                 break;
3114             case MM_TWIPS:
3115                 pt.y = MulDiv(-rc->top, 72 * 20, 2540) + 1;
3116                 pt.x = MulDiv( rc->left, 72 * 20, 2540);
3117                 break;
3118             default:
3119                 pt.x = pt.y = 0;
3120             }
3121             ok(near_match((short)rec->rdParm[0], pt.y), "got %d expect %d\n", (short)rec->rdParm[0], pt.y);
3122             ok(near_match((short)rec->rdParm[1], pt.x), "got %d expect %d\n", (short)rec->rdParm[1], pt.x);
3123         }
3124         if(rec_num == mfcomment_chunks + 2)
3125         {
3126             ok(rec->rdFunction == META_SETWINDOWEXT, "got %04x\n", rec->rdFunction);
3127             ok(near_match((short)rec->rdParm[0], MulDiv(rc->bottom - rc->top, vert_res, vert_size * 100)),
3128                "got %d\n", (short)rec->rdParm[0]);
3129             ok(near_match((short)rec->rdParm[1], MulDiv(rc->right - rc->left, horz_res, horz_size * 100)),
3130                "got %d\n", (short)rec->rdParm[1]);
3131         }
3132
3133         rec_num++;
3134         rec = (METARECORD*)((WORD*)rec + rec->rdSize);
3135     }
3136
3137 end:
3138     HeapFree(GetProcessHeap(), 0, mh);
3139     HeapFree(GetProcessHeap(), 0, enh_header);
3140     DeleteEnhMetaFile(emf);
3141
3142     ReleaseDC(NULL, display_dc);
3143 }
3144
3145 static void test_GetWinMetaFileBits(void)
3146 {
3147     UINT mode;
3148     RECT frames[] =
3149     {
3150         { 1000,  2000, 3000, 6000},
3151         {-1000,  2000, 3000, 6000},
3152         { 1000, -2000, 3000, 6000},
3153         { 1005,  2005, 3000, 6000},
3154         {-1005, -2005, 3000, 6000},
3155         {-1005, -2010, 3000, 6000},
3156         {-1005,  2010, 3000, 6000},
3157         {    0,     0,    1,    1},
3158         {   -1,    -1,    1,    1},
3159         {    0,     0,    0,    0}
3160     };
3161
3162     for(mode = MM_MIN; mode <= MM_MAX; mode++)
3163     {
3164         RECT *rc;
3165         trace("mode %d\n", mode);
3166
3167         for(rc = frames; rc->right - rc->left > 0; rc++)
3168         {
3169             trace("frame %d,%d - %d,%d\n", rc->left, rc->top, rc->right, rc->bottom);
3170             getwinmetafilebits(mode, 1, rc);
3171             getwinmetafilebits(mode, 2, rc);
3172         }
3173     }
3174 }
3175
3176 static BOOL (WINAPI *pGdiIsMetaPrintDC)(HDC);
3177 static BOOL (WINAPI *pGdiIsMetaFileDC)(HDC);
3178 static BOOL (WINAPI *pGdiIsPlayMetafileDC)(HDC);
3179
3180 static void test_gdiis(void)
3181 {
3182     RECT rect = {0,0,100,100};
3183     HDC hdc, hemfDC, hmfDC;
3184     HENHMETAFILE hemf;
3185     HMODULE hgdi32;
3186
3187     /* resolve all the functions */
3188     hgdi32 = GetModuleHandle("gdi32");
3189     pGdiIsMetaPrintDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaPrintDC");
3190     pGdiIsMetaFileDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaFileDC");
3191     pGdiIsPlayMetafileDC = (void*) GetProcAddress(hgdi32, "GdiIsPlayMetafileDC");
3192
3193     if(!pGdiIsMetaPrintDC || !pGdiIsMetaFileDC || !pGdiIsPlayMetafileDC)
3194     {
3195         win_skip("Needed GdiIs* functions are not available\n");
3196         return;
3197     }
3198
3199     /* try with nothing */
3200     ok(!pGdiIsMetaPrintDC(NULL), "ismetaprint with NULL parameter\n");
3201     ok(!pGdiIsMetaFileDC(NULL), "ismetafile with NULL parameter\n");
3202     ok(!pGdiIsPlayMetafileDC(NULL), "isplaymetafile with NULL parameter\n");
3203
3204     /* try with a metafile */
3205     hmfDC = CreateMetaFile(NULL);
3206     ok(!pGdiIsMetaPrintDC(hmfDC), "ismetaprint on metafile\n");
3207     ok(pGdiIsMetaFileDC(hmfDC), "ismetafile on metafile\n");
3208     ok(!pGdiIsPlayMetafileDC(hmfDC), "isplaymetafile on metafile\n");
3209     DeleteMetaFile(CloseMetaFile(hmfDC));
3210
3211     /* try with an enhanced metafile */
3212     hdc = GetDC(NULL);
3213     hemfDC = CreateEnhMetaFileW(hdc, NULL, &rect, NULL);
3214     ok(hemfDC != NULL, "failed to create emf\n");
3215
3216     ok(!pGdiIsMetaPrintDC(hemfDC), "ismetaprint on emf\n");
3217     ok(pGdiIsMetaFileDC(hemfDC), "ismetafile on emf\n");
3218     ok(!pGdiIsPlayMetafileDC(hemfDC), "isplaymetafile on emf\n");
3219
3220     hemf = CloseEnhMetaFile(hemfDC);
3221     ok(hemf != NULL, "failed to close EMF\n");
3222     DeleteEnhMetaFile(hemf);
3223     ReleaseDC(NULL,hdc);
3224 }
3225
3226 static void test_SetEnhMetaFileBits(void)
3227 {
3228     BYTE data[256];
3229     HENHMETAFILE hemf;
3230     ENHMETAHEADER *emh;
3231
3232     memset(data, 0xAA, sizeof(data));
3233     SetLastError(0xdeadbeef);
3234     hemf = SetEnhMetaFileBits(sizeof(data), data);
3235     ok(!hemf, "SetEnhMetaFileBits should fail\n");
3236     ok(GetLastError() == ERROR_INVALID_DATA ||
3237        GetLastError() == ERROR_INVALID_PARAMETER, /* Win9x, WinMe */
3238        "expected ERROR_INVALID_DATA or ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
3239
3240     emh = (ENHMETAHEADER *)data;
3241     memset(emh, 0, sizeof(*emh));
3242
3243     emh->iType = EMR_HEADER;
3244     emh->nSize = sizeof(*emh);
3245     emh->dSignature = ENHMETA_SIGNATURE;
3246     /* emh->nVersion  = 0x10000; XP doesn't care about version */
3247     emh->nBytes = sizeof(*emh);
3248     /* emh->nRecords = 1; XP doesn't care about records */
3249     emh->nHandles = 1; /* XP refuses to load a EMF if nHandles == 0 */
3250
3251     SetLastError(0xdeadbeef);
3252     hemf = SetEnhMetaFileBits(emh->nBytes, data);
3253     ok(hemf != 0, "SetEnhMetaFileBits error %u\n", GetLastError());
3254     DeleteEnhMetaFile(hemf);
3255
3256     /* XP refuses to load unaligned EMF */
3257     emh->nBytes++;
3258     SetLastError(0xdeadbeef);
3259     hemf = SetEnhMetaFileBits(emh->nBytes, data);
3260     ok(!hemf ||
3261        broken(hemf != NULL), /* Win9x, WinMe */
3262        "SetEnhMetaFileBits should fail\n");
3263     ok(GetLastError() == 0xdeadbeef, "Expected deadbeef, got %u\n", GetLastError());
3264     DeleteEnhMetaFile(hemf);
3265
3266     emh->dSignature = 0;
3267     emh->nBytes--;
3268     SetLastError(0xdeadbeef);
3269     hemf = SetEnhMetaFileBits(emh->nBytes, data);
3270     ok(!hemf ||
3271        broken(hemf != NULL), /* Win9x, WinMe */
3272        "SetEnhMetaFileBits should fail\n");
3273     ok(GetLastError() == 0xdeadbeef, "Expected deadbeef, got %u\n", GetLastError());
3274     DeleteEnhMetaFile(hemf);
3275 }
3276
3277 static void test_emf_polybezier(void)
3278 {
3279     HDC hdcMetafile;
3280     HENHMETAFILE hemf;
3281     POINT pts[4];
3282     BOOL ret;
3283
3284     SetLastError(0xdeadbeef);
3285     hdcMetafile = CreateEnhMetaFileA(GetDC(0), NULL, NULL, NULL);
3286     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
3287
3288     pts[0].x = pts[0].y = 10;
3289     pts[1].x = pts[1].y = 20;
3290     pts[2].x = pts[2].y = 15;
3291     pts[3].x = pts[3].y = 25;
3292     ret = PolyBezierTo(hdcMetafile, pts, 3);  /* EMR_POLYBEZIERTO16 */
3293     ok( ret, "PolyBezierTo failed\n" );
3294     ret = PolyBezier(hdcMetafile, pts, 4);    /* EMR_POLYBEZIER16   */
3295     ok( ret, "PolyBezier failed\n" );
3296
3297     pts[0].x = pts[0].y = 32769;
3298     ret = PolyBezier(hdcMetafile, pts, 4);    /* EMR_POLYBEZIER   */
3299     ok( ret, "PolyBezier failed\n" );
3300     ret = PolyBezierTo(hdcMetafile, pts, 3);  /* EMR_POLYBEZIERTO */
3301     ok( ret, "PolyBezierTo failed\n" );
3302
3303     hemf = CloseEnhMetaFile(hdcMetafile);
3304     ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
3305
3306     if(compare_emf_bits(hemf, EMF_BEZIER_BITS, sizeof(EMF_BEZIER_BITS),
3307         "emf_Bezier", FALSE) != 0)
3308     {
3309         dump_emf_bits(hemf, "emf_Bezier");
3310         dump_emf_records(hemf, "emf_Bezier");
3311     }
3312
3313     DeleteEnhMetaFile(hemf);
3314 }
3315
3316 START_TEST(metafile)
3317 {
3318     init_function_pointers();
3319
3320     /* For enhanced metafiles (enhmfdrv) */
3321     test_ExtTextOut();
3322     test_ExtTextOutScale();
3323     test_SaveDC();
3324     test_emf_BitBlt();
3325     test_emf_DCBrush();
3326     test_emf_ExtTextOut_on_path();
3327     test_emf_clipping();
3328     test_emf_polybezier();
3329
3330     /* For win-format metafiles (mfdrv) */
3331     test_mf_SaveDC();
3332     test_mf_Blank();
3333     test_mf_Graphics();
3334     test_mf_PatternBrush();
3335     test_mf_DCBrush();
3336     test_CopyMetaFile();
3337     test_SetMetaFileBits();
3338     test_mf_ExtTextOut_on_path();
3339     test_mf_clipping();
3340
3341     /* For metafile conversions */
3342     test_mf_conversions();
3343     test_SetWinMetaFileBits();
3344     test_GetWinMetaFileBits();
3345
3346     test_gdiis();
3347     test_SetEnhMetaFileBits();
3348 }