?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Included padded border into the border width in NONCLIENTMETRICS.
[wine.git] / dlls / user32 / tests / sysparams.c
blob95273f2bb9b63839ff895bd003fe30be28238f81
1 /* Unit test suite for functions SystemParametersInfo and GetSystemMetrics.
2 *
3 * Copyright 2002 Andriy Palamarchuk
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #define _WIN32_WINNT 0x0600 /* For SPI_GETMOUSEHOVERWIDTH and more */
21 #define _WIN32_IE 0x0700
22 #define WINVER 0x0600 /* For COLOR_MENUBAR, NONCLIENTMETRICS with padding */
23
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 #include "wine/test.h"
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winreg.h"
34 #include "winuser.h"
35 #include "winnls.h"
36
37 #ifndef SPI_GETDESKWALLPAPER
38 # define SPI_GETDESKWALLPAPER 0x0073
39 #endif
40
41 static LONG (WINAPI *pChangeDisplaySettingsExA)(LPCSTR, LPDEVMODEA, HWND, DWORD, LPVOID);
42 static BOOL (WINAPI *pIsProcessDPIAware)(void);
43 static BOOL (WINAPI *pSetProcessDPIAware)(void);
44 static BOOL (WINAPI *pSetProcessDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
45 static BOOL (WINAPI *pGetProcessDpiAwarenessInternal)(HANDLE,DPI_AWARENESS*);
46 static BOOL (WINAPI *pSetProcessDpiAwarenessInternal)(DPI_AWARENESS);
47 static UINT (WINAPI *pGetDpiForSystem)(void);
48 static DPI_AWARENESS_CONTEXT (WINAPI *pGetThreadDpiAwarenessContext)(void);
49 static DPI_AWARENESS_CONTEXT (WINAPI *pSetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
50 static DPI_AWARENESS_CONTEXT (WINAPI *pGetWindowDpiAwarenessContext)(HWND);
51 static DPI_AWARENESS (WINAPI *pGetAwarenessFromDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
52 static BOOL (WINAPI *pIsValidDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
53
54 static BOOL strict;
55 static int dpi, real_dpi;
56
57 #define eq(received, expected, label, type) \
58 ok((received) == (expected), "%s: got " type " instead of " type "\n", (label),(received),(expected))
59
60
61 #define SPI_SETBEEP_REGKEY "Control Panel\\Sound"
62 #define SPI_SETBEEP_VALNAME "Beep"
63 #define SPI_SETMOUSE_REGKEY "Control Panel\\Mouse"
64 #define SPI_SETMOUSE_VALNAME1 "MouseThreshold1"
65 #define SPI_SETMOUSE_VALNAME2 "MouseThreshold2"
66 #define SPI_SETMOUSE_VALNAME3 "MouseSpeed"
67 #define SPI_SETBORDER_REGKEY "Control Panel\\Desktop\\WindowMetrics"
68 #define SPI_SETBORDER_REGKEY2 "Control Panel\\Desktop"
69 #define SPI_SETBORDER_VALNAME "BorderWidth"
70 #define SPI_METRIC_REGKEY "Control Panel\\Desktop\\WindowMetrics"
71 #define SPI_SCROLLWIDTH_VALNAME "ScrollWidth"
72 #define SPI_SCROLLHEIGHT_VALNAME "ScrollHeight"
73 #define SPI_CAPTIONWIDTH_VALNAME "CaptionWidth"
74 #define SPI_CAPTIONHEIGHT_VALNAME "CaptionHeight"
75 #define SPI_CAPTIONFONT_VALNAME "CaptionFont"
76 #define SPI_SMCAPTIONWIDTH_VALNAME "SmCaptionWidth"
77 #define SPI_SMCAPTIONHEIGHT_VALNAME "SmCaptionHeight"
78 #define SPI_SMCAPTIONFONT_VALNAME "SmCaptionFont"
79 #define SPI_MENUWIDTH_VALNAME "MenuWidth"
80 #define SPI_MENUHEIGHT_VALNAME "MenuHeight"
81 #define SPI_MENUFONT_VALNAME "MenuFont"
82 #define SPI_STATUSFONT_VALNAME "StatusFont"
83 #define SPI_MESSAGEFONT_VALNAME "MessageFont"
84
85 #define SPI_SETKEYBOARDSPEED_REGKEY "Control Panel\\Keyboard"
86 #define SPI_SETKEYBOARDSPEED_VALNAME "KeyboardSpeed"
87 #define SPI_ICONHORIZONTALSPACING_REGKEY "Control Panel\\Desktop\\WindowMetrics"
88 #define SPI_ICONHORIZONTALSPACING_REGKEY2 "Control Panel\\Desktop"
89 #define SPI_ICONHORIZONTALSPACING_VALNAME "IconSpacing"
90 #define SPI_ICONVERTICALSPACING_REGKEY "Control Panel\\Desktop\\WindowMetrics"
91 #define SPI_ICONVERTICALSPACING_REGKEY2 "Control Panel\\Desktop"
92 #define SPI_ICONVERTICALSPACING_VALNAME "IconVerticalSpacing"
93 #define SPI_MINIMIZEDMETRICS_REGKEY "Control Panel\\Desktop\\WindowMetrics"
94 #define SPI_MINWIDTH_VALNAME "MinWidth"
95 #define SPI_MINHORZGAP_VALNAME "MinHorzGap"
96 #define SPI_MINVERTGAP_VALNAME "MinVertGap"
97 #define SPI_MINARRANGE_VALNAME "MinArrange"
98 #define SPI_SETSCREENSAVETIMEOUT_REGKEY "Control Panel\\Desktop"
99 #define SPI_SETSCREENSAVETIMEOUT_VALNAME "ScreenSaveTimeOut"
100 #define SPI_SETSCREENSAVEACTIVE_REGKEY "Control Panel\\Desktop"
101 #define SPI_SETSCREENSAVEACTIVE_VALNAME "ScreenSaveActive"
102 #define SPI_SETGRIDGRANULARITY_REGKEY "Control Panel\\Desktop"
103 #define SPI_SETGRIDGRANULARITY_VALNAME "GridGranularity"
104 #define SPI_SETKEYBOARDDELAY_REGKEY "Control Panel\\Keyboard"
105 #define SPI_SETKEYBOARDDELAY_VALNAME "KeyboardDelay"
106 #define SPI_SETICONTITLEWRAP_REGKEY1 "Control Panel\\Desktop\\WindowMetrics"
107 #define SPI_SETICONTITLEWRAP_REGKEY2 "Control Panel\\Desktop"
108 #define SPI_SETICONTITLEWRAP_VALNAME "IconTitleWrap"
109 #define SPI_SETMENUDROPALIGNMENT_REGKEY1 "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
110 #define SPI_SETMENUDROPALIGNMENT_REGKEY2 "Control Panel\\Desktop"
111 #define SPI_SETMENUDROPALIGNMENT_VALNAME "MenuDropAlignment"
112 #define SPI_SETDOUBLECLKWIDTH_REGKEY1 "Control Panel\\Mouse"
113 #define SPI_SETDOUBLECLKWIDTH_REGKEY2 "Control Panel\\Desktop"
114 #define SPI_SETDOUBLECLKWIDTH_VALNAME "DoubleClickWidth"
115 #define SPI_SETDOUBLECLKHEIGHT_REGKEY1 "Control Panel\\Mouse"
116 #define SPI_SETDOUBLECLKHEIGHT_REGKEY2 "Control Panel\\Desktop"
117 #define SPI_SETDOUBLECLKHEIGHT_VALNAME "DoubleClickHeight"
118 #define SPI_SETDOUBLECLICKTIME_REGKEY "Control Panel\\Mouse"
119 #define SPI_SETDOUBLECLICKTIME_VALNAME "DoubleClickSpeed"
120 #define SPI_SETMOUSEBUTTONSWAP_REGKEY "Control Panel\\Mouse"
121 #define SPI_SETMOUSEBUTTONSWAP_VALNAME "SwapMouseButtons"
122 #define SPI_SETWORKAREA_REGKEY "Control Panel\\Desktop"
123 #define SPI_SETWORKAREA_VALNAME "WINE_WorkArea"
124 #define SPI_SETSHOWSOUNDS_REGKEY "Control Panel\\Accessibility\\ShowSounds"
125 #define SPI_SETSHOWSOUNDS_VALNAME "On"
126 #define SPI_SETKEYBOARDPREF_REGKEY "Control Panel\\Accessibility\\Keyboard Preference"
127 #define SPI_SETKEYBOARDPREF_VALNAME "On"
128 #define SPI_SETKEYBOARDPREF_REGKEY_LEGACY "Control Panel\\Accessibility"
129 #define SPI_SETKEYBOARDPREF_VALNAME_LEGACY "Keyboard Preference"
130 #define SPI_SETSCREENREADER_REGKEY "Control Panel\\Accessibility\\Blind Access"
131 #define SPI_SETSCREENREADER_VALNAME "On"
132 #define SPI_SETSCREENREADER_REGKEY_LEGACY "Control Panel\\Accessibility"
133 #define SPI_SETSCREENREADER_VALNAME_LEGACY "Blind Access"
134 #define SPI_SETFONTSMOOTHING_REGKEY "Control Panel\\Desktop"
135 #define SPI_SETFONTSMOOTHING_VALNAME "FontSmoothing"
136 #define SPI_SETFONTSMOOTHINGTYPE_VALNAME "FontSmoothingType"
137 #define SPI_SETFONTSMOOTHINGCONTRAST_VALNAME "FontSmoothingGamma"
138 #define SPI_SETFONTSMOOTHINGORIENTATION_VALNAME "FontSmoothingOrientation"
139 #define SPI_SETLOWPOWERACTIVE_REGKEY "Control Panel\\Desktop"
140 #define SPI_SETLOWPOWERACTIVE_VALNAME "LowPowerActive"
141 #define SPI_SETPOWEROFFACTIVE_REGKEY "Control Panel\\Desktop"
142 #define SPI_SETPOWEROFFACTIVE_VALNAME "PowerOffActive"
143 #define SPI_SETDRAGFULLWINDOWS_REGKEY "Control Panel\\Desktop"
144 #define SPI_SETDRAGFULLWINDOWS_VALNAME "DragFullWindows"
145 #define SPI_SETSNAPTODEFBUTTON_REGKEY "Control Panel\\Mouse"
146 #define SPI_SETSNAPTODEFBUTTON_VALNAME "SnapToDefaultButton"
147 #define SPI_SETMOUSEHOVERWIDTH_REGKEY "Control Panel\\Mouse"
148 #define SPI_SETMOUSEHOVERWIDTH_VALNAME "MouseHoverWidth"
149 #define SPI_SETMOUSEHOVERHEIGHT_REGKEY "Control Panel\\Mouse"
150 #define SPI_SETMOUSEHOVERHEIGHT_VALNAME "MouseHoverHeight"
151 #define SPI_SETMOUSEHOVERTIME_REGKEY "Control Panel\\Mouse"
152 #define SPI_SETMOUSEHOVERTIME_VALNAME "MouseHoverTime"
153 #define SPI_SETMOUSESCROLLCHARS_REGKEY "Control Panel\\Desktop"
154 #define SPI_SETMOUSESCROLLCHARS_VALNAME "WheelScrollChars"
155 #define SPI_SETMOUSESCROLLLINES_REGKEY "Control Panel\\Desktop"
156 #define SPI_SETMOUSESCROLLLINES_VALNAME "WheelScrollLines"
157 #define SPI_SETMENUSHOWDELAY_REGKEY "Control Panel\\Desktop"
158 #define SPI_SETMENUSHOWDELAY_VALNAME "MenuShowDelay"
159 #define SPI_SETDESKWALLPAPER_REGKEY "Control Panel\\Desktop"
160 #define SPI_SETDESKWALLPAPER_VALNAME "Wallpaper"
161
162 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
163 #define WINE_CURRENT_USER_REGKEY "Wine"
164
165 static HWND ghTestWnd;
166
167 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam );
168 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
169 LPARAM lParam );
170 static int change_counter;
171 static int change_setworkarea_param, change_iconverticalspacing_param;
172 static int change_last_param;
173 static int last_bpp;
174 static BOOL displaychange_ok = FALSE, displaychange_test_active = FALSE;
175 static HANDLE displaychange_sem = 0;
176
177 static BOOL get_reg_dword(HKEY base, const char *key_name, const char *value_name, DWORD *value)
178 {
179 HKEY key;
180 DWORD type, data, size = sizeof(data);
181 BOOL ret = FALSE;
182
183 if (RegOpenKeyA(base, key_name, &key) == ERROR_SUCCESS)
184 {
185 if (RegQueryValueExA(key, value_name, NULL, &type, (void *)&data, &size) == ERROR_SUCCESS &&
186 type == REG_DWORD)
187 {
188 *value = data;
189 ret = TRUE;
190 }
191 RegCloseKey(key);
192 }
193 return ret;
194 }
195
196 static DWORD get_real_dpi(void)
197 {
198 DWORD dpi;
199
200 if (pSetThreadDpiAwarenessContext)
201 {
202 DPI_AWARENESS_CONTEXT context = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
203 dpi = pGetDpiForSystem();
204 pSetThreadDpiAwarenessContext( context );
205 return dpi;
206 }
207 if (get_reg_dword(HKEY_CURRENT_USER, "Control Panel\\Desktop", "LogPixels", &dpi))
208 return dpi;
209 if (get_reg_dword(HKEY_CURRENT_CONFIG, "Software\\Fonts", "LogPixels", &dpi))
210 return dpi;
211 return USER_DEFAULT_SCREEN_DPI;
212 }
213
214 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
215 LPARAM lParam )
216 {
217 switch (msg) {
218
219 case WM_DISPLAYCHANGE:
220 ok(displaychange_ok, "Unexpected WM_DISPLAYCHANGE message\n");
221 last_bpp = wParam;
222 displaychange_ok = FALSE;
223 ReleaseSemaphore(displaychange_sem, 1, 0);
224 break;
225
226 case WM_SETTINGCHANGE:
227 if (change_counter>0) {
228 /* ignore these messages caused by resizing of toolbars */
229 if( wParam == SPI_SETWORKAREA){
230 change_setworkarea_param = 1;
231 break;
232 } else if( wParam == SPI_ICONVERTICALSPACING) {
233 change_iconverticalspacing_param = 1;
234 break;
235 } else if( displaychange_test_active)
236 break;
237 if( !change_last_param){
238 change_last_param = wParam;
239 break;
240 }
241 ok(0,"too many changes counter=%d last change=%d\n",
242 change_counter,change_last_param);
243 change_counter++;
244 change_last_param = wParam;
245 break;
246 }
247 change_counter++;
248 change_last_param = change_setworkarea_param = change_iconverticalspacing_param =0;
249 if( wParam == SPI_SETWORKAREA)
250 change_setworkarea_param = 1;
251 else if( wParam == SPI_ICONVERTICALSPACING)
252 change_iconverticalspacing_param = 1;
253 else
254 change_last_param = wParam;
255 break;
256
257 case WM_DESTROY:
258 PostQuitMessage( 0 );
259 break;
260
261 /* drop through */
262 default:
263 return( DefWindowProcA( hWnd, msg, wParam, lParam ) );
264 }
265
266 return 0;
267 }
268
269 /*
270 Performs testing for system parameters messages
271 params:
272 - system parameter id
273 - supposed value of the registry key
274 */
275 static void test_change_message( int action, int optional )
276 {
277 if (change_counter==0 && optional==1)
278 return;
279 ok( 1 == change_counter,
280 "Missed a message: change_counter=%d\n", change_counter );
281 change_counter = 0;
282 ok( action == change_last_param ||
283 ( change_setworkarea_param && action == SPI_SETWORKAREA) ||
284 ( change_iconverticalspacing_param && action == SPI_ICONVERTICALSPACING),
285 "Wrong action got %d expected %d\n", change_last_param, action );
286 change_last_param = 0;
287 }
288
289 static BOOL test_error_msg ( int rc, const char *name )
290 {
291 DWORD last_error = GetLastError();
292
293 if (rc==0)
294 {
295 if (last_error==0xdeadbeef || last_error==ERROR_INVALID_SPI_VALUE || last_error==ERROR_INVALID_PARAMETER)
296 {
297 skip("%s not supported on this platform\n", name);
298 }
299 else if (last_error==ERROR_ACCESS_DENIED)
300 {
301 skip("%s does not have privileges to run\n", name);
302 }
303 else
304 {
305 trace("%s failed for reason: %d. Indicating test failure and skipping remainder of test\n",name,last_error);
306 ok(rc!=0,"SystemParametersInfoA: rc=%d err=%d\n",rc,last_error);
307 }
308 return FALSE;
309 }
310 else
311 {
312 ok(rc!=0,"SystemParametersInfoA: rc=%d err=%d\n",rc,last_error);
313 return TRUE;
314 }
315 }
316
317 /*
318 * Tests the HKEY_CURRENT_USER subkey value.
319 * The value should contain string value.
320 */
321 static void _test_reg_key( LPCSTR subKey1, LPCSTR subKey2, LPCSTR valName1, LPCSTR valName2,
322 const void *exp_value, DWORD exp_type, BOOL optional )
323 {
324 CHAR value[MAX_PATH];
325 DWORD valueLen;
326 DWORD type;
327 HKEY hKey;
328 LONG rc;
329 int found=0;
330
331 *value='\0';
332 valueLen=sizeof(value);
333 RegOpenKeyA( HKEY_CURRENT_USER, subKey1, &hKey );
334 rc=RegQueryValueExA( hKey, valName1, NULL, &type, (LPBYTE)value, &valueLen );
335 RegCloseKey( hKey );
336 if (rc==ERROR_SUCCESS)
337 {
338 ok( type == exp_type, "wrong type %u/%u\n", type, exp_type );
339 switch (exp_type)
340 {
341 case REG_DWORD:
342 ok( *(DWORD *)value == *(DWORD *)exp_value,
343 "Wrong value in registry: %s %s %08x/%08x\n",
344 subKey1, valName1, *(DWORD *)value, *(DWORD *)exp_value );
345 break;
346 case REG_SZ:
347 ok( !strcmp( exp_value, value ),
348 "Wrong value in registry: %s %s '%s' instead of '%s'\n",
349 subKey1, valName1, value, (const char *)exp_value );
350 break;
351 }
352 found++;
353 }
354 else if (strict)
355 {
356 ok(0,"Missing registry entry: subKey=%s, valName=%s\n",
357 subKey1, valName1);
358 }
359 if (valName2)
360 {
361 *value='\0';
362 valueLen=sizeof(value);
363 RegOpenKeyA( HKEY_CURRENT_USER, subKey1, &hKey );
364 rc=RegQueryValueExA( hKey, valName2, NULL, &type, (LPBYTE)value, &valueLen );
365 RegCloseKey( hKey );
366 if (rc==ERROR_SUCCESS)
367 {
368 ok( type == exp_type, "wrong type %u/%u\n", type, exp_type );
369 switch (exp_type)
370 {
371 case REG_DWORD:
372 ok( *(DWORD *)value == *(DWORD *)exp_value,
373 "Wrong value in registry: %s %s %08x/%08x\n",
374 subKey1, valName1, *(DWORD *)value, *(DWORD *)exp_value );
375 break;
376 case REG_SZ:
377 ok( !strcmp( exp_value, value ),
378 "Wrong value in registry: %s %s '%s' instead of '%s'\n",
379 subKey1, valName1, value, (const char *)exp_value );
380 break;
381 }
382 found++;
383 }
384 else if (strict)
385 {
386 ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
387 subKey1, valName2 );
388 }
389 }
390 if (subKey2 && !strict)
391 {
392 *value='\0';
393 valueLen=sizeof(value);
394 RegOpenKeyA( HKEY_CURRENT_USER, subKey2, &hKey );
395 rc=RegQueryValueExA( hKey, valName1, NULL, &type, (LPBYTE)value, &valueLen );
396 RegCloseKey( hKey );
397 if (rc==ERROR_SUCCESS)
398 {
399 ok( type == exp_type, "wrong type %u/%u\n", type, exp_type );
400 switch (exp_type)
401 {
402 case REG_DWORD:
403 ok( *(DWORD *)value == *(DWORD *)exp_value,
404 "Wrong value in registry: %s %s %08x/%08x\n",
405 subKey1, valName1, *(DWORD *)value, *(DWORD *)exp_value );
406 break;
407 case REG_SZ:
408 ok( !strcmp( exp_value, value ),
409 "Wrong value in registry: %s %s '%s' instead of '%s'\n",
410 subKey1, valName1, value, (const char *)exp_value );
411 break;
412 }
413 found++;
414 }
415 else if (strict)
416 {
417 ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
418 subKey2, valName1 );
419 }
420 if (valName2)
421 {
422 *value='\0';
423 valueLen=sizeof(value);
424 RegOpenKeyA( HKEY_CURRENT_USER, subKey2, &hKey );
425 rc=RegQueryValueExA( hKey, valName2, NULL, &type, (LPBYTE)value, &valueLen );
426 RegCloseKey( hKey );
427 if (rc==ERROR_SUCCESS)
428 {
429 ok( type == exp_type, "wrong type %u/%u\n", type, exp_type );
430 switch (exp_type)
431 {
432 case REG_DWORD:
433 ok( *(DWORD *)value == *(DWORD *)exp_value,
434 "Wrong value in registry: %s %s %08x/%08x\n",
435 subKey1, valName1, *(DWORD *)value, *(DWORD *)exp_value );
436 break;
437 case REG_SZ:
438 ok( !strcmp( exp_value, value ),
439 "Wrong value in registry: %s %s '%s' instead of '%s'\n",
440 subKey1, valName1, value, (const char *)exp_value );
441 break;
442 }
443 found++;
444 }
445 else if (strict)
446 {
447 ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
448 subKey2, valName2 );
449 }
450 }
451 }
452 ok(found || optional,
453 "Missing registry values: %s or %s in keys: %s or %s\n",
454 valName1, (valName2?valName2:"<n/a>"), subKey1, (subKey2?subKey2:"<n/a>") );
455 }
456
457 #define test_reg_key( subKey, valName, testValue ) \
458 _test_reg_key( subKey, NULL, valName, NULL, testValue, REG_SZ, FALSE )
459 #define test_reg_key_optional( subKey, valName, testValue ) \
460 _test_reg_key( subKey, NULL, valName, NULL, testValue, REG_SZ, TRUE )
461 #define test_reg_key_ex( subKey1, subKey2, valName, testValue ) \
462 _test_reg_key( subKey1, subKey2, valName, NULL, testValue, REG_SZ, FALSE )
463 #define test_reg_key_ex2( subKey1, subKey2, valName1, valName2, testValue ) \
464 _test_reg_key( subKey1, subKey2, valName1, valName2, testValue, REG_SZ, FALSE )
465 #define test_reg_key_ex2_optional( subKey1, subKey2, valName1, valName2, testValue ) \
466 _test_reg_key( subKey1, subKey2, valName1, valName2, testValue, REG_SZ, TRUE )
467 #define test_reg_key_dword( subKey, valName, testValue ) \
468 _test_reg_key( subKey, NULL, valName, NULL, testValue, REG_DWORD, FALSE )
469
470 /* get a metric from the registry. If the value is negative
471 * it is assumed to be in twips and converted to pixels */
472 static UINT metricfromreg( const char *keyname, const char *valname, int dpi)
473 {
474 HKEY hkey;
475 char buf[64];
476 DWORD ret;
477 DWORD size, type;
478 int value;
479
480 RegOpenKeyA( HKEY_CURRENT_USER, keyname, &hkey );
481 size = sizeof(buf);
482 ret=RegQueryValueExA( hkey, valname, NULL, &type, (LPBYTE)buf, &size );
483 RegCloseKey( hkey );
484 if( ret != ERROR_SUCCESS) return -1;
485 value = atoi( buf);
486 if( value < 0)
487 value = ( -value * dpi + 720) / 1440;
488 return value;
489 }
490
491 typedef struct
492 {
493 INT16 lfHeight;
494 INT16 lfWidth;
495 INT16 lfEscapement;
496 INT16 lfOrientation;
497 INT16 lfWeight;
498 BYTE lfItalic;
499 BYTE lfUnderline;
500 BYTE lfStrikeOut;
501 BYTE lfCharSet;
502 BYTE lfOutPrecision;
503 BYTE lfClipPrecision;
504 BYTE lfQuality;
505 BYTE lfPitchAndFamily;
506 CHAR lfFaceName[LF_FACESIZE];
507 } LOGFONT16, *LPLOGFONT16;
508
509 /* get logfont from the registry */
510 static int lffromreg( const char *keyname, const char *valname, LOGFONTA *plf)
511 {
512 HKEY hkey;
513 LOGFONTW lfw;
514 DWORD ret, size, type;
515
516 RegOpenKeyA( HKEY_CURRENT_USER, keyname, &hkey );
517 size = sizeof( lfw);
518 ret=RegQueryValueExA( hkey, valname, NULL, &type, (LPBYTE)&lfw, &size );
519 RegCloseKey( hkey );
520 ok( ret == ERROR_SUCCESS, "Key \"%s\" value \"%s\" not found\n", keyname, valname);
521 if( ret != ERROR_SUCCESS)
522 return FALSE;
523 if( size <= sizeof( LOGFONT16)) {
524 LOGFONT16 *plf16 = (LOGFONT16*) &lfw;
525 plf->lfHeight = plf16->lfHeight;
526 plf->lfWidth = plf16->lfWidth;
527 plf->lfEscapement = plf16->lfEscapement;
528 plf->lfOrientation = plf16->lfOrientation;
529 plf->lfWeight = plf16->lfWeight;
530 plf->lfItalic = plf16->lfItalic;
531 plf->lfUnderline = plf16->lfUnderline;
532 plf->lfStrikeOut = plf16->lfStrikeOut;
533 plf->lfCharSet = plf16->lfCharSet;
534 plf->lfOutPrecision = plf16->lfOutPrecision;
535 plf->lfClipPrecision = plf16->lfClipPrecision;
536 plf->lfQuality = plf16->lfQuality;
537 plf->lfPitchAndFamily = plf16->lfPitchAndFamily;
538 memcpy( plf->lfFaceName, plf16->lfFaceName, LF_FACESIZE );
539 } else if( size <= sizeof( LOGFONTA)) {
540 plf = (LOGFONTA*) &lfw;
541 } else {
542 plf->lfHeight = lfw.lfHeight;
543 plf->lfWidth = lfw.lfWidth;
544 plf->lfEscapement = lfw.lfEscapement;
545 plf->lfOrientation = lfw.lfOrientation;
546 plf->lfWeight = lfw.lfWeight;
547 plf->lfItalic = lfw.lfItalic;
548 plf->lfUnderline = lfw.lfUnderline;
549 plf->lfStrikeOut = lfw.lfStrikeOut;
550 plf->lfCharSet = lfw.lfCharSet;
551 plf->lfOutPrecision = lfw.lfOutPrecision;
552 plf->lfClipPrecision = lfw.lfClipPrecision;
553 plf->lfQuality = lfw.lfQuality;
554 plf->lfPitchAndFamily = lfw.lfPitchAndFamily;
555 WideCharToMultiByte( CP_ACP, 0, lfw.lfFaceName, -1, plf->lfFaceName,
556 LF_FACESIZE, NULL, NULL);
557
558 }
559 return TRUE;
560 }
561
562 static void test_SPI_SETBEEP( void ) /* 2 */
563 {
564 BOOL rc;
565 BOOL old_b;
566 BOOL b;
567 BOOL curr_val;
568
569 trace("testing SPI_{GET,SET}BEEP\n");
570 SetLastError(0xdeadbeef);
571 rc=SystemParametersInfoA( SPI_GETBEEP, 0, &old_b, 0 );
572 if (!test_error_msg(rc,"SPI_{GET,SET}BEEP"))
573 return;
574
575 curr_val = TRUE;
576 rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
577 if (!test_error_msg(rc,"SPI_SETBEEP")) return;
578 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
579 test_change_message( SPI_SETBEEP, 0 );
580 test_reg_key( SPI_SETBEEP_REGKEY,
581 SPI_SETBEEP_VALNAME,
582 curr_val ? "Yes" : "No" );
583 rc=SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
584 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
585 eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
586 rc=SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
587 if (rc || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
588 {
589 ok(rc, "SystemParametersInfoW: rc=%d err=%d\n", rc, GetLastError());
590 eq( b, curr_val, "SystemParametersInfoW", "%d" );
591 }
592
593 /* is a message sent for the second change? */
594 rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
595 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
596 test_change_message( SPI_SETBEEP, 0 );
597
598 curr_val = FALSE;
599 rc=SystemParametersInfoW( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
600 if (rc == FALSE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
601 rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
602 ok(rc, "SystemParametersInfo: rc=%d err=%d\n", rc, GetLastError());
603 test_change_message( SPI_SETBEEP, 0 );
604 test_reg_key( SPI_SETBEEP_REGKEY,
605 SPI_SETBEEP_VALNAME,
606 curr_val ? "Yes" : "No" );
607 rc=SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
608 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
609 eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
610 rc=SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
611 if (rc || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
612 {
613 ok(rc, "SystemParametersInfoW: rc=%d err=%d\n", rc, GetLastError());
614 eq( b, curr_val, "SystemParametersInfoW", "%d" );
615 }
616 ok( MessageBeep( MB_OK ), "Return value of MessageBeep when sound is disabled\n" );
617
618 rc=SystemParametersInfoA( SPI_SETBEEP, old_b, 0, SPIF_UPDATEINIFILE );
619 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
620 }
621
622 static const char *setmouse_valuenames[3] = {
623 SPI_SETMOUSE_VALNAME1,
624 SPI_SETMOUSE_VALNAME2,
625 SPI_SETMOUSE_VALNAME3
626 };
627
628 /*
629 * Runs check for one setting of spi_setmouse.
630 */
631 static BOOL run_spi_setmouse_test( int curr_val[], POINT *req_change, POINT *proj_change, int nchange )
632 {
633 BOOL rc;
634 INT mi[3];
635 static int aw_turn = 0;
636
637 char buf[20];
638 int i;
639
640 aw_turn++;
641 rc = FALSE;
642 SetLastError(0xdeadbeef);
643 if (aw_turn % 2) /* call unicode on odd (non even) calls */
644 rc=SystemParametersInfoW( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
645 else
646 rc=SystemParametersInfoA( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
647 if (!test_error_msg(rc,"SPI_SETMOUSE")) return FALSE;
648
649 ok(rc, "SystemParametersInfo: rc=%d err=%d\n", rc, GetLastError());
650 test_change_message( SPI_SETMOUSE, 0 );
651 for (i = 0; i < 3; i++)
652 {
653 sprintf( buf, "%d", curr_val[i] );
654 test_reg_key( SPI_SETMOUSE_REGKEY, setmouse_valuenames[i], buf );
655 }
656
657 rc=SystemParametersInfoA( SPI_GETMOUSE, 0, mi, 0 );
658 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
659 for (i = 0; i < 3; i++)
660 {
661 ok(mi[i] == curr_val[i],
662 "incorrect value for %d: %d != %d\n", i, mi[i], curr_val[i]);
663 }
664
665 rc=SystemParametersInfoW( SPI_GETMOUSE, 0, mi, 0 );
666 ok(rc, "SystemParametersInfoW: rc=%d err=%d\n", rc, GetLastError());
667 for (i = 0; i < 3; i++)
668 {
669 ok(mi[i] == curr_val[i],
670 "incorrect value for %d: %d != %d\n", i, mi[i], curr_val[i]);
671 }
672
673 if (0)
674 {
675 /* FIXME: this always fails for me - AJ */
676 for (i = 0; i < nchange; i++)
677 {
678 POINT mv;
679 mouse_event( MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 0, 0, 0, 0 );
680 mouse_event( MOUSEEVENTF_MOVE, req_change[i].x, req_change[i].y, 0, 0 );
681 GetCursorPos( &mv );
682 ok( proj_change[i].x == mv.x, "Projected dx and real dx comparison. May fail under high load.\n" );
683 ok( proj_change[i].y == mv.y, "Projected dy equals real dy. May fail under high load.\n" );
684 }
685 }
686 return TRUE;
687 }
688
689 static void test_SPI_SETMOUSE( void ) /* 4 */
690 {
691 BOOL rc;
692 INT old_mi[3];
693
694 /* win nt default values - 6, 10, 1 */
695 INT curr_val[3] = {6, 10, 1};
696
697 /* requested and projected mouse movements */
698 POINT req_change[] = { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
699 POINT proj_change1[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
700 POINT proj_change2[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {44, 20}, {400, 400} };
701 POINT proj_change3[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
702 POINT proj_change4[] = { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
703 POINT proj_change5[] = { {6, 6}, { 7, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
704 POINT proj_change6[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
705 POINT proj_change7[] = { {6, 6}, {14, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
706 POINT proj_change8[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
707
708 int nchange = sizeof( req_change ) / sizeof( POINT );
709
710 trace("testing SPI_{GET,SET}MOUSE\n");
711 SetLastError(0xdeadbeef);
712 rc=SystemParametersInfoA( SPI_GETMOUSE, 0, old_mi, 0 );
713 if (!test_error_msg(rc,"SPI_{GET,SET}MOUSE"))
714 return;
715
716 if (!run_spi_setmouse_test( curr_val, req_change, proj_change1, nchange )) return;
717
718 /* acceleration change */
719 curr_val[2] = 2;
720 run_spi_setmouse_test( curr_val, req_change, proj_change2, nchange );
721
722 /* acceleration change */
723 curr_val[2] = 3;
724 run_spi_setmouse_test( curr_val, req_change, proj_change3, nchange );
725
726 /* acceleration change */
727 curr_val[2] = 0;
728 run_spi_setmouse_test( curr_val, req_change, proj_change4, nchange );
729
730 /* threshold change */
731 curr_val[2] = 1;
732 curr_val[0] = 7;
733 run_spi_setmouse_test( curr_val, req_change, proj_change5, nchange );
734
735 /* threshold change */
736 curr_val[2] = 2;
737 curr_val[0] = 6;
738 curr_val[1] = 6;
739 run_spi_setmouse_test( curr_val, req_change, proj_change6, nchange );
740
741 /* threshold change */
742 curr_val[1] = 7;
743 run_spi_setmouse_test( curr_val, req_change, proj_change7, nchange );
744
745 /* threshold change */
746 curr_val[1] = 5;
747 run_spi_setmouse_test( curr_val, req_change, proj_change8, nchange );
748
749 rc=SystemParametersInfoA( SPI_SETMOUSE, 0, old_mi, SPIF_UPDATEINIFILE );
750 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
751 }
752
753 static BOOL test_setborder(UINT curr_val, int usesetborder, int dpi)
754 {
755 BOOL rc;
756 UINT border, regval;
757 INT frame;
758 NONCLIENTMETRICSA ncm;
759
760 ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
761 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
762 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
763 if( usesetborder) {
764 rc=SystemParametersInfoA( SPI_SETBORDER, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
765 if (!test_error_msg(rc,"SPI_SETBORDER")) return FALSE;
766 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
767 test_change_message( SPI_SETBORDER, 1 );
768 } else { /* set non client metrics */
769 ncm.iBorderWidth = curr_val;
770 rc=SystemParametersInfoA( SPI_SETNONCLIENTMETRICS, 0, &ncm, SPIF_UPDATEINIFILE|
771 SPIF_SENDCHANGE);
772 if (!test_error_msg(rc,"SPI_SETNONCLIENTMETRICS")) return FALSE;
773 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
774 test_change_message( SPI_SETNONCLIENTMETRICS, 1 );
775 }
776 if( curr_val) { /* skip if 0, some windows versions return 0 others 1 */
777 regval = metricfromreg( SPI_SETBORDER_REGKEY2, SPI_SETBORDER_VALNAME, dpi);
778 if( regval != curr_val)
779 regval = metricfromreg( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, dpi);
780 ok( regval==curr_val, "wrong value in registry %d, expected %d\n", regval, curr_val);
781 }
782 /* minimum border width is 1 */
783 if (curr_val == 0) curr_val = 1;
784 /* should be the same as the non client metrics */
785 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
786 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
787 eq( (UINT)ncm.iBorderWidth, curr_val, "NonClientMetric.iBorderWidth", "%d");
788 /* and from SPI_GETBORDER */
789 rc=SystemParametersInfoA( SPI_GETBORDER, 0, &border, 0 );
790 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
791 eq( border, curr_val, "SPI_{GET,SET}BORDER", "%d");
792 /* test some SystemMetrics */
793 frame = curr_val + GetSystemMetrics( SM_CXDLGFRAME );
794 eq( frame, GetSystemMetrics( SM_CXFRAME ), "SM_CXFRAME", "%d" );
795 eq( frame, GetSystemMetrics( SM_CYFRAME ), "SM_CYFRAME", "%d" );
796 eq( frame, GetSystemMetrics( SM_CXSIZEFRAME ), "SM_CXSIZEFRAME", "%d" );
797 eq( frame, GetSystemMetrics( SM_CYSIZEFRAME ), "SM_CYSIZEFRAME", "%d" );
798 return TRUE;
799 }
800
801 static void test_SPI_SETBORDER( void ) /* 6 */
802 {
803 BOOL rc;
804 UINT old_border;
805 NONCLIENTMETRICSA ncmsave;
806 INT CaptionWidth,
807 PaddedBorderWidth;
808
809 ncmsave.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
810 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, 0, &ncmsave, 0);
811 if( !rc) {
812 win_skip("SPI_GETNONCLIENTMETRICS is not available\n");
813 return;
814 }
815 /* CaptionWidth from the registry may have different value of iCaptionWidth
816 * from the non client metrics (observed on WinXP).
817 * Fix this so we can safely restore settings with the nonclientmetrics */
818 CaptionWidth = metricfromreg(
819 "Control Panel\\Desktop\\WindowMetrics","CaptionWidth", dpi);
820 ncmsave.iCaptionWidth = CaptionWidth;
821
822 /* These tests hang when XFree86 4.0 for Windows is running (tested on
823 * WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
824 * running.
825 */
826 if (FindWindowA( NULL, "Cygwin/XFree86" ))
827 return;
828
829 trace("testing SPI_{GET,SET}BORDER\n");
830
831 SetLastError(0xdeadbeef);
832 rc=SystemParametersInfoA( SPI_GETBORDER, 0, &old_border, 0 );
833 if (!test_error_msg(rc,"SPI_{GET,SET}BORDER"))
834 return;
835 /* FIXME: include new PaddedBorderWidth parameter */
836 PaddedBorderWidth = ncmsave.iBorderWidth - old_border;
837 if( PaddedBorderWidth){
838 win_skip( "Cannot reliably restore border width yet (PaddedBorderWidth = %d)\n",
839 PaddedBorderWidth);
840 return;
841 }
842 /* This will restore sane values if the test hang previous run. */
843 if ( old_border == 7 || old_border == 20 )
844 old_border = 1;
845
846 /* win2k3 fails if you set the same border twice, or if size is 0 */
847 if (!test_setborder(2, 1, dpi)) return;
848 test_setborder(1, 1, dpi);
849 test_setborder(3, 1, dpi);
850 if (!test_setborder(1, 0, dpi)) return;
851 test_setborder(0, 0, dpi);
852 test_setborder(3, 0, dpi);
853
854 rc=SystemParametersInfoA( SPI_SETNONCLIENTMETRICS, 0, &ncmsave,
855 SPIF_UPDATEINIFILE| SPIF_SENDCHANGE);
856 test_change_message( SPI_SETNONCLIENTMETRICS, 1 );
857 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
858 }
859
860 static void test_SPI_SETKEYBOARDSPEED( void ) /* 10 */
861 {
862 BOOL rc;
863 UINT old_speed;
864 const UINT vals[]={0,20,31};
865 unsigned int i;
866
867 trace("testing SPI_{GET,SET}KEYBOARDSPEED\n");
868 SetLastError(0xdeadbeef);
869 rc=SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &old_speed, 0 );
870 if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDSPEED"))
871 return;
872
873 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
874 {
875 UINT v;
876 char buf[10];
877
878 rc=SystemParametersInfoA( SPI_SETKEYBOARDSPEED, vals[i], 0,
879 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
880 if (!test_error_msg(rc,"SPI_SETKEYBOARDSPEED")) return;
881 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
882 test_change_message( SPI_SETKEYBOARDSPEED, 0 );
883 sprintf( buf, "%d", vals[i] );
884 test_reg_key( SPI_SETKEYBOARDSPEED_REGKEY, SPI_SETKEYBOARDSPEED_VALNAME, buf );
885
886 rc=SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &v, 0 );
887 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
888 eq( v, vals[i], "SPI_{GET,SET}KEYBOARDSPEED", "%d" );
889 }
890
891 rc=SystemParametersInfoA( SPI_SETKEYBOARDSPEED, old_speed, 0, SPIF_UPDATEINIFILE );
892 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
893 }
894
895 /* test_SPI_ICONHORIZONTALSPACING helper */
896 static BOOL dotest_spi_iconhorizontalspacing( INT curr_val)
897 {
898 BOOL rc;
899 INT spacing, regval, min_val = MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI );
900 ICONMETRICSA im;
901
902 rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, curr_val, 0,
903 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
904 if (!test_error_msg(rc,"SPI_ICONHORIZONTALSPACING")) return FALSE;
905 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
906 test_change_message( SPI_ICONHORIZONTALSPACING, 0 );
907 curr_val = max( curr_val, min_val );
908 /* The registry keys depend on the Windows version and the values too
909 * let's test (works on win95,ME,NT4,2k,XP)
910 */
911 regval = metricfromreg( SPI_ICONHORIZONTALSPACING_REGKEY2, SPI_ICONHORIZONTALSPACING_VALNAME, dpi);
912 if( regval != curr_val)
913 regval = metricfromreg( SPI_ICONHORIZONTALSPACING_REGKEY, SPI_ICONHORIZONTALSPACING_VALNAME, dpi);
914 ok( curr_val == regval,
915 "wrong value in registry %d, expected %d\n", regval, curr_val);
916 /* compare with what SPI_ICONHORIZONTALSPACING returns */
917 rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
918 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
919 eq( spacing, curr_val, "ICONHORIZONTALSPACING", "%d");
920 /* and with a system metrics */
921 eq( GetSystemMetrics( SM_CXICONSPACING ), curr_val, "SM_CXICONSPACING", "%d" );
922 /* and with what SPI_GETICONMETRICS returns */
923 im.cbSize = sizeof(ICONMETRICSA);
924 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im, FALSE );
925 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
926 eq( im.iHorzSpacing, curr_val, "SPI_GETICONMETRICS", "%d" );
927 return TRUE;
928 }
929
930 static void test_SPI_ICONHORIZONTALSPACING( void ) /* 13 */
931 {
932 BOOL rc;
933 INT old_spacing;
934
935 trace("testing SPI_ICONHORIZONTALSPACING\n");
936 SetLastError(0xdeadbeef);
937 /* default value: 75 */
938 rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &old_spacing, 0 );
939 if (!test_error_msg(rc,"SPI_ICONHORIZONTALSPACING"))
940 return;
941 /* do not increase the value as it would upset the user's icon layout */
942 if (!dotest_spi_iconhorizontalspacing( old_spacing - 1)) return;
943 dotest_spi_iconhorizontalspacing( 10); /* minimum is 32 */
944 /* restore */
945 rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, old_spacing, 0, SPIF_UPDATEINIFILE );
946 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
947 }
948
949 static void test_SPI_SETSCREENSAVETIMEOUT( void ) /* 14 */
950 {
951 BOOL rc;
952 UINT old_timeout;
953 const UINT vals[]={0,32767};
954 unsigned int i;
955
956 trace("testing SPI_{GET,SET}SCREENSAVETIMEOUT\n");
957 SetLastError(0xdeadbeef);
958 rc=SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &old_timeout, 0 );
959 if (!test_error_msg(rc,"SPI_{GET,SET}SCREENSAVETIMEOUT"))
960 return;
961
962 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
963 {
964 UINT v;
965 char buf[10];
966
967 rc=SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, vals[i], 0,
968 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
969 if (!test_error_msg(rc,"SPI_SETSCREENSAVETIMEOUT")) return;
970 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
971 test_change_message( SPI_SETSCREENSAVETIMEOUT, 0 );
972 sprintf( buf, "%d", vals[i] );
973 test_reg_key( SPI_SETSCREENSAVETIMEOUT_REGKEY,
974 SPI_SETSCREENSAVETIMEOUT_VALNAME, buf );
975
976 rc = SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &v, 0 );
977 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
978 eq( v, vals[i], "SPI_{GET,SET}SCREENSAVETIMEOUT", "%d" );
979 }
980
981 rc=SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, old_timeout, 0,
982 SPIF_UPDATEINIFILE );
983 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
984 }
985
986 static void test_SPI_SETSCREENSAVEACTIVE( void ) /* 17 */
987 {
988 BOOL rc;
989 BOOL old_b;
990 const UINT vals[]={TRUE,FALSE};
991 unsigned int i;
992
993 trace("testing SPI_{GET,SET}SCREENSAVEACTIVE\n");
994 SetLastError(0xdeadbeef);
995 rc=SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &old_b, 0 );
996 if (!test_error_msg(rc,"SPI_{GET,SET}SCREENSAVEACTIVE"))
997 return;
998
999 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1000 {
1001 UINT v;
1002
1003 rc=SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, vals[i], 0,
1004 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1005 if (!test_error_msg(rc,"SPI_SETSCREENSAVEACTIVE")) return;
1006 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1007 test_change_message( SPI_SETSCREENSAVEACTIVE, 0 );
1008 test_reg_key( SPI_SETSCREENSAVEACTIVE_REGKEY,
1009 SPI_SETSCREENSAVEACTIVE_VALNAME,
1010 vals[i] ? "1" : "0" );
1011
1012 rc=SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &v, 0 );
1013 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1014 ok(v == vals[i] || broken(! v) /* Win 7 */,
1015 "SPI_{GET,SET}SCREENSAVEACTIVE: got %d instead of %d\n", v, vals[i]);
1016 }
1017
1018 rc=SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
1019 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1020 }
1021
1022 static void test_SPI_SETGRIDGRANULARITY( void ) /* 19 */
1023 {
1024 /* ??? */;
1025 }
1026
1027 static void test_SPI_SETKEYBOARDDELAY( void ) /* 23 */
1028 {
1029 BOOL rc;
1030 UINT old_delay;
1031 const UINT vals[]={0,3};
1032 unsigned int i;
1033
1034 trace("testing SPI_{GET,SET}KEYBOARDDELAY\n");
1035 SetLastError(0xdeadbeef);
1036 rc=SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &old_delay, 0 );
1037 if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDDELAY"))
1038 return;
1039
1040 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1041 {
1042 UINT delay;
1043 char buf[10];
1044
1045 rc=SystemParametersInfoA( SPI_SETKEYBOARDDELAY, vals[i], 0,
1046 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1047 if (!test_error_msg(rc,"SPI_SETKEYBOARDDELAY")) return;
1048 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1049 test_change_message( SPI_SETKEYBOARDDELAY, 0 );
1050 sprintf( buf, "%d", vals[i] );
1051 test_reg_key( SPI_SETKEYBOARDDELAY_REGKEY,
1052 SPI_SETKEYBOARDDELAY_VALNAME, buf );
1053
1054 rc=SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &delay, 0 );
1055 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1056 eq( delay, vals[i], "SPI_{GET,SET}KEYBOARDDELAY", "%d" );
1057 }
1058
1059 rc=SystemParametersInfoA( SPI_SETKEYBOARDDELAY, old_delay, 0, SPIF_UPDATEINIFILE );
1060 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1061 }
1062
1063
1064 /* test_SPI_ICONVERTICALSPACING helper */
1065 static BOOL dotest_spi_iconverticalspacing( INT curr_val)
1066 {
1067 BOOL rc;
1068 INT spacing, regval, min_val = MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI );
1069 ICONMETRICSA im;
1070
1071 rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, curr_val, 0,
1072 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
1073 if (!test_error_msg(rc,"SPI_ICONVERTICALSPACING")) return FALSE;
1074 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1075 test_change_message( SPI_ICONVERTICALSPACING, 0 );
1076 curr_val = max( curr_val, min_val );
1077 /* The registry keys depend on the Windows version and the values too
1078 * let's test (works on win95,ME,NT4,2k,XP)
1079 */
1080 regval = metricfromreg( SPI_ICONVERTICALSPACING_REGKEY2, SPI_ICONVERTICALSPACING_VALNAME, dpi);
1081 if( regval != curr_val)
1082 regval = metricfromreg( SPI_ICONVERTICALSPACING_REGKEY, SPI_ICONVERTICALSPACING_VALNAME, dpi);
1083 ok( curr_val == regval,
1084 "wrong value in registry %d, expected %d\n", regval, curr_val);
1085 /* compare with what SPI_ICONVERTICALSPACING returns */
1086 rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
1087 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1088 eq( spacing, curr_val, "ICONVERTICALSPACING", "%d" );
1089 /* and with a system metrics */
1090 eq( GetSystemMetrics( SM_CYICONSPACING ), curr_val, "SM_CYICONSPACING", "%d" );
1091 /* and with what SPI_GETICONMETRICS returns */
1092 im.cbSize = sizeof(ICONMETRICSA);
1093 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im, FALSE );
1094 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1095 eq( im.iVertSpacing, curr_val, "SPI_GETICONMETRICS", "%d" );
1096 return TRUE;
1097 }
1098
1099 static void test_SPI_ICONVERTICALSPACING( void ) /* 24 */
1100 {
1101 BOOL rc;
1102 INT old_spacing;
1103
1104 trace("testing SPI_ICONVERTICALSPACING\n");
1105 SetLastError(0xdeadbeef);
1106 /* default value: 75 */
1107 rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &old_spacing, 0 );
1108 if (!test_error_msg(rc,"SPI_ICONVERTICALSPACING"))
1109 return;
1110 /* do not increase the value as it would upset the user's icon layout */
1111 if (!dotest_spi_iconverticalspacing( old_spacing - 1)) return;
1112 /* same tests with a value less than the minimum 32 */
1113 dotest_spi_iconverticalspacing( 10);
1114 /* restore */
1115 rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, old_spacing, 0,
1116 SPIF_UPDATEINIFILE );
1117 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1118 }
1119
1120 static void test_SPI_SETICONTITLEWRAP( void ) /* 26 */
1121 {
1122 BOOL rc;
1123 BOOL old_b;
1124 const UINT vals[]={TRUE,FALSE};
1125 unsigned int i;
1126 ICONMETRICSA im;
1127
1128 /* These tests hang when XFree86 4.0 for Windows is running (tested on
1129 * WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
1130 * running.
1131 */
1132 if (FindWindowA( NULL, "Cygwin/XFree86" ))
1133 return;
1134
1135 trace("testing SPI_{GET,SET}ICONTITLEWRAP\n");
1136 SetLastError(0xdeadbeef);
1137 rc=SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &old_b, 0 );
1138 if (!test_error_msg(rc,"SPI_{GET,SET}ICONTITLEWRAP"))
1139 return;
1140
1141 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1142 {
1143 UINT v;
1144 UINT regval;
1145
1146 rc=SystemParametersInfoA( SPI_SETICONTITLEWRAP, vals[i], 0,
1147 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1148 if (!test_error_msg(rc,"SPI_SETICONTITLEWRAP")) return;
1149 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1150 test_change_message( SPI_SETICONTITLEWRAP, 1 );
1151 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY2,
1152 SPI_SETICONTITLEWRAP_VALNAME, dpi);
1153 if( regval != vals[i])
1154 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY1,
1155 SPI_SETICONTITLEWRAP_VALNAME, dpi);
1156 ok( regval == vals[i], "wrong value in registry %d, expected %d\n", regval, vals[i] );
1157
1158 rc=SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &v, 0 );
1159 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1160 eq( v, vals[i], "SPI_{GET,SET}ICONTITLEWRAP", "%d" );
1161 /* and test with what SPI_GETICONMETRICS returns */
1162 im.cbSize = sizeof(ICONMETRICSA);
1163 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im, FALSE );
1164 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1165 eq( im.iTitleWrap, (BOOL)vals[i], "SPI_GETICONMETRICS", "%d" );
1166 }
1167
1168 rc=SystemParametersInfoA( SPI_SETICONTITLEWRAP, old_b, 0, SPIF_UPDATEINIFILE );
1169 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1170 }
1171
1172 static void test_SPI_SETMENUDROPALIGNMENT( void ) /* 28 */
1173 {
1174 BOOL rc;
1175 BOOL old_b;
1176 const UINT vals[]={TRUE,FALSE};
1177 unsigned int i;
1178
1179 trace("testing SPI_{GET,SET}MENUDROPALIGNMENT\n");
1180 SetLastError(0xdeadbeef);
1181 rc=SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &old_b, 0 );
1182 if (!test_error_msg(rc,"SPI_{GET,SET}MENUDROPALIGNMENT"))
1183 return;
1184
1185 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1186 {
1187 UINT v;
1188
1189 rc=SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, vals[i], 0,
1190 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1191 if (!test_error_msg(rc,"SPI_SETMENUDROPALIGNMENT")) return;
1192 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1193 test_change_message( SPI_SETMENUDROPALIGNMENT, 0 );
1194 test_reg_key_ex( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1195 SPI_SETMENUDROPALIGNMENT_REGKEY2,
1196 SPI_SETMENUDROPALIGNMENT_VALNAME,
1197 vals[i] ? "1" : "0" );
1198
1199 rc=SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &v, 0 );
1200 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1201 eq( v, vals[i], "SPI_{GET,SET}MENUDROPALIGNMENT", "%d" );
1202 eq( GetSystemMetrics( SM_MENUDROPALIGNMENT ), (int)vals[i],
1203 "SM_MENUDROPALIGNMENT", "%d" );
1204 }
1205
1206 rc=SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, old_b, 0,
1207 SPIF_UPDATEINIFILE );
1208 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1209 }
1210
1211 static void test_SPI_SETDOUBLECLKWIDTH( void ) /* 29 */
1212 {
1213 BOOL rc;
1214 INT old_width;
1215 const UINT vals[]={0,10000};
1216 unsigned int i;
1217
1218 trace("testing SPI_{GET,SET}DOUBLECLKWIDTH\n");
1219 old_width = GetSystemMetrics( SM_CXDOUBLECLK );
1220
1221 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1222 {
1223 char buf[10];
1224
1225 SetLastError(0xdeadbeef);
1226 rc=SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, vals[i], 0,
1227 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1228 if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLKWIDTH"))
1229 return;
1230
1231 test_change_message( SPI_SETDOUBLECLKWIDTH, 0 );
1232 sprintf( buf, "%d", vals[i] );
1233 test_reg_key_ex( SPI_SETDOUBLECLKWIDTH_REGKEY1,
1234 SPI_SETDOUBLECLKWIDTH_REGKEY2,
1235 SPI_SETDOUBLECLKWIDTH_VALNAME, buf );
1236 eq( GetSystemMetrics( SM_CXDOUBLECLK ), (int)vals[i],
1237 "SM_CXDOUBLECLK", "%d" );
1238 }
1239
1240 rc=SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, old_width, 0,
1241 SPIF_UPDATEINIFILE );
1242 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1243 }
1244
1245 static void test_SPI_SETDOUBLECLKHEIGHT( void ) /* 30 */
1246 {
1247 BOOL rc;
1248 INT old_height;
1249 const UINT vals[]={0,10000};
1250 unsigned int i;
1251
1252 trace("testing SPI_{GET,SET}DOUBLECLKHEIGHT\n");
1253 old_height = GetSystemMetrics( SM_CYDOUBLECLK );
1254
1255 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1256 {
1257 char buf[10];
1258
1259 SetLastError(0xdeadbeef);
1260 rc=SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, vals[i], 0,
1261 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1262 if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLKHEIGHT"))
1263 return;
1264
1265 test_change_message( SPI_SETDOUBLECLKHEIGHT, 0 );
1266 sprintf( buf, "%d", vals[i] );
1267 test_reg_key_ex( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
1268 SPI_SETDOUBLECLKHEIGHT_REGKEY2,
1269 SPI_SETDOUBLECLKHEIGHT_VALNAME, buf );
1270 eq( GetSystemMetrics( SM_CYDOUBLECLK ), (int)vals[i],
1271 "SM_CYDOUBLECLK", "%d" );
1272 }
1273
1274 rc=SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, old_height, 0,
1275 SPIF_UPDATEINIFILE );
1276 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1277 }
1278
1279 static void test_SPI_SETDOUBLECLICKTIME( void ) /* 32 */
1280 {
1281 BOOL rc;
1282 UINT curr_val;
1283 UINT saved_val;
1284 UINT old_time;
1285 char buf[10];
1286
1287 trace("testing SPI_{GET,SET}DOUBLECLICKTIME\n");
1288 old_time = GetDoubleClickTime();
1289
1290 curr_val = 0;
1291 SetLastError(0xdeadbeef);
1292 rc=SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
1293 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1294 if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLICKTIME"))
1295 return;
1296
1297 test_change_message( SPI_SETDOUBLECLICKTIME, 0 );
1298 sprintf( buf, "%d", curr_val );
1299 test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
1300 SPI_SETDOUBLECLICKTIME_VALNAME, buf );
1301 curr_val = 500; /* used value for 0 */
1302 eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
1303
1304 curr_val = 1000;
1305 rc=SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
1306 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1307 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1308 test_change_message( SPI_SETDOUBLECLICKTIME, 0 );
1309 sprintf( buf, "%d", curr_val );
1310 test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
1311 SPI_SETDOUBLECLICKTIME_VALNAME, buf );
1312 eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
1313
1314 saved_val = curr_val;
1315
1316 curr_val = 0;
1317 SetDoubleClickTime( curr_val );
1318 sprintf( buf, "%d", saved_val );
1319 test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
1320 SPI_SETDOUBLECLICKTIME_VALNAME, buf );
1321 curr_val = 500; /* used value for 0 */
1322 eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
1323
1324 curr_val = 1000;
1325 SetDoubleClickTime( curr_val );
1326 sprintf( buf, "%d", saved_val );
1327 test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
1328 SPI_SETDOUBLECLICKTIME_VALNAME, buf );
1329 eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
1330
1331 rc=SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, old_time, 0, SPIF_UPDATEINIFILE);
1332 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1333 }
1334
1335 static void test_SPI_SETMOUSEBUTTONSWAP( void ) /* 33 */
1336 {
1337 BOOL rc;
1338 BOOL old_b;
1339 const UINT vals[]={TRUE,FALSE};
1340 unsigned int i;
1341
1342 trace("testing SPI_{GET,SET}MOUSEBUTTONSWAP\n");
1343 old_b = GetSystemMetrics( SM_SWAPBUTTON );
1344
1345 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1346 {
1347 SetLastError(0xdeadbeef);
1348 rc=SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, vals[i], 0,
1349 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1350 if (!test_error_msg(rc,"SPI_SETMOUSEBUTTONSWAP")) return;
1351
1352 test_change_message( SPI_SETMOUSEBUTTONSWAP, 0 );
1353 test_reg_key( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1354 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1355 vals[i] ? "1" : "0" );
1356 eq( GetSystemMetrics( SM_SWAPBUTTON ), (int)vals[i],
1357 "SM_SWAPBUTTON", "%d" );
1358 rc=SwapMouseButton((BOOL)vals[i^1]);
1359 eq( GetSystemMetrics( SM_SWAPBUTTON ), (int)vals[i^1],
1360 "SwapMouseButton", "%d" );
1361 ok( rc==(BOOL)vals[i], "SwapMouseButton does not return previous state (really %d)\n", rc );
1362 }
1363
1364 rc=SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, old_b, 0,
1365 SPIF_UPDATEINIFILE );
1366 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1367 }
1368
1369 static void test_SPI_SETFASTTASKSWITCH( void ) /* 36 */
1370 {
1371 BOOL rc;
1372 BOOL v;
1373
1374 trace("testing SPI_GETFASTTASKSWITCH\n");
1375 SetLastError(0xdeadbeef);
1376 rc=SystemParametersInfoA( SPI_GETFASTTASKSWITCH, 0, &v, 0 );
1377 if (!test_error_msg(rc,"SPI_{GET,SET}FASTTASKSWITCH"))
1378 return;
1379
1380 /* there is not a single Windows platform on which SPI_GETFASTTASKSWITCH
1381 * works. That sure simplifies testing!
1382 */
1383 }
1384
1385 static void test_SPI_SETDRAGFULLWINDOWS( void ) /* 37 */
1386 {
1387 BOOL rc;
1388 BOOL old_b;
1389 const UINT vals[]={TRUE,FALSE};
1390 unsigned int i;
1391
1392 trace("testing SPI_{GET,SET}DRAGFULLWINDOWS\n");
1393 SetLastError(0xdeadbeef);
1394 rc=SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &old_b, 0 );
1395
1396 /* SPI_{GET,SET}DRAGFULLWINDOWS is not implemented on Win95 */
1397 if (!test_error_msg(rc,"SPI_{GET,SET}DRAGFULLWINDOWS"))
1398 return;
1399
1400 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1401 {
1402 UINT v;
1403
1404 rc=SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, vals[i], 0,
1405 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1406 if (!test_error_msg(rc,"SPI_SETDRAGFULLWINDOWS")) return;
1407 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1408 test_change_message( SPI_SETDRAGFULLWINDOWS, 0 );
1409 test_reg_key( SPI_SETDRAGFULLWINDOWS_REGKEY,
1410 SPI_SETDRAGFULLWINDOWS_VALNAME,
1411 vals[i] ? "1" : "0" );
1412
1413 rc=SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &v, 0 );
1414 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1415 eq( v, vals[i], "SPI_{GET,SET}DRAGFULLWINDOWS", "%d" );
1416 }
1417
1418 rc=SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, old_b, 0, SPIF_UPDATEINIFILE );
1419 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1420 }
1421
1422 #define test_reg_metric( KEY, VAL, val) do { \
1423 INT regval;\
1424 regval = metricfromreg( KEY, VAL, dpi);\
1425 ok( regval==val, "wrong value \"%s\" in registry %d, expected %d\n", VAL, regval, val);\
1426 } while(0)
1427
1428 #define test_reg_metric2( KEY1, KEY2, VAL, val) do { \
1429 INT regval;\
1430 regval = metricfromreg( KEY1, VAL, dpi);\
1431 if( regval != val) regval = metricfromreg( KEY2, VAL, dpi);\
1432 ok( regval==val, "wrong value \"%s\" in registry %d, expected %d\n", VAL, regval, val);\
1433 } while(0)
1434
1435 #define test_reg_font( KEY, VAL, LF) do { \
1436 LOGFONTA lfreg;\
1437 lffromreg( KEY, VAL, &lfreg);\
1438 ok( (lfreg.lfHeight < 0 ? (LF).lfHeight == MulDiv( lfreg.lfHeight, dpi, real_dpi ) : \
1439 MulDiv( -(LF).lfHeight , 72, dpi) == lfreg.lfHeight )&&\
1440 (LF).lfWidth == lfreg.lfWidth &&\
1441 (LF).lfWeight == lfreg.lfWeight &&\
1442 !strcmp( (LF).lfFaceName, lfreg.lfFaceName)\
1443 , "wrong value \"%s\" in registry %d, %d\n", VAL, (LF).lfHeight, lfreg.lfHeight);\
1444 } while(0)
1445
1446 #define TEST_NONCLIENTMETRICS_REG( ncm) do { \
1447 /*FIXME: test_reg_metric2( SPI_SETBORDER_REGKEY2, SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, (ncm).iBorderWidth);*/\
1448 test_reg_metric( SPI_METRIC_REGKEY, SPI_SCROLLWIDTH_VALNAME, (ncm).iScrollWidth);\
1449 test_reg_metric( SPI_METRIC_REGKEY, SPI_SCROLLHEIGHT_VALNAME, (ncm).iScrollHeight);\
1450 /*FIXME: test_reg_metric( SPI_METRIC_REGKEY, SPI_CAPTIONWIDTH_VALNAME, (ncm).iCaptionWidth);*/\
1451 test_reg_metric( SPI_METRIC_REGKEY, SPI_CAPTIONHEIGHT_VALNAME, (ncm).iCaptionHeight);\
1452 test_reg_metric( SPI_METRIC_REGKEY, SPI_SMCAPTIONWIDTH_VALNAME, (ncm).iSmCaptionWidth);\
1453 test_reg_metric( SPI_METRIC_REGKEY, SPI_SMCAPTIONHEIGHT_VALNAME, (ncm).iSmCaptionHeight);\
1454 test_reg_metric( SPI_METRIC_REGKEY, SPI_MENUWIDTH_VALNAME, (ncm).iMenuWidth);\
1455 test_reg_metric( SPI_METRIC_REGKEY, SPI_MENUHEIGHT_VALNAME, (ncm).iMenuHeight);\
1456 test_reg_font( SPI_METRIC_REGKEY, SPI_MENUFONT_VALNAME, (ncm).lfMenuFont);\
1457 test_reg_font( SPI_METRIC_REGKEY, SPI_CAPTIONFONT_VALNAME, (ncm).lfCaptionFont);\
1458 test_reg_font( SPI_METRIC_REGKEY, SPI_SMCAPTIONFONT_VALNAME, (ncm).lfSmCaptionFont);\
1459 test_reg_font( SPI_METRIC_REGKEY, SPI_STATUSFONT_VALNAME, (ncm).lfStatusFont);\
1460 test_reg_font( SPI_METRIC_REGKEY, SPI_MESSAGEFONT_VALNAME, (ncm).lfMessageFont); } while(0)
1461
1462 /* get text metric height value for the specified logfont */
1463 static int get_tmheight( LOGFONTA *plf, int flag)
1464 {
1465 TEXTMETRICA tm;
1466 HDC hdc = GetDC(0);
1467 HFONT hfont = CreateFontIndirectA( plf);
1468 hfont = SelectObject( hdc, hfont);
1469 GetTextMetricsA( hdc, &tm);
1470 hfont = SelectObject( hdc, hfont);
1471 ReleaseDC( 0, hdc );
1472 return tm.tmHeight + (flag ? tm.tmExternalLeading : 0);
1473 }
1474
1475 static void test_GetSystemMetrics( void);
1476 static UINT smcxsmsize = 999999999;
1477
1478 static void test_SPI_SETNONCLIENTMETRICS( void ) /* 44 */
1479 {
1480 BOOL rc;
1481 INT expect;
1482 NONCLIENTMETRICSA Ncmorig;
1483 NONCLIENTMETRICSA Ncmnew;
1484 NONCLIENTMETRICSA Ncmcur;
1485 NONCLIENTMETRICSA Ncmstart;
1486
1487 Ncmorig.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
1488 Ncmnew.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
1489 Ncmcur.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
1490 Ncmstart.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
1491
1492 trace("testing SPI_{GET,SET}NONCLIENTMETRICS\n");
1493 change_counter = 0;
1494 SetLastError(0xdeadbeef);
1495 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &Ncmorig, FALSE );
1496 if (!test_error_msg(rc,"SPI_{GET,SET}NONCLIENTMETRICS"))
1497 return;
1498 Ncmstart = Ncmorig;
1499 smcxsmsize = Ncmstart.iSmCaptionWidth;
1500 /* SPI_GETNONCLIENTMETRICS returns some "cooked" values. For instance if
1501 the caption font height is higher than the CaptionHeight field,
1502 the latter is adjusted accordingly. To be able to restore these setting
1503 accurately be restore the raw values. */
1504 Ncmorig.iCaptionWidth = metricfromreg( SPI_METRIC_REGKEY, SPI_CAPTIONWIDTH_VALNAME, real_dpi);
1505 Ncmorig.iCaptionHeight = metricfromreg( SPI_METRIC_REGKEY, SPI_CAPTIONHEIGHT_VALNAME, dpi);
1506 Ncmorig.iSmCaptionHeight = metricfromreg( SPI_METRIC_REGKEY, SPI_SMCAPTIONHEIGHT_VALNAME, dpi);
1507 Ncmorig.iMenuHeight = metricfromreg( SPI_METRIC_REGKEY, SPI_MENUHEIGHT_VALNAME, dpi);
1508 /* test registry entries */
1509 TEST_NONCLIENTMETRICS_REG( Ncmorig);
1510 Ncmorig.lfCaptionFont.lfHeight = MulDiv( Ncmorig.lfCaptionFont.lfHeight, real_dpi, dpi );
1511
1512 /* make small changes */
1513 Ncmnew = Ncmstart;
1514 Ncmnew.iBorderWidth += 1;
1515 Ncmnew.iScrollWidth += 1;
1516 Ncmnew.iScrollHeight -= 1;
1517 Ncmnew.iCaptionWidth -= 2;
1518 Ncmnew.iCaptionHeight += 2;
1519 Ncmnew.lfCaptionFont.lfHeight +=1;
1520 Ncmnew.lfCaptionFont.lfWidth +=2;
1521 Ncmnew.lfCaptionFont.lfWeight +=1;
1522 Ncmnew.iSmCaptionWidth += 1;
1523 Ncmnew.iSmCaptionHeight += 2;
1524 Ncmnew.lfSmCaptionFont.lfHeight +=3;
1525 Ncmnew.lfSmCaptionFont.lfWidth -=1;
1526 Ncmnew.lfSmCaptionFont.lfWeight +=3;
1527 Ncmnew.iMenuWidth += 1;
1528 Ncmnew.iMenuHeight += 2;
1529 Ncmnew.lfMenuFont.lfHeight +=1;
1530 Ncmnew.lfMenuFont.lfWidth +=1;
1531 Ncmnew.lfMenuFont.lfWeight +=2;
1532 Ncmnew.lfStatusFont.lfHeight -=1;
1533 Ncmnew.lfStatusFont.lfWidth -=1;
1534 Ncmnew.lfStatusFont.lfWeight +=3;
1535 Ncmnew.lfMessageFont.lfHeight -=2;
1536 Ncmnew.lfMessageFont.lfWidth -=1;
1537 Ncmnew.lfMessageFont.lfWeight +=4;
1538
1539 rc=SystemParametersInfoA( SPI_SETNONCLIENTMETRICS, 0, &Ncmnew, SPIF_UPDATEINIFILE|
1540 SPIF_SENDCHANGE);
1541 if (!test_error_msg(rc,"SPI_SETNONCLIENTMETRICS")) return;
1542 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1543 test_change_message( SPI_SETNONCLIENTMETRICS, 1 );
1544 /* get them back */
1545 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &Ncmcur, FALSE );
1546 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1547 /* test registry entries */
1548 TEST_NONCLIENTMETRICS_REG( Ncmcur );
1549 /* test the system metrics with these settings */
1550 test_GetSystemMetrics();
1551 /* now for something invalid: increase the {menu|caption|smcaption} fonts
1552 by a large amount will increase the {menu|caption|smcaption} height*/
1553 Ncmnew = Ncmstart;
1554 Ncmnew.lfMenuFont.lfHeight -= 8;
1555 Ncmnew.lfCaptionFont.lfHeight =-4;
1556 Ncmnew.lfSmCaptionFont.lfHeight -=10;
1557 /* also show that a few values are lo limited */
1558 Ncmnew.iCaptionWidth = 0;
1559 Ncmnew.iCaptionHeight = 0;
1560 Ncmnew.iScrollHeight = 0;
1561 Ncmnew.iScrollWidth = 0;
1562
1563 rc=SystemParametersInfoA( SPI_SETNONCLIENTMETRICS, 0, &Ncmnew, SPIF_UPDATEINIFILE|
1564 SPIF_SENDCHANGE);
1565 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1566 test_change_message( SPI_SETNONCLIENTMETRICS, 1 );
1567 /* raw values are in registry */
1568 TEST_NONCLIENTMETRICS_REG( Ncmnew );
1569 /* get them back */
1570 rc=SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &Ncmcur, FALSE );
1571 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1572 /* cooked values are returned */
1573 expect = max( Ncmnew.iMenuHeight, 2 + get_tmheight( &Ncmnew.lfMenuFont, 1));
1574 ok( Ncmcur.iMenuHeight == expect,
1575 "MenuHeight: %d expected %d\n", Ncmcur.iMenuHeight, expect);
1576 expect = max( Ncmnew.iCaptionHeight, 2 + get_tmheight(&Ncmnew.lfCaptionFont, 0));
1577 ok( Ncmcur.iCaptionHeight == expect,
1578 "CaptionHeight: %d expected %d\n", Ncmcur.iCaptionHeight, expect);
1579 expect = max( Ncmnew.iSmCaptionHeight, 2 + get_tmheight( &Ncmnew.lfSmCaptionFont, 0));
1580 ok( Ncmcur.iSmCaptionHeight == expect,
1581 "SmCaptionHeight: %d expected %d\n", Ncmcur.iSmCaptionHeight, expect);
1582
1583 /* iCaptionWidth depends on a version, could be 8, 12 (Vista, Win7), 13 */
1584 ok( (Ncmcur.iCaptionWidth >= 8 && Ncmcur.iCaptionWidth <= 13) ||
1585 Ncmcur.iCaptionWidth == Ncmstart.iCaptionWidth, /* with windows XP theme, the value never changes */
1586 "CaptionWidth: %d expected from [8, 13] or %d\n", Ncmcur.iCaptionWidth, Ncmstart.iCaptionWidth);
1587 ok( Ncmcur.iScrollWidth == 8,
1588 "ScrollWidth: %d expected 8\n", Ncmcur.iScrollWidth);
1589 ok( Ncmcur.iScrollHeight == 8,
1590 "ScrollHeight: %d expected 8\n", Ncmcur.iScrollHeight);
1591 /* test the system metrics with these settings */
1592 test_GetSystemMetrics();
1593 /* restore */
1594 rc=SystemParametersInfoA( SPI_SETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA),
1595 &Ncmorig, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
1596 test_change_message( SPI_SETNONCLIENTMETRICS, 0 );
1597 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1598 /* test the system metrics with these settings */
1599 test_GetSystemMetrics();
1600 }
1601
1602 static void test_SPI_SETMINIMIZEDMETRICS( void ) /* 44 */
1603 {
1604 BOOL rc;
1605 INT regval;
1606 MINIMIZEDMETRICS lpMm_orig;
1607 MINIMIZEDMETRICS lpMm_new;
1608 MINIMIZEDMETRICS lpMm_cur;
1609
1610 lpMm_orig.cbSize = sizeof(MINIMIZEDMETRICS);
1611 lpMm_new.cbSize = sizeof(MINIMIZEDMETRICS);
1612 lpMm_cur.cbSize = sizeof(MINIMIZEDMETRICS);
1613
1614 trace("testing SPI_{GET,SET}MINIMIZEDMETRICS\n");
1615 SetLastError(0xdeadbeef);
1616 rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_orig, FALSE );
1617 if (!test_error_msg(rc,"SPI_{GET,SET}MINIMIZEDMETRICS"))
1618 return;
1619 /* Test registry. Note that it is perfectly valid for some fields to
1620 * not be set.
1621 */
1622 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINWIDTH_VALNAME, dpi);
1623 ok( regval == -1 || regval == lpMm_orig.iWidth, "wrong value in registry %d, expected %d\n",
1624 regval, lpMm_orig.iWidth);
1625 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINHORZGAP_VALNAME, dpi);
1626 ok( regval == -1 || regval == lpMm_orig.iHorzGap, "wrong value in registry %d, expected %d\n",
1627 regval, lpMm_orig.iHorzGap);
1628 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINVERTGAP_VALNAME, dpi);
1629 ok( regval == -1 || regval == lpMm_orig.iVertGap, "wrong value in registry %d, expected %d\n",
1630 regval, lpMm_orig.iVertGap);
1631 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINARRANGE_VALNAME, dpi);
1632 ok( regval == -1 || regval == lpMm_orig.iArrange, "wrong value in registry %d, expected %d\n",
1633 regval, lpMm_orig.iArrange);
1634 /* set some new values */
1635 lpMm_cur.iWidth = 180;
1636 lpMm_cur.iHorzGap = 1;
1637 lpMm_cur.iVertGap = 1;
1638 lpMm_cur.iArrange = 5;
1639 rc=SystemParametersInfoA( SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS),
1640 &lpMm_cur, SPIF_UPDATEINIFILE );
1641 if (!test_error_msg(rc,"SPI_SETMINIMIZEDMETRICS")) return;
1642 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1643 /* read them back */
1644 rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_new, FALSE );
1645 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1646 /* and compare */
1647 eq( lpMm_new.iWidth, lpMm_cur.iWidth, "iWidth", "%d" );
1648 eq( lpMm_new.iHorzGap, lpMm_cur.iHorzGap, "iHorzGap", "%d" );
1649 eq( lpMm_new.iVertGap, lpMm_cur.iVertGap, "iVertGap", "%d" );
1650 eq( lpMm_new.iArrange, lpMm_cur.iArrange, "iArrange", "%d" );
1651 /* test registry */
1652 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINWIDTH_VALNAME, dpi);
1653 ok( regval == lpMm_new.iWidth, "wrong value in registry %d, expected %d\n",
1654 regval, lpMm_new.iWidth);
1655 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINHORZGAP_VALNAME, dpi);
1656 ok( regval == lpMm_new.iHorzGap, "wrong value in registry %d, expected %d\n",
1657 regval, lpMm_new.iHorzGap);
1658 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINVERTGAP_VALNAME, dpi);
1659 ok( regval == lpMm_new.iVertGap, "wrong value in registry %d, expected %d\n",
1660 regval, lpMm_new.iVertGap);
1661 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINARRANGE_VALNAME, dpi);
1662 ok( regval == lpMm_new.iArrange, "wrong value in registry %d, expected %d\n",
1663 regval, lpMm_new.iArrange);
1664 /* test some system metrics */
1665 eq( GetSystemMetrics( SM_CXMINIMIZED ) - 6,
1666 lpMm_new.iWidth, "iWidth", "%d" );
1667 eq( GetSystemMetrics( SM_CXMINSPACING ) - GetSystemMetrics( SM_CXMINIMIZED ),
1668 lpMm_new.iHorzGap, "iHorzGap", "%d" );
1669 eq( GetSystemMetrics( SM_CYMINSPACING ) - GetSystemMetrics( SM_CYMINIMIZED ),
1670 lpMm_new.iVertGap, "iVertGap", "%d" );
1671 eq( GetSystemMetrics( SM_ARRANGE ),
1672 lpMm_new.iArrange, "iArrange", "%d" );
1673 /* now some really invalid settings */
1674 lpMm_cur.iWidth = -1;
1675 lpMm_cur.iHorzGap = -1;
1676 lpMm_cur.iVertGap = -1;
1677 lpMm_cur.iArrange = - 1;
1678 rc=SystemParametersInfoA( SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS),
1679 &lpMm_cur, SPIF_UPDATEINIFILE );
1680 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1681 /* read back */
1682 rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_new, FALSE );
1683 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1684 /* the width and H/V gaps have minimum 0, arrange is and'd with 0xf */
1685 eq( lpMm_new.iWidth, 0, "iWidth", "%d" );
1686 eq( lpMm_new.iHorzGap, 0, "iHorzGap", "%d" );
1687 eq( lpMm_new.iVertGap, 0, "iVertGap", "%d" );
1688 eq( lpMm_new.iArrange, 0xf & lpMm_cur.iArrange, "iArrange", "%d" );
1689 /* test registry */
1690 if (0)
1691 {
1692 /* FIXME: cannot understand the results of this (11, 11, 11, 0) */
1693 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINWIDTH_VALNAME, dpi);
1694 ok( regval == lpMm_new.iWidth, "wrong value in registry %d, expected %d\n",
1695 regval, lpMm_new.iWidth);
1696 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINHORZGAP_VALNAME, dpi);
1697 ok( regval == lpMm_new.iHorzGap, "wrong value in registry %d, expected %d\n",
1698 regval, lpMm_new.iHorzGap);
1699 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINVERTGAP_VALNAME, dpi);
1700 ok( regval == lpMm_new.iVertGap, "wrong value in registry %d, expected %d\n",
1701 regval, lpMm_new.iVertGap);
1702 regval = metricfromreg( SPI_MINIMIZEDMETRICS_REGKEY, SPI_MINARRANGE_VALNAME, dpi);
1703 ok( regval == lpMm_new.iArrange, "wrong value in registry %d, expected %d\n",
1704 regval, lpMm_new.iArrange);
1705 }
1706 /* test some system metrics */
1707 eq( GetSystemMetrics( SM_CXMINIMIZED ) - 6,
1708 lpMm_new.iWidth, "iWidth", "%d" );
1709 eq( GetSystemMetrics( SM_CXMINSPACING ) - GetSystemMetrics( SM_CXMINIMIZED ),
1710 lpMm_new.iHorzGap, "iHorzGap", "%d" );
1711 eq( GetSystemMetrics( SM_CYMINSPACING ) - GetSystemMetrics( SM_CYMINIMIZED ),
1712 lpMm_new.iVertGap, "iVertGap", "%d" );
1713 eq( GetSystemMetrics( SM_ARRANGE ),
1714 lpMm_new.iArrange, "iArrange", "%d" );
1715 /* restore */
1716 rc=SystemParametersInfoA( SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS),
1717 &lpMm_orig, SPIF_UPDATEINIFILE );
1718 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1719 /* check that */
1720 rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_new, FALSE );
1721 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1722 eq( lpMm_new.iWidth, lpMm_orig.iWidth, "iWidth", "%d" );
1723 eq( lpMm_new.iHorzGap, lpMm_orig.iHorzGap, "iHorzGap", "%d" );
1724 eq( lpMm_new.iVertGap, lpMm_orig.iVertGap, "iVertGap", "%d" );
1725 eq( lpMm_new.iArrange, lpMm_orig.iArrange, "iArrange", "%d" );
1726 }
1727
1728 static void test_SPI_SETICONMETRICS( void ) /* 46 */
1729 {
1730 BOOL rc, wrap;
1731 INT spacing;
1732 ICONMETRICSA im_orig;
1733 ICONMETRICSA im_new;
1734 ICONMETRICSA im_cur;
1735 INT regval;
1736
1737 im_orig.cbSize = sizeof(ICONMETRICSA);
1738 im_new.cbSize = sizeof(ICONMETRICSA);
1739 im_cur.cbSize = sizeof(ICONMETRICSA);
1740
1741 trace("testing SPI_{GET,SET}ICONMETRICS\n");
1742 SetLastError(0xdeadbeef);
1743 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_orig, FALSE );
1744 if (!test_error_msg(rc,"SPI_{GET,SET}ICONMETRICS"))
1745 return;
1746 /* check some registry values */
1747 regval = metricfromreg( SPI_ICONHORIZONTALSPACING_REGKEY, SPI_ICONHORIZONTALSPACING_VALNAME, dpi);
1748 ok( regval==im_orig.iHorzSpacing,
1749 "wrong value in registry %d, expected %d\n", regval, im_orig.iHorzSpacing);
1750 regval = metricfromreg( SPI_ICONVERTICALSPACING_REGKEY, SPI_ICONVERTICALSPACING_VALNAME, dpi);
1751 ok( regval==im_orig.iVertSpacing,
1752 "wrong value in registry %d, expected %d\n", regval, im_orig.iVertSpacing);
1753 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY2, SPI_SETICONTITLEWRAP_VALNAME, dpi);
1754 if( regval != im_orig.iTitleWrap)
1755 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY1, SPI_SETICONTITLEWRAP_VALNAME, dpi);
1756 ok( regval==im_orig.iTitleWrap, "wrong value in registry %d, expected %d\n", regval, im_orig.iTitleWrap);
1757
1758 /* change everything without creating something invalid ( Win9x would ignore
1759 * an invalid font for instance) */
1760 im_cur = im_orig;
1761 im_cur.iHorzSpacing += 10;
1762 im_cur.iVertSpacing += 6;
1763 im_cur.iTitleWrap = !im_cur.iTitleWrap;
1764 im_cur.lfFont.lfHeight += 1;
1765 im_cur.lfFont.lfWidth += 2;
1766 im_cur.lfFont.lfEscapement = 1;
1767 im_cur.lfFont.lfWeight = im_cur.lfFont.lfWeight > 100 ? 1 : 314;
1768 im_cur.lfFont.lfItalic = !im_cur.lfFont.lfItalic;
1769 im_cur.lfFont.lfStrikeOut = !im_cur.lfFont.lfStrikeOut;
1770 im_cur.lfFont.lfUnderline = !im_cur.lfFont.lfUnderline;
1771 im_cur.lfFont.lfCharSet = im_cur.lfFont.lfCharSet ? 0 : 1;
1772 im_cur.lfFont.lfOutPrecision = im_cur.lfFont.lfOutPrecision == OUT_DEFAULT_PRECIS ?
1773 OUT_TT_PRECIS : OUT_DEFAULT_PRECIS;
1774 im_cur.lfFont.lfClipPrecision ^= CLIP_LH_ANGLES;
1775 im_cur.lfFont.lfPitchAndFamily = im_cur.lfFont.lfPitchAndFamily ? 0 : 1;
1776 im_cur.lfFont.lfQuality = im_cur.lfFont.lfQuality == DEFAULT_QUALITY ?
1777 DRAFT_QUALITY : DEFAULT_QUALITY;
1778 if( strcmp( im_cur.lfFont.lfFaceName, "MS Serif"))
1779 strcpy( im_cur.lfFont.lfFaceName, "MS Serif");
1780 else
1781 strcpy( im_cur.lfFont.lfFaceName, "MS Sans Serif");
1782
1783 rc=SystemParametersInfoA( SPI_SETICONMETRICS, sizeof(ICONMETRICSA), &im_cur, SPIF_UPDATEINIFILE );
1784 if (!test_error_msg(rc,"SPI_SETICONMETRICS")) return;
1785 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1786
1787 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_new, FALSE );
1788 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1789 /* test GET <-> SETICONMETRICS */
1790 eq( im_new.iHorzSpacing, im_cur.iHorzSpacing, "iHorzSpacing", "%d" );
1791 eq( im_new.iVertSpacing, im_cur.iVertSpacing, "iVertSpacing", "%d" );
1792 eq( im_new.iTitleWrap, im_cur.iTitleWrap, "iTitleWrap", "%d" );
1793 eq( im_new.lfFont.lfHeight, im_cur.lfFont.lfHeight, "lfHeight", "%d" );
1794 eq( im_new.lfFont.lfWidth, im_cur.lfFont.lfWidth, "lfWidth", "%d" );
1795 eq( im_new.lfFont.lfEscapement, im_cur.lfFont.lfEscapement, "lfEscapement", "%d" );
1796 eq( im_new.lfFont.lfWeight, im_cur.lfFont.lfWeight, "lfWeight", "%d" );
1797 eq( im_new.lfFont.lfItalic, im_cur.lfFont.lfItalic, "lfItalic", "%d" );
1798 eq( im_new.lfFont.lfStrikeOut, im_cur.lfFont.lfStrikeOut, "lfStrikeOut", "%d" );
1799 eq( im_new.lfFont.lfUnderline, im_cur.lfFont.lfUnderline, "lfUnderline", "%d" );
1800 eq( im_new.lfFont.lfCharSet, im_cur.lfFont.lfCharSet, "lfCharSet", "%d" );
1801 eq( im_new.lfFont.lfOutPrecision, im_cur.lfFont.lfOutPrecision, "lfOutPrecision", "%d" );
1802 eq( im_new.lfFont.lfClipPrecision, im_cur.lfFont.lfClipPrecision, "lfClipPrecision", "%d" );
1803 eq( im_new.lfFont.lfPitchAndFamily, im_cur.lfFont.lfPitchAndFamily, "lfPitchAndFamily", "%d" );
1804 eq( im_new.lfFont.lfQuality, im_cur.lfFont.lfQuality, "lfQuality", "%d" );
1805 ok( !strcmp( im_new.lfFont.lfFaceName, im_cur.lfFont.lfFaceName),
1806 "wrong facename \"%s\", should be \"%s\"\n", im_new.lfFont.lfFaceName,
1807 im_cur.lfFont.lfFaceName);
1808 /* test some system metrics */
1809 eq( GetSystemMetrics( SM_CXICONSPACING ),
1810 im_new.iHorzSpacing, "iHorzSpacing", "%d" );
1811 eq( GetSystemMetrics( SM_CYICONSPACING ),
1812 im_new.iVertSpacing, "iVertSpacing", "%d" );
1813 /* check some registry values */
1814 regval = metricfromreg( SPI_ICONHORIZONTALSPACING_REGKEY, SPI_ICONHORIZONTALSPACING_VALNAME, dpi);
1815 ok( regval==im_cur.iHorzSpacing, "wrong value in registry %d, expected %d\n", regval, im_cur.iHorzSpacing);
1816 regval = metricfromreg( SPI_ICONVERTICALSPACING_REGKEY, SPI_ICONVERTICALSPACING_VALNAME, dpi);
1817 ok( regval==im_cur.iVertSpacing, "wrong value in registry %d, expected %d\n", regval, im_cur.iVertSpacing);
1818 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY2, SPI_SETICONTITLEWRAP_VALNAME, dpi);
1819 if( regval != im_cur.iTitleWrap)
1820 regval = metricfromreg( SPI_SETICONTITLEWRAP_REGKEY1, SPI_SETICONTITLEWRAP_VALNAME, dpi);
1821 ok( regval==im_cur.iTitleWrap, "wrong value in registry %d, expected %d\n", regval, im_cur.iTitleWrap);
1822 /* test some values from other SPI_GETxxx calls */
1823 rc = SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
1824 ok( rc && spacing == im_cur.iHorzSpacing,
1825 "SystemParametersInfoA( SPI_ICONHORIZONTALSPACING...) failed or returns wrong value %d instead of %d\n",
1826 spacing, im_cur.iHorzSpacing);
1827 rc = SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
1828 ok( rc && spacing == im_cur.iVertSpacing,
1829 "SystemParametersInfoA( SPI_ICONVERTICALSPACING...) failed or returns wrong value %d instead of %d\n",
1830 spacing, im_cur.iVertSpacing);
1831 rc = SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &wrap, 0 );
1832 ok( rc && wrap == im_cur.iTitleWrap,
1833 "SystemParametersInfoA( SPI_GETICONTITLEWRAP...) failed or returns wrong value %d instead of %d\n",
1834 wrap, im_cur.iTitleWrap);
1835 /* restore old values */
1836 rc=SystemParametersInfoA( SPI_SETICONMETRICS, sizeof(ICONMETRICSA), &im_orig,SPIF_UPDATEINIFILE );
1837 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1838
1839 rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_new, FALSE );
1840 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1841
1842 eq( im_new.iHorzSpacing, im_orig.iHorzSpacing, "iHorzSpacing", "%d" );
1843 eq( im_new.iVertSpacing, im_orig.iVertSpacing, "iVertSpacing", "%d" );
1844 eq( im_new.iTitleWrap, im_orig.iTitleWrap, "iTitleWrap", "%d" );
1845 }
1846
1847 static void test_SPI_SETWORKAREA( void ) /* 47 */
1848 {
1849 BOOL rc;
1850 RECT old_area;
1851 RECT area;
1852 RECT curr_val;
1853
1854 trace("testing SPI_{GET,SET}WORKAREA\n");
1855 SetLastError(0xdeadbeef);
1856 rc=SystemParametersInfoA(SPI_GETWORKAREA, 0, &old_area, 0);
1857 if (!test_error_msg(rc,"SPI_{GET,SET}WORKAREA"))
1858 return;
1859
1860 /* Modify the work area only minimally as this causes the icons that
1861 * fall outside it to be moved around thus requiring the user to
1862 * reposition them manually one by one.
1863 * Changing the work area by just one pixel should make this occurrence
1864 * reasonably unlikely.
1865 */
1866 SetRect(&curr_val, old_area.left, old_area.top, old_area.right - 1, old_area.bottom - 1);
1867 rc=SystemParametersInfoA( SPI_SETWORKAREA, 0, &curr_val,
1868 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1869 if (!test_error_msg(rc,"SPI_SETWORKAREA")) return;
1870 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1871 rc=SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
1872 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1873 if( !EqualRect( &area, &curr_val)) /* no message if rect has not changed */
1874 test_change_message( SPI_SETWORKAREA, 0);
1875 eq( area.left, curr_val.left, "left", "%d" );
1876 eq( area.top, curr_val.top, "top", "%d" );
1877 /* size may be rounded */
1878 ok( area.right >= curr_val.right - 16 && area.right < curr_val.right + 16,
1879 "right: got %d instead of %d\n", area.right, curr_val.right );
1880 ok( area.bottom >= curr_val.bottom - 16 && area.bottom < curr_val.bottom + 16,
1881 "bottom: got %d instead of %d\n", area.bottom, curr_val.bottom );
1882 curr_val = area;
1883 rc=SystemParametersInfoA( SPI_SETWORKAREA, 0, &old_area,
1884 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1885 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1886 rc=SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
1887 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
1888 if( !EqualRect( &area, &curr_val)) /* no message if rect has not changed */
1889 test_change_message( SPI_SETWORKAREA, 0 );
1890 eq( area.left, old_area.left, "left", "%d" );
1891 eq( area.top, old_area.top, "top", "%d" );
1892 /* size may be rounded */
1893 ok( area.right >= old_area.right - 16 && area.right < old_area.right + 16,
1894 "right: got %d instead of %d\n", area.right, old_area.right );
1895 ok( area.bottom >= old_area.bottom - 16 && area.bottom < old_area.bottom + 16,
1896 "bottom: got %d instead of %d\n", area.bottom, old_area.bottom );
1897 }
1898
1899 static void test_SPI_SETSHOWSOUNDS( void ) /* 57 */
1900 {
1901 BOOL rc;
1902 BOOL old_b;
1903 const UINT vals[]={TRUE,FALSE};
1904 unsigned int i;
1905
1906 trace("testing SPI_{GET,SET}SHOWSOUNDS\n");
1907 SetLastError(0xdeadbeef);
1908 rc=SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &old_b, 0 );
1909 if (!test_error_msg(rc,"SPI_{GET,SET}SHOWSOUNDS"))
1910 return;
1911
1912 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1913 {
1914 UINT v;
1915
1916 rc=SystemParametersInfoA( SPI_SETSHOWSOUNDS, vals[i], 0,
1917 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1918 if (!test_error_msg(rc,"SPI_SETSHOWSOUNDS")) return;
1919 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1920 test_change_message( SPI_SETSHOWSOUNDS, 1 );
1921 test_reg_key( SPI_SETSHOWSOUNDS_REGKEY,
1922 SPI_SETSHOWSOUNDS_VALNAME,
1923 vals[i] ? "1" : "0" );
1924
1925 rc=SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &v, 0 );
1926 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1927 eq( v, vals[i], "SPI_GETSHOWSOUNDS", "%d" );
1928 eq( GetSystemMetrics( SM_SHOWSOUNDS ), (int)vals[i],
1929 "SM_SHOWSOUNDS", "%d" );
1930 }
1931
1932 rc=SystemParametersInfoA( SPI_SETSHOWSOUNDS, old_b, 0, SPIF_UPDATEINIFILE );
1933 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1934 }
1935
1936 static void test_SPI_SETKEYBOARDPREF( void ) /* 69 */
1937 {
1938 BOOL rc;
1939 BOOL old_b;
1940 const UINT vals[]={TRUE,FALSE};
1941 unsigned int i;
1942
1943 trace("testing SPI_{GET,SET}KEYBOARDPREF\n");
1944 SetLastError(0xdeadbeef);
1945 rc=SystemParametersInfoA( SPI_GETKEYBOARDPREF, 0, &old_b, 0 );
1946 if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDPREF"))
1947 return;
1948
1949 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1950 {
1951 BOOL v;
1952
1953 rc=SystemParametersInfoA( SPI_SETKEYBOARDPREF, vals[i], 0,
1954 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1955 if (!test_error_msg(rc,"SPI_SETKEYBOARDPREF")) return;
1956 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1957 test_change_message( SPI_SETKEYBOARDPREF, 1 );
1958 test_reg_key_ex2( SPI_SETKEYBOARDPREF_REGKEY, SPI_SETKEYBOARDPREF_REGKEY_LEGACY,
1959 SPI_SETKEYBOARDPREF_VALNAME, SPI_SETKEYBOARDPREF_VALNAME_LEGACY,
1960 vals[i] ? "1" : "0" );
1961
1962 rc=SystemParametersInfoA( SPI_GETKEYBOARDPREF, 0, &v, 0 );
1963 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1964 eq( v, (BOOL)vals[i], "SPI_GETKEYBOARDPREF", "%d" );
1965 }
1966
1967 rc=SystemParametersInfoA( SPI_SETKEYBOARDPREF, old_b, 0, SPIF_UPDATEINIFILE );
1968 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
1969 }
1970
1971 static void test_SPI_SETSCREENREADER( void ) /* 71 */
1972 {
1973 BOOL rc;
1974 BOOL old_b;
1975 const UINT vals[]={TRUE,FALSE};
1976 unsigned int i;
1977
1978 trace("testing SPI_{GET,SET}SCREENREADER\n");
1979 SetLastError(0xdeadbeef);
1980 rc=SystemParametersInfoA( SPI_GETSCREENREADER, 0, &old_b, 0 );
1981 if (!test_error_msg(rc,"SPI_{GET,SET}SCREENREADER"))
1982 return;
1983
1984 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1985 {
1986 BOOL v;
1987
1988 rc=SystemParametersInfoA( SPI_SETSCREENREADER, vals[i], 0,
1989 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1990 if (!test_error_msg(rc,"SPI_SETSCREENREADER")) return;
1991 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1992 test_change_message( SPI_SETSCREENREADER, 1 );
1993 test_reg_key_ex2_optional( SPI_SETSCREENREADER_REGKEY, SPI_SETSCREENREADER_REGKEY_LEGACY,
1994 SPI_SETSCREENREADER_VALNAME, SPI_SETSCREENREADER_VALNAME_LEGACY,
1995 vals[i] ? "1" : "0" );
1996
1997 rc=SystemParametersInfoA( SPI_GETSCREENREADER, 0, &v, 0 );
1998 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
1999 eq( v, (BOOL)vals[i], "SPI_GETSCREENREADER", "%d" );
2000 }
2001
2002 rc=SystemParametersInfoA( SPI_SETSCREENREADER, old_b, 0, SPIF_UPDATEINIFILE );
2003 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2004 }
2005
2006 static void test_SPI_SETFONTSMOOTHING( void ) /* 75 */
2007 {
2008 BOOL rc;
2009 BOOL old_b;
2010 DWORD old_type, old_contrast, old_orient;
2011 const UINT vals[]={0xffffffff,0,1,2};
2012 unsigned int i;
2013
2014 trace("testing SPI_{GET,SET}FONTSMOOTHING\n");
2015 SetLastError(0xdeadbeef);
2016 rc=SystemParametersInfoA( SPI_GETFONTSMOOTHING, 0, &old_b, 0 );
2017 if (!test_error_msg(rc,"SPI_{GET,SET}FONTSMOOTHING"))
2018 return;
2019 SystemParametersInfoA( SPI_GETFONTSMOOTHINGTYPE, 0, &old_type, 0 );
2020 SystemParametersInfoA( SPI_GETFONTSMOOTHINGCONTRAST, 0, &old_contrast, 0 );
2021 SystemParametersInfoA( SPI_GETFONTSMOOTHINGORIENTATION, 0, &old_orient, 0 );
2022
2023 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2024 {
2025 UINT v;
2026
2027 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHING, vals[i], 0,
2028 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2029 if (!test_error_msg(rc,"SPI_SETFONTSMOOTHING")) return;
2030 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2031 test_change_message( SPI_SETFONTSMOOTHING, 0 );
2032 test_reg_key( SPI_SETFONTSMOOTHING_REGKEY,
2033 SPI_SETFONTSMOOTHING_VALNAME,
2034 vals[i] ? "2" : "0" );
2035
2036 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGTYPE, 0, UlongToPtr(vals[i]),
2037 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2038 if (!test_error_msg(rc,"SPI_SETFONTSMOOTHINGTYPE")) return;
2039 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2040 test_change_message( SPI_SETFONTSMOOTHINGTYPE, 0 );
2041 test_reg_key_dword( SPI_SETFONTSMOOTHING_REGKEY,
2042 SPI_SETFONTSMOOTHINGTYPE_VALNAME, &vals[i] );
2043
2044 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGCONTRAST, 0, UlongToPtr(vals[i]),
2045 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2046 if (!test_error_msg(rc,"SPI_SETFONTSMOOTHINGCONTRAST")) return;
2047 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2048 test_change_message( SPI_SETFONTSMOOTHINGCONTRAST, 0 );
2049 test_reg_key_dword( SPI_SETFONTSMOOTHING_REGKEY,
2050 SPI_SETFONTSMOOTHINGCONTRAST_VALNAME, &vals[i] );
2051
2052 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGORIENTATION, 0, UlongToPtr(vals[i]),
2053 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2054 if (!test_error_msg(rc,"SPI_SETFONTSMOOTHINGORIENTATION")) return;
2055 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2056 test_change_message( SPI_SETFONTSMOOTHINGORIENTATION, 0 );
2057 test_reg_key_dword( SPI_SETFONTSMOOTHING_REGKEY,
2058 SPI_SETFONTSMOOTHINGORIENTATION_VALNAME, &vals[i] );
2059
2060 rc=SystemParametersInfoA( SPI_GETFONTSMOOTHING, 0, &v, 0 );
2061 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2062 eq( v, vals[i] ? 1 : 0, "SPI_GETFONTSMOOTHING", "%d" );
2063
2064 rc=SystemParametersInfoA( SPI_GETFONTSMOOTHINGTYPE, 0, &v, 0 );
2065 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2066 ok( v == vals[i], "wrong value %x/%x\n", v, vals[i] );
2067
2068 rc=SystemParametersInfoA( SPI_GETFONTSMOOTHINGCONTRAST, 0, &v, 0 );
2069 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2070 ok( v == vals[i], "wrong value %x/%x\n", v, vals[i] );
2071
2072 rc=SystemParametersInfoA( SPI_GETFONTSMOOTHINGORIENTATION, 0, &v, 0 );
2073 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2074 ok( v == vals[i], "wrong value %x/%x\n", v, vals[i] );
2075 }
2076
2077 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHING, old_b, 0, SPIF_UPDATEINIFILE );
2078 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2079 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGTYPE, old_type, 0, SPIF_UPDATEINIFILE );
2080 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2081 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGCONTRAST, old_contrast, 0, SPIF_UPDATEINIFILE );
2082 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2083 rc=SystemParametersInfoA( SPI_SETFONTSMOOTHINGORIENTATION, old_orient, 0, SPIF_UPDATEINIFILE );
2084 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2085 }
2086
2087 static void test_SPI_SETLOWPOWERACTIVE( void ) /* 85 */
2088 {
2089 BOOL rc;
2090 BOOL old_b;
2091 const UINT vals[]={TRUE,FALSE};
2092 unsigned int i;
2093
2094 trace("testing SPI_{GET,SET}LOWPOWERACTIVE\n");
2095 SetLastError(0xdeadbeef);
2096 rc=SystemParametersInfoA( SPI_GETLOWPOWERACTIVE, 0, &old_b, 0 );
2097 if (!test_error_msg(rc,"SPI_{GET,SET}LOWPOWERACTIVE"))
2098 return;
2099
2100 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2101 {
2102 UINT v;
2103
2104 rc=SystemParametersInfoA( SPI_SETLOWPOWERACTIVE, vals[i], 0,
2105 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2106 if (!test_error_msg(rc,"SPI_SETLOWPOWERACTIVE")) return;
2107 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2108 test_change_message( SPI_SETLOWPOWERACTIVE, 1 );
2109 test_reg_key_optional( SPI_SETLOWPOWERACTIVE_REGKEY,
2110 SPI_SETLOWPOWERACTIVE_VALNAME,
2111 vals[i] ? "1" : "0" );
2112
2113 /* SPI_SETLOWPOWERACTIVE is not persistent in win2k3 and above */
2114 v = 0xdeadbeef;
2115 rc=SystemParametersInfoA( SPI_GETLOWPOWERACTIVE, 0, &v, 0 );
2116 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2117 ok(v == vals[i] || v == 0, /* win2k3 */
2118 "SPI_GETLOWPOWERACTIVE: got %d instead of 0 or %d\n", v, vals[i]);
2119 }
2120
2121 rc=SystemParametersInfoA( SPI_SETLOWPOWERACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
2122 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2123 }
2124
2125 static void test_SPI_SETPOWEROFFACTIVE( void ) /* 86 */
2126 {
2127 BOOL rc;
2128 BOOL old_b;
2129 const UINT vals[]={TRUE,FALSE};
2130 unsigned int i;
2131
2132 trace("testing SPI_{GET,SET}POWEROFFACTIVE\n");
2133 SetLastError(0xdeadbeef);
2134 rc=SystemParametersInfoA( SPI_GETPOWEROFFACTIVE, 0, &old_b, 0 );
2135 if (!test_error_msg(rc,"SPI_{GET,SET}POWEROFFACTIVE"))
2136 return;
2137
2138 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2139 {
2140 UINT v;
2141
2142 rc=SystemParametersInfoA( SPI_SETPOWEROFFACTIVE, vals[i], 0,
2143 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2144 if (!test_error_msg(rc,"SPI_SETPOWEROFFACTIVE")) return;
2145 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2146 test_change_message( SPI_SETPOWEROFFACTIVE, 1 );
2147 test_reg_key_optional( SPI_SETPOWEROFFACTIVE_REGKEY,
2148 SPI_SETPOWEROFFACTIVE_VALNAME,
2149 vals[i] ? "1" : "0" );
2150
2151 /* SPI_SETPOWEROFFACTIVE is not persistent in win2k3 and above */
2152 v = 0xdeadbeef;
2153 rc=SystemParametersInfoA( SPI_GETPOWEROFFACTIVE, 0, &v, 0 );
2154 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2155 ok(v == vals[i] || v == 0, /* win2k3 */
2156 "SPI_GETPOWEROFFACTIVE: got %d instead of 0 or %d\n", v, vals[i]);
2157 }
2158
2159 rc=SystemParametersInfoA( SPI_SETPOWEROFFACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
2160 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2161 }
2162
2163 static void test_SPI_SETSNAPTODEFBUTTON( void ) /* 95 */
2164 {
2165 BOOL rc;
2166 BOOL old_b;
2167 const UINT vals[]={TRUE,FALSE};
2168 unsigned int i;
2169
2170 trace("testing SPI_{GET,SET}SNAPTODEFBUTTON\n");
2171 SetLastError(0xdeadbeef);
2172 rc=SystemParametersInfoA( SPI_GETSNAPTODEFBUTTON, 0, &old_b, 0 );
2173 if (!test_error_msg(rc,"SPI_GETSNAPTODEFBUTTON"))
2174 return;
2175
2176 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2177 {
2178 UINT v;
2179
2180 rc=SystemParametersInfoA( SPI_SETSNAPTODEFBUTTON, vals[i], 0,
2181 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2182 if (!test_error_msg(rc,"SPI_SETSNAPTODEFBUTTON")) return;
2183 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2184 test_change_message( SPI_SETSNAPTODEFBUTTON, 0 );
2185 test_reg_key_optional( SPI_SETSNAPTODEFBUTTON_REGKEY,
2186 SPI_SETSNAPTODEFBUTTON_VALNAME,
2187 vals[i] ? "1" : "0" );
2188
2189 rc=SystemParametersInfoA( SPI_GETSNAPTODEFBUTTON, 0, &v, 0 );
2190 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2191 eq( v, vals[i], "SPI_GETSNAPTODEFBUTTON", "%d" );
2192 }
2193
2194 rc=SystemParametersInfoA( SPI_SETSNAPTODEFBUTTON, old_b, 0, SPIF_UPDATEINIFILE );
2195 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2196 }
2197
2198 static void test_SPI_SETMOUSEHOVERWIDTH( void ) /* 99 */
2199 {
2200 BOOL rc;
2201 UINT old_width;
2202 const UINT vals[]={0,32767};
2203 unsigned int i;
2204
2205 trace("testing SPI_{GET,SET}MOUSEHOVERWIDTH\n");
2206 SetLastError(0xdeadbeef);
2207 rc=SystemParametersInfoA( SPI_GETMOUSEHOVERWIDTH, 0, &old_width, 0 );
2208 if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERWIDTH"))
2209 return;
2210
2211 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2212 {
2213 UINT v;
2214 char buf[10];
2215
2216 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERWIDTH, vals[i], 0,
2217 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2218 if (!test_error_msg(rc,"SPI_SETMOUSEHOVERWIDTH")) return;
2219 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2220 test_change_message( SPI_SETMOUSEHOVERWIDTH, 0 );
2221 sprintf( buf, "%d", vals[i] );
2222 test_reg_key( SPI_SETMOUSEHOVERWIDTH_REGKEY,
2223 SPI_SETMOUSEHOVERWIDTH_VALNAME, buf );
2224
2225 SystemParametersInfoA( SPI_GETMOUSEHOVERWIDTH, 0, &v, 0 );
2226 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2227 eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERWIDTH", "%d" );
2228 }
2229
2230 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERWIDTH, old_width, 0,
2231 SPIF_UPDATEINIFILE );
2232 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2233 }
2234
2235 static void test_SPI_SETMOUSEHOVERHEIGHT( void ) /* 101 */
2236 {
2237 BOOL rc;
2238 UINT old_height;
2239 const UINT vals[]={0,32767};
2240 unsigned int i;
2241
2242 trace("testing SPI_{GET,SET}MOUSEHOVERHEIGHT\n");
2243 SetLastError(0xdeadbeef);
2244 rc=SystemParametersInfoA( SPI_GETMOUSEHOVERHEIGHT, 0, &old_height, 0 );
2245 if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERHEIGHT"))
2246 return;
2247
2248 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2249 {
2250 UINT v;
2251 char buf[10];
2252
2253 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERHEIGHT, vals[i], 0,
2254 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2255 if (!test_error_msg(rc,"SPI_SETMOUSEHOVERHEIGHT")) return;
2256 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2257 test_change_message( SPI_SETMOUSEHOVERHEIGHT, 0 );
2258 sprintf( buf, "%d", vals[i] );
2259 test_reg_key( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
2260 SPI_SETMOUSEHOVERHEIGHT_VALNAME, buf );
2261
2262 SystemParametersInfoA( SPI_GETMOUSEHOVERHEIGHT, 0, &v, 0 );
2263 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2264 eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERHEIGHT", "%d" );
2265 }
2266
2267 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERHEIGHT, old_height, 0,
2268 SPIF_UPDATEINIFILE );
2269 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2270 }
2271
2272 static void test_SPI_SETMOUSEHOVERTIME( void ) /* 103 */
2273 {
2274 BOOL rc;
2275 UINT old_time;
2276
2277 /* Windows XP accepts 10 as the minimum hover time. Any value below will be
2278 * defaulted to a value of 10 automatically.
2279 */
2280 const UINT vals[]={10,32767};
2281 unsigned int i;
2282
2283 trace("testing SPI_{GET,SET}MOUSEHOVERTIME\n");
2284 SetLastError(0xdeadbeef);
2285 rc=SystemParametersInfoA( SPI_GETMOUSEHOVERTIME, 0, &old_time, 0 );
2286 if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERTIME"))
2287 return;
2288
2289 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2290 {
2291 UINT v;
2292 char buf[10];
2293
2294 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERTIME, vals[i], 0,
2295 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2296 if (!test_error_msg(rc,"SPI_SETMOUSEHOVERTIME")) return;
2297 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2298 test_change_message( SPI_SETMOUSEHOVERTIME, 0 );
2299 sprintf( buf, "%d", vals[i] );
2300 test_reg_key( SPI_SETMOUSEHOVERTIME_REGKEY,
2301 SPI_SETMOUSEHOVERTIME_VALNAME, buf );
2302
2303 SystemParametersInfoA( SPI_GETMOUSEHOVERTIME, 0, &v, 0 );
2304 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2305 eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERTIME", "%d" );
2306 }
2307
2308 rc=SystemParametersInfoA( SPI_SETMOUSEHOVERTIME, old_time, 0,
2309 SPIF_UPDATEINIFILE );
2310 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2311 }
2312
2313 static void test_SPI_SETWHEELSCROLLLINES( void ) /* 105 */
2314 {
2315 BOOL rc;
2316 UINT old_lines;
2317 const UINT vals[]={0,32767};
2318 unsigned int i;
2319
2320 trace("testing SPI_{GET,SET}WHEELSCROLLLINES\n");
2321 SetLastError(0xdeadbeef);
2322 rc=SystemParametersInfoA( SPI_GETWHEELSCROLLLINES, 0, &old_lines, 0 );
2323
2324 /* SPI_{GET,SET}WHEELSCROLLLINES not supported on Windows 95 */
2325 if (!test_error_msg(rc,"SPI_{GET,SET}WHEELSCROLLLINES"))
2326 return;
2327
2328 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2329 {
2330 UINT v;
2331 char buf[10];
2332
2333 rc=SystemParametersInfoA( SPI_SETWHEELSCROLLLINES, vals[i], 0,
2334 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2335 if (!test_error_msg(rc,"SPI_SETWHEELSCROLLLINES")) return;
2336 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2337 test_change_message( SPI_SETWHEELSCROLLLINES, 0 );
2338 sprintf( buf, "%d", vals[i] );
2339 test_reg_key( SPI_SETMOUSESCROLLLINES_REGKEY,
2340 SPI_SETMOUSESCROLLLINES_VALNAME, buf );
2341
2342 SystemParametersInfoA( SPI_GETWHEELSCROLLLINES, 0, &v, 0 );
2343 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2344 eq( v, vals[i], "SPI_{GET,SET}WHEELSCROLLLINES", "%d" );
2345 }
2346
2347 rc=SystemParametersInfoA( SPI_SETWHEELSCROLLLINES, old_lines, 0,
2348 SPIF_UPDATEINIFILE );
2349 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2350 }
2351
2352 static void test_SPI_SETMENUSHOWDELAY( void ) /* 107 */
2353 {
2354 BOOL rc;
2355 UINT old_delay;
2356 const UINT vals[]={0,32767};
2357 unsigned int i;
2358
2359 trace("testing SPI_{GET,SET}MENUSHOWDELAY\n");
2360 SetLastError(0xdeadbeef);
2361 rc=SystemParametersInfoA( SPI_GETMENUSHOWDELAY, 0, &old_delay, 0 );
2362
2363 /* SPI_{GET,SET}MENUSHOWDELAY not supported on Windows 95 */
2364 if (!test_error_msg(rc,"SPI_{GET,SET}MENUSHOWDELAY"))
2365 return;
2366
2367 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2368 {
2369 UINT v;
2370 char buf[10];
2371
2372 rc=SystemParametersInfoA( SPI_SETMENUSHOWDELAY, vals[i], 0,
2373 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2374 if (!test_error_msg(rc,"SPI_SETMENUSHOWDELAY")) return;
2375 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2376 test_change_message( SPI_SETMENUSHOWDELAY, 0 );
2377 sprintf( buf, "%d", vals[i] );
2378 test_reg_key( SPI_SETMENUSHOWDELAY_REGKEY,
2379 SPI_SETMENUSHOWDELAY_VALNAME, buf );
2380
2381 SystemParametersInfoA( SPI_GETMENUSHOWDELAY, 0, &v, 0 );
2382 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2383 eq( v, vals[i], "SPI_{GET,SET}MENUSHOWDELAY", "%d" );
2384 }
2385
2386 rc=SystemParametersInfoA( SPI_SETMENUSHOWDELAY, old_delay, 0,
2387 SPIF_UPDATEINIFILE );
2388 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2389 }
2390
2391 static void test_SPI_SETWHEELSCROLLCHARS( void ) /* 108 */
2392 {
2393 BOOL rc;
2394 UINT old_chars;
2395 const UINT vals[]={32767,0};
2396 unsigned int i;
2397
2398 trace("testing SPI_{GET,SET}WHEELSCROLLCHARS\n");
2399 SetLastError(0xdeadbeef);
2400 rc=SystemParametersInfoA( SPI_GETWHEELSCROLLCHARS, 0, &old_chars, 0 );
2401
2402 /* SPI_{GET,SET}WHEELSCROLLCHARS not supported on Windows 95 */
2403 if (!test_error_msg(rc,"SPI_{GET,SET}WHEELSCROLLCHARS"))
2404 return;
2405
2406 for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
2407 {
2408 UINT v;
2409 char buf[10];
2410
2411 rc=SystemParametersInfoA( SPI_SETWHEELSCROLLCHARS, vals[i], 0,
2412 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
2413 if (!test_error_msg(rc,"SPI_SETWHEELSCROLLCHARS")) return;
2414 test_change_message( SPI_SETWHEELSCROLLCHARS, 0 );
2415 sprintf( buf, "%d", vals[i] );
2416 test_reg_key( SPI_SETMOUSESCROLLCHARS_REGKEY,
2417 SPI_SETMOUSESCROLLCHARS_VALNAME, buf );
2418
2419 SystemParametersInfoA( SPI_GETWHEELSCROLLCHARS, 0, &v, 0 );
2420 ok(rc, "%d: rc=%d err=%d\n", i, rc, GetLastError());
2421 eq( v, vals[i], "SPI_{GET,SET}WHEELSCROLLCHARS", "%d" );
2422 }
2423
2424 rc=SystemParametersInfoA( SPI_SETWHEELSCROLLCHARS, old_chars, 0,
2425 SPIF_UPDATEINIFILE );
2426 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2427 }
2428
2429 static void test_SPI_SETWALLPAPER( void ) /* 115 */
2430 {
2431 BOOL rc;
2432 char oldval[260];
2433 char newval[260];
2434
2435 trace("testing SPI_{GET,SET}DESKWALLPAPER\n");
2436 SetLastError(0xdeadbeef);
2437 rc=SystemParametersInfoA(SPI_GETDESKWALLPAPER, 260, oldval, 0);
2438 if (!test_error_msg(rc,"SPI_{GET,SET}DESKWALLPAPER"))
2439 return;
2440
2441 strcpy(newval, "");
2442 rc=SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, newval, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
2443 if (!test_error_msg(rc,"SPI_SETDESKWALLPAPER")) return;
2444 ok(rc, "SystemParametersInfoA: rc=%d err=%d\n", rc, GetLastError());
2445 test_change_message(SPI_SETDESKWALLPAPER, 0);
2446
2447 rc=SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, oldval, SPIF_UPDATEINIFILE);
2448 ok(rc, "***warning*** failed to restore the original value: rc=%d err=%d\n", rc, GetLastError());
2449
2450 test_reg_key(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, oldval);
2451 }
2452
2453 static void test_WM_DISPLAYCHANGE(void)
2454 {
2455 DEVMODEA mode, startmode;
2456 int start_bpp, last_set_bpp = 0;
2457 int test_bpps[] = {8, 16, 24, 32}, i;
2458 LONG change_ret;
2459 DWORD wait_ret;
2460
2461 if (!pChangeDisplaySettingsExA)
2462 {
2463 win_skip("ChangeDisplaySettingsExA is not available\n");
2464 return;
2465 }
2466
2467 displaychange_test_active = TRUE;
2468
2469 memset(&startmode, 0, sizeof(startmode));
2470 startmode.dmSize = sizeof(startmode);
2471 EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &startmode);
2472 start_bpp = startmode.dmBitsPerPel;
2473
2474 displaychange_sem = CreateSemaphoreW(NULL, 0, 1, NULL);
2475
2476 for(i = 0; i < sizeof(test_bpps)/sizeof(test_bpps[0]); i++) {
2477 last_bpp = -1;
2478
2479 memset(&mode, 0, sizeof(mode));
2480 mode.dmSize = sizeof(mode);
2481 mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
2482 mode.dmBitsPerPel = test_bpps[i];
2483 mode.dmPelsWidth = GetSystemMetrics(SM_CXSCREEN);
2484 mode.dmPelsHeight = GetSystemMetrics(SM_CYSCREEN);
2485
2486 change_counter = 0; /* This sends a SETTINGSCHANGE message as well in which we aren't interested */
2487 displaychange_ok = TRUE;
2488 change_ret = pChangeDisplaySettingsExA(NULL, &mode, NULL, 0, NULL);
2489 /* Wait quite long for the message, screen setting changes can take some time */
2490 if(change_ret == DISP_CHANGE_SUCCESSFUL) {
2491 wait_ret = WaitForSingleObject(displaychange_sem, 10000);
2492 /* we may not get a notification if nothing changed */
2493 if (wait_ret == WAIT_TIMEOUT && !last_set_bpp && start_bpp == test_bpps[i])
2494 continue;
2495 ok(wait_ret == WAIT_OBJECT_0, "Waiting for the WM_DISPLAYCHANGE message timed out\n");
2496 }
2497 displaychange_ok = FALSE;
2498
2499 if(change_ret != DISP_CHANGE_SUCCESSFUL) {
2500 skip("Setting depth %d failed(ret = %d)\n", test_bpps[i], change_ret);
2501 ok(last_bpp == -1, "WM_DISPLAYCHANGE was sent with wParam %d despite mode change failure\n", last_bpp);
2502 continue;
2503 }
2504
2505 todo_wine_if(start_bpp != test_bpps[i]) {
2506 ok(last_bpp == test_bpps[i], "Set bpp %d, but WM_DISPLAYCHANGE reported bpp %d\n", test_bpps[i], last_bpp);
2507 }
2508 last_set_bpp = test_bpps[i];
2509 }
2510
2511 if(start_bpp != last_set_bpp && last_set_bpp != 0) {
2512 memset(&mode, 0, sizeof(mode));
2513 mode.dmSize = sizeof(mode);
2514 mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
2515 mode.dmBitsPerPel = start_bpp;
2516 mode.dmPelsWidth = GetSystemMetrics(SM_CXSCREEN);
2517 mode.dmPelsHeight = GetSystemMetrics(SM_CYSCREEN);
2518
2519 displaychange_ok = TRUE;
2520 change_ret = pChangeDisplaySettingsExA(NULL, &mode, NULL, 0, NULL);
2521 WaitForSingleObject(displaychange_sem, 10000);
2522 displaychange_ok = FALSE;
2523 CloseHandle(displaychange_sem);
2524 displaychange_sem = 0;
2525 }
2526
2527 displaychange_test_active = FALSE;
2528 }
2529
2530 /*
2531 * Registry entries for the system parameters.
2532 * Names are created by 'SET' flags names.
2533 * We assume that corresponding 'GET' entries use the same registry keys.
2534 */
2535 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam )
2536 {
2537 test_SPI_SETBEEP(); /* 1 */
2538 test_SPI_SETMOUSE(); /* 4 */
2539 test_SPI_SETBORDER(); /* 6 */
2540 test_SPI_SETKEYBOARDSPEED(); /* 10 */
2541 test_SPI_ICONHORIZONTALSPACING(); /* 13 */
2542 test_SPI_SETSCREENSAVETIMEOUT(); /* 14 */
2543 test_SPI_SETSCREENSAVEACTIVE(); /* 17 */
2544 test_SPI_SETGRIDGRANULARITY(); /* 19 */
2545 test_SPI_SETKEYBOARDDELAY(); /* 23 */
2546 test_SPI_ICONVERTICALSPACING(); /* 24 */
2547 test_SPI_SETICONTITLEWRAP(); /* 26 */
2548 test_SPI_SETMENUDROPALIGNMENT(); /* 28 */
2549 test_SPI_SETDOUBLECLKWIDTH(); /* 29 */
2550 test_SPI_SETDOUBLECLKHEIGHT(); /* 30 */
2551 test_SPI_SETDOUBLECLICKTIME(); /* 32 */
2552 test_SPI_SETMOUSEBUTTONSWAP(); /* 33 */
2553 test_SPI_SETFASTTASKSWITCH(); /* 36 */
2554 test_SPI_SETDRAGFULLWINDOWS(); /* 37 */
2555 /* test_WM_DISPLAYCHANGE seems to be somewhat buggy on
2556 * some versions of Windows (Vista, Win2k8, Win7B) in that
2557 * not all metrics are properly restored. Problems are
2558 * SM_CXMAXTRACK, SM_CYMAXTRACK
2559 * Fortunately setting the Non-Client metrics like in
2560 * test_SPI_SETNONCLIENTMETRICS will correct this. That is why
2561 * we do the DISPLAY change now... */
2562 test_WM_DISPLAYCHANGE();
2563 test_SPI_SETNONCLIENTMETRICS(); /* 42 */
2564 test_SPI_SETMINIMIZEDMETRICS(); /* 44 */
2565 test_SPI_SETICONMETRICS(); /* 46 */
2566 test_SPI_SETWORKAREA(); /* 47 */
2567 test_SPI_SETSHOWSOUNDS(); /* 57 */
2568 test_SPI_SETKEYBOARDPREF(); /* 69 */
2569 test_SPI_SETSCREENREADER(); /* 71 */
2570 test_SPI_SETFONTSMOOTHING(); /* 75 */
2571 test_SPI_SETLOWPOWERACTIVE(); /* 85 */
2572 test_SPI_SETPOWEROFFACTIVE(); /* 86 */
2573 test_SPI_SETSNAPTODEFBUTTON(); /* 95 */
2574 test_SPI_SETMOUSEHOVERWIDTH(); /* 99 */
2575 test_SPI_SETMOUSEHOVERHEIGHT(); /* 101 */
2576 test_SPI_SETMOUSEHOVERTIME(); /* 103 */
2577 test_SPI_SETWHEELSCROLLLINES(); /* 105 */
2578 test_SPI_SETMENUSHOWDELAY(); /* 107 */
2579 test_SPI_SETWHEELSCROLLCHARS(); /* 108 */
2580 test_SPI_SETWALLPAPER(); /* 115 */
2581
2582
2583 SendMessageA( ghTestWnd, WM_DESTROY, 0, 0 );
2584 return 0;
2585 }
2586
2587 /* test calculation of GetSystemMetrics values (mostly) from non client metrics,
2588 * icon metrics and minimized metrics.
2589 */
2590
2591 /* copied from wine's GdiGetCharDimensions, which is not available on most
2592 * windows versions */
2593 static LONG _GdiGetCharDimensions(HDC hdc, LPTEXTMETRICA lptm, LONG *height)
2594 {
2595 SIZE sz;
2596 static const CHAR alphabet[] = {
2597 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
2598 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
2599 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
2600
2601 if(lptm && !GetTextMetricsA(hdc, lptm)) return 0;
2602
2603 if(!GetTextExtentPointA(hdc, alphabet, 52, &sz)) return 0;
2604
2605 if (height) *height = sz.cy;
2606 return (sz.cx / 26 + 1) / 2;
2607 }
2608
2609 /* get text metrics and/or "average" char width of the specified logfont
2610 * for the specified dc */
2611 static void get_text_metr_size( HDC hdc, LOGFONTA *plf, TEXTMETRICA * ptm, UINT *psz)
2612 {
2613 HFONT hfont, hfontsav;
2614 TEXTMETRICA tm;
2615 if( !ptm) ptm = &tm;
2616 hfont = CreateFontIndirectA( plf);
2617 if( !hfont || ( hfontsav = SelectObject( hdc, hfont)) == NULL ) {
2618 ptm->tmHeight = -1;
2619 if( psz) *psz = 10;
2620 if( hfont) DeleteObject( hfont);
2621 return;
2622 }
2623 GetTextMetricsA( hdc, ptm);
2624 if( psz)
2625 if( !(*psz = _GdiGetCharDimensions( hdc, ptm, NULL)))
2626 *psz = 10;
2627 SelectObject( hdc, hfontsav);
2628 DeleteObject( hfont);
2629 }
2630
2631 static int gsm_error_ctr;
2632
2633 #define ok_gsm( i, e)\
2634 {\
2635 int exp = (e);\
2636 int act = GetSystemMetrics( (i));\
2637 if( exp != act) gsm_error_ctr++;\
2638 ok( !( exp != act),"GetSystemMetrics(%s): expected %d actual %d\n", #i, exp,act);\
2639 }
2640 #define ok_gsm_2( i, e1, e2)\
2641 {\
2642 int exp1 = (e1);\
2643 int exp2 = (e2);\
2644 int act = GetSystemMetrics( (i));\
2645 if( exp1 != act && exp2 != act) gsm_error_ctr++;\
2646 ok( !( exp1 != act && exp2 != act), "GetSystemMetrics(%s): expected %d or %d actual %d\n", #i, exp1, exp2, act);\
2647 }
2648 #define ok_gsm_3( i, e1, e2, e3)\
2649 {\
2650 int exp1 = (e1);\
2651 int exp2 = (e2);\
2652 int exp3 = (e3);\
2653 int act = GetSystemMetrics( (i));\
2654 if( exp1 != act && exp2 != act && exp3 != act) gsm_error_ctr++;\
2655 ok( !( exp1 != act && exp2 != act && exp3 != act),"GetSystemMetrics(%s): expected %d or %d or %d actual %d\n", #i, exp1, exp2, exp3, act);\
2656 }
2657
2658 static INT CALLBACK enum_all_fonts_proc(const LOGFONTA *elf, const TEXTMETRICA *ntm, DWORD type, LPARAM lparam)
2659 {
2660 return lstrcmpiA(elf->lfFaceName, (const char *)lparam);
2661 }
2662
2663 static BOOL is_font_enumerated(const char *name)
2664 {
2665 HDC hdc = CreateCompatibleDC(0);
2666 BOOL ret = FALSE;
2667
2668 if (!EnumFontFamiliesA(hdc, NULL, enum_all_fonts_proc, (LPARAM)name))
2669 ret = TRUE;
2670
2671 DeleteDC(hdc);
2672 return ret;
2673 }
2674
2675 static int get_cursor_size( int size )
2676 {
2677 /* only certain sizes are allowed for cursors */
2678 if (size >= 64) return 64;
2679 if (size >= 48) return 48;
2680 return 32;
2681 }
2682
2683 static void test_GetSystemMetrics( void)
2684 {
2685 TEXTMETRICA tmMenuFont;
2686 UINT IconSpacing, IconVerticalSpacing;
2687 BOOL rc;
2688
2689 HDC hdc = CreateICA( "Display", 0, 0, 0);
2690 UINT avcwCaption;
2691 INT CaptionWidthfromreg, smicon, broken_val;
2692 MINIMIZEDMETRICS minim;
2693 NONCLIENTMETRICSA ncm;
2694 SIZE screen;
2695
2696 assert(sizeof(ncm) == 344);
2697
2698 ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
2699 rc = SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
2700 ok(rc, "SystemParametersInfoA failed\n");
2701
2702 ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth) - 1;
2703 rc = SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
2704 ok(!rc, "SystemParametersInfoA should fail\n");
2705
2706 ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth) + 1;
2707 SetLastError(0xdeadbeef);
2708 rc = SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
2709 ok(!rc, "SystemParametersInfoA should fail\n");
2710
2711 ncm.cbSize = sizeof(ncm); /* Vista added padding */
2712 SetLastError(0xdeadbeef);
2713 ncm.iPaddedBorderWidth = 0xcccc;
2714 rc = SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
2715 ok(rc || broken(!rc) /* before Vista */, "SystemParametersInfoA failed\n");
2716 if (rc) ok( ncm.iPaddedBorderWidth == 0, "wrong iPaddedBorderWidth %u\n", ncm.iPaddedBorderWidth );
2717
2718 minim.cbSize = sizeof( minim);
2719 ncm.cbSize = FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth);
2720 SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, 0, &minim, 0);
2721 rc = SystemParametersInfoA( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
2722 if( !rc) {
2723 win_skip("SPI_GETNONCLIENTMETRICS is not available\n");
2724 return;
2725 }
2726
2727 ok(is_font_enumerated(ncm.lfCaptionFont.lfFaceName), "font %s should be enumerated\n", ncm.lfCaptionFont.lfFaceName);
2728 ok(is_font_enumerated(ncm.lfSmCaptionFont.lfFaceName), "font %s should be enumerated\n", ncm.lfSmCaptionFont.lfFaceName);
2729 ok(is_font_enumerated(ncm.lfMenuFont.lfFaceName), "font %s should be enumerated\n", ncm.lfMenuFont.lfFaceName);
2730 ok(is_font_enumerated(ncm.lfStatusFont.lfFaceName), "font %s should be enumerated\n", ncm.lfStatusFont.lfFaceName);
2731 ok(is_font_enumerated(ncm.lfMessageFont.lfFaceName), "font %s should be enumerated\n", ncm.lfMessageFont.lfFaceName);
2732
2733 /* CaptionWidth from the registry may have different value of iCaptionWidth
2734 * from the non client metrics (observed on WinXP) */
2735 CaptionWidthfromreg = metricfromreg(
2736 "Control Panel\\Desktop\\WindowMetrics","CaptionWidth", dpi);
2737 get_text_metr_size( hdc, &ncm.lfMenuFont, &tmMenuFont, NULL);
2738 get_text_metr_size( hdc, &ncm.lfCaptionFont, NULL, &avcwCaption);
2739 /* FIXME: use icon metric */
2740 if( !SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &IconVerticalSpacing, 0))
2741 IconVerticalSpacing = 0;
2742 if( !SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &IconSpacing, 0 ))
2743 IconSpacing = 0;
2744 /* reset error counters */
2745 gsm_error_ctr = 0;
2746
2747 /* the tests: */
2748
2749 /* SM_CXSCREEN, cannot test these two */
2750 /* SM_CYSCREEN */
2751 ok_gsm( SM_CXVSCROLL, ncm.iScrollWidth);
2752 ok_gsm( SM_CYHSCROLL, ncm.iScrollWidth);
2753 ok_gsm( SM_CYCAPTION, ncm.iCaptionHeight+1);
2754 ok_gsm( SM_CXBORDER, 1);
2755 ok_gsm( SM_CYBORDER, 1);
2756 ok_gsm( SM_CXDLGFRAME, 3);
2757 ok_gsm( SM_CYDLGFRAME, 3);
2758 ok_gsm( SM_CYVTHUMB, ncm.iScrollHeight);
2759 ok_gsm( SM_CXHTHUMB, ncm.iScrollHeight);
2760 /* These don't depend on the Shell Icon Size registry value */
2761 ok_gsm( SM_CXICON, MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI ) );
2762 ok_gsm( SM_CYICON, MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI ) );
2763 ok_gsm( SM_CXCURSOR, get_cursor_size( MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI )));
2764 ok_gsm( SM_CYCURSOR, get_cursor_size( MulDiv( 32, dpi, USER_DEFAULT_SCREEN_DPI )));
2765 ok_gsm( SM_CYMENU, ncm.iMenuHeight + 1);
2766 ok_gsm( SM_CXFULLSCREEN,
2767 GetSystemMetrics( SM_CXMAXIMIZED) - 2 * GetSystemMetrics( SM_CXFRAME));
2768 ok_gsm( SM_CYFULLSCREEN,
2769 GetSystemMetrics( SM_CYMAXIMIZED) - GetSystemMetrics( SM_CYMIN));
2770 /* SM_CYKANJIWINDOW */
2771 /* SM_MOUSEPRESENT */
2772 ok_gsm( SM_CYVSCROLL, ncm.iScrollHeight);
2773 ok_gsm( SM_CXHSCROLL, ncm.iScrollHeight);
2774 /* SM_DEBUG */
2775 /* SM_SWAPBUTTON */
2776 /* SM_RESERVED1 */
2777 /* SM_RESERVED2 */
2778 /* SM_RESERVED3 */
2779 /* SM_RESERVED4 */
2780 ok_gsm( SM_CXMIN, 3 * max( CaptionWidthfromreg >= 0 ? CaptionWidthfromreg : ncm.iCaptionWidth, 8) +
2781 GetSystemMetrics( SM_CYSIZE) + 4 + 4 * avcwCaption + 2 * GetSystemMetrics( SM_CXFRAME));
2782 ok_gsm( SM_CYMIN, GetSystemMetrics( SM_CYCAPTION) +
2783 2 * GetSystemMetrics( SM_CYFRAME));
2784 ok_gsm_2( SM_CXSIZE,
2785 ncm.iCaptionWidth, /* classic/standard windows style */
2786 GetSystemMetrics( SM_CYCAPTION) - 1 /* WinXP style */
2787 );
2788 ok_gsm( SM_CYSIZE, ncm.iCaptionHeight);
2789 ok_gsm( SM_CXFRAME, ncm.iBorderWidth + 3);
2790 ok_gsm( SM_CYFRAME, ncm.iBorderWidth + 3);
2791 ok_gsm( SM_CXMINTRACK, GetSystemMetrics( SM_CXMIN));
2792 ok_gsm( SM_CYMINTRACK, GetSystemMetrics( SM_CYMIN));
2793 /* SM_CXDOUBLECLK */
2794 /* SM_CYDOUBLECLK */
2795 if( IconSpacing) ok_gsm( SM_CXICONSPACING, IconSpacing);
2796 if( IconVerticalSpacing) ok_gsm( SM_CYICONSPACING, IconVerticalSpacing);
2797 /* SM_MENUDROPALIGNMENT */
2798 /* SM_PENWINDOWS */
2799 /* SM_DBCSENABLED */
2800 /* SM_CMOUSEBUTTONS */
2801 /* SM_SECURE */
2802 ok_gsm( SM_CXEDGE, 2);
2803 ok_gsm( SM_CYEDGE, 2);
2804 /* sign-extension for iHorzGap/iVertGap is broken on Win9x */
2805 ok_gsm( SM_CXMINSPACING, GetSystemMetrics( SM_CXMINIMIZED) + (short)minim.iHorzGap );
2806 ok_gsm( SM_CYMINSPACING, GetSystemMetrics( SM_CYMINIMIZED) + (short)minim.iVertGap );
2807
2808 smicon = MulDiv( 16, dpi, USER_DEFAULT_SCREEN_DPI );
2809 if (!pIsProcessDPIAware || pIsProcessDPIAware())
2810 smicon = max( min( smicon, CaptionWidthfromreg - 2), 4 ) & ~1;
2811 todo_wine_if( real_dpi == dpi && smicon != (MulDiv( 16, dpi, USER_DEFAULT_SCREEN_DPI) & ~1) )
2812 {
2813 broken_val = (min( ncm.iCaptionHeight, CaptionWidthfromreg ) - 2) & ~1;
2814 broken_val = min( broken_val, 20 );
2815
2816 if (smicon == 4)
2817 {
2818 ok_gsm_2( SM_CXSMICON, smicon, 6 );
2819 ok_gsm_2( SM_CYSMICON, smicon, 6 );
2820 }
2821 else if (smicon < broken_val)
2822 {
2823 ok_gsm_2( SM_CXSMICON, smicon, broken_val );
2824 ok_gsm_2( SM_CYSMICON, smicon, broken_val );
2825 }
2826 else
2827 {
2828 ok_gsm( SM_CXSMICON, smicon );
2829 ok_gsm( SM_CYSMICON, smicon );
2830 }
2831 }
2832
2833 ok_gsm( SM_CYSMCAPTION, ncm.iSmCaptionHeight + 1);
2834 ok_gsm_3( SM_CXSMSIZE,
2835 ncm.iSmCaptionWidth, /* classic/standard windows style */
2836 GetSystemMetrics( SM_CYSMCAPTION) - 1, /* WinXP style */
2837 smcxsmsize /* winXP seems to cache this value: setnonclientmetric
2838 does not change it */
2839 );
2840 ok_gsm( SM_CYSMSIZE, GetSystemMetrics( SM_CYSMCAPTION) - 1);
2841 ok_gsm( SM_CXMENUSIZE, ncm.iMenuWidth);
2842 ok_gsm( SM_CYMENUSIZE, ncm.iMenuHeight);
2843 /* SM_ARRANGE */
2844 ok_gsm( SM_CXMINIMIZED, minim.iWidth + 6);
2845 ok_gsm( SM_CYMINIMIZED, GetSystemMetrics( SM_CYCAPTION) + 5);
2846 screen.cx = GetSystemMetrics( SM_CXVIRTUALSCREEN );
2847 screen.cy = GetSystemMetrics( SM_CYVIRTUALSCREEN );
2848 if (!screen.cx || !screen.cy) /* not supported on NT4 */
2849 {
2850 screen.cx = GetSystemMetrics( SM_CXSCREEN );
2851 screen.cy = GetSystemMetrics( SM_CYSCREEN );
2852 }
2853 ok_gsm_3( SM_CXMAXTRACK, screen.cx + 4 + 2 * GetSystemMetrics(SM_CXFRAME),
2854 screen.cx - 4 + 2 * GetSystemMetrics(SM_CXFRAME), /* Vista */
2855 screen.cx + 2 * GetSystemMetrics(SM_CXFRAME)); /* Win8 */
2856 ok_gsm_3( SM_CYMAXTRACK, screen.cy + 4 + 2 * GetSystemMetrics(SM_CYFRAME),
2857 screen.cy - 4 + 2 * GetSystemMetrics(SM_CYFRAME), /* Vista */
2858 screen.cy + 2 * GetSystemMetrics(SM_CYFRAME)); /* Win8 */
2859 /* the next two cannot really be tested as they depend on (application)
2860 * toolbars */
2861 /* SM_CXMAXIMIZED */
2862 /* SM_CYMAXIMIZED */
2863 /* SM_NETWORK */
2864 /* */
2865 /* */
2866 /* */
2867 /* SM_CLEANBOOT */
2868 /* SM_CXDRAG */
2869 /* SM_CYDRAG */
2870 /* SM_SHOWSOUNDS */
2871 ok_gsm( SM_CXMENUCHECK,
2872 ((tmMenuFont.tmHeight + tmMenuFont.tmExternalLeading+1)/2)*2-1);
2873 ok_gsm( SM_CYMENUCHECK,
2874 ((tmMenuFont.tmHeight + tmMenuFont.tmExternalLeading+1)/2)*2-1);
2875 /* SM_SLOWMACHINE */
2876 /* SM_MIDEASTENABLED */
2877 /* SM_MOUSEWHEELPRESENT */
2878 /* SM_XVIRTUALSCREEN */
2879 /* SM_YVIRTUALSCREEN */
2880 /* SM_CXVIRTUALSCREEN */
2881 /* SM_CYVIRTUALSCREEN */
2882 /* SM_CMONITORS */
2883 /* SM_SAMEDISPLAYFORMAT */
2884 /* SM_IMMENABLED */
2885 /* SM_CXFOCUSBORDER */
2886 /* SM_CYFOCUSBORDER */
2887 /* SM_TABLETPC */
2888 /* SM_MEDIACENTER */
2889 /* SM_CMETRICS */
2890 /* end of tests */
2891 if( gsm_error_ctr ) { /* if any errors where found */
2892 trace( "BorderWidth %d CaptionWidth %d CaptionHeight %d IconSpacing %d IconVerticalSpacing %d\n",
2893 ncm.iBorderWidth, ncm.iCaptionWidth, ncm.iCaptionHeight, IconSpacing, IconVerticalSpacing);
2894 trace( "MenuHeight %d MenuWidth %d ScrollHeight %d ScrollWidth %d SmCaptionHeight %d SmCaptionWidth %d\n",
2895 ncm.iMenuHeight, ncm.iMenuWidth, ncm.iScrollHeight, ncm.iScrollWidth, ncm.iSmCaptionHeight, ncm.iSmCaptionWidth);
2896 trace( "Captionfontchar width %d MenuFont %d,%d CaptionWidth from registry: %d screen %d,%d\n",
2897 avcwCaption, tmMenuFont.tmHeight, tmMenuFont.tmExternalLeading, CaptionWidthfromreg, screen.cx, screen.cy);
2898 }
2899
2900 DeleteDC(hdc);
2901 }
2902
2903 static void test_EnumDisplaySettings(void)
2904 {
2905 DEVMODEA devmode;
2906 DWORD val;
2907 HDC hdc;
2908 DWORD num;
2909
2910 memset(&devmode, 0, sizeof(devmode));
2911 EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &devmode);
2912
2913 hdc = GetDC(0);
2914 val = GetDeviceCaps(hdc, BITSPIXEL);
2915 ok(devmode.dmBitsPerPel == val,
2916 "GetDeviceCaps(BITSPIXEL) returned %d, EnumDisplaySettings returned %d\n",
2917 val, devmode.dmBitsPerPel);
2918
2919 val = GetDeviceCaps(hdc, NUMCOLORS);
2920 if(devmode.dmBitsPerPel <= 8) {
2921 ok(val == 256, "Screen bpp is %d, NUMCOLORS returned %d\n", devmode.dmBitsPerPel, val);
2922 } else {
2923 ok(val == -1, "Screen bpp is %d, NUMCOLORS returned %d\n", devmode.dmBitsPerPel, val);
2924 }
2925
2926 ReleaseDC(0, hdc);
2927
2928 num = 1;
2929 while (1) {
2930 SetLastError (0xdeadbeef);
2931 if (!EnumDisplaySettingsA(NULL, num, &devmode)) {
2932 DWORD le = GetLastError();
2933 ok(le == ERROR_NO_MORE_FILES ||
2934 le == ERROR_MOD_NOT_FOUND /* Win8 */ ||
2935 le == 0xdeadbeef, /* XP, 2003 */
2936 "Expected ERROR_NO_MORE_FILES, ERROR_MOD_NOT_FOUND or 0xdeadbeef, got %d for %d\n", le, num);
2937 break;
2938 }
2939 num++;
2940 }
2941 }
2942
2943 static void test_GetSysColorBrush(void)
2944 {
2945 HBRUSH hbr;
2946
2947 SetLastError(0xdeadbeef);
2948 hbr = GetSysColorBrush(-1);
2949 ok(hbr == NULL, "Expected NULL brush\n");
2950 ok(GetLastError() == 0xdeadbeef, "Expected last error not set, got %x\n", GetLastError());
2951 /* greater than max index */
2952 hbr = GetSysColorBrush(COLOR_MENUBAR);
2953 if (hbr)
2954 {
2955 SetLastError(0xdeadbeef);
2956 hbr = GetSysColorBrush(COLOR_MENUBAR + 1);
2957 ok(hbr == NULL, "Expected NULL brush\n");
2958 ok(GetLastError() == 0xdeadbeef, "Expected last error not set, got %x\n", GetLastError());
2959 }
2960 else
2961 win_skip("COLOR_MENUBAR unsupported\n");
2962 }
2963
2964 static void test_dpi_stock_objects( HDC hdc )
2965 {
2966 DPI_AWARENESS_CONTEXT context;
2967 HGDIOBJ obj[STOCK_LAST + 1], obj2[STOCK_LAST + 1];
2968 LOGFONTW lf, lf2;
2969 UINT i, dpi;
2970
2971 context = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
2972 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
2973 ok( dpi == USER_DEFAULT_SCREEN_DPI, "wrong dpi %u\n", dpi );
2974 ok( !pIsProcessDPIAware(), "not aware\n" );
2975 for (i = 0; i <= STOCK_LAST; i++) obj[i] = GetStockObject( i );
2976
2977 pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
2978 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
2979 ok( dpi == real_dpi, "wrong dpi %u\n", dpi );
2980 ok( pIsProcessDPIAware(), "not aware\n" );
2981 for (i = 0; i <= STOCK_LAST; i++) obj2[i] = GetStockObject( i );
2982
2983 for (i = 0; i <= STOCK_LAST; i++)
2984 {
2985 switch (i)
2986 {
2987 case OEM_FIXED_FONT:
2988 case SYSTEM_FIXED_FONT:
2989 ok( obj[i] != obj2[i], "%u: same object\n", i );
2990 break;
2991 case SYSTEM_FONT:
2992 case DEFAULT_GUI_FONT:
2993 ok( obj[i] != obj2[i], "%u: same object\n", i );
2994 GetObjectW( obj[i], sizeof(lf), &lf );
2995 GetObjectW( obj2[i], sizeof(lf2), &lf2 );
2996 ok( lf.lfHeight == MulDiv( lf2.lfHeight, USER_DEFAULT_SCREEN_DPI, real_dpi ),
2997 "%u: wrong height %d / %d\n", i, lf.lfHeight, lf2.lfHeight );
2998 break;
2999 default:
3000 ok( obj[i] == obj2[i], "%u: different object\n", i );
3001 break;
3002 }
3003 }
3004
3005 pSetThreadDpiAwarenessContext( context );
3006 }
3007
3008 static void test_dpi_aware(void)
3009 {
3010 BOOL ret;
3011
3012 if (!pIsProcessDPIAware)
3013 {
3014 win_skip("IsProcessDPIAware not available\n");
3015 return;
3016 }
3017
3018 if (pSetProcessDpiAwarenessContext)
3019 {
3020 DPI_AWARENESS awareness;
3021 DPI_AWARENESS_CONTEXT context;
3022 ULONG_PTR i;
3023 UINT dpi;
3024 HDC hdc = GetDC( 0 );
3025
3026 context = pGetThreadDpiAwarenessContext();
3027 todo_wine
3028 ok( context == (DPI_AWARENESS_CONTEXT)0x10, "wrong context %p\n", context );
3029 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3030 todo_wine
3031 ok( awareness == DPI_AWARENESS_UNAWARE, "wrong awareness %u\n", awareness );
3032 todo_wine
3033 ok( !pIsProcessDPIAware(), "already aware\n" );
3034 dpi = pGetDpiForSystem();
3035 todo_wine_if (real_dpi != USER_DEFAULT_SCREEN_DPI)
3036 ok( dpi == USER_DEFAULT_SCREEN_DPI, "wrong dpi %u\n", dpi );
3037 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
3038 todo_wine_if (real_dpi != USER_DEFAULT_SCREEN_DPI)
3039 ok( dpi == USER_DEFAULT_SCREEN_DPI, "wrong dpi %u\n", dpi );
3040 SetLastError( 0xdeadbeef );
3041 ret = pSetProcessDpiAwarenessContext( NULL );
3042 ok( !ret, "got %d\n", ret );
3043 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3044 SetLastError( 0xdeadbeef );
3045 ret = pSetProcessDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)-5 );
3046 ok( !ret, "got %d\n", ret );
3047 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3048 ret = pSetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
3049 ok( ret, "got %d\n", ret );
3050 ok( pIsProcessDPIAware(), "not aware\n" );
3051 real_dpi = pGetDpiForSystem();
3052 SetLastError( 0xdeadbeef );
3053 ret = pSetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
3054 ok( !ret, "got %d\n", ret );
3055 ok( GetLastError() == ERROR_ACCESS_DENIED, "wrong error %u\n", GetLastError() );
3056 SetLastError( 0xdeadbeef );
3057 ret = pSetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
3058 ok( !ret, "got %d\n", ret );
3059 ok( GetLastError() == ERROR_ACCESS_DENIED, "wrong error %u\n", GetLastError() );
3060
3061 ret = pSetProcessDpiAwarenessInternal( DPI_AWARENESS_INVALID );
3062 ok( !ret, "got %d\n", ret );
3063 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3064 ret = pSetProcessDpiAwarenessInternal( DPI_AWARENESS_UNAWARE );
3065 ok( !ret, "got %d\n", ret );
3066 ok( GetLastError() == ERROR_ACCESS_DENIED, "wrong error %u\n", GetLastError() );
3067 ret = pGetProcessDpiAwarenessInternal( 0, &awareness );
3068 ok( ret, "got %d\n", ret );
3069 ok( awareness == DPI_AWARENESS_SYSTEM_AWARE, "wrong value %d\n", awareness );
3070 ret = pGetProcessDpiAwarenessInternal( GetCurrentProcess(), &awareness );
3071 ok( ret, "got %d\n", ret );
3072 ok( awareness == DPI_AWARENESS_SYSTEM_AWARE, "wrong value %d\n", awareness );
3073 ret = pGetProcessDpiAwarenessInternal( (HANDLE)0xdeadbeef, &awareness );
3074 ok( ret, "got %d\n", ret );
3075 ok( awareness == DPI_AWARENESS_UNAWARE, "wrong value %d\n", awareness );
3076
3077 ret = pIsProcessDPIAware();
3078 ok(ret, "got %d\n", ret);
3079 context = pGetThreadDpiAwarenessContext();
3080 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3081 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3082 ok( awareness == DPI_AWARENESS_SYSTEM_AWARE, "wrong awareness %u\n", awareness );
3083 SetLastError( 0xdeadbeef );
3084 context = pSetThreadDpiAwarenessContext( 0 );
3085 ok( !context, "got %p\n", context );
3086 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3087 SetLastError( 0xdeadbeef );
3088 context = pSetThreadDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)-5 );
3089 ok( !context, "got %p\n", context );
3090 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3091 context = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
3092 ok( context == (DPI_AWARENESS_CONTEXT)0x80000011, "wrong context %p\n", context );
3093 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3094 ok( awareness == DPI_AWARENESS_SYSTEM_AWARE, "wrong awareness %u\n", awareness );
3095 dpi = pGetDpiForSystem();
3096 ok( dpi == USER_DEFAULT_SCREEN_DPI, "wrong dpi %u\n", dpi );
3097 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
3098 ok( dpi == USER_DEFAULT_SCREEN_DPI, "wrong dpi %u\n", dpi );
3099 ok( !pIsProcessDPIAware(), "still aware\n" );
3100 context = pGetThreadDpiAwarenessContext();
3101 ok( context == (DPI_AWARENESS_CONTEXT)0x10, "wrong context %p\n", context );
3102 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3103 ok( awareness == DPI_AWARENESS_UNAWARE, "wrong awareness %u\n", awareness );
3104 context = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE );
3105 ok( context == (DPI_AWARENESS_CONTEXT)0x10, "wrong context %p\n", context );
3106 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3107 ok( awareness == DPI_AWARENESS_UNAWARE, "wrong awareness %u\n", awareness );
3108 dpi = pGetDpiForSystem();
3109 ok( dpi == real_dpi, "wrong dpi %u/%u\n", dpi, real_dpi );
3110 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
3111 ok( dpi == real_dpi, "wrong dpi %u\n", dpi );
3112 context = pGetThreadDpiAwarenessContext();
3113 ok( context == (DPI_AWARENESS_CONTEXT)0x12, "wrong context %p\n", context );
3114 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3115 ok( awareness == DPI_AWARENESS_PER_MONITOR_AWARE, "wrong awareness %u\n", awareness );
3116 context = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
3117 ok( context == (DPI_AWARENESS_CONTEXT)0x12, "wrong context %p\n", context );
3118 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3119 ok( awareness == DPI_AWARENESS_PER_MONITOR_AWARE, "wrong awareness %u\n", awareness );
3120 dpi = pGetDpiForSystem();
3121 ok( dpi == real_dpi, "wrong dpi %u/%u\n", dpi, real_dpi );
3122 dpi = GetDeviceCaps( hdc, LOGPIXELSX );
3123 ok( dpi == real_dpi, "wrong dpi %u\n", dpi );
3124 ok( pIsProcessDPIAware(), "not aware\n" );
3125 context = pGetThreadDpiAwarenessContext();
3126 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3127 context = pSetThreadDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)0x80000010 );
3128 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3129 context = pGetThreadDpiAwarenessContext();
3130 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3131 context = pSetThreadDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)0x80000011 );
3132 ok( context == (DPI_AWARENESS_CONTEXT)0x80000011, "wrong context %p\n", context );
3133 context = pGetThreadDpiAwarenessContext();
3134 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3135 context = pSetThreadDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)0x12 );
3136 ok( context == (DPI_AWARENESS_CONTEXT)0x80000011, "wrong context %p\n", context );
3137 context = pSetThreadDpiAwarenessContext( context );
3138 ok( context == (DPI_AWARENESS_CONTEXT)0x12, "wrong context %p\n", context );
3139 context = pGetThreadDpiAwarenessContext();
3140 ok( context == (DPI_AWARENESS_CONTEXT)0x11, "wrong context %p\n", context );
3141 for (i = 0; i < 0x100; i++)
3142 {
3143 awareness = pGetAwarenessFromDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)i );
3144 switch (i)
3145 {
3146 case 0x10:
3147 case 0x11:
3148 case 0x12:
3149 ok( awareness == (i & ~0x10), "%lx: wrong value %u\n", i, awareness );
3150 ok( pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)i ), "%lx: not valid\n", i );
3151 break;
3152 default:
3153 ok( awareness == DPI_AWARENESS_INVALID, "%lx: wrong value %u\n", i, awareness );
3154 ok( !pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)i ), "%lx: valid\n", i );
3155 break;
3156 }
3157 awareness = pGetAwarenessFromDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)(i | 0x80000000) );
3158 switch (i)
3159 {
3160 case 0x10:
3161 case 0x11:
3162 case 0x12:
3163 ok( awareness == (i & ~0x10), "%lx: wrong value %u\n", i | 0x80000000, awareness );
3164 ok( pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)(i | 0x80000000) ),
3165 "%lx: not valid\n", i | 0x80000000 );
3166 break;
3167 default:
3168 ok( awareness == DPI_AWARENESS_INVALID, "%lx: wrong value %u\n", i | 0x80000000, awareness );
3169 ok( !pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)(i | 0x80000000) ),
3170 "%lx: valid\n", i | 0x80000000 );
3171 break;
3172 }
3173 awareness = pGetAwarenessFromDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)~i );
3174 switch (~i)
3175 {
3176 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE:
3177 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE:
3178 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE:
3179 ok( awareness == i, "%lx: wrong value %u\n", ~i, awareness );
3180 ok( pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)~i ), "%lx: not valid\n", ~i );
3181 break;
3182 default:
3183 ok( awareness == DPI_AWARENESS_INVALID, "%lx: wrong value %u\n", ~i, awareness );
3184 ok( !pIsValidDpiAwarenessContext( (DPI_AWARENESS_CONTEXT)~i ), "%lx: valid\n", ~i );
3185 break;
3186 }
3187 }
3188 if (real_dpi != USER_DEFAULT_SCREEN_DPI) test_dpi_stock_objects( hdc );
3189 ReleaseDC( 0, hdc );
3190 }
3191 else win_skip( "SetProcessDpiAwarenessContext not supported\n" );
3192
3193 ret = pSetProcessDPIAware();
3194 ok(ret, "got %d\n", ret);
3195
3196 ret = pIsProcessDPIAware();
3197 ok(ret, "got %d\n", ret);
3198
3199 if (pGetDpiForSystem) real_dpi = pGetDpiForSystem();
3200 dpi = real_dpi;
3201 test_GetSystemMetrics();
3202 }
3203
3204 static void test_window_dpi(void)
3205 {
3206 DPI_AWARENESS_CONTEXT context, orig;
3207 DPI_AWARENESS awareness;
3208 HWND hwnd;
3209
3210 if (!pGetWindowDpiAwarenessContext)
3211 {
3212 win_skip( "GetWindowDpiAwarenessContext not supported\n" );
3213 return;
3214 }
3215 orig = pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
3216 hwnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
3217 WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL );
3218 ok( hwnd != 0, "failed to create window\n" );
3219 context = pGetWindowDpiAwarenessContext( hwnd );
3220 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3221 ok( awareness == DPI_AWARENESS_UNAWARE, "wrong awareness %u\n", awareness );
3222 DestroyWindow( hwnd );
3223
3224 pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_SYSTEM_AWARE );
3225 hwnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
3226 WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL );
3227 ok( hwnd != 0, "failed to create window\n" );
3228 context = pGetWindowDpiAwarenessContext( hwnd );
3229 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3230 ok( awareness == DPI_AWARENESS_SYSTEM_AWARE, "wrong awareness %u\n", awareness );
3231 DestroyWindow( hwnd );
3232
3233 pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE );
3234 hwnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
3235 WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL );
3236 ok( hwnd != 0, "failed to create window\n" );
3237 context = pGetWindowDpiAwarenessContext( hwnd );
3238 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3239 ok( awareness == DPI_AWARENESS_PER_MONITOR_AWARE, "wrong awareness %u\n", awareness );
3240 DestroyWindow( hwnd );
3241
3242 SetLastError( 0xdeadbeef );
3243 context = pGetWindowDpiAwarenessContext( (HWND)0xdeadbeef );
3244 ok( !context, "got %p\n", context );
3245 ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
3246
3247 SetLastError( 0xdeadbeef );
3248 context = pGetWindowDpiAwarenessContext( GetDesktopWindow() );
3249 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3250 ok( awareness == DPI_AWARENESS_PER_MONITOR_AWARE, "wrong awareness %u\n", awareness );
3251
3252 pSetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_UNAWARE );
3253 SetLastError( 0xdeadbeef );
3254 context = pGetWindowDpiAwarenessContext( GetDesktopWindow() );
3255 awareness = pGetAwarenessFromDpiAwarenessContext( context );
3256 ok( awareness == DPI_AWARENESS_PER_MONITOR_AWARE, "wrong awareness %u\n", awareness );
3257
3258 pSetThreadDpiAwarenessContext( orig );
3259 }
3260
3261 START_TEST(sysparams)
3262 {
3263 int argc;
3264 char** argv;
3265 WNDCLASSA wc;
3266 MSG msg;
3267 HDC hdc;
3268 HANDLE hThread;
3269 DWORD dwThreadId;
3270 HANDLE hInstance, hdll;
3271
3272 hdll = GetModuleHandleA("user32.dll");
3273 pChangeDisplaySettingsExA = (void*)GetProcAddress(hdll, "ChangeDisplaySettingsExA");
3274 pIsProcessDPIAware = (void*)GetProcAddress(hdll, "IsProcessDPIAware");
3275 pSetProcessDPIAware = (void*)GetProcAddress(hdll, "SetProcessDPIAware");
3276 pGetDpiForSystem = (void*)GetProcAddress(hdll, "GetDpiForSystem");
3277 pSetProcessDpiAwarenessContext = (void*)GetProcAddress(hdll, "SetProcessDpiAwarenessContext");
3278 pGetProcessDpiAwarenessInternal = (void*)GetProcAddress(hdll, "GetProcessDpiAwarenessInternal");
3279 pSetProcessDpiAwarenessInternal = (void*)GetProcAddress(hdll, "SetProcessDpiAwarenessInternal");
3280 pGetThreadDpiAwarenessContext = (void*)GetProcAddress(hdll, "GetThreadDpiAwarenessContext");
3281 pSetThreadDpiAwarenessContext = (void*)GetProcAddress(hdll, "SetThreadDpiAwarenessContext");
3282 pGetWindowDpiAwarenessContext = (void*)GetProcAddress(hdll, "GetWindowDpiAwarenessContext");
3283 pGetAwarenessFromDpiAwarenessContext = (void*)GetProcAddress(hdll, "GetAwarenessFromDpiAwarenessContext");
3284 pIsValidDpiAwarenessContext = (void*)GetProcAddress(hdll, "IsValidDpiAwarenessContext");
3285
3286 hInstance = GetModuleHandleA( NULL );
3287 hdc = GetDC(0);
3288 dpi = GetDeviceCaps( hdc, LOGPIXELSY);
3289 real_dpi = get_real_dpi();
3290 trace("dpi %d real_dpi %d\n", dpi, real_dpi);
3291 ReleaseDC( 0, hdc);
3292
3293 /* This test requires interactivity, if we don't have it, give up */
3294 if (!SystemParametersInfoA( SPI_SETBEEP, TRUE, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE ) &&
3295 GetLastError()==ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION) return;
3296
3297 argc = winetest_get_mainargs(&argv);
3298 strict=(argc >= 3 && strcmp(argv[2],"strict")==0);
3299 trace("strict=%d\n",strict);
3300
3301 trace("testing GetSystemMetrics with your current desktop settings\n");
3302 test_GetSystemMetrics( );
3303 trace("testing EnumDisplaySettings vs GetDeviceCaps\n");
3304 test_EnumDisplaySettings( );
3305 test_GetSysColorBrush( );
3306
3307 change_counter = 0;
3308 change_last_param = 0;
3309
3310 wc.lpszClassName = "SysParamsTestClass";
3311 wc.lpfnWndProc = SysParamsTestWndProc;
3312 wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
3313 wc.hInstance = hInstance;
3314 wc.hIcon = LoadIconA( 0, (LPCSTR)IDI_APPLICATION );
3315 wc.hCursor = LoadCursorA( 0, (LPCSTR)IDC_ARROW );
3316 wc.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
3317 wc.lpszMenuName = 0;
3318 wc.cbClsExtra = 0;
3319 wc.cbWndExtra = 0;
3320 RegisterClassA( &wc );
3321
3322 ghTestWnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
3323 WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, hInstance, NULL );
3324
3325 hThread = CreateThread( NULL, 0, SysParamsThreadFunc, 0, 0, &dwThreadId );
3326 assert( hThread );
3327 CloseHandle( hThread );
3328
3329 while( GetMessageA( &msg, 0, 0, 0 )) {
3330 TranslateMessage( &msg );
3331 DispatchMessageA( &msg );
3332 }
3333
3334 test_dpi_aware();
3335 test_window_dpi();
3336 }
Windows API implementation