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