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