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