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

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