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