Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers...
[reactos.git] / modules / rostests / winetests / user32 / monitor.c
1 /*
2 * Unit tests for monitor APIs
3 *
4 * Copyright 2005 Huw Davies
5 * Copyright 2008 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "wine/test.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winuser.h"
26
27 static HMODULE hdll;
28 static LONG (WINAPI *pChangeDisplaySettingsExA)(LPCSTR, LPDEVMODEA, HWND, DWORD, LPVOID);
29 static LONG (WINAPI *pChangeDisplaySettingsExW)(LPCWSTR, LPDEVMODEW, HWND, DWORD, LPVOID);
30 static BOOL (WINAPI *pEnumDisplayDevicesA)(LPCSTR,DWORD,LPDISPLAY_DEVICEA,DWORD);
31 static BOOL (WINAPI *pEnumDisplayMonitors)(HDC,LPRECT,MONITORENUMPROC,LPARAM);
32 static BOOL (WINAPI *pGetMonitorInfoA)(HMONITOR,LPMONITORINFO);
33 static BOOL (WINAPI *pGetMonitorInfoW)(HMONITOR,LPMONITORINFO);
34 static HMONITOR (WINAPI *pMonitorFromPoint)(POINT,DWORD);
35 static HMONITOR (WINAPI *pMonitorFromRect)(LPCRECT,DWORD);
36 static HMONITOR (WINAPI *pMonitorFromWindow)(HWND,DWORD);
37 static LONG (WINAPI *pGetDisplayConfigBufferSizes)(UINT32,UINT32*,UINT32*);
38
39 static void init_function_pointers(void)
40 {
41 hdll = GetModuleHandleA("user32.dll");
42
43 #define GET_PROC(func) \
44 p ## func = (void*)GetProcAddress(hdll, #func); \
45 if(!p ## func) \
46 trace("GetProcAddress(%s) failed\n", #func);
47
48 GET_PROC(ChangeDisplaySettingsExA)
49 GET_PROC(ChangeDisplaySettingsExW)
50 GET_PROC(EnumDisplayDevicesA)
51 GET_PROC(EnumDisplayMonitors)
52 GET_PROC(GetDisplayConfigBufferSizes)
53 GET_PROC(GetMonitorInfoA)
54 GET_PROC(GetMonitorInfoW)
55 GET_PROC(MonitorFromPoint)
56 GET_PROC(MonitorFromRect)
57 GET_PROC(MonitorFromWindow)
58
59 #undef GET_PROC
60 }
61
62 static BOOL CALLBACK monitor_enum_proc(HMONITOR hmon, HDC hdc, LPRECT lprc,
63 LPARAM lparam)
64 {
65 MONITORINFOEXA mi;
66 char *primary = (char *)lparam;
67
68 mi.cbSize = sizeof(mi);
69
70 ok(pGetMonitorInfoA(hmon, (MONITORINFO*)&mi), "GetMonitorInfo failed\n");
71 if (mi.dwFlags & MONITORINFOF_PRIMARY)
72 strcpy(primary, mi.szDevice);
73
74 return TRUE;
75 }
76
77 static void test_enumdisplaydevices(void)
78 {
79 DISPLAY_DEVICEA dd;
80 char primary_device_name[32];
81 char primary_monitor_device_name[32];
82 DWORD primary_num = -1, num = 0;
83 BOOL ret;
84
85 if (!pEnumDisplayDevicesA)
86 {
87 win_skip("EnumDisplayDevicesA is not available\n");
88 return;
89 }
90
91 dd.cb = sizeof(dd);
92 for (num = 0;; num++)
93 {
94 HDC dc;
95 ret = pEnumDisplayDevicesA(NULL, num, &dd, 0);
96 if(!ret) break;
97
98 if(dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
99 {
100 strcpy(primary_device_name, dd.DeviceName);
101 primary_num = num;
102 }
103 if(dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
104 {
105 /* test creating DC */
106 dc = CreateDCA(dd.DeviceName, NULL, NULL, NULL);
107 ok(dc != NULL, "Failed to CreateDC(\"%s\") err=%d\n", dd.DeviceName, GetLastError());
108 DeleteDC(dc);
109 }
110 }
111
112 if (primary_num == -1 || !pEnumDisplayMonitors || !pGetMonitorInfoA)
113 {
114 win_skip("EnumDisplayMonitors or GetMonitorInfoA are not available\n");
115 return;
116 }
117
118 primary_monitor_device_name[0] = 0;
119 ret = pEnumDisplayMonitors(NULL, NULL, monitor_enum_proc, (LPARAM)primary_monitor_device_name);
120 ok(ret, "EnumDisplayMonitors failed\n");
121 ok(!strcmp(primary_monitor_device_name, primary_device_name),
122 "monitor device name %s, device name %s\n", primary_monitor_device_name,
123 primary_device_name);
124
125 dd.cb = sizeof(dd);
126 for (num = 0;; num++)
127 {
128 ret = pEnumDisplayDevicesA(primary_device_name, num, &dd, 0);
129 if (!ret) break;
130
131 dd.DeviceID[63] = 0;
132 ok(!strcasecmp(dd.DeviceID, "Monitor\\Default_Monitor\\{4D36E96E-E325-11CE-BFC1-08002BE10318}\\"),
133 "DeviceID \"%s\" does not start with \"Monitor\\Default_Monitor\\...\" prefix\n", dd.DeviceID);
134 }
135 }
136
137 struct vid_mode
138 {
139 DWORD w, h, bpp, freq, fields;
140 BOOL must_succeed;
141 };
142
143 static const struct vid_mode vid_modes_test[] = {
144 {640, 480, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY, 0},
145 {640, 480, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY, 1},
146 {640, 480, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL , 0},
147 {640, 480, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT , 1},
148 {640, 480, 0, 0, DM_BITSPERPEL , 0},
149 {640, 480, 0, 0, DM_DISPLAYFREQUENCY, 0},
150
151 {0, 0, 0, 0, DM_PELSWIDTH, 0},
152 {0, 0, 0, 0, DM_PELSHEIGHT, 0},
153
154 {640, 480, 0, 0, DM_PELSWIDTH, 0},
155 {640, 480, 0, 0, DM_PELSHEIGHT, 0},
156 { 0, 480, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT, 0},
157 {640, 0, 0, 0, DM_PELSWIDTH | DM_PELSHEIGHT, 0},
158
159 /* the following test succeeds under XP SP3
160 {0, 0, 0, 0, DM_DISPLAYFREQUENCY, 0}
161 */
162 };
163 #define vid_modes_cnt (sizeof(vid_modes_test) / sizeof(vid_modes_test[0]))
164
165 static void test_ChangeDisplaySettingsEx(void)
166 {
167 DEVMODEA dm;
168 DEVMODEW dmW;
169 DWORD width;
170 LONG res;
171 int i;
172
173 if (!pChangeDisplaySettingsExA)
174 {
175 win_skip("ChangeDisplaySettingsExA is not available\n");
176 return;
177 }
178
179 SetLastError(0xdeadbeef);
180 res = EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &dm);
181 ok(res, "EnumDisplaySettings error %u\n", GetLastError());
182
183 width = dm.dmPelsWidth;
184
185 dm.dmDriverExtra = 1;
186 res = ChangeDisplaySettingsA(&dm, CDS_TEST);
187 ok(res == DISP_CHANGE_SUCCESSFUL,
188 "ChangeDisplaySettingsA returned %d, expected DISP_CHANGE_SUCCESSFUL\n", res);
189 ok(dm.dmDriverExtra == 0 || broken(dm.dmDriverExtra == 1) /* win9x */,
190 "ChangeDisplaySettingsA didn't reset dmDriverExtra to 0\n");
191
192 /* crashes under XP SP3 for large dmDriverExtra values */
193 dm.dmDriverExtra = 1;
194 res = pChangeDisplaySettingsExA(NULL, &dm, NULL, CDS_TEST, NULL);
195 ok(res == DISP_CHANGE_SUCCESSFUL,
196 "ChangeDisplaySettingsExW returned %d, expected DISP_CHANGE_SUCCESSFUL\n", res);
197 ok(dm.dmDriverExtra == 1, "ChangeDisplaySettingsExA shouldn't reset dmDriverExtra to 0\n");
198
199 memset(&dmW, 0, sizeof(dmW));
200 dmW.dmSize = sizeof(dmW);
201 dmW.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
202 dmW.dmPelsWidth = dm.dmPelsWidth;
203 dmW.dmPelsHeight = dm.dmPelsHeight;
204 dmW.dmDriverExtra = 1;
205 SetLastError(0xdeadbeef);
206 res = ChangeDisplaySettingsW(&dmW, CDS_TEST);
207 if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
208 {
209 ok(res == DISP_CHANGE_SUCCESSFUL,
210 "ChangeDisplaySettingsW returned %d, expected DISP_CHANGE_SUCCESSFUL\n", res);
211 ok(dmW.dmDriverExtra == 0, "ChangeDisplaySettingsW didn't reset dmDriverExtra to 0\n");
212 }
213
214 /* Apparently XP treats dmDriverExtra being != 0 as an error */
215 dmW.dmDriverExtra = 1;
216 res = pChangeDisplaySettingsExW(NULL, &dmW, NULL, CDS_TEST, NULL);
217 if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
218 {
219 ok(res == DISP_CHANGE_SUCCESSFUL,
220 "ChangeDisplaySettingsExW returned %d, expected DISP_CHANGE_SUCCESSFUL\n", res);
221 ok(dmW.dmDriverExtra == 1, "ChangeDisplaySettingsExW shouldn't reset dmDriverExtra to 0\n");
222 }
223
224 /* the following 2 tests show that dm.dmSize being 0 is invalid, but
225 * ChangeDisplaySettingsExA still reports success.
226 */
227 memset(&dm, 0, sizeof(dm));
228 dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
229 dm.dmPelsWidth = width;
230 res = pChangeDisplaySettingsExA(NULL, &dm, NULL, CDS_TEST, NULL);
231 ok(res == DISP_CHANGE_SUCCESSFUL ||
232 res == DISP_CHANGE_BADMODE || /* Win98, WinMe */
233 res == DISP_CHANGE_FAILED, /* NT4 */
234 "ChangeDisplaySettingsExA returned unexpected %d\n", res);
235
236 memset(&dmW, 0, sizeof(dmW));
237 dmW.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
238 dmW.dmPelsWidth = width;
239 SetLastError(0xdeadbeef);
240 res = pChangeDisplaySettingsExW(NULL, &dmW, NULL, CDS_TEST, NULL);
241 if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
242 ok(res == DISP_CHANGE_FAILED ||
243 res == DISP_CHANGE_BADPARAM || /* NT4 */
244 res == DISP_CHANGE_BADMODE /* XP SP3 */,
245 "ChangeDisplaySettingsExW returned %d\n", res);
246
247 memset(&dm, 0, sizeof(dm));
248 dm.dmSize = sizeof(dm);
249
250 for (i = 0; i < vid_modes_cnt; i++)
251 {
252 dm.dmPelsWidth = vid_modes_test[i].w;
253 dm.dmPelsHeight = vid_modes_test[i].h;
254 dm.dmBitsPerPel = vid_modes_test[i].bpp;
255 dm.dmDisplayFrequency = vid_modes_test[i].freq;
256 dm.dmFields = vid_modes_test[i].fields;
257 res = pChangeDisplaySettingsExA(NULL, &dm, NULL, CDS_TEST, NULL);
258 ok(vid_modes_test[i].must_succeed ?
259 (res == DISP_CHANGE_SUCCESSFUL || res == DISP_CHANGE_RESTART) :
260 (res == DISP_CHANGE_SUCCESSFUL || res == DISP_CHANGE_RESTART ||
261 res == DISP_CHANGE_BADMODE || res == DISP_CHANGE_BADPARAM),
262 "Unexpected ChangeDisplaySettingsEx() return code for resolution[%d]: %d\n", i, res);
263
264 if (res == DISP_CHANGE_SUCCESSFUL)
265 {
266 RECT r, r1, virt;
267
268 SetRect(&virt, 0, 0, GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN));
269 if (IsRectEmpty(&virt)) /* NT4 doesn't have SM_CX/YVIRTUALSCREEN */
270 SetRect(&virt, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
271 OffsetRect(&virt, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN));
272
273 /* Resolution change resets clip rect */
274 ok(GetClipCursor(&r), "GetClipCursor() failed\n");
275 ok(EqualRect(&r, &virt), "Invalid clip rect: %s\n", wine_dbgstr_rect(&r));
276
277 if (!ClipCursor(NULL)) continue;
278 ok(GetClipCursor(&r), "GetClipCursor() failed\n");
279 ok(EqualRect(&r, &virt), "Invalid clip rect: %s\n", wine_dbgstr_rect(&r));
280
281 /* This should always work. Primary monitor is at (0,0) */
282 SetRect(&r1, 10, 10, 20, 20);
283 ok(ClipCursor(&r1), "ClipCursor() failed\n");
284 ok(GetClipCursor(&r), "GetClipCursor() failed\n");
285 ok(EqualRect(&r, &r1), "Invalid clip rect: %s\n", wine_dbgstr_rect(&r));
286 SetRect(&r1, 10, 10, 10, 10);
287 ok(ClipCursor(&r1), "ClipCursor() failed\n");
288 ok(GetClipCursor(&r), "GetClipCursor() failed\n");
289 ok(EqualRect(&r, &r1), "Invalid clip rect: %s\n", wine_dbgstr_rect(&r));
290 SetRect(&r1, 10, 10, 10, 9);
291 ok(!ClipCursor(&r1), "ClipCursor() succeeded\n");
292 /* Windows bug: further clipping fails once an empty rect is set, so we have to reset it */
293 ClipCursor(NULL);
294
295 SetRect(&r1, virt.left - 10, virt.top - 10, virt.right + 20, virt.bottom + 20);
296 ok(ClipCursor(&r1), "ClipCursor() failed\n");
297 ok(GetClipCursor(&r), "GetClipCursor() failed\n");
298 ok(EqualRect(&r, &virt) || broken(EqualRect(&r, &r1)) /* win9x */,
299 "Invalid clip rect: %s\n", wine_dbgstr_rect(&r));
300 ClipCursor(&virt);
301 }
302 }
303 res = pChangeDisplaySettingsExA(NULL, NULL, NULL, CDS_RESET, NULL);
304 ok(res == DISP_CHANGE_SUCCESSFUL, "Failed to reset default resolution: %d\n", res);
305 }
306
307 static void test_monitors(void)
308 {
309 HMONITOR monitor, primary, nearest;
310 POINT pt;
311 RECT rc;
312 MONITORINFO mi;
313 MONITORINFOEXA miexa;
314 MONITORINFOEXW miexw;
315 BOOL ret;
316 DWORD i;
317
318 static const struct
319 {
320 DWORD cbSize;
321 BOOL ret;
322 } testdatami[] = {
323 {0, FALSE},
324 {sizeof(MONITORINFO)+1, FALSE},
325 {sizeof(MONITORINFO)-1, FALSE},
326 {sizeof(MONITORINFO), TRUE},
327 {-1, FALSE},
328 {0xdeadbeef, FALSE},
329 },
330 testdatamiexa[] = {
331 {0, FALSE},
332 {sizeof(MONITORINFOEXA)+1, FALSE},
333 {sizeof(MONITORINFOEXA)-1, FALSE},
334 {sizeof(MONITORINFOEXA), TRUE},
335 {-1, FALSE},
336 {0xdeadbeef, FALSE},
337 },
338 testdatamiexw[] = {
339 {0, FALSE},
340 {sizeof(MONITORINFOEXW)+1, FALSE},
341 {sizeof(MONITORINFOEXW)-1, FALSE},
342 {sizeof(MONITORINFOEXW), TRUE},
343 {-1, FALSE},
344 {0xdeadbeef, FALSE},
345 };
346
347 if (!pMonitorFromPoint || !pMonitorFromWindow || !pMonitorFromRect)
348 {
349 win_skip("MonitorFromPoint, MonitorFromWindow, or MonitorFromRect is not available\n");
350 return;
351 }
352
353 pt.x = pt.y = 0;
354 primary = pMonitorFromPoint( pt, MONITOR_DEFAULTTOPRIMARY );
355 ok( primary != 0, "couldn't get primary monitor\n" );
356
357 monitor = pMonitorFromWindow( 0, MONITOR_DEFAULTTONULL );
358 ok( !monitor, "got %p, should not get a monitor for an invalid window\n", monitor );
359 monitor = pMonitorFromWindow( 0, MONITOR_DEFAULTTOPRIMARY );
360 ok( monitor == primary, "got %p, should get primary %p for MONITOR_DEFAULTTOPRIMARY\n", monitor, primary );
361 monitor = pMonitorFromWindow( 0, MONITOR_DEFAULTTONEAREST );
362 ok( monitor == primary, "got %p, should get primary %p for MONITOR_DEFAULTTONEAREST\n", monitor, primary );
363
364 SetRect( &rc, 0, 0, 1, 1 );
365 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
366 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
367
368 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTOPRIMARY );
369 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
370
371 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONEAREST );
372 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
373
374 /* Empty rect at 0,0 is considered inside the primary monitor */
375 SetRect( &rc, 0, 0, -1, -1 );
376 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
377 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
378
379 /* Even if there is a monitor left of the primary, the primary will have the most overlapping area */
380 SetRect( &rc, -1, 0, 2, 1 );
381 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
382 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
383
384 /* But the width of the rect doesn't matter if it's empty. */
385 SetRect( &rc, -1, 0, 2, -1 );
386 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
387 ok( monitor != primary, "got primary %p\n", monitor );
388
389 if (!pGetMonitorInfoA)
390 {
391 win_skip("GetMonitorInfoA is not available\n");
392 return;
393 }
394
395 /* Search for a monitor that has no others equally near to (left, top-1) */
396 SetRect( &rc, -1, -2, 2, 0 );
397 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
398 nearest = primary;
399 while (monitor != NULL)
400 {
401 ok( monitor != primary, "got primary %p\n", monitor );
402 nearest = monitor;
403 mi.cbSize = sizeof(mi);
404 ret = pGetMonitorInfoA( monitor, &mi );
405 ok( ret, "GetMonitorInfo failed\n" );
406 SetRect( &rc, mi.rcMonitor.left-1, mi.rcMonitor.top-2, mi.rcMonitor.left+2, mi.rcMonitor.top );
407 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
408 }
409
410 /* tests for cbSize in MONITORINFO */
411 monitor = pMonitorFromWindow( 0, MONITOR_DEFAULTTOPRIMARY );
412 for (i = 0; i < (sizeof(testdatami) / sizeof(testdatami[0])); i++)
413 {
414 memset( &mi, 0, sizeof(mi) );
415 mi.cbSize = testdatami[i].cbSize;
416 ret = pGetMonitorInfoA( monitor, &mi );
417 ok( ret == testdatami[i].ret, "GetMonitorInfo returned wrong value\n" );
418 if (ret)
419 ok( (mi.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag isn't set\n" );
420 else
421 ok( !(mi.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag is set\n" );
422
423 memset( &miexw, 0, sizeof(miexw) );
424 miexw.cbSize = testdatamiexw[i].cbSize;
425 ret = pGetMonitorInfoW( monitor, (LPMONITORINFO)&miexw );
426 ok( ret == testdatamiexw[i].ret, "GetMonitorInfo returned wrong value\n" );
427 if (ret)
428 ok( (miexw.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag isn't set\n" );
429 else
430 ok( !(miexw.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag is set\n" );
431 }
432
433 /* tests for cbSize in MONITORINFOEXA */
434 for (i = 0; i < (sizeof(testdatamiexa) / sizeof(testdatamiexa[0])); i++)
435 {
436 memset( &miexa, 0, sizeof(miexa) );
437 miexa.cbSize = testdatamiexa[i].cbSize;
438 ret = pGetMonitorInfoA( monitor, (LPMONITORINFO)&miexa );
439 ok( ret == testdatamiexa[i].ret, "GetMonitorInfo returned wrong value\n" );
440 if (ret)
441 ok( (miexa.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag isn't set\n" );
442 else
443 ok( !(miexa.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag is set\n" );
444 }
445
446 /* tests for cbSize in MONITORINFOEXW */
447 for (i = 0; i < (sizeof(testdatamiexw) / sizeof(testdatamiexw[0])); i++)
448 {
449 memset( &miexw, 0, sizeof(miexw) );
450 miexw.cbSize = testdatamiexw[i].cbSize;
451 ret = pGetMonitorInfoW( monitor, (LPMONITORINFO)&miexw );
452 ok( ret == testdatamiexw[i].ret, "GetMonitorInfo returned wrong value\n" );
453 if (ret)
454 ok( (miexw.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag isn't set\n" );
455 else
456 ok( !(miexw.dwFlags & MONITORINFOF_PRIMARY), "MONITORINFOF_PRIMARY flag is set\n" );
457 }
458
459 SetRect( &rc, rc.left+1, rc.top+1, rc.left+2, rc.top+2 );
460
461 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONULL );
462 ok( monitor == NULL, "got %p\n", monitor );
463
464 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTOPRIMARY );
465 ok( monitor == primary, "got %p, should get primary %p\n", monitor, primary );
466
467 monitor = pMonitorFromRect( &rc, MONITOR_DEFAULTTONEAREST );
468 ok( monitor == nearest, "got %p, should get nearest %p\n", monitor, nearest );
469 }
470
471 static BOOL CALLBACK find_primary_mon(HMONITOR hmon, HDC hdc, LPRECT rc, LPARAM lp)
472 {
473 MONITORINFO mi;
474 BOOL ret;
475
476 mi.cbSize = sizeof(mi);
477 ret = pGetMonitorInfoA(hmon, &mi);
478 ok(ret, "GetMonitorInfo failed\n");
479 if (mi.dwFlags & MONITORINFOF_PRIMARY)
480 {
481 *(HMONITOR *)lp = hmon;
482 return FALSE;
483 }
484 return TRUE;
485 }
486
487 static void test_work_area(void)
488 {
489 HMONITOR hmon;
490 MONITORINFO mi;
491 RECT rc_work, rc_normal;
492 HWND hwnd;
493 WINDOWPLACEMENT wp;
494 BOOL ret;
495
496 if (!pEnumDisplayMonitors || !pGetMonitorInfoA)
497 {
498 win_skip("EnumDisplayMonitors or GetMonitorInfoA are not available\n");
499 return;
500 }
501
502 hmon = 0;
503 ret = pEnumDisplayMonitors(NULL, NULL, find_primary_mon, (LPARAM)&hmon);
504 ok(!ret && hmon != 0, "Failed to find primary monitor\n");
505
506 mi.cbSize = sizeof(mi);
507 SetLastError(0xdeadbeef);
508 ret = pGetMonitorInfoA(hmon, &mi);
509 ok(ret, "GetMonitorInfo error %u\n", GetLastError());
510 ok(mi.dwFlags & MONITORINFOF_PRIMARY, "not a primary monitor\n");
511 trace("primary monitor %s\n", wine_dbgstr_rect(&mi.rcMonitor));
512
513 SetLastError(0xdeadbeef);
514 ret = SystemParametersInfoA(SPI_GETWORKAREA, 0, &rc_work, 0);
515 ok(ret, "SystemParametersInfo error %u\n", GetLastError());
516 trace("work area %s\n", wine_dbgstr_rect(&rc_work));
517 ok(EqualRect(&rc_work, &mi.rcWork), "work area is different\n");
518
519 hwnd = CreateWindowExA(0, "static", NULL, WS_OVERLAPPEDWINDOW|WS_VISIBLE,100,100,10,10,0,0,0,NULL);
520 ok(hwnd != 0, "CreateWindowEx failed\n");
521
522 ret = GetWindowRect(hwnd, &rc_normal);
523 ok(ret, "GetWindowRect failed\n");
524 trace("normal %s\n", wine_dbgstr_rect(&rc_normal));
525
526 wp.length = sizeof(wp);
527 ret = GetWindowPlacement(hwnd, &wp);
528 ok(ret, "GetWindowPlacement failed\n");
529 trace("min: %d,%d max %d,%d normal %s\n", wp.ptMinPosition.x, wp.ptMinPosition.y,
530 wp.ptMaxPosition.x, wp.ptMaxPosition.y, wine_dbgstr_rect(&wp.rcNormalPosition));
531 OffsetRect(&wp.rcNormalPosition, rc_work.left, rc_work.top);
532 todo_wine_if (mi.rcMonitor.left != mi.rcWork.left ||
533 mi.rcMonitor.top != mi.rcWork.top) /* FIXME: remove once Wine is fixed */
534 {
535 ok(EqualRect(&rc_normal, &wp.rcNormalPosition), "normal pos is different\n");
536 }
537
538 SetWindowLongA(hwnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW);
539
540 wp.length = sizeof(wp);
541 ret = GetWindowPlacement(hwnd, &wp);
542 ok(ret, "GetWindowPlacement failed\n");
543 trace("min: %d,%d max %d,%d normal %s\n", wp.ptMinPosition.x, wp.ptMinPosition.y,
544 wp.ptMaxPosition.x, wp.ptMaxPosition.y, wine_dbgstr_rect(&wp.rcNormalPosition));
545 ok(EqualRect(&rc_normal, &wp.rcNormalPosition), "normal pos is different\n");
546
547 DestroyWindow(hwnd);
548 }
549
550 static void test_display_config(void)
551 {
552 UINT32 paths, modes;
553 LONG ret;
554
555 if (!pGetDisplayConfigBufferSizes)
556 {
557 win_skip("GetDisplayConfigBufferSizes is not supported\n");
558 return;
559 }
560
561 ret = pGetDisplayConfigBufferSizes(QDC_ALL_PATHS, NULL, NULL);
562 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
563
564 paths = 100;
565 ret = pGetDisplayConfigBufferSizes(QDC_ALL_PATHS, &paths, NULL);
566 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
567 ok(paths == 100, "got %u\n", paths);
568
569 modes = 100;
570 ret = pGetDisplayConfigBufferSizes(QDC_ALL_PATHS, NULL, &modes);
571 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
572 ok(modes == 100, "got %u\n", modes);
573
574 paths = modes = 0;
575 ret = pGetDisplayConfigBufferSizes(QDC_ALL_PATHS, &paths, &modes);
576 if (!ret)
577 ok(paths > 0 && modes > 0, "got %u, %u\n", paths, modes);
578 else
579 ok(ret == ERROR_NOT_SUPPORTED, "got %d\n", ret);
580
581 /* Invalid flags, non-zero invalid flags validation is version (or driver?) dependent,
582 it's unreliable to use in tests. */
583 ret = pGetDisplayConfigBufferSizes(0, NULL, NULL);
584 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
585
586 paths = 100;
587 ret = pGetDisplayConfigBufferSizes(0, &paths, NULL);
588 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
589 ok(paths == 100, "got %u\n", paths);
590
591 modes = 100;
592 ret = pGetDisplayConfigBufferSizes(0, NULL, &modes);
593 ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret);
594 ok(modes == 100, "got %u\n", modes);
595
596 paths = modes = 100;
597 ret = pGetDisplayConfigBufferSizes(0, &paths, &modes);
598 ok(ret == ERROR_INVALID_PARAMETER || ret == ERROR_NOT_SUPPORTED, "got %d\n", ret);
599 ok(modes == 0 && paths == 0, "got %u, %u\n", modes, paths);
600 }
601
602 START_TEST(monitor)
603 {
604 init_function_pointers();
605 test_enumdisplaydevices();
606 test_ChangeDisplaySettingsEx();
607 test_monitors();
608 test_work_area();
609 test_display_config();
610 }