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