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