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