rostests/winetests/user32/sysparams.c

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