git.oblomov.eu Git - wine/blob - windows/sysparams.c

   1 /*
   2  * System parameters functions
   3  *
   4  * Copyright 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winnls.h"
  30 #include "wingdi.h"
  31 #include "winreg.h"
  32 #include "wine/winuser16.h"
  33 #include "winerror.h"
  34
  35 #include "controls.h"
  36 #include "user.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(system);
  40
  41 /* System parameter indexes */
  42 #define SPI_SETBEEP_IDX                         0
  43 #define SPI_SETMOUSE_IDX                        1
  44 #define SPI_SETBORDER_IDX                       2
  45 #define SPI_SETKEYBOARDSPEED_IDX                3
  46 #define SPI_ICONHORIZONTALSPACING_IDX           4
  47 #define SPI_SETSCREENSAVETIMEOUT_IDX            5
  48 #define SPI_SETGRIDGRANULARITY_IDX              6
  49 #define SPI_SETKEYBOARDDELAY_IDX                7
  50 #define SPI_ICONVERTICALSPACING_IDX             8
  51 #define SPI_SETICONTITLEWRAP_IDX                9
  52 #define SPI_SETMENUDROPALIGNMENT_IDX            10
  53 #define SPI_SETDOUBLECLKWIDTH_IDX               11
  54 #define SPI_SETDOUBLECLKHEIGHT_IDX              12
  55 #define SPI_SETDOUBLECLICKTIME_IDX              13
  56 #define SPI_SETMOUSEBUTTONSWAP_IDX              14
  57 #define SPI_SETDRAGFULLWINDOWS_IDX              15
  58 #define SPI_SETWORKAREA_IDX                     16
  59 #define SPI_SETSHOWSOUNDS_IDX                   17
  60 #define SPI_SETKEYBOARDPREF_IDX                 18
  61 #define SPI_SETSCREENREADER_IDX                 19
  62 #define SPI_SETSCREENSAVERRUNNING_IDX           20
  63 #define SPI_WINE_IDX                            SPI_SETSCREENSAVERRUNNING_IDX
  64
  65 /**
  66  * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
  67  * for the system parameters.
  68  * Names of the keys are created by adding string "_REGKEY" to
  69  * "SET" action names, value names are created by adding "_REG_NAME"
  70  * to the "SET" action name.
  71  */
  72 #define SPI_SETBEEP_REGKEY              "Control Panel\\Sound"
  73 #define SPI_SETBEEP_VALNAME             "Beep"
  74 #define SPI_SETMOUSE_REGKEY             "Control Panel\\Mouse"
  75 #define SPI_SETMOUSE_VALNAME1           "MouseThreshold1"
  76 #define SPI_SETMOUSE_VALNAME2           "MouseThreshold2"
  77 #define SPI_SETMOUSE_VALNAME3           "MouseSpeed"
  78 #define SPI_SETBORDER_REGKEY            "Control Panel\\Desktop"
  79 #define SPI_SETBORDER_VALNAME           "BorderWidth"
  80 #define SPI_SETKEYBOARDSPEED_REGKEY             "Control Panel\\Keyboard"
  81 #define SPI_SETKEYBOARDSPEED_VALNAME            "KeyboardSpeed"
  82 #define SPI_ICONHORIZONTALSPACING_REGKEY        "Control Panel\\Desktop\\WindowMetrics"
  83 #define SPI_ICONHORIZONTALSPACING_VALNAME       "IconSpacing"
  84 #define SPI_SETSCREENSAVETIMEOUT_REGKEY         "Control Panel\\Desktop"
  85 #define SPI_SETSCREENSAVETIMEOUT_VALNAME        "ScreenSaveTimeOut"
  86 #define SPI_SETSCREENSAVEACTIVE_REGKEY          "Control Panel\\Desktop"
  87 #define SPI_SETSCREENSAVEACTIVE_VALNAME         "ScreenSaveActive"
  88 #define SPI_SETGRIDGRANULARITY_REGKEY           "Control Panel\\Desktop"
  89 #define SPI_SETGRIDGRANULARITY_VALNAME          "GridGranularity"
  90 #define SPI_SETKEYBOARDDELAY_REGKEY             "Control Panel\\Keyboard"
  91 #define SPI_SETKEYBOARDDELAY_VALNAME            "KeyboardDelay"
  92 #define SPI_ICONVERTICALSPACING_REGKEY          "Control Panel\\Desktop\\WindowMetrics"
  93 #define SPI_ICONVERTICALSPACING_VALNAME         "IconVerticalSpacing"
  94 #define SPI_SETICONTITLEWRAP_REGKEY1            "Control Panel\\Desktop\\WindowMetrics"
  95 #define SPI_SETICONTITLEWRAP_REGKEY2            "Control Panel\\Desktop"
  96 #define SPI_SETICONTITLEWRAP_VALNAME            "IconTitleWrap"
  97 #define SPI_SETMENUDROPALIGNMENT_REGKEY1        "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
  98 #define SPI_SETMENUDROPALIGNMENT_REGKEY2        "Control Panel\\Desktop"
  99 #define SPI_SETMENUDROPALIGNMENT_VALNAME        "MenuDropAlignment"
 100 #define SPI_SETDOUBLECLKWIDTH_REGKEY1           "Control Panel\\Mouse"
 101 #define SPI_SETDOUBLECLKWIDTH_REGKEY2           "Control Panel\\Desktop"
 102 #define SPI_SETDOUBLECLKWIDTH_VALNAME           "DoubleClickWidth"
 103 #define SPI_SETDOUBLECLKHEIGHT_REGKEY1          "Control Panel\\Mouse"
 104 #define SPI_SETDOUBLECLKHEIGHT_REGKEY2          "Control Panel\\Desktop"
 105 #define SPI_SETDOUBLECLKHEIGHT_VALNAME          "DoubleClickHeight"
 106 #define SPI_SETDOUBLECLICKTIME_REGKEY           "Control Panel\\Mouse"
 107 #define SPI_SETDOUBLECLICKTIME_VALNAME          "DoubleClickSpeed"
 108 #define SPI_SETMOUSEBUTTONSWAP_REGKEY           "Control Panel\\Mouse"
 109 #define SPI_SETMOUSEBUTTONSWAP_VALNAME          "SwapMouseButtons"
 110 #define SPI_SETDRAGFULLWINDOWS_REGKEY           "Control Panel\\Desktop"
 111 #define SPI_SETDRAGFULLWINDOWS_VALNAME          "DragFullWindows"
 112 #define SPI_SETWORKAREA_REGKEY                  "Control Panel\\Desktop"
 113 #define SPI_SETWORKAREA_VALNAME                 "WINE_WorkArea"
 114 #define SPI_SETSHOWSOUNDS_REGKEY        "Control Panel\\Accessibility\\ShowSounds"
 115 #define SPI_SETSHOWSOUNDS_VALNAME       "On"
 116 #define SPI_SETDESKWALLPAPER_REGKEY     "Control Panel\\Desktop"
 117 #define SPI_SETDESKWALLPAPER_VALNAME    "Wallpaper"
 118 /* FIXME - real values */
 119 #define SPI_SETKEYBOARDPREF_REGKEY      "Control Panel\\Desktop"
 120 #define SPI_SETKEYBOARDPREF_VALNAME     "WINE_KeyboardPref"
 121 #define SPI_SETSCREENREADER_REGKEY      "Control Panel\\Desktop"
 122 #define SPI_SETSCREENREADER_VALNAME     "WINE_ScreenReader"
 123 #define SPI_SETSCREENSAVERRUNNING_REGKEY        "Control Panel\\Desktop"
 124 #define SPI_SETSCREENSAVERRUNNING_VALNAME       "WINE_ScreenSaverRunning"
 125
 126 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
 127 #define WINE_CURRENT_USER_REGKEY     "Wine"
 128
 129 /* Indicators whether system parameter value is loaded */
 130 static char spi_loaded[SPI_WINE_IDX + 1];
 131
 132 static BOOL notify_change = TRUE;
 133
 134 /* System parameters storage */
 135 static BOOL beep_active = TRUE;
 136 static int mouse_threshold1 = 6;
 137 static int mouse_threshold2 = 10;
 138 static int mouse_speed = 1;
 139 static int border = 1;
 140 static int keyboard_speed = 31;
 141 static int screensave_timeout = 300;
 142 static int grid_granularity = 0;
 143 static int keyboard_delay = 1;
 144 static BOOL icon_title_wrap = TRUE;
 145 static int double_click_time = 500;
 146 static BOOL drag_full_windows = FALSE;
 147 static RECT work_area;
 148 static BOOL keyboard_pref = TRUE;
 149 static BOOL screen_reader = FALSE;
 150 static BOOL screensaver_running = FALSE;
 151
 152 /***********************************************************************
 153  *              GetTimerResolution (USER.14)
 154  */
 155 LONG WINAPI GetTimerResolution16(void)
 156 {
 157         return (1000);
 158 }
 159
 160 /***********************************************************************
 161  *              ControlPanelInfo (USER.273)
 162  */
 163 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
 164 {
 165         FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
 166 }
 167
 168 /* This function is a copy of the one in objects/font.c */
 169 static void SYSPARAMS_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
 170 {
 171     font16->lfHeight = font32->lfHeight;
 172     font16->lfWidth = font32->lfWidth;
 173     font16->lfEscapement = font32->lfEscapement;
 174     font16->lfOrientation = font32->lfOrientation;
 175     font16->lfWeight = font32->lfWeight;
 176     font16->lfItalic = font32->lfItalic;
 177     font16->lfUnderline = font32->lfUnderline;
 178     font16->lfStrikeOut = font32->lfStrikeOut;
 179     font16->lfCharSet = font32->lfCharSet;
 180     font16->lfOutPrecision = font32->lfOutPrecision;
 181     font16->lfClipPrecision = font32->lfClipPrecision;
 182     font16->lfQuality = font32->lfQuality;
 183     font16->lfPitchAndFamily = font32->lfPitchAndFamily;
 184     lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
 185 }
 186
 187 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
 188 {
 189     font32W->lfHeight = font32A->lfHeight;
 190     font32W->lfWidth = font32A->lfWidth;
 191     font32W->lfEscapement = font32A->lfEscapement;
 192     font32W->lfOrientation = font32A->lfOrientation;
 193     font32W->lfWeight = font32A->lfWeight;
 194     font32W->lfItalic = font32A->lfItalic;
 195     font32W->lfUnderline = font32A->lfUnderline;
 196     font32W->lfStrikeOut = font32A->lfStrikeOut;
 197     font32W->lfCharSet = font32A->lfCharSet;
 198     font32W->lfOutPrecision = font32A->lfOutPrecision;
 199     font32W->lfClipPrecision = font32A->lfClipPrecision;
 200     font32W->lfQuality = font32A->lfQuality;
 201     font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
 202     MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
 203     font32W->lfFaceName[LF_FACESIZE-1] = 0;
 204 }
 205
 206 static void SYSPARAMS_NonClientMetrics32ATo16( const NONCLIENTMETRICSA* lpnm32, LPNONCLIENTMETRICS16 lpnm16 )
 207 {
 208     lpnm16->iBorderWidth        = lpnm32->iBorderWidth;
 209     lpnm16->iScrollWidth        = lpnm32->iScrollWidth;
 210     lpnm16->iScrollHeight       = lpnm32->iScrollHeight;
 211     lpnm16->iCaptionWidth       = lpnm32->iCaptionWidth;
 212     lpnm16->iCaptionHeight      = lpnm32->iCaptionHeight;
 213     SYSPARAMS_LogFont32ATo16( &lpnm32->lfCaptionFont,   &lpnm16->lfCaptionFont );
 214     lpnm16->iSmCaptionWidth     = lpnm32->iSmCaptionWidth;
 215     lpnm16->iSmCaptionHeight    = lpnm32->iSmCaptionHeight;
 216     SYSPARAMS_LogFont32ATo16( &lpnm32->lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
 217     lpnm16->iMenuWidth          = lpnm32->iMenuWidth;
 218     lpnm16->iMenuHeight         = lpnm32->iMenuHeight;
 219     SYSPARAMS_LogFont32ATo16( &lpnm32->lfMenuFont,      &lpnm16->lfMenuFont );
 220     SYSPARAMS_LogFont32ATo16( &lpnm32->lfStatusFont,    &lpnm16->lfStatusFont );
 221     SYSPARAMS_LogFont32ATo16( &lpnm32->lfMessageFont,   &lpnm16->lfMessageFont );
 222 }
 223
 224 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
 225 {
 226     lpnm32W->iBorderWidth       = lpnm32A->iBorderWidth;
 227     lpnm32W->iScrollWidth       = lpnm32A->iScrollWidth;
 228     lpnm32W->iScrollHeight      = lpnm32A->iScrollHeight;
 229     lpnm32W->iCaptionWidth      = lpnm32A->iCaptionWidth;
 230     lpnm32W->iCaptionHeight     = lpnm32A->iCaptionHeight;
 231     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfCaptionFont,         &lpnm32W->lfCaptionFont );
 232     lpnm32W->iSmCaptionWidth    = lpnm32A->iSmCaptionWidth;
 233     lpnm32W->iSmCaptionHeight   = lpnm32A->iSmCaptionHeight;
 234     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont,       &lpnm32W->lfSmCaptionFont );
 235     lpnm32W->iMenuWidth         = lpnm32A->iMenuWidth;
 236     lpnm32W->iMenuHeight        = lpnm32A->iMenuHeight;
 237     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont,            &lpnm32W->lfMenuFont );
 238     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont,          &lpnm32W->lfStatusFont );
 239     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont,         &lpnm32W->lfMessageFont );
 240 }
 241
 242 /***********************************************************************
 243  *           SYSPARAMS_Reset
 244  *
 245  * Sets the system parameter which should be always loaded to
 246  * current value stored in registry.
 247  * Invalidates lazy loaded parameter, so it will be loaded the next time
 248  * it is requested.
 249  *
 250  * Parameters:
 251  * uiAction - system parameter to reload value for.
 252  *      Note, only "SET" values can be used for this parameter.
 253  *      If uiAction is 0 all system parameters are reset.
 254  */
 255 void SYSPARAMS_Reset( UINT uiAction )
 256 {
 257 #define WINE_RELOAD_SPI(x) \
 258     case x: \
 259         spi_loaded[x##_IDX] = FALSE; \
 260         SystemParametersInfoA( x, 0, dummy_buf, 0 );\
 261         if (uiAction) \
 262             break
 263
 264 #define WINE_IGNORE_SPI(x) \
 265     case x: \
 266         if (uiAction) \
 267             break
 268
 269 #define WINE_INVALIDATE_SPI(x) \
 270     case x: \
 271         spi_loaded[x##_IDX] = FALSE; \
 272         break
 273
 274     BOOL not_all_processed = TRUE;
 275     char dummy_buf[10];
 276
 277     /* Execution falls through all the branches for uiAction == 0 */
 278     switch (uiAction)
 279     {
 280     case 0:
 281         memset( spi_loaded, 0, sizeof(spi_loaded) );
 282
 283     WINE_RELOAD_SPI(SPI_SETBORDER);
 284     WINE_RELOAD_SPI(SPI_ICONHORIZONTALSPACING);
 285     WINE_RELOAD_SPI(SPI_ICONVERTICALSPACING);
 286     WINE_IGNORE_SPI(SPI_SETSCREENSAVEACTIVE);
 287     WINE_RELOAD_SPI(SPI_SETDOUBLECLKWIDTH);
 288     WINE_RELOAD_SPI(SPI_SETDOUBLECLKHEIGHT);
 289     WINE_RELOAD_SPI(SPI_SETMOUSEBUTTONSWAP);
 290     WINE_RELOAD_SPI(SPI_SETSHOWSOUNDS);
 291     WINE_RELOAD_SPI(SPI_SETMENUDROPALIGNMENT);
 292
 293     default:
 294         if (uiAction)
 295         {
 296             /* lazy loaded parameters */
 297             switch (uiAction)
 298             {
 299             WINE_INVALIDATE_SPI(SPI_SETBEEP);
 300             WINE_INVALIDATE_SPI(SPI_SETMOUSE);
 301             WINE_INVALIDATE_SPI(SPI_SETKEYBOARDSPEED);
 302             WINE_INVALIDATE_SPI(SPI_SETSCREENSAVETIMEOUT);
 303             WINE_INVALIDATE_SPI(SPI_SETGRIDGRANULARITY);
 304             WINE_INVALIDATE_SPI(SPI_SETKEYBOARDDELAY);
 305             WINE_INVALIDATE_SPI(SPI_SETICONTITLEWRAP);
 306             WINE_INVALIDATE_SPI(SPI_SETDOUBLECLICKTIME);
 307             WINE_INVALIDATE_SPI(SPI_SETDRAGFULLWINDOWS);
 308             WINE_INVALIDATE_SPI(SPI_SETWORKAREA);
 309             WINE_INVALIDATE_SPI(SPI_SETKEYBOARDPREF);
 310             WINE_INVALIDATE_SPI(SPI_SETSCREENREADER);
 311             WINE_INVALIDATE_SPI(SPI_SETSCREENSAVERRUNNING);
 312             default:
 313                 FIXME( "Unknown action reset: %u\n", uiAction );
 314                 break;
 315             }
 316         }
 317         else
 318             not_all_processed = FALSE;
 319         break;
 320     }
 321
 322     if (!uiAction && not_all_processed)
 323         ERR( "Incorrect implementation of SYSPARAMS_Reset. "
 324              "Not all params are reloaded.\n" );
 325 #undef WINE_INVALIDATE_SPI
 326 #undef WINE_IGNORE_SPI
 327 #undef WINE_RELOAD_SPI
 328 }
 329
 330 /***********************************************************************
 331  *           get_volatile_regkey
 332  *
 333  * Return a handle to the volatile registry key used to store
 334  * non-permanently modified parameters.
 335  */
 336 static HKEY get_volatile_regkey(void)
 337 {
 338     static HKEY volatile_key;
 339
 340     if (!volatile_key)
 341     {
 342         if (RegCreateKeyExA( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
 343                              0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
 344                              &volatile_key, 0 ) != ERROR_SUCCESS)
 345             ERR("Can't create wine configuration registry branch\n");
 346     }
 347     return volatile_key;
 348 }
 349
 350 /***********************************************************************
 351  *           SYSPARAMS_NotifyChange
 352  *
 353  * Sends notification about system parameter update.
 354  */
 355 void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
 356 {
 357     if (notify_change)
 358     {
 359         if (fWinIni & SPIF_UPDATEINIFILE)
 360         {
 361             if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
 362                 SendMessageA(HWND_BROADCAST, WM_SETTINGCHANGE,
 363                              uiAction, (LPARAM) "");
 364         }
 365         else
 366         {
 367             /* FIXME notify other wine processes with internal message */
 368         }
 369     }
 370 }
 371
 372
 373 /***********************************************************************
 374  * Loads system parameter from user profile.
 375  */
 376 static BOOL SYSPARAMS_Load( LPCSTR lpRegKey, LPCSTR lpValName, LPSTR lpBuf, DWORD count )
 377 {
 378     BOOL ret = FALSE;
 379     DWORD type;
 380     HKEY hKey;
 381
 382     if ((RegOpenKeyA( get_volatile_regkey(), lpRegKey, &hKey ) == ERROR_SUCCESS) ||
 383         (RegOpenKeyA( HKEY_CURRENT_USER, lpRegKey, &hKey ) == ERROR_SUCCESS))
 384     {
 385         ret = !RegQueryValueExA( hKey, lpValName, NULL, &type, lpBuf, &count );
 386         RegCloseKey( hKey );
 387     }
 388     return ret;
 389 }
 390
 391 /***********************************************************************
 392  * Saves system parameter to user profile.
 393  */
 394 static BOOL SYSPARAMS_Save( LPCSTR lpRegKey, LPCSTR lpValName, LPCSTR lpValue,
 395                             UINT fWinIni )
 396 {
 397     HKEY hKey;
 398     HKEY hBaseKey;
 399     DWORD dwOptions;
 400     BOOL ret = FALSE;
 401
 402     if (fWinIni & SPIF_UPDATEINIFILE)
 403     {
 404         hBaseKey = HKEY_CURRENT_USER;
 405         dwOptions = 0;
 406     }
 407     else
 408     {
 409         hBaseKey = get_volatile_regkey();
 410         dwOptions = REG_OPTION_VOLATILE;
 411     }
 412
 413     if (RegCreateKeyExA( hBaseKey, lpRegKey,
 414                          0, 0, dwOptions, KEY_ALL_ACCESS,
 415                          0, &hKey, 0 ) == ERROR_SUCCESS)
 416     {
 417         if (RegSetValueExA( hKey, lpValName, 0, REG_SZ,
 418                             lpValue, strlen(lpValue) + 1 ) == ERROR_SUCCESS)
 419         {
 420             ret = TRUE;
 421             if (hBaseKey == HKEY_CURRENT_USER)
 422                 RegDeleteKeyA( get_volatile_regkey(), lpRegKey );
 423         }
 424         RegCloseKey( hKey );
 425     }
 426     return ret;
 427 }
 428
 429
 430 /***********************************************************************
 431  *           SYSPARAMS_GetDoubleClickSize
 432  *
 433  * There is no SPI_GETDOUBLECLK* so we export this function instead.
 434  */
 435 void SYSPARAMS_GetDoubleClickSize( INT *width, INT *height )
 436 {
 437     char buf[10];
 438
 439     if (!spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX])
 440     {
 441         char buf[10];
 442
 443         if (SYSPARAMS_Load( SPI_SETDOUBLECLKWIDTH_REGKEY1,
 444                             SPI_SETDOUBLECLKWIDTH_VALNAME, buf, sizeof(buf) ))
 445         {
 446             SYSMETRICS_Set( SM_CXDOUBLECLK, atoi( buf ) );
 447         }
 448         spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX] = TRUE;
 449     }
 450     if (!spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX])
 451     {
 452         if (SYSPARAMS_Load( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
 453                             SPI_SETDOUBLECLKHEIGHT_VALNAME, buf, sizeof(buf) ))
 454         {
 455             SYSMETRICS_Set( SM_CYDOUBLECLK, atoi( buf ) );
 456         }
 457         spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX] = TRUE;
 458     }
 459     *width  = GetSystemMetrics( SM_CXDOUBLECLK );
 460     *height = GetSystemMetrics( SM_CYDOUBLECLK );
 461 }
 462
 463
 464 /***********************************************************************
 465  *           SYSPARAMS_GetMouseButtonSwap
 466  *
 467  * There is no SPI_GETMOUSEBUTTONSWAP so we export this function instead.
 468  */
 469 INT SYSPARAMS_GetMouseButtonSwap( void )
 470 {
 471         int spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
 472
 473         if (!spi_loaded[spi_idx])
 474         {
 475             char buf[5];
 476
 477             if (SYSPARAMS_Load( SPI_SETMOUSEBUTTONSWAP_REGKEY,
 478                                 SPI_SETMOUSEBUTTONSWAP_VALNAME, buf, sizeof(buf) ))
 479             {
 480                 SYSMETRICS_Set( SM_SWAPBUTTON, atoi( buf ) );
 481             }
 482             spi_loaded[spi_idx] = TRUE;
 483         }
 484
 485         return GetSystemMetrics( SM_SWAPBUTTON );
 486 }
 487
 488 /***********************************************************************
 489  *
 490  *      SYSPARAMS_GetGUIFont
 491  *
 492  *  fills LOGFONT with 'default GUI font'.
 493  */
 494
 495 static void SYSPARAMS_GetGUIFont( LOGFONTA* plf )
 496 {
 497         HFONT   hf;
 498
 499         memset( plf, 0, sizeof(LOGFONTA) );
 500         hf = (HFONT)GetStockObject( DEFAULT_GUI_FONT );
 501         if ( GetObjectA( hf, sizeof(LOGFONTA), plf ) != sizeof(LOGFONTA) )
 502         {
 503                 /*
 504                  * GetObjectA() would be succeeded always
 505                  * since this is a stock object
 506                  */
 507                 ERR("GetObjectA() failed\n");
 508         }
 509 }
 510
 511 /* copied from GetSystemMetrics()'s RegistryTwips2Pixels() */
 512 inline static int SYSPARAMS_Twips2Pixels(int x)
 513 {
 514     if (x < 0)
 515         x = (-x+7)/15;
 516     return x;
 517 }
 518
 519 /***********************************************************************
 520  *              SystemParametersInfoA (USER32.@)
 521  *
 522  *     Each system parameter has flag which shows whether the parameter
 523  * is loaded or not. Parameters, stored directly in SysParametersInfo are
 524  * loaded from registry only when they are requested and the flag is
 525  * "false", after the loading the flag is set to "true". On interprocess
 526  * notification of the parameter change the corresponding parameter flag is
 527  * set to "false". The parameter value will be reloaded when it is requested
 528  * the next time.
 529  *     Parameters, backed by or depend on GetSystemMetrics are processed
 530  * differently. These parameters are always loaded. They are reloaded right
 531  * away on interprocess change notification. We can't do lazy loading because
 532  * we don't want to complicate GetSystemMetrics.
 533  *     Parameters, backed by X settings are read from corresponding setting.
 534  * On the parameter change request the setting is changed. Interprocess change
 535  * notifications are ignored.
 536  *     When parameter value is updated the changed value is stored in permanent
 537  * registry branch if saving is requested. Otherwise it is stored
 538  * in temporary branch
 539  *
 540  * Some SPI values can also be stored as Twips values in the registry,
 541  * don't forget the conversion!
 542  */
 543 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
 544                                    PVOID pvParam, UINT fWinIni )
 545 {
 546 #define WINE_SPI_FIXME(x) \
 547     case x: \
 548         FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
 549         SetLastError( ERROR_INVALID_SPI_VALUE ); \
 550         ret = FALSE; \
 551         break
 552 #define WINE_SPI_WARN(x) \
 553     case x: \
 554         WARN( "Ignored action: %u (%s)\n", x, #x ); \
 555         break
 556
 557     BOOL ret = TRUE;
 558     unsigned spi_idx = 0;
 559
 560     TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fWinIni);
 561
 562     switch (uiAction)
 563     {
 564     case SPI_GETBEEP:                           /*      1 */
 565         if (!pvParam) return FALSE;
 566
 567         spi_idx = SPI_SETBEEP_IDX;
 568         if (!spi_loaded[spi_idx])
 569         {
 570             char buf[5];
 571
 572             if (SYSPARAMS_Load( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME, buf, sizeof(buf) ))
 573                 beep_active  = !strcasecmp( "Yes", buf );
 574             spi_loaded[spi_idx] = TRUE;
 575         }
 576
 577         *(BOOL *)pvParam = beep_active;
 578         break;
 579
 580     case SPI_SETBEEP:                           /*      2 */
 581         spi_idx = SPI_SETBEEP_IDX;
 582         if (SYSPARAMS_Save( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME,
 583                             (uiParam ? "Yes" : "No"), fWinIni ))
 584         {
 585             beep_active = uiParam;
 586             spi_loaded[spi_idx] = TRUE;
 587         }
 588         else
 589             ret = FALSE;
 590         break;
 591
 592     case SPI_GETMOUSE:                          /*      3 */
 593         if (!pvParam) return FALSE;
 594
 595         spi_idx = SPI_SETMOUSE_IDX;
 596         if (!spi_loaded[spi_idx])
 597         {
 598             char buf[10];
 599
 600             if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
 601                                 buf, sizeof(buf) ))
 602                 mouse_threshold1 = atoi( buf );
 603             if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
 604                                 buf, sizeof(buf) ))
 605                 mouse_threshold2 = atoi( buf );
 606             if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
 607                                 buf, sizeof(buf) ))
 608                 mouse_speed = atoi( buf );
 609             spi_loaded[spi_idx] = TRUE;
 610         }
 611         ((INT *)pvParam)[0] = mouse_threshold1;
 612         ((INT *)pvParam)[1] = mouse_threshold2;
 613         ((INT *)pvParam)[2] = mouse_speed;
 614         break;
 615
 616     case SPI_SETMOUSE:                          /*      4 */
 617     {
 618         char buf[10];
 619
 620         if (!pvParam) return FALSE;
 621
 622         spi_idx = SPI_SETMOUSE_IDX;
 623         sprintf(buf, "%d", ((INT *)pvParam)[0]);
 624
 625         if (SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
 626                             buf, fWinIni ))
 627         {
 628             mouse_threshold1 = ((INT *)pvParam)[0];
 629             spi_loaded[spi_idx] = TRUE;
 630
 631             sprintf(buf, "%d", ((INT *)pvParam)[1]);
 632             SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
 633                             buf, fWinIni );
 634             mouse_threshold2 = ((INT *)pvParam)[1];
 635
 636             sprintf(buf, "%d", ((INT *)pvParam)[2]);
 637             SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
 638                             buf, fWinIni );
 639             mouse_speed = ((INT *)pvParam)[2];
 640         }
 641         else
 642             ret = FALSE;
 643         break;
 644     }
 645
 646     case SPI_GETBORDER:                         /*      5 */
 647         if (!pvParam) return FALSE;
 648
 649         spi_idx = SPI_SETBORDER_IDX;
 650         if (!spi_loaded[spi_idx])
 651         {
 652             char buf[10];
 653
 654             if (SYSPARAMS_Load( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, buf, sizeof(buf) ))
 655                 border = SYSPARAMS_Twips2Pixels( atoi(buf) );
 656
 657             spi_loaded[spi_idx] = TRUE;
 658             if (TWEAK_WineLook > WIN31_LOOK)
 659             {
 660                 SYSMETRICS_Set( SM_CXFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
 661                 SYSMETRICS_Set( SM_CYFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
 662             }
 663         }
 664         *(INT *)pvParam = border;
 665         break;
 666
 667     case SPI_SETBORDER:                         /*      6 */
 668     {
 669         char buf[10];
 670
 671         spi_idx = SPI_SETBORDER_IDX;
 672         sprintf(buf, "%u", uiParam);
 673
 674         if (SYSPARAMS_Save( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
 675                             buf, fWinIni ))
 676         {
 677             if (uiParam > 0)
 678             {
 679                 border = uiParam;
 680                 spi_loaded[spi_idx] = TRUE;
 681                 if (TWEAK_WineLook > WIN31_LOOK)
 682                 {
 683                     SYSMETRICS_Set( SM_CXFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
 684                     SYSMETRICS_Set( SM_CYFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
 685                 }
 686             }
 687         }
 688         else
 689             ret = FALSE;
 690         break;
 691     }
 692
 693     case SPI_GETKEYBOARDSPEED:                  /*     10 */
 694         if (!pvParam) return FALSE;
 695
 696         spi_idx = SPI_SETKEYBOARDSPEED_IDX;
 697         if (!spi_loaded[spi_idx])
 698         {
 699             char buf[10];
 700
 701             if (SYSPARAMS_Load( SPI_SETKEYBOARDSPEED_REGKEY,
 702                                 SPI_SETKEYBOARDSPEED_VALNAME,
 703                                 buf, sizeof(buf) ))
 704                 keyboard_speed = atoi( buf );
 705             spi_loaded[spi_idx] = TRUE;
 706         }
 707         *(INT *)pvParam = keyboard_speed;
 708         break;
 709
 710     case SPI_SETKEYBOARDSPEED:                  /*     11 */
 711     {
 712         char buf[10];
 713
 714         spi_idx = SPI_SETKEYBOARDSPEED_IDX;
 715         if (uiParam > 31)
 716             uiParam = 31;
 717         sprintf(buf, "%u", uiParam);
 718
 719         if (SYSPARAMS_Save( SPI_SETKEYBOARDSPEED_REGKEY,
 720                             SPI_SETKEYBOARDSPEED_VALNAME,
 721                             buf, fWinIni ))
 722         {
 723             keyboard_speed = uiParam;
 724             spi_loaded[spi_idx] = TRUE;
 725         }
 726         else
 727             ret = FALSE;
 728         break;
 729     }
 730
 731     /* not implemented in Windows */
 732     WINE_SPI_WARN(SPI_LANGDRIVER);              /*     12 */
 733
 734     case SPI_ICONHORIZONTALSPACING:             /*     13 */
 735         spi_idx = SPI_ICONHORIZONTALSPACING_IDX;
 736         if (pvParam != NULL)
 737         {
 738             if (!spi_loaded[spi_idx])
 739             {
 740                 char buf[10];
 741                 int val;
 742
 743                 if (SYSPARAMS_Load( SPI_ICONHORIZONTALSPACING_REGKEY,
 744                                     SPI_ICONHORIZONTALSPACING_VALNAME, buf, sizeof(buf) ))
 745                 {
 746                     val = SYSPARAMS_Twips2Pixels( atoi(buf) );
 747                     SYSMETRICS_Set( SM_CXICONSPACING, val );
 748                 }
 749                 spi_loaded[spi_idx] = TRUE;
 750             }
 751
 752             *(INT *)pvParam = GetSystemMetrics( SM_CXICONSPACING );
 753         }
 754         else
 755         {
 756             char buf[10];
 757
 758             if (uiParam < 32) uiParam = 32;
 759
 760             sprintf(buf, "%u", uiParam);
 761             if (SYSPARAMS_Save( SPI_ICONHORIZONTALSPACING_REGKEY,
 762                                 SPI_ICONHORIZONTALSPACING_VALNAME,
 763                                 buf, fWinIni ))
 764             {
 765                 SYSMETRICS_Set( SM_CXICONSPACING, uiParam );
 766                 spi_loaded[spi_idx] = TRUE;
 767             }
 768             else
 769                 ret = FALSE;
 770         }
 771         break;
 772
 773     case SPI_GETSCREENSAVETIMEOUT:              /*     14 */
 774         if (!pvParam) return FALSE;
 775
 776         spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
 777         if (!spi_loaded[spi_idx])
 778         {
 779             char buf[10];
 780
 781             if (SYSPARAMS_Load( SPI_SETSCREENSAVETIMEOUT_REGKEY,
 782                                 SPI_SETSCREENSAVETIMEOUT_VALNAME,
 783                                 buf, sizeof(buf) ))
 784                 screensave_timeout = atoi( buf );
 785
 786             spi_loaded[spi_idx] = TRUE;
 787         }
 788         *(INT *)pvParam = screensave_timeout;
 789         break;
 790
 791     case SPI_SETSCREENSAVETIMEOUT:              /*     15 */
 792     {
 793         char buf[10];
 794
 795         spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
 796         sprintf(buf, "%u", uiParam);
 797
 798         if (SYSPARAMS_Save( SPI_SETSCREENSAVETIMEOUT_REGKEY,
 799                             SPI_SETSCREENSAVETIMEOUT_VALNAME,
 800                             buf, fWinIni ))
 801         {
 802             screensave_timeout = uiParam;
 803             spi_loaded[spi_idx] = TRUE;
 804         }
 805         else
 806             ret = FALSE;
 807         break;
 808     }
 809
 810     case SPI_GETSCREENSAVEACTIVE:               /*     16 */
 811         if (!pvParam) return FALSE;
 812         *(BOOL *)pvParam = USER_Driver.pGetScreenSaveActive();
 813         break;
 814
 815     case SPI_SETSCREENSAVEACTIVE:               /*     17 */
 816     {
 817         char buf[5];
 818
 819         sprintf(buf, "%u", uiParam);
 820         USER_Driver.pSetScreenSaveActive( uiParam );
 821         /* saved value does not affect Wine */
 822         SYSPARAMS_Save( SPI_SETSCREENSAVEACTIVE_REGKEY,
 823                         SPI_SETSCREENSAVEACTIVE_VALNAME,
 824                         buf, fWinIni );
 825         break;
 826     }
 827
 828     case SPI_GETGRIDGRANULARITY:                /*     18 */
 829         if (!pvParam) return FALSE;
 830
 831         spi_idx = SPI_SETGRIDGRANULARITY_IDX;
 832         if (!spi_loaded[spi_idx])
 833         {
 834             char buf[10];
 835
 836             if (SYSPARAMS_Load( SPI_SETGRIDGRANULARITY_REGKEY,
 837                                 SPI_SETGRIDGRANULARITY_VALNAME,
 838                                 buf, sizeof(buf) ))
 839                 grid_granularity = atoi( buf );
 840
 841             spi_loaded[spi_idx] = TRUE;
 842         }
 843         *(INT *)pvParam = grid_granularity;
 844         break;
 845
 846     case SPI_SETGRIDGRANULARITY:                /*     19 */
 847     {
 848         char buf[10];
 849
 850         spi_idx = SPI_SETGRIDGRANULARITY_IDX;
 851         sprintf(buf, "%u", uiParam);
 852
 853         if (SYSPARAMS_Save( SPI_SETGRIDGRANULARITY_REGKEY,
 854                             SPI_SETGRIDGRANULARITY_VALNAME,
 855                             buf, fWinIni ))
 856         {
 857             grid_granularity = uiParam;
 858             spi_loaded[spi_idx] = TRUE;
 859         }
 860         else
 861             ret = FALSE;
 862         break;
 863     }
 864
 865     case SPI_SETDESKWALLPAPER:                  /*     20 */
 866         if (!pvParam || !SetDeskWallPaper( (LPSTR)pvParam )) return FALSE;
 867         SYSPARAMS_Save(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, pvParam, fWinIni);
 868         break;
 869     case SPI_SETDESKPATTERN:                    /*     21 */
 870         /* FIXME: the ability to specify a pattern in pvParam
 871            doesn't seem to be documented for Win32 */
 872         if ((INT16)uiParam == -1)
 873         {
 874             char buffer[256];
 875             GetProfileStringA( "Desktop", "Pattern",
 876                                "170 85 170 85 170 85 170 85",
 877                                buffer, sizeof(buffer) );
 878             ret = DESKTOP_SetPattern( (LPSTR)buffer );
 879         } else
 880             ret = DESKTOP_SetPattern( (LPSTR)pvParam );
 881         break;
 882
 883     case SPI_GETKEYBOARDDELAY:                  /*     22 */
 884         if (!pvParam) return FALSE;
 885
 886         spi_idx = SPI_SETKEYBOARDDELAY_IDX;
 887         if (!spi_loaded[spi_idx])
 888         {
 889             char buf[10];
 890
 891             if (SYSPARAMS_Load( SPI_SETKEYBOARDDELAY_REGKEY,
 892                                 SPI_SETKEYBOARDDELAY_VALNAME,
 893                                 buf, sizeof(buf) ))
 894             {
 895                 int i = atoi( buf );
 896                 if ( (i >= 0) && (i <= 3)) keyboard_delay = i;
 897             }
 898
 899             spi_loaded[spi_idx] = TRUE;
 900         }
 901         *(INT *)pvParam = keyboard_delay;
 902         break;
 903
 904     case SPI_SETKEYBOARDDELAY:                  /*     23 */
 905     {
 906         char buf[10];
 907
 908         spi_idx = SPI_SETKEYBOARDDELAY_IDX;
 909         sprintf(buf, "%u", uiParam);
 910
 911         if (SYSPARAMS_Save( SPI_SETKEYBOARDDELAY_REGKEY,
 912                             SPI_SETKEYBOARDDELAY_VALNAME,
 913                             buf, fWinIni ))
 914         {
 915             if (uiParam <= 3)
 916                 keyboard_delay = uiParam;
 917             spi_loaded[spi_idx] = TRUE;
 918         }
 919         else
 920             ret = FALSE;
 921         break;
 922     }
 923
 924     case SPI_ICONVERTICALSPACING:               /*     24 */
 925         spi_idx = SPI_ICONVERTICALSPACING_IDX;
 926         if (pvParam != NULL)
 927         {
 928             if (!spi_loaded[spi_idx])
 929             {
 930                 char buf[10];
 931                 int val;
 932
 933                 if (SYSPARAMS_Load( SPI_ICONVERTICALSPACING_REGKEY,
 934                                     SPI_ICONVERTICALSPACING_VALNAME, buf, sizeof(buf) ))
 935                 {
 936                     val = SYSPARAMS_Twips2Pixels( atoi(buf) );
 937                     SYSMETRICS_Set( SM_CYICONSPACING, val );
 938                 }
 939                 spi_loaded[spi_idx] = TRUE;
 940             }
 941
 942             *(INT *)pvParam = GetSystemMetrics( SM_CYICONSPACING );
 943         }
 944         else
 945         {
 946             char buf[10];
 947
 948             if (uiParam < 32) uiParam = 32;
 949
 950             sprintf(buf, "%u", uiParam);
 951             if (SYSPARAMS_Save( SPI_ICONVERTICALSPACING_REGKEY,
 952                                 SPI_ICONVERTICALSPACING_VALNAME,
 953                                 buf, fWinIni ))
 954             {
 955                 SYSMETRICS_Set( SM_CYICONSPACING, uiParam );
 956                 spi_loaded[spi_idx] = TRUE;
 957             }
 958             else
 959                 ret = FALSE;
 960         }
 961
 962         break;
 963
 964     case SPI_GETICONTITLEWRAP:                  /*     25 */
 965         if (!pvParam) return FALSE;
 966
 967         spi_idx = SPI_SETICONTITLEWRAP_IDX;
 968         if (!spi_loaded[spi_idx])
 969         {
 970             char buf[5];
 971
 972             if (SYSPARAMS_Load( SPI_SETICONTITLEWRAP_REGKEY1,
 973                                 SPI_SETICONTITLEWRAP_VALNAME, buf, sizeof(buf) ))
 974                 icon_title_wrap  = atoi(buf);
 975             spi_loaded[spi_idx] = TRUE;
 976         }
 977
 978         *(BOOL *)pvParam = icon_title_wrap;
 979         break;
 980
 981     case SPI_SETICONTITLEWRAP:                  /*     26 */
 982     {
 983         char buf[5];
 984
 985         spi_idx = SPI_SETICONTITLEWRAP_IDX;
 986         sprintf(buf, "%u", uiParam);
 987         if (SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY1,
 988                             SPI_SETICONTITLEWRAP_VALNAME,
 989                             buf, fWinIni ))
 990         {
 991             SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY2,
 992                             SPI_SETICONTITLEWRAP_VALNAME,
 993                             buf, fWinIni );
 994             icon_title_wrap = uiParam;
 995             spi_loaded[spi_idx] = TRUE;
 996         }
 997         else
 998             ret = FALSE;
 999         break;
1000     }
1001
1002     case SPI_GETMENUDROPALIGNMENT:              /*     27 */
1003         if (!pvParam) return FALSE;
1004
1005         spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1006
1007         if (!spi_loaded[spi_idx])
1008         {
1009             char buf[5];
1010
1011             if (SYSPARAMS_Load( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1012                                 SPI_SETMENUDROPALIGNMENT_VALNAME, buf, sizeof(buf) ))
1013             {
1014                 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, atoi( buf ) );
1015             }
1016             spi_loaded[spi_idx] = TRUE;
1017         }
1018
1019         *(BOOL *)pvParam = GetSystemMetrics( SM_MENUDROPALIGNMENT );
1020         break;
1021
1022     case SPI_SETMENUDROPALIGNMENT:              /*     28 */
1023     {
1024         char buf[5];
1025         spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1026
1027         sprintf(buf, "%u", uiParam);
1028         if (SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1029                             SPI_SETMENUDROPALIGNMENT_VALNAME,
1030                             buf, fWinIni ))
1031         {
1032             SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY2,
1033                             SPI_SETMENUDROPALIGNMENT_VALNAME,
1034                             buf, fWinIni );
1035             SYSMETRICS_Set( SM_MENUDROPALIGNMENT, uiParam );
1036             spi_loaded[spi_idx] = TRUE;
1037         }
1038         else
1039             ret = FALSE;
1040         break;
1041     }
1042
1043     case SPI_SETDOUBLECLKWIDTH:                 /*     29 */
1044     {
1045         char buf[10];
1046         spi_idx = SPI_SETDOUBLECLKWIDTH_IDX;
1047
1048         sprintf(buf, "%u", uiParam);
1049         if (SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY1,
1050                             SPI_SETDOUBLECLKWIDTH_VALNAME,
1051                             buf, fWinIni ))
1052         {
1053             SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY2,
1054                             SPI_SETDOUBLECLKWIDTH_VALNAME,
1055                             buf, fWinIni );
1056             SYSMETRICS_Set( SM_CXDOUBLECLK, uiParam );
1057             spi_loaded[spi_idx] = TRUE;
1058         }
1059         else
1060             ret = FALSE;
1061         break;
1062     }
1063
1064     case SPI_SETDOUBLECLKHEIGHT:                /*     30 */
1065     {
1066         char buf[10];
1067         spi_idx = SPI_SETDOUBLECLKHEIGHT_IDX;
1068
1069         sprintf(buf, "%u", uiParam);
1070         if (SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
1071                             SPI_SETDOUBLECLKHEIGHT_VALNAME,
1072                             buf, fWinIni ))
1073         {
1074             SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY2,
1075                             SPI_SETDOUBLECLKHEIGHT_VALNAME,
1076                             buf, fWinIni );
1077             SYSMETRICS_Set( SM_CYDOUBLECLK, uiParam );
1078             spi_loaded[spi_idx] = TRUE;
1079         }
1080         else
1081             ret = FALSE;
1082         break;
1083     }
1084
1085     case SPI_GETICONTITLELOGFONT:               /*     31 */
1086     {
1087         LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
1088         LOGFONTA        lfDefault;
1089
1090         if (!pvParam) return FALSE;
1091
1092         /*
1093          * The 'default GDI fonts' seems to be returned.
1094          * If a returned font is not a correct font in your environment,
1095          * please try to fix objects/gdiobj.c at first.
1096          */
1097         SYSPARAMS_GetGUIFont( &lfDefault );
1098
1099         GetProfileStringA( "Desktop", "IconTitleFaceName",
1100                            lfDefault.lfFaceName,
1101                            lpLogFont->lfFaceName, LF_FACESIZE );
1102         lpLogFont->lfHeight = -GetProfileIntA( "Desktop", "IconTitleSize", 11 );
1103         lpLogFont->lfWidth = 0;
1104         lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1105         lpLogFont->lfWeight = FW_NORMAL;
1106         lpLogFont->lfItalic = FALSE;
1107         lpLogFont->lfStrikeOut = FALSE;
1108         lpLogFont->lfUnderline = FALSE;
1109         lpLogFont->lfCharSet = lfDefault.lfCharSet; /* at least 'charset' should not be hard-coded */
1110         lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1111         lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1112         lpLogFont->lfPitchAndFamily = DEFAULT_PITCH;
1113         lpLogFont->lfQuality = DEFAULT_QUALITY;
1114         break;
1115     }
1116
1117     case SPI_SETDOUBLECLICKTIME:                /*     32 */
1118     {
1119         char buf[10];
1120
1121         spi_idx = SPI_SETDOUBLECLICKTIME_IDX;
1122         sprintf(buf, "%u", uiParam);
1123
1124         if (SYSPARAMS_Save( SPI_SETDOUBLECLICKTIME_REGKEY,
1125                             SPI_SETDOUBLECLICKTIME_VALNAME,
1126                             buf, fWinIni ))
1127         {
1128             if (!uiParam)
1129                 uiParam = 500;
1130             double_click_time = uiParam;
1131             spi_loaded[spi_idx] = TRUE;
1132         }
1133         else
1134             ret = FALSE;
1135         break;
1136     }
1137
1138     case SPI_SETMOUSEBUTTONSWAP:                /*     33 */
1139     {
1140         char buf[5];
1141         spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
1142
1143         sprintf(buf, "%u", uiParam);
1144         if (SYSPARAMS_Save( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1145                             SPI_SETMOUSEBUTTONSWAP_VALNAME,
1146                             buf, fWinIni ))
1147         {
1148             SYSMETRICS_Set( SM_SWAPBUTTON, uiParam );
1149             spi_loaded[spi_idx] = TRUE;
1150         }
1151         else
1152             ret = FALSE;
1153         break;
1154     }
1155
1156     WINE_SPI_FIXME(SPI_SETICONTITLELOGFONT);    /*     34 */
1157
1158     case SPI_GETFASTTASKSWITCH:                 /*     35 */
1159         if (!pvParam) return FALSE;
1160         *(BOOL *)pvParam = 1;
1161         break;
1162
1163     case SPI_SETFASTTASKSWITCH:                 /*     36 */
1164         /* the action is disabled */
1165         ret = FALSE;
1166         break;
1167
1168     case SPI_SETDRAGFULLWINDOWS:                /*     37  WINVER >= 0x0400 */
1169     {
1170         char buf[5];
1171
1172         spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1173         sprintf(buf, "%u", uiParam);
1174         if (SYSPARAMS_Save( SPI_SETDRAGFULLWINDOWS_REGKEY,
1175                             SPI_SETDRAGFULLWINDOWS_VALNAME,
1176                             buf, fWinIni ))
1177         {
1178             drag_full_windows = uiParam;
1179             spi_loaded[spi_idx] = TRUE;
1180         }
1181         else
1182             ret = FALSE;
1183         break;
1184     }
1185
1186     case SPI_GETDRAGFULLWINDOWS:                /*     38  WINVER >= 0x0400 */
1187         if (!pvParam) return FALSE;
1188
1189         spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1190         if (!spi_loaded[spi_idx])
1191         {
1192             char buf[5];
1193
1194             if (SYSPARAMS_Load( SPI_SETDRAGFULLWINDOWS_REGKEY,
1195                                 SPI_SETDRAGFULLWINDOWS_VALNAME, buf, sizeof(buf) ))
1196                 drag_full_windows  = atoi(buf);
1197             spi_loaded[spi_idx] = TRUE;
1198         }
1199
1200         *(BOOL *)pvParam = drag_full_windows;
1201         break;
1202
1203     case SPI_GETNONCLIENTMETRICS:               /*     41  WINVER >= 0x400 */
1204     {
1205         LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
1206
1207         if (!pvParam) return FALSE;
1208
1209         if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA))
1210         {
1211             /* clear the struct, so we have 'sane' members */
1212             memset(
1213                 (char *)pvParam + sizeof(lpnm->cbSize),
1214                 0,
1215                 lpnm->cbSize - sizeof(lpnm->cbSize)
1216                 );
1217
1218             /* initialize geometry entries */
1219             lpnm->iBorderWidth = 1;
1220             lpnm->iScrollWidth = GetSystemMetrics(SM_CXVSCROLL);
1221             lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1222
1223             /* size of the normal caption buttons */
1224             lpnm->iCaptionWidth = GetSystemMetrics(SM_CXSIZE);
1225             lpnm->iCaptionHeight = GetSystemMetrics(SM_CYSIZE);
1226
1227             /* caption font metrics */
1228             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont), 0 );
1229             lpnm->lfCaptionFont.lfWeight = FW_BOLD;
1230
1231             /* size of the small caption buttons */
1232             lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1233             lpnm->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
1234
1235             /* small caption font metrics */
1236             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont), 0 );
1237
1238             /* menus, FIXME: names of wine.conf entries are bogus */
1239
1240             /* size of the menu (MDI) buttons */
1241             lpnm->iMenuWidth = GetSystemMetrics(SM_CXMENUSIZE);
1242             lpnm->iMenuHeight = GetSystemMetrics(SM_CYMENUSIZE);
1243
1244             /* menu font metrics */
1245             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfMenuFont), 0 );
1246             GetProfileStringA( "Desktop", "MenuFont",
1247                                (TWEAK_WineLook > WIN31_LOOK) ? lpnm->lfCaptionFont.lfFaceName : "System",
1248                                lpnm->lfMenuFont.lfFaceName, LF_FACESIZE );
1249             lpnm->lfMenuFont.lfHeight = -GetProfileIntA( "Desktop", "MenuFontSize", 11 );
1250             lpnm->lfMenuFont.lfWeight = (TWEAK_WineLook > WIN31_LOOK) ? FW_NORMAL : FW_BOLD;
1251
1252             /* status bar font metrics */
1253             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1254                                    (LPVOID)&(lpnm->lfStatusFont), 0 );
1255             /* message font metrics */
1256             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1257                                    (LPVOID)&(lpnm->lfMessageFont), 0 );
1258         }
1259         else
1260         {
1261             WARN("size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSA));
1262             /* FIXME: SetLastError? */
1263             ret = FALSE;
1264         }
1265         break;
1266     }
1267     WINE_SPI_FIXME(SPI_SETNONCLIENTMETRICS);    /*     42  WINVER >= 0x400 */
1268
1269     case SPI_GETMINIMIZEDMETRICS:               /*     43  WINVER >= 0x400 */
1270     {
1271         MINIMIZEDMETRICS * lpMm = pvParam;
1272         if (lpMm && lpMm->cbSize == sizeof(*lpMm))
1273         {
1274             /* these taken from Win2k SP3 */
1275             lpMm->iWidth = 154;
1276             lpMm->iHorzGap = 0;
1277             lpMm->iVertGap = 0;
1278             lpMm->iArrange = 8;
1279         }
1280         else
1281             ret = FALSE;
1282         break;
1283     }
1284     WINE_SPI_FIXME(SPI_SETMINIMIZEDMETRICS);    /*     44  WINVER >= 0x400 */
1285
1286     case SPI_GETICONMETRICS:                    /*     45  WINVER >= 0x400 */
1287     {
1288         LPICONMETRICSA lpIcon = pvParam;
1289         if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1290         {
1291             SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0,
1292                                    &lpIcon->iHorzSpacing, FALSE );
1293             SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0,
1294                                    &lpIcon->iVertSpacing, FALSE );
1295             SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0,
1296                                    &lpIcon->iTitleWrap, FALSE );
1297             SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1298                                    &lpIcon->lfFont, FALSE );
1299         }
1300         else
1301         {
1302             ret = FALSE;
1303         }
1304         break;
1305     }
1306     WINE_SPI_FIXME(SPI_SETICONMETRICS);         /*     46  WINVER >= 0x400 */
1307
1308     case SPI_SETWORKAREA:                       /*     47  WINVER >= 0x400 */
1309     {
1310         char buf[20];
1311         RECT *pr = (RECT *) pvParam;
1312
1313         if (!pvParam) return FALSE;
1314
1315         spi_idx = SPI_SETWORKAREA_IDX;
1316         sprintf(buf, "%ld %ld %ld %ld",
1317                 pr->left, pr->top,
1318                 pr->right, pr->bottom );
1319
1320         if (SYSPARAMS_Save( SPI_SETWORKAREA_REGKEY,
1321                             SPI_SETWORKAREA_VALNAME,
1322                             buf, fWinIni ))
1323         {
1324             CopyRect( &work_area, (RECT *)pvParam );
1325             spi_loaded[spi_idx] = TRUE;
1326         }
1327         else
1328             ret = FALSE;
1329         break;
1330     }
1331
1332     case SPI_GETWORKAREA:                       /*     48  WINVER >= 0x400 */
1333         if (!pvParam) return FALSE;
1334
1335       spi_idx = SPI_SETWORKAREA_IDX;
1336       if (!spi_loaded[spi_idx])
1337       {
1338           char buf[20];
1339
1340           SetRect( &work_area, 0, 0,
1341                    GetSystemMetrics( SM_CXSCREEN ),
1342                    GetSystemMetrics( SM_CYSCREEN ) );
1343
1344           if (SYSPARAMS_Load( SPI_SETWORKAREA_REGKEY,
1345                               SPI_SETWORKAREA_VALNAME,
1346                               buf, sizeof(buf) ))
1347           {
1348               sscanf( buf, "%ld %ld %ld %ld",
1349                       &work_area.left, &work_area.top,
1350                       &work_area.right, &work_area.bottom );
1351           }
1352           spi_loaded[spi_idx] = TRUE;
1353       }
1354       CopyRect( (RECT *)pvParam, &work_area );
1355
1356       break;
1357
1358     WINE_SPI_FIXME(SPI_SETPENWINDOWS);          /*     49  WINVER >= 0x400 */
1359
1360     case SPI_GETFILTERKEYS:                     /*     50 */
1361     {
1362         LPFILTERKEYS lpFilterKeys = (LPFILTERKEYS)pvParam;
1363         WARN("SPI_GETFILTERKEYS not fully implemented\n");
1364         if (lpFilterKeys && lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1365         {
1366             /* Indicate that no FilterKeys feature available */
1367             lpFilterKeys->dwFlags = 0;
1368             lpFilterKeys->iWaitMSec = 0;
1369             lpFilterKeys->iDelayMSec = 0;
1370             lpFilterKeys->iRepeatMSec = 0;
1371             lpFilterKeys->iBounceMSec = 0;
1372          }
1373         else
1374         {
1375             ret = FALSE;
1376         }
1377         break;
1378     }
1379     WINE_SPI_FIXME(SPI_SETFILTERKEYS);          /*     51 */
1380
1381     case SPI_GETTOGGLEKEYS:                     /*     52 */
1382     {
1383         LPTOGGLEKEYS lpToggleKeys = (LPTOGGLEKEYS)pvParam;
1384         WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1385         if (lpToggleKeys && lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1386         {
1387             /* Indicate that no ToggleKeys feature available */
1388             lpToggleKeys->dwFlags = 0;
1389         }
1390         else
1391         {
1392             ret = FALSE;
1393         }
1394         break;
1395     }
1396     WINE_SPI_FIXME(SPI_SETTOGGLEKEYS);          /*     53 */
1397
1398     case SPI_GETMOUSEKEYS:                      /*     54 */
1399     {
1400         LPMOUSEKEYS lpMouseKeys = (LPMOUSEKEYS)pvParam;
1401         WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1402         if (lpMouseKeys && lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1403         {
1404             /* Indicate that no MouseKeys feature available */
1405             lpMouseKeys->dwFlags = 0;
1406             lpMouseKeys->iMaxSpeed = 360;
1407             lpMouseKeys->iTimeToMaxSpeed = 1000;
1408             lpMouseKeys->iCtrlSpeed = 0;
1409             lpMouseKeys->dwReserved1 = 0;
1410             lpMouseKeys->dwReserved2 = 0;
1411         }
1412         else
1413         {
1414             ret = FALSE;
1415         }
1416         break;
1417     }
1418     WINE_SPI_FIXME(SPI_SETMOUSEKEYS);           /*     55 */
1419
1420     case SPI_GETSHOWSOUNDS:                     /*     56 */
1421         if (!pvParam) return FALSE;
1422
1423         spi_idx = SPI_SETSHOWSOUNDS_IDX;
1424
1425         if (!spi_loaded[spi_idx])
1426         {
1427             char buf[10];
1428
1429             if (SYSPARAMS_Load( SPI_SETSHOWSOUNDS_REGKEY,
1430                                 SPI_SETSHOWSOUNDS_VALNAME, buf, sizeof(buf) ))
1431             {
1432                 SYSMETRICS_Set( SM_SHOWSOUNDS, atoi( buf ) );
1433             }
1434             spi_loaded[spi_idx] = TRUE;
1435         }
1436
1437         *(INT *)pvParam = GetSystemMetrics( SM_SHOWSOUNDS );
1438         break;
1439
1440     case SPI_SETSHOWSOUNDS:                     /*     57 */
1441     {
1442         char buf[10];
1443         spi_idx = SPI_SETSHOWSOUNDS_IDX;
1444
1445         sprintf(buf, "%u", uiParam);
1446         if (SYSPARAMS_Save( SPI_SETSHOWSOUNDS_REGKEY,
1447                             SPI_SETSHOWSOUNDS_VALNAME,
1448                             buf, fWinIni ))
1449         {
1450             SYSMETRICS_Set( SM_SHOWSOUNDS, uiParam );
1451             spi_loaded[spi_idx] = TRUE;
1452         }
1453         else
1454             ret = FALSE;
1455         break;
1456     }
1457
1458     case SPI_GETSTICKYKEYS:                     /*     58 */
1459     {
1460         LPSTICKYKEYS lpStickyKeys = (LPSTICKYKEYS)pvParam;
1461         WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1462         if (lpStickyKeys && lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1463         {
1464             /* Indicate that no StickyKeys feature available */
1465             lpStickyKeys->dwFlags = 0;
1466         }
1467         else
1468         {
1469             ret = FALSE;
1470         }
1471         break;
1472     }
1473     WINE_SPI_FIXME(SPI_SETSTICKYKEYS);          /*     59 */
1474
1475     case SPI_GETACCESSTIMEOUT:                  /*     60 */
1476     {
1477         LPACCESSTIMEOUT lpAccessTimeout = (LPACCESSTIMEOUT)pvParam;
1478         WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1479         if (lpAccessTimeout && lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1480         {
1481             /* Indicate that no accessibility features timeout is available */
1482             lpAccessTimeout->dwFlags = 0;
1483             lpAccessTimeout->iTimeOutMSec = 0;
1484         }
1485         else
1486         {
1487             ret = FALSE;
1488         }
1489         break;
1490     }
1491     WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT);       /*     61 */
1492
1493     case SPI_GETSERIALKEYS:                     /*     62  WINVER >= 0x400 */
1494     {
1495         LPSERIALKEYSA lpSerialKeysA = (LPSERIALKEYSA)pvParam;
1496         WARN("SPI_GETSERIALKEYS not fully implemented\n");
1497         if (lpSerialKeysA && lpSerialKeysA->cbSize == sizeof(SERIALKEYSA))
1498         {
1499             /* Indicate that no SerialKeys feature available */
1500             lpSerialKeysA->dwFlags = 0;
1501             lpSerialKeysA->lpszActivePort = NULL;
1502             lpSerialKeysA->lpszPort = NULL;
1503             lpSerialKeysA->iBaudRate = 0;
1504             lpSerialKeysA->iPortState = 0;
1505         }
1506         else
1507         {
1508             ret = FALSE;
1509         }
1510         break;
1511     }
1512     WINE_SPI_FIXME(SPI_SETSERIALKEYS);          /*     63  WINVER >= 0x400 */
1513
1514     case SPI_GETSOUNDSENTRY:                    /*     64 */
1515     {
1516         LPSOUNDSENTRYA lpSoundSentryA = (LPSOUNDSENTRYA)pvParam;
1517         WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1518         if (lpSoundSentryA && lpSoundSentryA->cbSize == sizeof(SOUNDSENTRYA))
1519         {
1520             /* Indicate that no SoundSentry feature available */
1521             lpSoundSentryA->dwFlags = 0;
1522             lpSoundSentryA->iFSTextEffect = 0;
1523             lpSoundSentryA->iFSTextEffectMSec = 0;
1524             lpSoundSentryA->iFSTextEffectColorBits = 0;
1525             lpSoundSentryA->iFSGrafEffect = 0;
1526             lpSoundSentryA->iFSGrafEffectMSec = 0;
1527             lpSoundSentryA->iFSGrafEffectColor = 0;
1528             lpSoundSentryA->iWindowsEffect = 0;
1529             lpSoundSentryA->iWindowsEffectMSec = 0;
1530             lpSoundSentryA->lpszWindowsEffectDLL = 0;
1531             lpSoundSentryA->iWindowsEffectOrdinal = 0;
1532         }
1533         else
1534         {
1535             ret = FALSE;
1536         }
1537         break;
1538     }
1539     WINE_SPI_FIXME(SPI_SETSOUNDSENTRY);         /*     65 */
1540
1541     case SPI_GETHIGHCONTRAST:                   /*     66  WINVER >= 0x400 */
1542     {
1543         LPHIGHCONTRASTA lpHighContrastA = (LPHIGHCONTRASTA)pvParam;
1544         WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1545         if (lpHighContrastA && lpHighContrastA->cbSize == sizeof(HIGHCONTRASTA))
1546         {
1547             /* Indicate that no high contrast feature available */
1548             lpHighContrastA->dwFlags = 0;
1549             lpHighContrastA->lpszDefaultScheme = NULL;
1550         }
1551         else
1552         {
1553             ret = FALSE;
1554         }
1555         break;
1556     }
1557     WINE_SPI_FIXME(SPI_SETHIGHCONTRAST);        /*     67  WINVER >= 0x400 */
1558
1559     case SPI_GETKEYBOARDPREF:                   /*     68  WINVER >= 0x400 */
1560         if (!pvParam) return FALSE;
1561
1562         spi_idx = SPI_SETKEYBOARDPREF_IDX;
1563         if (!spi_loaded[spi_idx])
1564         {
1565             char buf[5];
1566
1567             if (SYSPARAMS_Load( SPI_SETKEYBOARDPREF_REGKEY,
1568                                 SPI_SETKEYBOARDPREF_VALNAME, buf, sizeof(buf) ))
1569                 keyboard_pref  = atoi(buf);
1570             spi_loaded[spi_idx] = TRUE;
1571         }
1572
1573         *(BOOL *)pvParam = keyboard_pref;
1574         break;
1575
1576     case SPI_SETKEYBOARDPREF:                   /*     69  WINVER >= 0x400 */
1577     {
1578         char buf[5];
1579
1580         spi_idx = SPI_SETKEYBOARDPREF_IDX;
1581         sprintf(buf, "%u", uiParam);
1582         if (SYSPARAMS_Save( SPI_SETKEYBOARDPREF_REGKEY,
1583                             SPI_SETKEYBOARDPREF_VALNAME,
1584                             buf, fWinIni ))
1585         {
1586             keyboard_pref = uiParam;
1587             spi_loaded[spi_idx] = TRUE;
1588         }
1589         else
1590             ret = FALSE;
1591         break;
1592     }
1593
1594     case SPI_GETSCREENREADER:                   /*     70  WINVER >= 0x400 */
1595         if (!pvParam) return FALSE;
1596
1597         spi_idx = SPI_SETSCREENREADER_IDX;
1598         if (!spi_loaded[spi_idx])
1599         {
1600             char buf[5];
1601
1602             if (SYSPARAMS_Load( SPI_SETSCREENREADER_REGKEY,
1603                                 SPI_SETSCREENREADER_VALNAME, buf, sizeof(buf) ))
1604                 screen_reader  = atoi(buf);
1605             spi_loaded[spi_idx] = TRUE;
1606         }
1607
1608         *(BOOL *)pvParam = screen_reader;
1609         break;
1610
1611     case SPI_SETSCREENREADER:                   /*     71  WINVER >= 0x400 */
1612     {
1613         char buf[5];
1614
1615         spi_idx = SPI_SETSCREENREADER_IDX;
1616         sprintf(buf, "%u", uiParam);
1617         if (SYSPARAMS_Save( SPI_SETSCREENREADER_REGKEY,
1618                             SPI_SETSCREENREADER_VALNAME,
1619                             buf, fWinIni ))
1620         {
1621             screen_reader = uiParam;
1622             spi_loaded[spi_idx] = TRUE;
1623         }
1624         else
1625             ret = FALSE;
1626         break;
1627     }
1628
1629     case SPI_GETANIMATION:                      /*     72  WINVER >= 0x400 */
1630     {
1631         LPANIMATIONINFO lpAnimInfo = (LPANIMATIONINFO)pvParam;
1632
1633         /* Tell it "disabled" */
1634         if (lpAnimInfo && lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
1635             lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
1636         else
1637             ret = FALSE;
1638         break;
1639     }
1640     WINE_SPI_WARN(SPI_SETANIMATION);            /*     73  WINVER >= 0x400 */
1641
1642     WINE_SPI_FIXME(SPI_GETFONTSMOOTHING);       /*     74  WINVER >= 0x400 */
1643     WINE_SPI_FIXME(SPI_SETFONTSMOOTHING);       /*     75  WINVER >= 0x400 */
1644
1645     WINE_SPI_FIXME(SPI_SETDRAGWIDTH);           /*     76  WINVER >= 0x400 */
1646     WINE_SPI_FIXME(SPI_SETDRAGHEIGHT);          /*     77  WINVER >= 0x400 */
1647
1648     WINE_SPI_FIXME(SPI_SETHANDHELD);            /*     78  WINVER >= 0x400 */
1649
1650     WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT);     /*     79  WINVER >= 0x400 */
1651     WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT);     /*     80  WINVER >= 0x400 */
1652     WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT);     /*     81  WINVER >= 0x400 */
1653     WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT);     /*     82  WINVER >= 0x400 */
1654     WINE_SPI_FIXME(SPI_GETLOWPOWERACTIVE);      /*     83  WINVER >= 0x400 */
1655     WINE_SPI_FIXME(SPI_GETPOWEROFFACTIVE);      /*     84  WINVER >= 0x400 */
1656     WINE_SPI_FIXME(SPI_SETLOWPOWERACTIVE);      /*     85  WINVER >= 0x400 */
1657     WINE_SPI_FIXME(SPI_SETPOWEROFFACTIVE);      /*     86  WINVER >= 0x400 */
1658
1659     WINE_SPI_FIXME(SPI_SETCURSORS);             /*     87  WINVER >= 0x400 */
1660     WINE_SPI_FIXME(SPI_SETICONS);               /*     88  WINVER >= 0x400 */
1661
1662     case SPI_GETDEFAULTINPUTLANG:       /*     89  WINVER >= 0x400 */
1663         ret = GetKeyboardLayout(0) ? TRUE : FALSE;
1664         break;
1665
1666     WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG);    /*     90  WINVER >= 0x400 */
1667
1668     WINE_SPI_FIXME(SPI_SETLANGTOGGLE);          /*     91  WINVER >= 0x400 */
1669
1670     case SPI_GETWINDOWSEXTENSION:               /*     92  WINVER >= 0x400 */
1671         WARN("pretend no support for Win9x Plus! for now.\n");
1672         ret = FALSE; /* yes, this is the result value */
1673         break;
1674
1675     WINE_SPI_FIXME(SPI_SETMOUSETRAILS);         /*     93  WINVER >= 0x400 */
1676     WINE_SPI_FIXME(SPI_GETMOUSETRAILS);         /*     94  WINVER >= 0x400 */
1677
1678     case SPI_SETSCREENSAVERRUNNING:             /*     97  WINVER >= 0x400 */
1679         {
1680         /* SPI_SCREENSAVERRUNNING is an alias for SPI_SETSCREENSAVERRUNNING */
1681         char buf[5];
1682
1683         spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1684         sprintf(buf, "%u", uiParam);
1685
1686         /* save only temporarily */
1687         if (SYSPARAMS_Save( SPI_SETSCREENSAVERRUNNING_REGKEY,
1688                             SPI_SETSCREENSAVERRUNNING_VALNAME,
1689                             buf, 0 ))
1690         {
1691             screensaver_running = uiParam;
1692             spi_loaded[spi_idx] = TRUE;
1693         }
1694         else
1695             ret = FALSE;
1696         break;
1697     }
1698
1699     case SPI_GETMOUSEHOVERWIDTH:                /*     98  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1700         if (!pvParam) return FALSE;
1701         *(UINT *)pvParam = 4;
1702         break;
1703     WINE_SPI_FIXME(SPI_SETMOUSEHOVERWIDTH);     /*     99  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1704
1705     case SPI_GETMOUSEHOVERHEIGHT:               /*    100  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1706         if (!pvParam) return FALSE;
1707         *(UINT *)pvParam = 4;
1708         break;
1709     WINE_SPI_FIXME(SPI_SETMOUSEHOVERHEIGHT);    /*    101  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1710
1711     case SPI_GETMOUSEHOVERTIME:                 /*    102  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1712         if (!pvParam) return FALSE;
1713         *(UINT *)pvParam = 400; /* default for menu dropdowns */
1714         break;
1715     WINE_SPI_FIXME(SPI_SETMOUSEHOVERTIME);      /*    103  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1716
1717     case SPI_GETWHEELSCROLLLINES:               /*    104  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1718         if (!pvParam) return FALSE;
1719         *(UINT *)pvParam = 3; /* default for num scroll lines */
1720         break;
1721
1722     WINE_SPI_FIXME(SPI_SETWHEELSCROLLLINES);    /*    105  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1723
1724     case SPI_GETMENUSHOWDELAY:                  /*    106  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1725         if (!pvParam) return FALSE;
1726         *(UINT *)pvParam = 400; /* Tested against Windows NT 4.0 and Windows 2000 */
1727         break;
1728
1729     WINE_SPI_FIXME(SPI_GETSHOWIMEUI);           /*    110  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1730     WINE_SPI_FIXME(SPI_SETSHOWIMEUI);           /*    111  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1731
1732     case SPI_GETSCREENSAVERRUNNING:             /*    114  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1733         if (!pvParam) return FALSE;
1734
1735         spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1736         if (!spi_loaded[spi_idx])
1737         {
1738             char buf[5];
1739
1740             if (SYSPARAMS_Load( SPI_SETSCREENSAVERRUNNING_REGKEY,
1741                                 SPI_SETSCREENSAVERRUNNING_VALNAME, buf, sizeof(buf) ))
1742                 screensaver_running  = atoi( buf );
1743             spi_loaded[spi_idx] = TRUE;
1744         }
1745
1746         *(BOOL *)pvParam = screensaver_running;
1747         break;
1748
1749     case SPI_GETDESKWALLPAPER:                  /*    115  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1750     {
1751         char buf[MAX_PATH];
1752
1753         if (!pvParam) return FALSE;
1754
1755         if (uiParam > MAX_PATH)
1756         {
1757             uiParam = MAX_PATH;
1758         }
1759
1760         if (SYSPARAMS_Load(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, buf, sizeof(buf)))
1761         {
1762             strncpy((char*)pvParam, buf, uiParam);
1763         }
1764         else
1765         {
1766             /* Return an empty string */
1767             memset((char*)pvParam, 0, uiParam);
1768         }
1769
1770         break;
1771     }
1772
1773     WINE_SPI_FIXME(SPI_GETACTIVEWINDOWTRACKING);/* 0x1000  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1774     WINE_SPI_FIXME(SPI_SETACTIVEWINDOWTRACKING);/* 0x1001  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1775     WINE_SPI_FIXME(SPI_GETMENUANIMATION);       /* 0x1002  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1776     WINE_SPI_FIXME(SPI_SETMENUANIMATION);       /* 0x1003  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1777     WINE_SPI_FIXME(SPI_GETCOMBOBOXANIMATION);   /* 0x1004  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1778     WINE_SPI_FIXME(SPI_SETCOMBOBOXANIMATION);   /* 0x1005  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1779     WINE_SPI_FIXME(SPI_GETLISTBOXSMOOTHSCROLLING);/* 0x1006  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1780     WINE_SPI_FIXME(SPI_SETLISTBOXSMOOTHSCROLLING);/* 0x1007  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1781
1782     case SPI_GETGRADIENTCAPTIONS:    /* 0x1008  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1783         if (!pvParam) return FALSE;
1784         FIXME("case SPI_GETGRADIENTCAPTIONS always return false\n");
1785         *(BOOL *)pvParam = FALSE;
1786         break;
1787
1788     WINE_SPI_FIXME(SPI_SETGRADIENTCAPTIONS);    /* 0x1009  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1789     WINE_SPI_FIXME(SPI_GETKEYBOARDCUES);        /* 0x100A  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1790     WINE_SPI_FIXME(SPI_SETKEYBOARDCUES);        /* 0x100B  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1791     WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKZORDER);  /* 0x100C  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1792     WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKZORDER);  /* 0x100D  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1793     WINE_SPI_FIXME(SPI_GETHOTTRACKING);         /* 0x100E  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1794     WINE_SPI_FIXME(SPI_SETHOTTRACKING);         /* 0x100F  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1795     WINE_SPI_FIXME(SPI_GETSELECTIONFADE);       /* 0x1014  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1796     WINE_SPI_FIXME(SPI_SETSELECTIONFADE);       /* 0x1015  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1797     WINE_SPI_FIXME(SPI_GETDROPSHADOW);          /* 0x1024  _WIN32_WINNT >= 0x510 */
1798     WINE_SPI_FIXME(SPI_SETDROPSHADOW);          /* 0x1025  _WIN32_WINNT >= 0x510 */
1799     WINE_SPI_FIXME(SPI_GETFOREGROUNDLOCKTIMEOUT);/* 0x2000  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1800     WINE_SPI_FIXME(SPI_SETFOREGROUNDLOCKTIMEOUT);/* 0x2001  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1801     WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKTIMEOUT); /* 0x2002  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1802     WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKTIMEOUT); /* 0x2003  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1803     WINE_SPI_FIXME(SPI_GETFOREGROUNDFLASHCOUNT);/* 0x2004  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1804     WINE_SPI_FIXME(SPI_SETFOREGROUNDFLASHCOUNT);/* 0x2005  _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1805
1806     default:
1807         FIXME( "Unknown action: %u\n", uiAction );
1808         SetLastError( ERROR_INVALID_SPI_VALUE );
1809         ret = FALSE;
1810         break;
1811     }
1812
1813     if (ret)
1814         SYSPARAMS_NotifyChange( uiAction, fWinIni );
1815     return ret;
1816
1817 #undef WINE_SPI_FIXME
1818 #undef WINE_SPI_WARN
1819 }
1820
1821
1822 /***********************************************************************
1823  *              SystemParametersInfo (USER.483)
1824  */
1825 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
1826                                       LPVOID lpvParam, UINT16 fuWinIni )
1827 {
1828     BOOL16 ret;
1829
1830     TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
1831
1832     switch (uAction)
1833     {
1834     case SPI_GETBEEP:                           /*      1 */
1835     case SPI_GETSCREENSAVEACTIVE:               /*     16 */
1836     case SPI_GETICONTITLEWRAP:                  /*     25 */
1837     case SPI_GETMENUDROPALIGNMENT:              /*     27 */
1838     case SPI_GETFASTTASKSWITCH:                 /*     35 */
1839     case SPI_GETDRAGFULLWINDOWS:                /*     38  WINVER >= 0x0400 */
1840     {
1841         BOOL tmp;
1842         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1843         if (ret && lpvParam)
1844             *(BOOL16 *)lpvParam = tmp;
1845         break;
1846     }
1847
1848     case SPI_GETBORDER:                         /*      5 */
1849     case SPI_ICONHORIZONTALSPACING:             /*     13 */
1850     case SPI_GETSCREENSAVETIMEOUT:              /*     14 */
1851     case SPI_GETGRIDGRANULARITY:                /*     18 */
1852     case SPI_GETKEYBOARDDELAY:                  /*     22 */
1853     case SPI_ICONVERTICALSPACING:               /*     24 */
1854     {
1855         INT tmp;
1856         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1857         if (ret && lpvParam)
1858             *(INT16 *)lpvParam = tmp;
1859         break;
1860     }
1861
1862     case SPI_GETKEYBOARDSPEED:                  /*     10 */
1863     {
1864         DWORD tmp;
1865         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1866         if (ret && lpvParam)
1867             *(WORD *)lpvParam = tmp;
1868         break;
1869     }
1870
1871     case SPI_GETICONTITLELOGFONT:               /*     31 */
1872     {
1873         LOGFONTA tmp;
1874         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1875         if (ret && lpvParam)
1876             SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
1877         break;
1878     }
1879
1880     case SPI_GETNONCLIENTMETRICS:               /*     41  WINVER >= 0x400 */
1881     {
1882         NONCLIENTMETRICSA tmp;
1883         LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
1884         if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
1885         {
1886             tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1887             ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
1888             if (ret)
1889                 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
1890         }
1891         else /* winfile 95 sets cbSize to 340 */
1892             ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1893         break;
1894     }
1895
1896     case SPI_GETWORKAREA:                       /*     48  WINVER >= 0x400 */
1897     {
1898         RECT tmp;
1899         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1900         if (ret && lpvParam)
1901             CONV_RECT32TO16( &tmp, (RECT16 *)lpvParam );
1902         break;
1903     }
1904
1905     case SPI_GETMOUSEHOVERWIDTH:                /*     98  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1906     case SPI_GETMOUSEHOVERHEIGHT:               /*    100  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1907     case SPI_GETMOUSEHOVERTIME:                 /*    102  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1908     {
1909         UINT tmp;
1910         ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1911         if (ret && lpvParam)
1912             *(UINT16 *)lpvParam = tmp;
1913         break;
1914     }
1915
1916     default:
1917         ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1918     }
1919
1920     return ret;
1921 }
1922
1923 /***********************************************************************
1924  *              SystemParametersInfoW (USER32.@)
1925  */
1926 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
1927                                    PVOID pvParam, UINT fuWinIni )
1928 {
1929     BOOL ret;
1930
1931     TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
1932
1933     switch (uiAction)
1934     {
1935     case SPI_SETDESKWALLPAPER:                  /*     20 */
1936     case SPI_SETDESKPATTERN:                    /*     21 */
1937     {
1938         char buffer[256];
1939         if (pvParam)
1940             if (!WideCharToMultiByte( CP_ACP, 0, (LPWSTR)pvParam, -1,
1941                                       buffer, sizeof(buffer), NULL, NULL ))
1942                 buffer[sizeof(buffer)-1] = 0;
1943         ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
1944         break;
1945     }
1946
1947     case SPI_GETICONTITLELOGFONT:               /*     31 */
1948     {
1949         LOGFONTA tmp;
1950         ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
1951         if (ret && pvParam)
1952             SYSPARAMS_LogFont32ATo32W( &tmp, (LPLOGFONTW)pvParam );
1953         break;
1954     }
1955
1956     case SPI_GETNONCLIENTMETRICS:               /*     41  WINVER >= 0x400 */
1957     {
1958         NONCLIENTMETRICSA tmp;
1959         LPNONCLIENTMETRICSW lpnmW = (LPNONCLIENTMETRICSW)pvParam;
1960         if (lpnmW && lpnmW->cbSize == sizeof(NONCLIENTMETRICSW))
1961         {
1962             tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1963             ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1964             if (ret)
1965                 SYSPARAMS_NonClientMetrics32ATo32W( &tmp, lpnmW );
1966         }
1967         else
1968             ret = FALSE;
1969         break;
1970     }
1971
1972     case SPI_GETICONMETRICS:                    /*     45  WINVER >= 0x400 */
1973     {
1974         ICONMETRICSA tmp;
1975         LPICONMETRICSW lpimW = (LPICONMETRICSW)pvParam;
1976         if (lpimW && lpimW->cbSize == sizeof(ICONMETRICSW))
1977         {
1978             tmp.cbSize = sizeof(ICONMETRICSA);
1979             ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1980             if (ret)
1981             {
1982                 lpimW->iHorzSpacing = tmp.iHorzSpacing;
1983                 lpimW->iVertSpacing = tmp.iVertSpacing;
1984                 lpimW->iTitleWrap   = tmp.iTitleWrap;
1985                 SYSPARAMS_LogFont32ATo32W( &tmp.lfFont, &lpimW->lfFont );
1986             }
1987         }
1988         else
1989             ret = FALSE;
1990         break;
1991     }
1992
1993     case SPI_GETHIGHCONTRAST:                   /*     66  WINVER >= 0x400 */
1994     {
1995         HIGHCONTRASTA tmp;
1996         LPHIGHCONTRASTW lphcW = (LPHIGHCONTRASTW)pvParam;
1997         if (lphcW && lphcW->cbSize == sizeof(HIGHCONTRASTW))
1998         {
1999             tmp.cbSize = sizeof(HIGHCONTRASTA);
2000             ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
2001             if (ret)
2002             {
2003                 lphcW->dwFlags = tmp.dwFlags;
2004                 lphcW->lpszDefaultScheme = NULL;  /* FIXME? */
2005             }
2006         }
2007         else
2008             ret = FALSE;
2009         break;
2010     }
2011
2012     default:
2013         ret = SystemParametersInfoA( uiAction, uiParam, pvParam, fuWinIni );
2014         break;
2015     }
2016     return ret;
2017 }
2018
2019
2020 /**********************************************************************
2021  *              SetDoubleClickTime (USER32.@)
2022  */
2023 BOOL WINAPI SetDoubleClickTime( UINT interval )
2024 {
2025     return SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
2026 }
2027
2028
2029 /**********************************************************************
2030  *              GetDoubleClickTime (USER32.@)
2031  */
2032 UINT WINAPI GetDoubleClickTime(void)
2033 {
2034     char buf[10];
2035
2036     if (!spi_loaded[SPI_SETDOUBLECLICKTIME_IDX])
2037     {
2038         if (SYSPARAMS_Load( SPI_SETDOUBLECLICKTIME_REGKEY,
2039                             SPI_SETDOUBLECLICKTIME_VALNAME,
2040                             buf, sizeof(buf) ))
2041         {
2042             double_click_time = atoi( buf );
2043             if (!double_click_time) double_click_time = 500;
2044         }
2045         spi_loaded[SPI_SETDOUBLECLICKTIME_IDX] = TRUE;
2046     }
2047     return double_click_time;
2048 }