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