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