git.oblomov.eu Git - wine/blob - dlls/user32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
  29 #define NONAMELESSUNION
  30 #define NONAMELESSSTRUCT
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winnls.h"
  35 #include "wingdi.h"
  36 #include "winreg.h"
  37 #include "wine/wingdi16.h"
  38 #include "winerror.h"
  39
  40 #include "controls.h"
  41 #include "user_private.h"
  42 #include "wine/gdi_driver.h"
  43 #include "wine/unicode.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(system);
  47
  48 /* System parameter indexes */
  49 enum spi_index
  50 {
  51     SPI_SETWORKAREA_IDX,
  52     SPI_INDEX_COUNT
  53 };
  54
  55 static const struct
  56 {
  57     const char *name;
  58     COLORREF    rgb;
  59 } DefSysColors[] =
  60 {
  61     {"Scrollbar", RGB(212, 208, 200)},              /* COLOR_SCROLLBAR */
  62     {"Background", RGB(58, 110, 165)},              /* COLOR_BACKGROUND */
  63     {"ActiveTitle", RGB(10, 36, 106)},              /* COLOR_ACTIVECAPTION */
  64     {"InactiveTitle", RGB(128, 128, 128)},          /* COLOR_INACTIVECAPTION */
  65     {"Menu", RGB(212, 208, 200)},                   /* COLOR_MENU */
  66     {"Window", RGB(255, 255, 255)},                 /* COLOR_WINDOW */
  67     {"WindowFrame", RGB(0, 0, 0)},                  /* COLOR_WINDOWFRAME */
  68     {"MenuText", RGB(0, 0, 0)},                     /* COLOR_MENUTEXT */
  69     {"WindowText", RGB(0, 0, 0)},                   /* COLOR_WINDOWTEXT */
  70     {"TitleText", RGB(255, 255, 255)},              /* COLOR_CAPTIONTEXT */
  71     {"ActiveBorder", RGB(212, 208, 200)},           /* COLOR_ACTIVEBORDER */
  72     {"InactiveBorder", RGB(212, 208, 200)},         /* COLOR_INACTIVEBORDER */
  73     {"AppWorkSpace", RGB(128, 128, 128)},           /* COLOR_APPWORKSPACE */
  74     {"Hilight", RGB(10, 36, 106)},                  /* COLOR_HIGHLIGHT */
  75     {"HilightText", RGB(255, 255, 255)},            /* COLOR_HIGHLIGHTTEXT */
  76     {"ButtonFace", RGB(212, 208, 200)},             /* COLOR_BTNFACE */
  77     {"ButtonShadow", RGB(128, 128, 128)},           /* COLOR_BTNSHADOW */
  78     {"GrayText", RGB(128, 128, 128)},               /* COLOR_GRAYTEXT */
  79     {"ButtonText", RGB(0, 0, 0)},                   /* COLOR_BTNTEXT */
  80     {"InactiveTitleText", RGB(212, 208, 200)},      /* COLOR_INACTIVECAPTIONTEXT */
  81     {"ButtonHilight", RGB(255, 255, 255)},          /* COLOR_BTNHIGHLIGHT */
  82     {"ButtonDkShadow", RGB(64, 64, 64)},            /* COLOR_3DDKSHADOW */
  83     {"ButtonLight", RGB(212, 208, 200)},            /* COLOR_3DLIGHT */
  84     {"InfoText", RGB(0, 0, 0)},                     /* COLOR_INFOTEXT */
  85     {"InfoWindow", RGB(255, 255, 225)},             /* COLOR_INFOBK */
  86     {"ButtonAlternateFace", RGB(181, 181, 181)},    /* COLOR_ALTERNATEBTNFACE */
  87     {"HotTrackingColor", RGB(0, 0, 200)},           /* COLOR_HOTLIGHT */
  88     {"GradientActiveTitle", RGB(166, 202, 240)},    /* COLOR_GRADIENTACTIVECAPTION */
  89     {"GradientInactiveTitle", RGB(192, 192, 192)},  /* COLOR_GRADIENTINACTIVECAPTION */
  90     {"MenuHilight", RGB(10, 36, 106)},              /* COLOR_MENUHILIGHT */
  91     {"MenuBar", RGB(212, 208, 200)}                 /* COLOR_MENUBAR */
  92 };
  93
  94 /**
  95  * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
  96  * for the system parameters.
  97  * Names of the keys are created by adding string "_REGKEY" to
  98  * "SET" action names, value names are created by adding "_REG_NAME"
  99  * to the "SET" action name.
 100  */
 101
 102 /* the various registry keys that are used to store parameters */
 103 enum parameter_key
 104 {
 105     DESKTOP_KEY,
 106     KEYBOARD_KEY,
 107     MOUSE_KEY,
 108     METRICS_KEY,
 109     SOUND_KEY,
 110     VERSION_KEY,
 111     SHOWSOUNDS_KEY,
 112     KEYBOARDPREF_KEY,
 113     SCREENREADER_KEY,
 114     NB_PARAM_KEYS
 115 };
 116
 117 static const WCHAR DESKTOP_REGKEY[] =  {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
 118 static const WCHAR KEYBOARD_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
 119 static const WCHAR MOUSE_REGKEY[] =    {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
 120 static const WCHAR METRICS_REGKEY[] =  {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
 121                                         'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
 122 static const WCHAR SOUND_REGKEY[]=     {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','S','o','u','n','d',0};
 123 static const WCHAR VERSION_REGKEY[] =  {'S','o','f','t','w','a','r','e','\\',
 124                                         'M','i','c','r','o','s','o','f','t','\\',
 125                                         'W','i','n','d','o','w','s',' ','N','T','\\',
 126                                         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 127                                         'W','i','n','d','o','w','s',0};
 128 static const WCHAR SHOWSOUNDS_REGKEY[] =   {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 129                                             'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
 130                                             'S','h','o','w','S','o','u','n','d','s',0};
 131 static const WCHAR KEYBOARDPREF_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 132                                             'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
 133                                             'K','e','y','b','o','a','r','d',' ','P','r','e','f','e','r','e','n','c','e',0};
 134 static const WCHAR SCREENREADER_REGKEY[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 135                                             'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
 136                                             'B','l','i','n','d',' ','A','c','c','e','s','s',0};
 137
 138 static const WCHAR *parameter_key_names[NB_PARAM_KEYS] =
 139 {
 140     DESKTOP_REGKEY,
 141     KEYBOARD_REGKEY,
 142     MOUSE_REGKEY,
 143     METRICS_REGKEY,
 144     SOUND_REGKEY,
 145     VERSION_REGKEY,
 146     SHOWSOUNDS_REGKEY,
 147     KEYBOARDPREF_REGKEY,
 148     SCREENREADER_REGKEY,
 149 };
 150
 151 /* parameter key values; the first char is actually an enum parameter_key to specify the key */
 152 static const WCHAR BEEP_VALNAME[]=                     {SOUND_KEY,'B','e','e','p',0};
 153 static const WCHAR MOUSETHRESHOLD1_VALNAME[]=          {MOUSE_KEY,'M','o','u','s','e','T','h','r','e','s','h','o','l','d','1',0};
 154 static const WCHAR MOUSETHRESHOLD2_VALNAME[]=          {MOUSE_KEY,'M','o','u','s','e','T','h','r','e','s','h','o','l','d','2',0};
 155 static const WCHAR MOUSEACCELERATION_VALNAME[]=        {MOUSE_KEY,'M','o','u','s','e','S','p','e','e','d',0};
 156 static const WCHAR BORDER_VALNAME[]=                   {METRICS_KEY,'B','o','r','d','e','r','W','i','d','t','h',0};
 157 static const WCHAR KEYBOARDSPEED_VALNAME[]=            {KEYBOARD_KEY,'K','e','y','b','o','a','r','d','S','p','e','e','d',0};
 158 static const WCHAR ICONHORIZONTALSPACING_VALNAME[]=    {METRICS_KEY,'I','c','o','n','S','p','a','c','i','n','g',0};
 159 static const WCHAR SCREENSAVETIMEOUT_VALNAME[]=        {DESKTOP_KEY,'S','c','r','e','e','n','S','a','v','e','T','i','m','e','O','u','t',0};
 160 static const WCHAR SCREENSAVEACTIVE_VALNAME[]=         {DESKTOP_KEY,'S','c','r','e','e','n','S','a','v','e','A','c','t','i','v','e',0};
 161 static const WCHAR GRIDGRANULARITY_VALNAME[]=          {DESKTOP_KEY,'G','r','i','d','G','r','a','n','u','l','a','r','i','t','y',0};
 162 static const WCHAR KEYBOARDDELAY_VALNAME[]=            {KEYBOARD_KEY,'K','e','y','b','o','a','r','d','D','e','l','a','y',0};
 163 static const WCHAR ICONVERTICALSPACING_VALNAME[]=      {METRICS_KEY,'I','c','o','n','V','e','r','t','i','c','a','l','S','p','a','c','i','n','g',0};
 164 static const WCHAR ICONTITLEWRAP_VALNAME[]=            {DESKTOP_KEY,'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
 165 static const WCHAR ICONTITLEWRAP_MIRROR[]=             {METRICS_KEY,'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
 166 static const WCHAR ICONTITLELOGFONT_VALNAME[]=         {METRICS_KEY,'I','c','o','n','F','o','n','t',0};
 167 static const WCHAR MENUDROPALIGNMENT_VALNAME[]=        {DESKTOP_KEY,'M','e','n','u','D','r','o','p','A','l','i','g','n','m','e','n','t',0};
 168 static const WCHAR MENUDROPALIGNMENT_MIRROR[]=         {VERSION_KEY,'M','e','n','u','D','r','o','p','A','l','i','g','n','m','e','n','t',0};
 169 static const WCHAR MOUSETRAILS_VALNAME[]=              {MOUSE_KEY,'M','o','u','s','e','T','r','a','i','l','s',0};
 170 static const WCHAR SNAPTODEFBUTTON_VALNAME[]=          {MOUSE_KEY,'S','n','a','p','T','o','D','e','f','a','u','l','t','B','u','t','t','o','n',0};
 171 static const WCHAR DOUBLECLKWIDTH_VALNAME[]=           {MOUSE_KEY,'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
 172 static const WCHAR DOUBLECLKWIDTH_MIRROR[]=            {DESKTOP_KEY,'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
 173 static const WCHAR DOUBLECLKHEIGHT_VALNAME[]=          {MOUSE_KEY,'D','o','u','b','l','e','C','l','i','c','k','H','e','i','g','h','t',0};
 174 static const WCHAR DOUBLECLKHEIGHT_MIRROR[]=           {DESKTOP_KEY,'D','o','u','b','l','e','C','l','i','c','k','H','e','i','g','h','t',0};
 175 static const WCHAR DOUBLECLICKTIME_VALNAME[]=          {MOUSE_KEY,'D','o','u','b','l','e','C','l','i','c','k','S','p','e','e','d',0};
 176 static const WCHAR MOUSEBUTTONSWAP_VALNAME[]=          {MOUSE_KEY,'S','w','a','p','M','o','u','s','e','B','u','t','t','o','n','s',0};
 177 static const WCHAR DRAGFULLWINDOWS_VALNAME[]=          {DESKTOP_KEY,'D','r','a','g','F','u','l','l','W','i','n','d','o','w','s',0};
 178 static const WCHAR SHOWSOUNDS_VALNAME[]=               {SHOWSOUNDS_KEY,'O','n',0};
 179 static const WCHAR KEYBOARDPREF_VALNAME[]=             {KEYBOARDPREF_KEY,'O','n',0};
 180 static const WCHAR SCREENREADER_VALNAME[]=             {SCREENREADER_KEY,'O','n',0};
 181 static const WCHAR DESKWALLPAPER_VALNAME[]=            {DESKTOP_KEY,'W','a','l','l','p','a','p','e','r',0};
 182 static const WCHAR DESKPATTERN_VALNAME[]=              {DESKTOP_KEY,'P','a','t','t','e','r','n',0};
 183 static const WCHAR FONTSMOOTHING_VALNAME[]=            {DESKTOP_KEY,'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
 184 static const WCHAR DRAGWIDTH_VALNAME[]=                {DESKTOP_KEY,'D','r','a','g','W','i','d','t','h',0};
 185 static const WCHAR DRAGHEIGHT_VALNAME[]=               {DESKTOP_KEY,'D','r','a','g','H','e','i','g','h','t',0};
 186 static const WCHAR LOWPOWERACTIVE_VALNAME[]=           {DESKTOP_KEY,'L','o','w','P','o','w','e','r','A','c','t','i','v','e',0};
 187 static const WCHAR POWEROFFACTIVE_VALNAME[]=           {DESKTOP_KEY,'P','o','w','e','r','O','f','f','A','c','t','i','v','e',0};
 188 static const WCHAR USERPREFERENCESMASK_VALNAME[]=      {DESKTOP_KEY,'U','s','e','r','P','r','e','f','e','r','e','n','c','e','s','M','a','s','k',0};
 189 static const WCHAR MOUSEHOVERWIDTH_VALNAME[]=          {MOUSE_KEY,'M','o','u','s','e','H','o','v','e','r','W','i','d','t','h',0};
 190 static const WCHAR MOUSEHOVERHEIGHT_VALNAME[]=         {MOUSE_KEY,'M','o','u','s','e','H','o','v','e','r','H','e','i','g','h','t',0};
 191 static const WCHAR MOUSEHOVERTIME_VALNAME[]=           {MOUSE_KEY,'M','o','u','s','e','H','o','v','e','r','T','i','m','e',0};
 192 static const WCHAR WHEELSCROLLCHARS_VALNAME[]=         {DESKTOP_KEY,'W','h','e','e','l','S','c','r','o','l','l','C','h','a','r','s',0};
 193 static const WCHAR WHEELSCROLLLINES_VALNAME[]=         {DESKTOP_KEY,'W','h','e','e','l','S','c','r','o','l','l','L','i','n','e','s',0};
 194 static const WCHAR ACTIVEWINDOWTRACKING_VALNAME[]=     {MOUSE_KEY,'A','c','t','i','v','e','W','i','n','d','o','w','T','r','a','c','k','i','n','g',0};
 195 static const WCHAR MENUSHOWDELAY_VALNAME[]=            {DESKTOP_KEY,'M','e','n','u','S','h','o','w','D','e','l','a','y',0};
 196 static const WCHAR BLOCKSENDINPUTRESETS_VALNAME[]=     {DESKTOP_KEY,'B','l','o','c','k','S','e','n','d','I','n','p','u','t','R','e','s','e','t','s',0};
 197 static const WCHAR FOREGROUNDLOCKTIMEOUT_VALNAME[]=    {DESKTOP_KEY,'F','o','r','e','g','r','o','u','n','d','L','o','c','k','T','i','m','e','o','u','t',0};
 198 static const WCHAR ACTIVEWNDTRKTIMEOUT_VALNAME[]=      {DESKTOP_KEY,'A','c','t','i','v','e','W','n','d','T','r','a','c','k','T','i','m','e','o','u','t',0};
 199 static const WCHAR FOREGROUNDFLASHCOUNT_VALNAME[]=     {DESKTOP_KEY,'F','o','r','e','g','r','o','u','n','d','F','l','a','s','h','C','o','u','n','t',0};
 200 static const WCHAR CARETWIDTH_VALNAME[]=               {DESKTOP_KEY,'C','a','r','e','t','W','i','d','t','h',0};
 201 static const WCHAR MOUSECLICKLOCKTIME_VALNAME[]=       {DESKTOP_KEY,'C','l','i','c','k','L','o','c','k','T','i','m','e',0};
 202 static const WCHAR MOUSESPEED_VALNAME[]=               {MOUSE_KEY,'M','o','u','s','e','S','e','n','s','i','t','i','v','i','t','y',0};
 203 static const WCHAR FONTSMOOTHINGTYPE_VALNAME[]=        {DESKTOP_KEY,'F','o','n','t','S','m','o','o','t','h','i','n','g','T','y','p','e',0};
 204 static const WCHAR FONTSMOOTHINGCONTRAST_VALNAME[]=    {DESKTOP_KEY,'F','o','n','t','S','m','o','o','t','h','i','n','g','G','a','m','m','a',0};
 205 static const WCHAR FONTSMOOTHINGORIENTATION_VALNAME[]= {DESKTOP_KEY,'F','o','n','t','S','m','o','o','t','h','i','n','g','O','r','i','e','n','t','a','t','i','o','n',0};
 206 static const WCHAR FOCUSBORDERWIDTH_VALNAME[]=         {DESKTOP_KEY,'F','o','c','u','s','B','o','r','d','e','r','W','i','d','t','h',0};
 207 static const WCHAR FOCUSBORDERHEIGHT_VALNAME[]=        {DESKTOP_KEY,'F','o','c','u','s','B','o','r','d','e','r','H','e','i','g','h','t',0};
 208 static const WCHAR SCROLLWIDTH_VALNAME[]=              {METRICS_KEY,'S','c','r','o','l','l','W','i','d','t','h',0};
 209 static const WCHAR SCROLLHEIGHT_VALNAME[]=             {METRICS_KEY,'S','c','r','o','l','l','H','e','i','g','h','t',0};
 210 static const WCHAR CAPTIONWIDTH_VALNAME[]=             {METRICS_KEY,'C','a','p','t','i','o','n','W','i','d','t','h',0};
 211 static const WCHAR CAPTIONHEIGHT_VALNAME[]=            {METRICS_KEY,'C','a','p','t','i','o','n','H','e','i','g','h','t',0};
 212 static const WCHAR SMCAPTIONWIDTH_VALNAME[]=           {METRICS_KEY,'S','m','C','a','p','t','i','o','n','W','i','d','t','h',0};
 213 static const WCHAR SMCAPTIONHEIGHT_VALNAME[]=          {METRICS_KEY,'S','m','C','a','p','t','i','o','n','H','e','i','g','h','t',0};
 214 static const WCHAR MENUWIDTH_VALNAME[]=                {METRICS_KEY,'M','e','n','u','W','i','d','t','h',0};
 215 static const WCHAR MENUHEIGHT_VALNAME[]=               {METRICS_KEY,'M','e','n','u','H','e','i','g','h','t',0};
 216 static const WCHAR ICONSIZE_VALNAME[]=                 {METRICS_KEY,'S','h','e','l','l',' ','I','c','o','n',' ','S','i','z','e',0};
 217 static const WCHAR PADDEDBORDERWIDTH_VALNAME[]=        {METRICS_KEY,'P','a','d','d','e','d','B','o','r','d','e','r','W','i','d','t','h',0};
 218 static const WCHAR CAPTIONLOGFONT_VALNAME[]=           {METRICS_KEY,'C','a','p','t','i','o','n','F','o','n','t',0};
 219 static const WCHAR SMCAPTIONLOGFONT_VALNAME[]=         {METRICS_KEY,'S','m','C','a','p','t','i','o','n','F','o','n','t',0};
 220 static const WCHAR MENULOGFONT_VALNAME[]=              {METRICS_KEY,'M','e','n','u','F','o','n','t',0};
 221 static const WCHAR MESSAGELOGFONT_VALNAME[]=           {METRICS_KEY,'M','e','s','s','a','g','e','F','o','n','t',0};
 222 static const WCHAR STATUSLOGFONT_VALNAME[]=            {METRICS_KEY,'S','t','a','t','u','s','F','o','n','t',0};
 223 static const WCHAR MINWIDTH_VALNAME[] =                {METRICS_KEY,'M','i','n','W','i','d','t','h',0};
 224 static const WCHAR MINHORZGAP_VALNAME[] =              {METRICS_KEY,'M','i','n','H','o','r','z','G','a','p',0};
 225 static const WCHAR MINVERTGAP_VALNAME[] =              {METRICS_KEY,'M','i','n','V','e','r','t','G','a','p',0};
 226 static const WCHAR MINARRANGE_VALNAME[] =              {METRICS_KEY,'M','i','n','A','r','r','a','n','g','e',0};
 227 /* FIXME - real value */
 228 static const WCHAR SCREENSAVERRUNNING_VALNAME[]=  {DESKTOP_KEY,'W','I','N','E','_','S','c','r','e','e','n','S','a','v','e','r','R','u','n','n','i','n','g',0};
 229
 230 static const WCHAR WINE_CURRENT_USER_REGKEY[] = {'S','o','f','t','w','a','r','e','\\',
 231                                                  'W','i','n','e',0};
 232
 233 /* volatile registry branch under WINE_CURRENT_USER_REGKEY for temporary values storage */
 234 static const WCHAR WINE_CURRENT_USER_REGKEY_TEMP_PARAMS[] = {'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 static const WCHAR Yes[]=                                    {'Y','e','s',0};
 239 static const WCHAR No[]=                                     {'N','o',0};
 240 static const WCHAR Desktop[]=                                {'D','e','s','k','t','o','p',0};
 241 static const WCHAR Pattern[]=                                {'P','a','t','t','e','r','n',0};
 242 static const WCHAR MenuFont[]=                               {'M','e','n','u','F','o','n','t',0};
 243 static const WCHAR MenuFontSize[]=                           {'M','e','n','u','F','o','n','t','S','i','z','e',0};
 244 static const WCHAR StatusFont[]=                             {'S','t','a','t','u','s','F','o','n','t',0};
 245 static const WCHAR StatusFontSize[]=                         {'S','t','a','t','u','s','F','o','n','t','S','i','z','e',0};
 246 static const WCHAR MessageFont[]=                            {'M','e','s','s','a','g','e','F','o','n','t',0};
 247 static const WCHAR MessageFontSize[]=                        {'M','e','s','s','a','g','e','F','o','n','t','S','i','z','e',0};
 248 static const WCHAR System[]=                                 {'S','y','s','t','e','m',0};
 249 static const WCHAR IconTitleSize[]=                          {'I','c','o','n','T','i','t','l','e','S','i','z','e',0};
 250 static const WCHAR IconTitleFaceName[]=                      {'I','c','o','n','T','i','t','l','e','F','a','c','e','N','a','m','e',0};
 251 static const WCHAR defPattern[]=                             {'0',' ','0',' ','0',' ','0',' ','0',' ','0',' ','0',' ','0',0};
 252 static const WCHAR CSu[]=                                    {'%','u',0};
 253 static const WCHAR CSd[]=                                    {'%','d',0};
 254
 255 /* Indicators whether system parameter value is loaded */
 256 static char spi_loaded[SPI_INDEX_COUNT];
 257
 258 static BOOL notify_change = TRUE;
 259
 260 /* System parameters storage */
 261 static RECT work_area;
 262
 263 #define NUM_SYS_COLORS     (COLOR_MENUBAR+1)
 264
 265 static COLORREF SysColors[NUM_SYS_COLORS];
 266 static HBRUSH SysColorBrushes[NUM_SYS_COLORS];
 267 static HPEN   SysColorPens[NUM_SYS_COLORS];
 268
 269 static const WORD wPattern55AA[] = { 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa };
 270
 271 HBRUSH SYSCOLOR_55AABrush = 0;
 272
 273 union sysparam_all_entry;
 274
 275 struct sysparam_entry
 276 {
 277     BOOL       (*get)( union sysparam_all_entry *entry, UINT int_param, void *ptr_param );
 278     BOOL       (*set)( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags );
 279     const WCHAR *regval;
 280     const WCHAR *mirror;
 281     BOOL         loaded;
 282 };
 283
 284 struct sysparam_uint_entry
 285 {
 286     struct sysparam_entry hdr;
 287     UINT                  val;
 288 };
 289
 290 struct sysparam_bool_entry
 291 {
 292     struct sysparam_entry hdr;
 293     BOOL                  val;
 294 };
 295
 296 struct sysparam_dword_entry
 297 {
 298     struct sysparam_entry hdr;
 299     DWORD                 val;
 300 };
 301
 302 struct sysparam_binary_entry
 303 {
 304     struct sysparam_entry hdr;
 305     void                 *ptr;
 306     size_t                size;
 307 };
 308
 309 struct sysparam_path_entry
 310 {
 311     struct sysparam_entry hdr;
 312     WCHAR                 path[MAX_PATH];
 313 };
 314
 315 struct sysparam_font_entry
 316 {
 317     struct sysparam_entry hdr;
 318     UINT                  weight;
 319     LOGFONTW              val;
 320 };
 321
 322 struct sysparam_pref_entry
 323 {
 324     struct sysparam_entry hdr;
 325     struct sysparam_binary_entry *parent;
 326     UINT                  offset;
 327     UINT                  mask;
 328 };
 329
 330 union sysparam_all_entry
 331 {
 332     struct sysparam_entry        hdr;
 333     struct sysparam_uint_entry   uint;
 334     struct sysparam_bool_entry   bool;
 335     struct sysparam_dword_entry  dword;
 336     struct sysparam_binary_entry bin;
 337     struct sysparam_path_entry   path;
 338     struct sysparam_font_entry   font;
 339     struct sysparam_pref_entry   pref;
 340 };
 341
 342 static void SYSPARAMS_LogFont16To32W( const LOGFONT16 *font16, LPLOGFONTW font32 )
 343 {
 344     font32->lfHeight = font16->lfHeight;
 345     font32->lfWidth = font16->lfWidth;
 346     font32->lfEscapement = font16->lfEscapement;
 347     font32->lfOrientation = font16->lfOrientation;
 348     font32->lfWeight = font16->lfWeight;
 349     font32->lfItalic = font16->lfItalic;
 350     font32->lfUnderline = font16->lfUnderline;
 351     font32->lfStrikeOut = font16->lfStrikeOut;
 352     font32->lfCharSet = font16->lfCharSet;
 353     font32->lfOutPrecision = font16->lfOutPrecision;
 354     font32->lfClipPrecision = font16->lfClipPrecision;
 355     font32->lfQuality = font16->lfQuality;
 356     font32->lfPitchAndFamily = font16->lfPitchAndFamily;
 357     MultiByteToWideChar( CP_ACP, 0, font16->lfFaceName, -1, font32->lfFaceName, LF_FACESIZE );
 358     font32->lfFaceName[LF_FACESIZE-1] = 0;
 359 }
 360
 361 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW* font32W, LPLOGFONTA font32A )
 362 {
 363     font32A->lfHeight = font32W->lfHeight;
 364     font32A->lfWidth = font32W->lfWidth;
 365     font32A->lfEscapement = font32W->lfEscapement;
 366     font32A->lfOrientation = font32W->lfOrientation;
 367     font32A->lfWeight = font32W->lfWeight;
 368     font32A->lfItalic = font32W->lfItalic;
 369     font32A->lfUnderline = font32W->lfUnderline;
 370     font32A->lfStrikeOut = font32W->lfStrikeOut;
 371     font32A->lfCharSet = font32W->lfCharSet;
 372     font32A->lfOutPrecision = font32W->lfOutPrecision;
 373     font32A->lfClipPrecision = font32W->lfClipPrecision;
 374     font32A->lfQuality = font32W->lfQuality;
 375     font32A->lfPitchAndFamily = font32W->lfPitchAndFamily;
 376     WideCharToMultiByte( CP_ACP, 0, font32W->lfFaceName, -1, font32A->lfFaceName, LF_FACESIZE, NULL, NULL );
 377     font32A->lfFaceName[LF_FACESIZE-1] = 0;
 378 }
 379
 380 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
 381 {
 382     font32W->lfHeight = font32A->lfHeight;
 383     font32W->lfWidth = font32A->lfWidth;
 384     font32W->lfEscapement = font32A->lfEscapement;
 385     font32W->lfOrientation = font32A->lfOrientation;
 386     font32W->lfWeight = font32A->lfWeight;
 387     font32W->lfItalic = font32A->lfItalic;
 388     font32W->lfUnderline = font32A->lfUnderline;
 389     font32W->lfStrikeOut = font32A->lfStrikeOut;
 390     font32W->lfCharSet = font32A->lfCharSet;
 391     font32W->lfOutPrecision = font32A->lfOutPrecision;
 392     font32W->lfClipPrecision = font32A->lfClipPrecision;
 393     font32W->lfQuality = font32A->lfQuality;
 394     font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
 395     MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
 396     font32W->lfFaceName[LF_FACESIZE-1] = 0;
 397 }
 398
 399 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW* lpnm32W, LPNONCLIENTMETRICSA lpnm32A )
 400 {
 401     lpnm32A->iBorderWidth       = lpnm32W->iBorderWidth;
 402     lpnm32A->iScrollWidth       = lpnm32W->iScrollWidth;
 403     lpnm32A->iScrollHeight      = lpnm32W->iScrollHeight;
 404     lpnm32A->iCaptionWidth      = lpnm32W->iCaptionWidth;
 405     lpnm32A->iCaptionHeight     = lpnm32W->iCaptionHeight;
 406     SYSPARAMS_LogFont32WTo32A(  &lpnm32W->lfCaptionFont,        &lpnm32A->lfCaptionFont );
 407     lpnm32A->iSmCaptionWidth    = lpnm32W->iSmCaptionWidth;
 408     lpnm32A->iSmCaptionHeight   = lpnm32W->iSmCaptionHeight;
 409     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfSmCaptionFont,       &lpnm32A->lfSmCaptionFont );
 410     lpnm32A->iMenuWidth         = lpnm32W->iMenuWidth;
 411     lpnm32A->iMenuHeight        = lpnm32W->iMenuHeight;
 412     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMenuFont,            &lpnm32A->lfMenuFont );
 413     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfStatusFont,          &lpnm32A->lfStatusFont );
 414     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMessageFont,         &lpnm32A->lfMessageFont );
 415     if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
 416     {
 417         if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
 418             lpnm32A->iPaddedBorderWidth = lpnm32W->iPaddedBorderWidth;
 419         else
 420             lpnm32A->iPaddedBorderWidth = 0;
 421     }
 422 }
 423
 424 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
 425 {
 426     lpnm32W->iBorderWidth       = lpnm32A->iBorderWidth;
 427     lpnm32W->iScrollWidth       = lpnm32A->iScrollWidth;
 428     lpnm32W->iScrollHeight      = lpnm32A->iScrollHeight;
 429     lpnm32W->iCaptionWidth      = lpnm32A->iCaptionWidth;
 430     lpnm32W->iCaptionHeight     = lpnm32A->iCaptionHeight;
 431     SYSPARAMS_LogFont32ATo32W(  &lpnm32A->lfCaptionFont,        &lpnm32W->lfCaptionFont );
 432     lpnm32W->iSmCaptionWidth    = lpnm32A->iSmCaptionWidth;
 433     lpnm32W->iSmCaptionHeight   = lpnm32A->iSmCaptionHeight;
 434     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont,       &lpnm32W->lfSmCaptionFont );
 435     lpnm32W->iMenuWidth         = lpnm32A->iMenuWidth;
 436     lpnm32W->iMenuHeight        = lpnm32A->iMenuHeight;
 437     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont,            &lpnm32W->lfMenuFont );
 438     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont,          &lpnm32W->lfStatusFont );
 439     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont,         &lpnm32W->lfMessageFont );
 440     if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
 441     {
 442         if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
 443             lpnm32W->iPaddedBorderWidth = lpnm32A->iPaddedBorderWidth;
 444         else
 445             lpnm32W->iPaddedBorderWidth = 0;
 446     }
 447 }
 448
 449
 450 /* Helper functions to retrieve monitors info */
 451
 452 struct monitor_info
 453 {
 454     int count;
 455     RECT virtual_rect;
 456 };
 457
 458 static BOOL CALLBACK monitor_info_proc( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
 459 {
 460     struct monitor_info *info = (struct monitor_info *)lp;
 461     info->count++;
 462     UnionRect( &info->virtual_rect, &info->virtual_rect, rect );
 463     return TRUE;
 464 }
 465
 466 static void get_monitors_info( struct monitor_info *info )
 467 {
 468     info->count = 0;
 469     SetRectEmpty( &info->virtual_rect );
 470     EnumDisplayMonitors( 0, NULL, monitor_info_proc, (LPARAM)info );
 471 }
 472
 473 RECT get_virtual_screen_rect(void)
 474 {
 475     struct monitor_info info;
 476     get_monitors_info( &info );
 477     return info.virtual_rect;
 478 }
 479
 480 /* get text metrics and/or "average" char width of the specified logfont
 481  * for the specified dc */
 482 static void get_text_metr_size( HDC hdc, LOGFONTW *plf, TEXTMETRICW * ptm, UINT *psz)
 483 {
 484     HFONT hfont, hfontsav;
 485     TEXTMETRICW tm;
 486     if( !ptm) ptm = &tm;
 487     hfont = CreateFontIndirectW( plf);
 488     if( !hfont || ( hfontsav = SelectObject( hdc, hfont)) == NULL ) {
 489         ptm->tmHeight = -1;
 490         if( psz) *psz = 10;
 491         if( hfont) DeleteObject( hfont);
 492         return;
 493     }
 494     GetTextMetricsW( hdc, ptm);
 495     if( psz)
 496         if( !(*psz = GdiGetCharDimensions( hdc, ptm, NULL)))
 497             *psz = 10;
 498     SelectObject( hdc, hfontsav);
 499     DeleteObject( hfont);
 500 }
 501
 502 /***********************************************************************
 503  *           get_volatile_regkey
 504  *
 505  * Return a handle to the volatile registry key used to store
 506  * non-permanently modified parameters.
 507  */
 508 static HKEY get_volatile_regkey(void)
 509 {
 510     static HKEY volatile_key;
 511
 512     if (!volatile_key)
 513     {
 514         HKEY key;
 515         /* This must be non-volatile! */
 516         if (RegCreateKeyExW( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
 517                              0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0,
 518                              &key, 0 ) != ERROR_SUCCESS)
 519         {
 520             ERR("Can't create wine registry branch\n");
 521         }
 522         else
 523         {
 524             /* @@ Wine registry key: HKCU\Software\Wine\Temporary System Parameters */
 525             if (RegCreateKeyExW( key, WINE_CURRENT_USER_REGKEY_TEMP_PARAMS,
 526                                  0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
 527                                  &volatile_key, 0 ) != ERROR_SUCCESS)
 528                 ERR("Can't create non-permanent wine registry branch\n");
 529
 530             RegCloseKey(key);
 531         }
 532     }
 533     return volatile_key;
 534 }
 535
 536 /***********************************************************************
 537  *           SYSPARAMS_NotifyChange
 538  *
 539  * Sends notification about system parameter update.
 540  */
 541 static void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
 542 {
 543     static const WCHAR emptyW[1];
 544
 545     if (notify_change)
 546     {
 547         if (fWinIni & SPIF_UPDATEINIFILE)
 548         {
 549             if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
 550                 SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE,
 551                                     uiAction, (LPARAM) emptyW,
 552                                     SMTO_ABORTIFHUNG, 2000, NULL );
 553         }
 554         else
 555         {
 556             /* FIXME notify other wine processes with internal message */
 557         }
 558     }
 559 }
 560
 561
 562 /***********************************************************************
 563  * Saves system parameter to user profile.
 564  */
 565
 566 /* Save data as-is */
 567 static BOOL SYSPARAMS_SaveRaw( LPCWSTR lpRegKey, LPCWSTR lpValName,
 568                                const void *lpValue, DWORD valueSize,
 569                                DWORD type, UINT fWinIni )
 570 {
 571     HKEY hKey;
 572     HKEY hBaseKey;
 573     DWORD dwOptions;
 574     BOOL ret = FALSE;
 575
 576     if (fWinIni & SPIF_UPDATEINIFILE)
 577     {
 578         hBaseKey = HKEY_CURRENT_USER;
 579         dwOptions = 0;
 580     }
 581     else
 582     {
 583         hBaseKey = get_volatile_regkey();
 584         dwOptions = REG_OPTION_VOLATILE;
 585     }
 586
 587     if (RegCreateKeyExW( hBaseKey, lpRegKey,
 588                          0, 0, dwOptions, KEY_ALL_ACCESS,
 589                          0, &hKey, 0 ) == ERROR_SUCCESS)
 590     {
 591         if (RegSetValueExW( hKey, lpValName, 0, type,
 592                             lpValue, valueSize) == ERROR_SUCCESS)
 593         {
 594             ret = TRUE;
 595             if (hBaseKey == HKEY_CURRENT_USER)
 596                 RegDeleteKeyW( get_volatile_regkey(), lpRegKey );
 597         }
 598         RegCloseKey( hKey );
 599     }
 600     return ret;
 601 }
 602
 603 /* load a value to a registry entry */
 604 static DWORD load_entry( struct sysparam_entry *entry, void *data, DWORD size )
 605 {
 606     DWORD type, count = 0;
 607     HKEY key;
 608
 609     if (!RegOpenKeyW( get_volatile_regkey(), parameter_key_names[entry->regval[0]], &key ))
 610     {
 611         count = size;
 612         if (RegQueryValueExW( key, entry->regval + 1, NULL, &type, data, &count )) count = 0;
 613         RegCloseKey( key );
 614     }
 615     if (!count && !RegOpenKeyW( HKEY_CURRENT_USER, parameter_key_names[entry->regval[0]], &key ))
 616     {
 617         count = size;
 618         if (RegQueryValueExW( key, entry->regval + 1, NULL, &type, data, &count )) count = 0;
 619         RegCloseKey( key );
 620     }
 621     /* make sure strings are null-terminated */
 622     if (size && count == size && type == REG_SZ) ((WCHAR *)data)[count - 1] = 0;
 623     entry->loaded = TRUE;
 624     return count;
 625 }
 626
 627 /* save a value to a registry entry */
 628 static BOOL save_entry( const struct sysparam_entry *entry, const void *data, DWORD size,
 629                         DWORD type, UINT flags )
 630 {
 631     if (!SYSPARAMS_SaveRaw( parameter_key_names[entry->regval[0]], entry->regval + 1, data, size, type, flags ))
 632         return FALSE;
 633     if (entry->mirror) SYSPARAMS_SaveRaw( parameter_key_names[entry->mirror[0]], entry->mirror + 1, data, size, type, flags );
 634     return TRUE;
 635 }
 636
 637 /* save a string value to a registry entry */
 638 static BOOL save_entry_string( const struct sysparam_entry *entry, const WCHAR *str, UINT flags )
 639 {
 640     return save_entry( entry, str, (strlenW(str) + 1) * sizeof(WCHAR), REG_SZ, flags );
 641 }
 642
 643 static inline HDC get_display_dc(void)
 644 {
 645     static const WCHAR DISPLAY[] = {'D','I','S','P','L','A','Y',0};
 646     static HDC display_dc;
 647     if (!display_dc)
 648     {
 649         display_dc = CreateICW( DISPLAY, NULL, NULL, NULL );
 650         __wine_make_gdi_object_system( display_dc, TRUE );
 651     }
 652     return display_dc;
 653 }
 654
 655 static inline int get_display_dpi(void)
 656 {
 657     static int display_dpi;
 658     if (!display_dpi) display_dpi = GetDeviceCaps( get_display_dc(), LOGPIXELSY );
 659     return display_dpi;
 660 }
 661
 662 /*************************************************************************
 663  *             SYSPARAMS_SetSysColor
 664  */
 665 static void SYSPARAMS_SetSysColor( int index, COLORREF color )
 666 {
 667     if (index < 0 || index >= NUM_SYS_COLORS) return;
 668     SysColors[index] = color;
 669     if (SysColorBrushes[index])
 670     {
 671         __wine_make_gdi_object_system( SysColorBrushes[index], FALSE);
 672         DeleteObject( SysColorBrushes[index] );
 673     }
 674     SysColorBrushes[index] = CreateSolidBrush( color );
 675     __wine_make_gdi_object_system( SysColorBrushes[index], TRUE);
 676
 677     if (SysColorPens[index])
 678     {
 679         __wine_make_gdi_object_system( SysColorPens[index], FALSE);
 680         DeleteObject( SysColorPens[index] );
 681     }
 682     SysColorPens[index] = CreatePen( PS_SOLID, 1, color );
 683     __wine_make_gdi_object_system( SysColorPens[index], TRUE);
 684 }
 685
 686 /***********************************************************************
 687  *           SYSPARAMS_Init
 688  *
 689  * Initialisation of the system metrics array.
 690  */
 691 void SYSPARAMS_Init(void)
 692 {
 693     HKEY hkey; /* key to the window metrics area of the registry */
 694     int i, r, g, b;
 695     char buffer[100];
 696     HBITMAP h55AABitmap;
 697
 698     /* initialize system colors */
 699
 700     if (RegCreateKeyExA(HKEY_CURRENT_USER, "Control Panel\\Colors", 0, 0, 0, KEY_ALL_ACCESS, 0, &hkey, 0))
 701         hkey = 0;
 702     for (i = 0; i < NUM_SYS_COLORS; i++)
 703     {
 704         BOOL bOk = FALSE;
 705
 706         /* first try, registry */
 707         if (hkey)
 708         {
 709             DWORD dwDataSize = sizeof(buffer);
 710             if (!(RegQueryValueExA(hkey,DefSysColors[i].name, 0, 0, (LPBYTE) buffer, &dwDataSize)))
 711                 if (sscanf( buffer, "%d %d %d", &r, &g, &b ) == 3) bOk = TRUE;
 712         }
 713
 714         /* second try, win.ini */
 715         if (!bOk)
 716         {
 717             GetProfileStringA( "colors", DefSysColors[i].name, NULL, buffer, 100 );
 718             if (sscanf( buffer, " %d %d %d", &r, &g, &b ) == 3) bOk = TRUE;
 719         }
 720
 721         /* else, take the default */
 722         if (!bOk)
 723             SYSPARAMS_SetSysColor( i, DefSysColors[i].rgb );
 724         else
 725             SYSPARAMS_SetSysColor( i, RGB(r,g,b) );
 726     }
 727     if (hkey) RegCloseKey( hkey );
 728
 729     /* create 55AA bitmap */
 730
 731     h55AABitmap = CreateBitmap( 8, 8, 1, 1, wPattern55AA );
 732     SYSCOLOR_55AABrush = CreatePatternBrush( h55AABitmap );
 733     __wine_make_gdi_object_system( SYSCOLOR_55AABrush, TRUE );
 734 }
 735
 736
 737 /* adjust some of the raw values found in the registry */
 738 static void normalize_nonclientmetrics( NONCLIENTMETRICSW *pncm)
 739 {
 740     TEXTMETRICW tm;
 741     if( pncm->iBorderWidth < 1) pncm->iBorderWidth = 1;
 742     if( pncm->iCaptionWidth < 8) pncm->iCaptionWidth = 8;
 743     if( pncm->iScrollWidth < 8) pncm->iScrollWidth = 8;
 744     if( pncm->iScrollHeight < 8) pncm->iScrollHeight = 8;
 745
 746     /* adjust some heights to the corresponding font */
 747     get_text_metr_size( get_display_dc(), &pncm->lfMenuFont, &tm, NULL);
 748     pncm->iMenuHeight = max( pncm->iMenuHeight, 2 + tm.tmHeight + tm.tmExternalLeading );
 749     get_text_metr_size( get_display_dc(), &pncm->lfCaptionFont, &tm, NULL);
 750     pncm->iCaptionHeight = max( pncm->iCaptionHeight, 2 + tm.tmHeight);
 751     get_text_metr_size( get_display_dc(), &pncm->lfSmCaptionFont, &tm, NULL);
 752     pncm->iSmCaptionHeight = max( pncm->iSmCaptionHeight, 2 + tm.tmHeight);
 753 }
 754
 755 static BOOL CALLBACK enum_monitors( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
 756 {
 757     MONITORINFO mi;
 758
 759     mi.cbSize = sizeof(mi);
 760     if (GetMonitorInfoW( monitor, &mi ) && (mi.dwFlags & MONITORINFOF_PRIMARY))
 761     {
 762         LPRECT work = (LPRECT)lp;
 763         *work = mi.rcWork;
 764         return FALSE;
 765     }
 766     return TRUE;
 767 }
 768
 769 /* load a uint parameter from the registry */
 770 static BOOL get_uint_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 771 {
 772     if (!ptr_param) return FALSE;
 773
 774     if (!entry->hdr.loaded)
 775     {
 776         WCHAR buf[32];
 777
 778         if (load_entry( &entry->hdr, buf, sizeof(buf) )) entry->uint.val = atoiW( buf );
 779     }
 780     *(UINT *)ptr_param = entry->uint.val;
 781     return TRUE;
 782 }
 783
 784 /* set a uint parameter in the registry */
 785 static BOOL set_uint_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 786 {
 787     WCHAR buf[32];
 788
 789     wsprintfW( buf, CSu, int_param );
 790     if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
 791     entry->uint.val = int_param;
 792     entry->hdr.loaded = TRUE;
 793     return TRUE;
 794 }
 795
 796 /* set an int parameter in the registry */
 797 static BOOL set_int_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 798 {
 799     WCHAR buf[32];
 800
 801     wsprintfW( buf, CSd, int_param );
 802     if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
 803     entry->uint.val = int_param;
 804     entry->hdr.loaded = TRUE;
 805     return TRUE;
 806 }
 807
 808 /* load a twips parameter from the registry */
 809 static BOOL get_twips_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 810 {
 811     if (!ptr_param) return FALSE;
 812
 813     if (!entry->hdr.loaded)
 814     {
 815         WCHAR buf[32];
 816
 817         if (load_entry( &entry->hdr, buf, sizeof(buf) ))
 818         {
 819             int val = atoiW( buf );
 820             /* Dimension are quoted as being "twips" values if negative and pixels if positive.
 821              * One inch is 1440 twips.
 822              * See for example
 823              *       Technical Reference to the Windows 2000 Registry ->
 824              *       HKEY_CURRENT_USER -> Control Panel -> Desktop -> WindowMetrics
 825              */
 826             if (val < 0) val = (-val * get_display_dpi() + 720) / 1440;
 827             entry->uint.val = val;
 828         }
 829     }
 830     *(UINT *)ptr_param = entry->uint.val;
 831     return TRUE;
 832 }
 833
 834 /* load a bool parameter from the registry */
 835 static BOOL get_bool_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 836 {
 837     if (!ptr_param) return FALSE;
 838
 839     if (!entry->hdr.loaded)
 840     {
 841         WCHAR buf[32];
 842
 843         if (load_entry( &entry->hdr, buf, sizeof(buf) )) entry->bool.val = atoiW( buf ) != 0;
 844     }
 845     *(UINT *)ptr_param = entry->bool.val;
 846     return TRUE;
 847 }
 848
 849 /* set a bool parameter in the registry */
 850 static BOOL set_bool_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 851 {
 852     WCHAR buf[32];
 853
 854     wsprintfW( buf, CSu, int_param != 0 );
 855     if (!save_entry_string( &entry->hdr, buf, flags )) return FALSE;
 856     entry->bool.val = int_param != 0;
 857     entry->hdr.loaded = TRUE;
 858     return TRUE;
 859 }
 860
 861 /* load a bool parameter using Yes/No strings from the registry */
 862 static BOOL get_yesno_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 863 {
 864     if (!ptr_param) return FALSE;
 865
 866     if (!entry->hdr.loaded)
 867     {
 868         WCHAR buf[32];
 869
 870         if (load_entry( &entry->hdr, buf, sizeof(buf) )) entry->bool.val = !lstrcmpiW( Yes, buf );
 871     }
 872     *(UINT *)ptr_param = entry->bool.val;
 873     return TRUE;
 874 }
 875
 876 /* set a bool parameter using Yes/No strings from the registry */
 877 static BOOL set_yesno_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 878 {
 879     const WCHAR *str = int_param ? Yes : No;
 880
 881     if (!save_entry_string( &entry->hdr, str, flags )) return FALSE;
 882     entry->bool.val = int_param != 0;
 883     entry->hdr.loaded = TRUE;
 884     return TRUE;
 885 }
 886
 887 /* load a dword (binary) parameter from the registry */
 888 static BOOL get_dword_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 889 {
 890     if (!ptr_param) return FALSE;
 891
 892     if (!entry->hdr.loaded)
 893     {
 894         DWORD val;
 895         if (load_entry( &entry->hdr, &val, sizeof(val) ) == sizeof(DWORD)) entry->dword.val = val;
 896     }
 897     *(DWORD *)ptr_param = entry->bool.val;
 898     return TRUE;
 899 }
 900
 901 /* set a dword (binary) parameter in the registry */
 902 static BOOL set_dword_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 903 {
 904     DWORD val = PtrToUlong( ptr_param );
 905
 906     if (!save_entry( &entry->hdr, &val, sizeof(val), REG_DWORD, flags )) return FALSE;
 907     entry->dword.val = val;
 908     entry->hdr.loaded = TRUE;
 909     return TRUE;
 910 }
 911
 912 /* load a font (binary) parameter from the registry */
 913 static BOOL get_font_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 914 {
 915     if (!ptr_param) return FALSE;
 916
 917     if (!entry->hdr.loaded)
 918     {
 919         LOGFONTW font;
 920
 921         switch (load_entry( &entry->hdr, &font, sizeof(font) ))
 922         {
 923         case sizeof(font):
 924             entry->font.val = font;
 925             if (font.lfHeight > 0) /* positive height value means points ( inch/72 ) */
 926                 font.lfHeight = -MulDiv( font.lfHeight, get_display_dpi(), 72 );
 927             break;
 928         case sizeof(LOGFONT16): /* win9x-winME format */
 929             SYSPARAMS_LogFont16To32W( (LOGFONT16 *)&font, &entry->font.val );
 930             if (entry->font.val.lfHeight > 0)
 931                 entry->font.val.lfHeight = -MulDiv( entry->font.val.lfHeight, get_display_dpi(), 72 );
 932             break;
 933         default:
 934             WARN( "Unknown format in key %s value %s\n",
 935                   debugstr_w( parameter_key_names[entry->hdr.regval[0]] ),
 936                   debugstr_w( entry->hdr.regval + 1 ));
 937             /* fall through */
 938         case 0: /* use the default GUI font */
 939             GetObjectW( GetStockObject( DEFAULT_GUI_FONT ), sizeof(font), &font );
 940             font.lfWeight = entry->font.weight;
 941             entry->font.val = font;
 942             break;
 943         }
 944         entry->hdr.loaded = TRUE;
 945     }
 946     *(LOGFONTW *)ptr_param = entry->font.val;
 947     return TRUE;
 948 }
 949
 950 /* set a font (binary) parameter in the registry */
 951 static BOOL set_font_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 952 {
 953     LOGFONTW font;
 954     WCHAR *ptr;
 955
 956     memcpy( &font, ptr_param, sizeof(font) );
 957     /* zero pad the end of lfFaceName so we don't save uninitialised data */
 958     ptr = memchrW( font.lfFaceName, 0, LF_FACESIZE );
 959     if (ptr) memset( ptr, 0, (font.lfFaceName + LF_FACESIZE - ptr) * sizeof(WCHAR) );
 960
 961     if (!save_entry( &entry->hdr, &font, sizeof(font), REG_BINARY, flags )) return FALSE;
 962     entry->font.val = font;
 963     entry->hdr.loaded = TRUE;
 964     return TRUE;
 965 }
 966
 967 /* get a path parameter in the registry */
 968 static BOOL get_path_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
 969 {
 970     if (!ptr_param) return FALSE;
 971
 972     if (!entry->hdr.loaded)
 973     {
 974         WCHAR buffer[MAX_PATH];
 975
 976         if (load_entry( &entry->hdr, buffer, sizeof(buffer) ))
 977             lstrcpynW( entry->path.path, buffer, MAX_PATH );
 978         HeapFree( GetProcessHeap(), 0, buffer );
 979     }
 980     lstrcpynW( ptr_param, entry->path.path, int_param );
 981     return TRUE;
 982 }
 983
 984 /* set a path parameter in the registry */
 985 static BOOL set_path_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
 986 {
 987     WCHAR buffer[MAX_PATH];
 988     BOOL ret;
 989
 990     lstrcpynW( buffer, ptr_param, MAX_PATH );
 991     ret = save_entry_string( &entry->hdr, buffer, flags );
 992     if (ret)
 993     {
 994         strcpyW( entry->path.path, buffer );
 995         entry->hdr.loaded = TRUE;
 996     }
 997     HeapFree( GetProcessHeap(), 0, buffer );
 998     return ret;
 999 }
1000
1001 /* get a binary parameter in the registry */
1002 static BOOL get_binary_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
1003 {
1004     if (!ptr_param) return FALSE;
1005
1006     if (!entry->hdr.loaded)
1007     {
1008         void *buffer = HeapAlloc( GetProcessHeap(), 0, entry->bin.size );
1009         DWORD len = load_entry( &entry->hdr, buffer, entry->bin.size );
1010
1011         if (len)
1012         {
1013             memcpy( entry->bin.ptr, buffer, entry->bin.size );
1014             memset( (char *)entry->bin.ptr + len, 0, entry->bin.size - len );
1015         }
1016         HeapFree( GetProcessHeap(), 0, buffer );
1017     }
1018     memcpy( ptr_param, entry->bin.ptr, min( int_param, entry->bin.size ) );
1019     return TRUE;
1020 }
1021
1022 /* set a binary parameter in the registry */
1023 static BOOL set_binary_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
1024 {
1025     BOOL ret;
1026     void *buffer = HeapAlloc( GetProcessHeap(), 0, entry->bin.size );
1027
1028     memcpy( buffer, entry->bin.ptr, entry->bin.size );
1029     memcpy( buffer, ptr_param, min( int_param, entry->bin.size ));
1030     ret = save_entry( &entry->hdr, buffer, entry->bin.size, REG_BINARY, flags );
1031     if (ret)
1032     {
1033         memcpy( entry->bin.ptr, buffer, entry->bin.size );
1034         entry->hdr.loaded = TRUE;
1035     }
1036     HeapFree( GetProcessHeap(), 0, buffer );
1037     return ret;
1038 }
1039
1040 /* get a user pref parameter in the registry */
1041 static BOOL get_userpref_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param )
1042 {
1043     union sysparam_all_entry *parent_entry = (union sysparam_all_entry *)entry->pref.parent;
1044     BYTE prefs[8];
1045
1046     if (!ptr_param) return FALSE;
1047
1048     if (!parent_entry->hdr.get( parent_entry, sizeof(prefs), prefs )) return FALSE;
1049     *(BOOL *)ptr_param = (prefs[entry->pref.offset] & entry->pref.mask) != 0;
1050     return TRUE;
1051 }
1052
1053 /* set a user pref parameter in the registry */
1054 static BOOL set_userpref_entry( union sysparam_all_entry *entry, UINT int_param, void *ptr_param, UINT flags )
1055 {
1056     union sysparam_all_entry *parent_entry = (union sysparam_all_entry *)entry->pref.parent;
1057     BYTE prefs[8];
1058
1059     parent_entry->hdr.loaded = FALSE;  /* force loading it again */
1060     if (!parent_entry->hdr.get( parent_entry, sizeof(prefs), prefs )) return FALSE;
1061
1062     if (PtrToUlong( ptr_param )) prefs[entry->pref.offset] |= entry->pref.mask;
1063     else prefs[entry->pref.offset] &= ~entry->pref.mask;
1064
1065     return parent_entry->hdr.set( parent_entry, sizeof(prefs), prefs, flags );
1066 }
1067
1068 static BOOL get_entry( void *ptr,  UINT int_param, void *ptr_param )
1069 {
1070     union sysparam_all_entry *entry = ptr;
1071     return entry->hdr.get( entry, int_param, ptr_param );
1072 }
1073
1074 static BOOL set_entry( void *ptr,  UINT int_param, void *ptr_param, UINT flags )
1075 {
1076     union sysparam_all_entry *entry = ptr;
1077     return entry->hdr.set( entry, int_param, ptr_param, flags );
1078 }
1079
1080 #define UINT_ENTRY(name,val) \
1081     struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_uint_entry, \
1082                                                   name ##_VALNAME }, (val) }
1083
1084 #define UINT_ENTRY_MIRROR(name,val) \
1085     struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_uint_entry, \
1086                                                   name ##_VALNAME, name ##_MIRROR }, (val) }
1087
1088 #define INT_ENTRY(name,val) \
1089     struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_int_entry, \
1090                                                   name ##_VALNAME }, (val) }
1091
1092 #define BOOL_ENTRY(name,val) \
1093     struct sysparam_bool_entry entry_##name = { { get_bool_entry, set_bool_entry, \
1094                                                   name ##_VALNAME }, (val) }
1095
1096 #define BOOL_ENTRY_MIRROR(name,val) \
1097     struct sysparam_bool_entry entry_##name = { { get_bool_entry, set_bool_entry, \
1098                                                   name ##_VALNAME, name ##_MIRROR }, (val) }
1099
1100 #define YESNO_ENTRY(name,val) \
1101     struct sysparam_bool_entry entry_##name = { { get_yesno_entry, set_yesno_entry, \
1102                                                   name ##_VALNAME }, (val) }
1103
1104 #define TWIPS_ENTRY(name,val) \
1105     struct sysparam_uint_entry entry_##name = { { get_twips_entry, set_int_entry, \
1106                                                   name ##_VALNAME }, (val) }
1107
1108 #define DWORD_ENTRY(name,val) \
1109     struct sysparam_dword_entry entry_##name = { { get_dword_entry, set_dword_entry, \
1110                                                    name ##_VALNAME }, (val) }
1111
1112 #define BINARY_ENTRY(name,data) \
1113     struct sysparam_binary_entry entry_##name = { { get_binary_entry, set_binary_entry, \
1114                                                     name ##_VALNAME }, &(data), sizeof(data) }
1115
1116 #define PATH_ENTRY(name) \
1117     struct sysparam_binary_entry entry_##name = { { get_path_entry, set_path_entry, \
1118                                                     name ##_VALNAME } }
1119
1120 #define FONT_ENTRY(name,weight) \
1121     struct sysparam_font_entry entry_##name = { { get_font_entry, set_font_entry, \
1122                                                   name ##_VALNAME }, (weight) }
1123
1124 #define USERPREF_ENTRY(name,offset,mask) \
1125     struct sysparam_pref_entry entry_##name = { { get_userpref_entry, set_userpref_entry }, \
1126                                                 &entry_USERPREFERENCESMASK, (offset), (mask) }
1127
1128 static UINT_ENTRY( CARETWIDTH, 1 );
1129 static UINT_ENTRY( DRAGWIDTH, 4 );
1130 static UINT_ENTRY( DRAGHEIGHT, 4 );
1131 static UINT_ENTRY( DOUBLECLICKTIME, 500 );
1132 static UINT_ENTRY( FONTSMOOTHING, 0 );
1133 static UINT_ENTRY( GRIDGRANULARITY, 0 );
1134 static UINT_ENTRY( ICONSIZE, 32 );
1135 static UINT_ENTRY( KEYBOARDDELAY, 1 );
1136 static UINT_ENTRY( KEYBOARDSPEED, 31 );
1137 static UINT_ENTRY( MENUSHOWDELAY, 400 );
1138 static UINT_ENTRY( MINARRANGE, ARW_HIDE );
1139 static UINT_ENTRY( MINHORZGAP, 0 );
1140 static UINT_ENTRY( MINVERTGAP, 0 );
1141 static UINT_ENTRY( MINWIDTH, 154 );
1142 static UINT_ENTRY( MOUSEHOVERHEIGHT, 4 );
1143 static UINT_ENTRY( MOUSEHOVERTIME, 400 );
1144 static UINT_ENTRY( MOUSEHOVERWIDTH, 4 );
1145 static UINT_ENTRY( MOUSESPEED, 10 );
1146 static UINT_ENTRY( MOUSETRAILS, 0 );
1147 static UINT_ENTRY( SCREENSAVETIMEOUT, 300 );
1148 static UINT_ENTRY( WHEELSCROLLCHARS, 3 );
1149 static UINT_ENTRY( WHEELSCROLLLINES, 3 );
1150 static UINT_ENTRY_MIRROR( DOUBLECLKHEIGHT, 4 );
1151 static UINT_ENTRY_MIRROR( DOUBLECLKWIDTH, 4 );
1152 static UINT_ENTRY_MIRROR( MENUDROPALIGNMENT, 0 );
1153
1154 static INT_ENTRY( MOUSETHRESHOLD1, 6 );
1155 static INT_ENTRY( MOUSETHRESHOLD2, 10 );
1156 static INT_ENTRY( MOUSEACCELERATION, 1 );
1157
1158 static BOOL_ENTRY( BLOCKSENDINPUTRESETS, FALSE );
1159 static BOOL_ENTRY( DRAGFULLWINDOWS, FALSE );
1160 static BOOL_ENTRY( KEYBOARDPREF, TRUE );
1161 static BOOL_ENTRY( LOWPOWERACTIVE, FALSE );
1162 static BOOL_ENTRY( MOUSEBUTTONSWAP, FALSE );
1163 static BOOL_ENTRY( POWEROFFACTIVE, FALSE );
1164 static BOOL_ENTRY( SCREENREADER, FALSE );
1165 static BOOL_ENTRY( SCREENSAVEACTIVE, TRUE );
1166 static BOOL_ENTRY( SCREENSAVERRUNNING, FALSE );
1167 static BOOL_ENTRY( SHOWSOUNDS, FALSE );
1168 static BOOL_ENTRY( SNAPTODEFBUTTON, FALSE );
1169 static BOOL_ENTRY_MIRROR( ICONTITLEWRAP, TRUE );
1170
1171 static YESNO_ENTRY( BEEP, TRUE );
1172
1173 static TWIPS_ENTRY( BORDER, 1 );
1174 static TWIPS_ENTRY( CAPTIONHEIGHT, 18 );
1175 static TWIPS_ENTRY( CAPTIONWIDTH, 18 );
1176 static TWIPS_ENTRY( ICONHORIZONTALSPACING, 75 );
1177 static TWIPS_ENTRY( ICONVERTICALSPACING, 75 );
1178 static TWIPS_ENTRY( MENUHEIGHT, 18 );
1179 static TWIPS_ENTRY( MENUWIDTH, 18 );
1180 static TWIPS_ENTRY( PADDEDBORDERWIDTH, 0 );
1181 static TWIPS_ENTRY( SCROLLHEIGHT, 16 );
1182 static TWIPS_ENTRY( SCROLLWIDTH, 16 );
1183 static TWIPS_ENTRY( SMCAPTIONHEIGHT, 15 );
1184 static TWIPS_ENTRY( SMCAPTIONWIDTH, 13 );
1185
1186 static DWORD_ENTRY( ACTIVEWINDOWTRACKING, 0 );
1187 static DWORD_ENTRY( ACTIVEWNDTRKTIMEOUT, 0 );
1188 static DWORD_ENTRY( FOCUSBORDERHEIGHT, 1 );
1189 static DWORD_ENTRY( FOCUSBORDERWIDTH, 1 );
1190 static DWORD_ENTRY( FONTSMOOTHINGCONTRAST, 0 );
1191 static DWORD_ENTRY( FONTSMOOTHINGORIENTATION, 0 );
1192 static DWORD_ENTRY( FONTSMOOTHINGTYPE, 0 );
1193 static DWORD_ENTRY( FOREGROUNDFLASHCOUNT, 3 );
1194 static DWORD_ENTRY( FOREGROUNDLOCKTIMEOUT, 0 );
1195 static DWORD_ENTRY( MOUSECLICKLOCKTIME, 1200 );
1196
1197 static PATH_ENTRY( DESKPATTERN );
1198 static PATH_ENTRY( DESKWALLPAPER );
1199
1200 static BYTE user_prefs[8] = { 0x30, 0x00, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00 };
1201 static BINARY_ENTRY( USERPREFERENCESMASK, user_prefs );
1202
1203 static FONT_ENTRY( CAPTIONLOGFONT, FW_BOLD );
1204 static FONT_ENTRY( ICONTITLELOGFONT, FW_NORMAL );
1205 static FONT_ENTRY( MENULOGFONT, FW_NORMAL );
1206 static FONT_ENTRY( MESSAGELOGFONT, FW_NORMAL );
1207 static FONT_ENTRY( SMCAPTIONLOGFONT, FW_NORMAL );
1208 static FONT_ENTRY( STATUSLOGFONT, FW_NORMAL );
1209
1210 static USERPREF_ENTRY( MENUANIMATION,            0, 0x02 );
1211 static USERPREF_ENTRY( COMBOBOXANIMATION,        0, 0x04 );
1212 static USERPREF_ENTRY( LISTBOXSMOOTHSCROLLING,   0, 0x08 );
1213 static USERPREF_ENTRY( GRADIENTCAPTIONS,         0, 0x10 );
1214 static USERPREF_ENTRY( KEYBOARDCUES,             0, 0x20 );
1215 static USERPREF_ENTRY( ACTIVEWNDTRKZORDER,       0, 0x40 );
1216 static USERPREF_ENTRY( HOTTRACKING,              0, 0x80 );
1217 static USERPREF_ENTRY( MENUFADE,                 1, 0x02 );
1218 static USERPREF_ENTRY( SELECTIONFADE,            1, 0x04 );
1219 static USERPREF_ENTRY( TOOLTIPANIMATION,         1, 0x08 );
1220 static USERPREF_ENTRY( TOOLTIPFADE,              1, 0x10 );
1221 static USERPREF_ENTRY( CURSORSHADOW,             1, 0x20 );
1222 static USERPREF_ENTRY( MOUSESONAR,               1, 0x40 );
1223 static USERPREF_ENTRY( MOUSECLICKLOCK,           1, 0x80 );
1224 static USERPREF_ENTRY( MOUSEVANISH,              2, 0x01 );
1225 static USERPREF_ENTRY( FLATMENU,                 2, 0x02 );
1226 static USERPREF_ENTRY( DROPSHADOW,               2, 0x04 );
1227 static USERPREF_ENTRY( UIEFFECTS,                3, 0x80 );
1228 static USERPREF_ENTRY( DISABLEOVERLAPPEDCONTENT, 4, 0x01 );
1229 static USERPREF_ENTRY( CLIENTAREAANIMATION,      4, 0x02 );
1230 static USERPREF_ENTRY( CLEARTYPE,                4, 0x10 );
1231 static USERPREF_ENTRY( SPEECHRECOGNITION,        4, 0x20 );
1232
1233 /***********************************************************************
1234  *              SystemParametersInfoW (USER32.@)
1235  *
1236  *     Each system parameter has flag which shows whether the parameter
1237  * is loaded or not. Parameters, stored directly in SysParametersInfo are
1238  * loaded from registry only when they are requested and the flag is
1239  * "false", after the loading the flag is set to "true". On interprocess
1240  * notification of the parameter change the corresponding parameter flag is
1241  * set to "false". The parameter value will be reloaded when it is requested
1242  * the next time.
1243  *     Parameters, backed by or depend on GetSystemMetrics are processed
1244  * differently. These parameters are always loaded. They are reloaded right
1245  * away on interprocess change notification. We can't do lazy loading because
1246  * we don't want to complicate GetSystemMetrics.
1247  *     Parameters, backed by X settings are read from corresponding setting.
1248  * On the parameter change request the setting is changed. Interprocess change
1249  * notifications are ignored.
1250  *     When parameter value is updated the changed value is stored in permanent
1251  * registry branch if saving is requested. Otherwise it is stored
1252  * in temporary branch
1253  *
1254  * Some SPI values can also be stored as Twips values in the registry,
1255  * don't forget the conversion!
1256  */
1257 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
1258                                    PVOID pvParam, UINT fWinIni )
1259 {
1260 #define WINE_SPI_FIXME(x) \
1261     case x: \
1262         { \
1263             static BOOL warn = TRUE; \
1264             if (warn) \
1265             { \
1266                 warn = FALSE; \
1267                 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
1268             } \
1269         } \
1270         SetLastError( ERROR_INVALID_SPI_VALUE ); \
1271         ret = FALSE; \
1272         break
1273 #define WINE_SPI_WARN(x) \
1274     case x: \
1275         WARN( "Ignored action: %u (%s)\n", x, #x ); \
1276         ret = TRUE; \
1277         break
1278
1279     BOOL ret = USER_Driver->pSystemParametersInfo( uiAction, uiParam, pvParam, fWinIni );
1280     unsigned spi_idx = 0;
1281
1282     if (!ret) switch (uiAction)
1283     {
1284     case SPI_GETBEEP:
1285         ret = get_entry( &entry_BEEP, uiParam, pvParam );
1286         break;
1287     case SPI_SETBEEP:
1288         ret = set_entry( &entry_BEEP, uiParam, pvParam, fWinIni );
1289         break;
1290     case SPI_GETMOUSE:
1291         ret = get_entry( &entry_MOUSETHRESHOLD1, uiParam, (INT *)pvParam ) &&
1292               get_entry( &entry_MOUSETHRESHOLD2, uiParam, (INT *)pvParam + 1 ) &&
1293               get_entry( &entry_MOUSEACCELERATION, uiParam, (INT *)pvParam + 2 );
1294         break;
1295     case SPI_SETMOUSE:
1296         ret = set_entry( &entry_MOUSETHRESHOLD1, ((INT *)pvParam)[0], pvParam, fWinIni ) &&
1297               set_entry( &entry_MOUSETHRESHOLD2, ((INT *)pvParam)[1], pvParam, fWinIni ) &&
1298               set_entry( &entry_MOUSEACCELERATION, ((INT *)pvParam)[2], pvParam, fWinIni );
1299         break;
1300     case SPI_GETBORDER:
1301         ret = get_entry( &entry_BORDER, uiParam, pvParam );
1302         if (*(INT*)pvParam < 1) *(INT*)pvParam = 1;
1303         break;
1304     case SPI_SETBORDER:
1305         ret = set_entry( &entry_BORDER, uiParam, pvParam, fWinIni );
1306         break;
1307     case SPI_GETKEYBOARDSPEED:
1308         ret = get_entry( &entry_KEYBOARDSPEED, uiParam, pvParam );
1309         break;
1310     case SPI_SETKEYBOARDSPEED:
1311         if (uiParam > 31) uiParam = 31;
1312         ret = set_entry( &entry_KEYBOARDSPEED, uiParam, pvParam, fWinIni );
1313         break;
1314
1315     /* not implemented in Windows */
1316     WINE_SPI_WARN(SPI_LANGDRIVER);              /*     12 */
1317
1318     case SPI_ICONHORIZONTALSPACING:
1319         if (pvParam != NULL)
1320             ret = get_entry( &entry_ICONHORIZONTALSPACING, uiParam, pvParam );
1321         else
1322             ret = set_entry( &entry_ICONHORIZONTALSPACING, max( 32, uiParam ), pvParam, fWinIni );
1323         break;
1324     case SPI_GETSCREENSAVETIMEOUT:
1325         ret = get_entry( &entry_SCREENSAVETIMEOUT, uiParam, pvParam );
1326         break;
1327     case SPI_SETSCREENSAVETIMEOUT:
1328         ret = set_entry( &entry_SCREENSAVETIMEOUT, uiParam, pvParam, fWinIni );
1329         break;
1330     case SPI_GETSCREENSAVEACTIVE:
1331         ret = get_entry( &entry_SCREENSAVEACTIVE, uiParam, pvParam );
1332         break;
1333     case SPI_SETSCREENSAVEACTIVE:
1334         ret = set_entry( &entry_SCREENSAVEACTIVE, uiParam, pvParam, fWinIni );
1335         break;
1336     case SPI_GETGRIDGRANULARITY:
1337         ret = get_entry( &entry_GRIDGRANULARITY, uiParam, pvParam );
1338         break;
1339     case SPI_SETGRIDGRANULARITY:
1340         ret = set_entry( &entry_GRIDGRANULARITY, uiParam, pvParam, fWinIni );
1341         break;
1342     case SPI_SETDESKWALLPAPER:
1343         ret = set_entry( &entry_DESKWALLPAPER, uiParam, pvParam, fWinIni );
1344         break;
1345     case SPI_SETDESKPATTERN:
1346         if (!pvParam || set_entry( &entry_DESKPATTERN, uiParam, pvParam, fWinIni ))
1347         {
1348             WCHAR buf[256];
1349             ret = get_entry( &entry_DESKPATTERN, 256, buf ) && DESKTOP_SetPattern( buf );
1350         }
1351         break;
1352     case SPI_GETKEYBOARDDELAY:
1353         ret = get_entry( &entry_KEYBOARDDELAY, uiParam, pvParam );
1354         break;
1355     case SPI_SETKEYBOARDDELAY:
1356         ret = set_entry( &entry_KEYBOARDDELAY, uiParam, pvParam, fWinIni );
1357         break;
1358     case SPI_ICONVERTICALSPACING:
1359         if (pvParam != NULL)
1360             ret = get_entry( &entry_ICONVERTICALSPACING, uiParam, pvParam );
1361         else
1362             ret = set_entry( &entry_ICONVERTICALSPACING, max( 32, uiParam ), pvParam, fWinIni );
1363         break;
1364     case SPI_GETICONTITLEWRAP:
1365         ret = get_entry( &entry_ICONTITLEWRAP, uiParam, pvParam );
1366         break;
1367     case SPI_SETICONTITLEWRAP:
1368         ret = set_entry( &entry_ICONTITLEWRAP, uiParam, pvParam, fWinIni );
1369         break;
1370     case SPI_GETMENUDROPALIGNMENT:
1371         ret = get_entry( &entry_MENUDROPALIGNMENT, uiParam, pvParam );
1372         break;
1373     case SPI_SETMENUDROPALIGNMENT:
1374         ret = set_entry( &entry_MENUDROPALIGNMENT, uiParam, pvParam, fWinIni );
1375         break;
1376     case SPI_SETDOUBLECLKWIDTH:
1377         ret = set_entry( &entry_DOUBLECLKWIDTH, uiParam, pvParam, fWinIni );
1378         break;
1379     case SPI_SETDOUBLECLKHEIGHT:
1380         ret = set_entry( &entry_DOUBLECLKHEIGHT, uiParam, pvParam, fWinIni );
1381         break;
1382     case SPI_GETICONTITLELOGFONT:
1383         ret = get_entry( &entry_ICONTITLELOGFONT, uiParam, pvParam );
1384         break;
1385     case SPI_SETDOUBLECLICKTIME:
1386         ret = set_entry( &entry_DOUBLECLICKTIME, uiParam, pvParam, fWinIni );
1387         break;
1388     case SPI_SETMOUSEBUTTONSWAP:
1389         ret = set_entry( &entry_MOUSEBUTTONSWAP, uiParam, pvParam, fWinIni );
1390         break;
1391     case SPI_SETICONTITLELOGFONT:
1392         ret = set_entry( &entry_ICONTITLELOGFONT, uiParam, pvParam, fWinIni );
1393         break;
1394
1395     case SPI_GETFASTTASKSWITCH:                 /*     35 */
1396         if (!pvParam) return FALSE;
1397         *(BOOL *)pvParam = 1;
1398         ret = TRUE;
1399         break;
1400
1401     case SPI_SETFASTTASKSWITCH:                 /*     36 */
1402         /* the action is disabled */
1403         ret = FALSE;
1404         break;
1405
1406     case SPI_SETDRAGFULLWINDOWS:
1407         ret = set_entry( &entry_DRAGFULLWINDOWS, uiParam, pvParam, fWinIni );
1408         break;
1409     case SPI_GETDRAGFULLWINDOWS:
1410         ret = get_entry( &entry_DRAGFULLWINDOWS, uiParam, pvParam );
1411         break;
1412     case SPI_GETNONCLIENTMETRICS:
1413     {
1414         LPNONCLIENTMETRICSW lpnm = pvParam;
1415
1416         if (!pvParam) return FALSE;
1417
1418         ret = get_entry( &entry_BORDER, 0, &lpnm->iBorderWidth ) &&
1419               get_entry( &entry_SCROLLWIDTH, 0, &lpnm->iScrollWidth ) &&
1420               get_entry( &entry_SCROLLHEIGHT, 0, &lpnm->iScrollHeight ) &&
1421               get_entry( &entry_CAPTIONWIDTH, 0, &lpnm->iCaptionWidth ) &&
1422               get_entry( &entry_CAPTIONHEIGHT, 0, &lpnm->iCaptionHeight ) &&
1423               get_entry( &entry_CAPTIONLOGFONT, 0, &lpnm->lfCaptionFont ) &&
1424               get_entry( &entry_SMCAPTIONWIDTH, 0, &lpnm->iSmCaptionWidth ) &&
1425               get_entry( &entry_SMCAPTIONHEIGHT, 0, &lpnm->iSmCaptionHeight ) &&
1426               get_entry( &entry_SMCAPTIONLOGFONT, 0, &lpnm->lfSmCaptionFont ) &&
1427               get_entry( &entry_MENUWIDTH, 0, &lpnm->iMenuWidth ) &&
1428               get_entry( &entry_MENUHEIGHT, 0, &lpnm->iMenuHeight ) &&
1429               get_entry( &entry_MENULOGFONT, 0, &lpnm->lfMenuFont ) &&
1430               get_entry( &entry_STATUSLOGFONT, 0, &lpnm->lfStatusFont ) &&
1431               get_entry( &entry_MESSAGELOGFONT, 0, &lpnm->lfMessageFont );
1432         if (ret && lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1433             ret = get_entry( &entry_PADDEDBORDERWIDTH, 0, &lpnm->iPaddedBorderWidth );
1434         normalize_nonclientmetrics( lpnm );
1435         break;
1436     }
1437     case SPI_SETNONCLIENTMETRICS:
1438     {
1439         LPNONCLIENTMETRICSW lpnm = pvParam;
1440
1441         if (lpnm && (lpnm->cbSize == sizeof(NONCLIENTMETRICSW) ||
1442                      lpnm->cbSize == FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth)))
1443         {
1444             ret = set_entry( &entry_BORDER, lpnm->iBorderWidth, NULL, fWinIni ) &&
1445                   set_entry( &entry_SCROLLWIDTH, lpnm->iScrollWidth, NULL, fWinIni ) &&
1446                   set_entry( &entry_SCROLLHEIGHT, lpnm->iScrollHeight, NULL, fWinIni ) &&
1447                   set_entry( &entry_CAPTIONWIDTH, lpnm->iCaptionWidth, NULL, fWinIni ) &&
1448                   set_entry( &entry_CAPTIONHEIGHT, lpnm->iCaptionHeight, NULL, fWinIni ) &&
1449                   set_entry( &entry_SMCAPTIONWIDTH, lpnm->iSmCaptionWidth, NULL, fWinIni ) &&
1450                   set_entry( &entry_SMCAPTIONHEIGHT, lpnm->iSmCaptionHeight, NULL, fWinIni ) &&
1451                   set_entry( &entry_MENUWIDTH, lpnm->iMenuWidth, NULL, fWinIni ) &&
1452                   set_entry( &entry_MENUHEIGHT, lpnm->iMenuHeight, NULL, fWinIni ) &&
1453                   set_entry( &entry_MENULOGFONT, 0, &lpnm->lfMenuFont, fWinIni ) &&
1454                   set_entry( &entry_CAPTIONLOGFONT, 0, &lpnm->lfCaptionFont, fWinIni ) &&
1455                   set_entry( &entry_SMCAPTIONLOGFONT, 0, &lpnm->lfSmCaptionFont, fWinIni ) &&
1456                   set_entry( &entry_STATUSLOGFONT, 0, &lpnm->lfStatusFont, fWinIni ) &&
1457                   set_entry( &entry_MESSAGELOGFONT, 0, &lpnm->lfMessageFont, fWinIni );
1458
1459             if (ret && lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1460                 set_entry( &entry_PADDEDBORDERWIDTH, lpnm->iPaddedBorderWidth, NULL, fWinIni );
1461         }
1462         break;
1463     }
1464     case SPI_GETMINIMIZEDMETRICS:
1465     {
1466         MINIMIZEDMETRICS * lpMm = pvParam;
1467         if (lpMm && lpMm->cbSize == sizeof(*lpMm)) {
1468             ret = get_entry( &entry_MINWIDTH, 0, &lpMm->iWidth ) &&
1469                   get_entry( &entry_MINHORZGAP, 0, &lpMm->iHorzGap ) &&
1470                   get_entry( &entry_MINVERTGAP, 0, &lpMm->iVertGap ) &&
1471                   get_entry( &entry_MINARRANGE, 0, &lpMm->iArrange );
1472             lpMm->iWidth = max( 0, lpMm->iWidth );
1473             lpMm->iHorzGap = max( 0, lpMm->iHorzGap );
1474             lpMm->iVertGap = max( 0, lpMm->iVertGap );
1475             lpMm->iArrange &= 0x0f;
1476         }
1477         break;
1478     }
1479     case SPI_SETMINIMIZEDMETRICS:
1480     {
1481         MINIMIZEDMETRICS * lpMm = pvParam;
1482         if (lpMm && lpMm->cbSize == sizeof(*lpMm))
1483             ret = set_entry( &entry_MINWIDTH, max( 0, lpMm->iWidth ), NULL, fWinIni ) &&
1484                   set_entry( &entry_MINHORZGAP, max( 0, lpMm->iHorzGap ), NULL, fWinIni ) &&
1485                   set_entry( &entry_MINVERTGAP, max( 0, lpMm->iVertGap ), NULL, fWinIni ) &&
1486                   set_entry( &entry_MINARRANGE, lpMm->iArrange & 0x0f, NULL, fWinIni );
1487         break;
1488     }
1489     case SPI_GETICONMETRICS:
1490     {
1491         LPICONMETRICSW lpIcon = pvParam;
1492         if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1493         {
1494             ret = get_entry( &entry_ICONHORIZONTALSPACING, 0, &lpIcon->iHorzSpacing ) &&
1495                   get_entry( &entry_ICONVERTICALSPACING, 0, &lpIcon->iVertSpacing ) &&
1496                   get_entry( &entry_ICONTITLEWRAP, 0, &lpIcon->iTitleWrap ) &&
1497                   get_entry( &entry_ICONTITLELOGFONT, 0, &lpIcon->lfFont );
1498         }
1499         break;
1500     }
1501     case SPI_SETICONMETRICS:
1502     {
1503         LPICONMETRICSW lpIcon = pvParam;
1504         if (lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1505             ret = set_entry( &entry_ICONVERTICALSPACING, max(32,lpIcon->iVertSpacing), NULL, fWinIni ) &&
1506                   set_entry( &entry_ICONHORIZONTALSPACING, max(32,lpIcon->iHorzSpacing), NULL, fWinIni ) &&
1507                   set_entry( &entry_ICONTITLEWRAP, lpIcon->iTitleWrap, NULL, fWinIni ) &&
1508                   set_entry( &entry_ICONTITLELOGFONT, 0, &lpIcon->lfFont, fWinIni );
1509         break;
1510     }
1511
1512     case SPI_SETWORKAREA:                       /*     47  WINVER >= 0x400 */
1513     {
1514         if (!pvParam) return FALSE;
1515
1516         spi_idx = SPI_SETWORKAREA_IDX;
1517         CopyRect( &work_area, pvParam );
1518         spi_loaded[spi_idx] = TRUE;
1519         ret = TRUE;
1520         break;
1521     }
1522
1523     case SPI_GETWORKAREA:                       /*     48  WINVER >= 0x400 */
1524     {
1525         if (!pvParam) return FALSE;
1526
1527         spi_idx = SPI_SETWORKAREA_IDX;
1528         if (!spi_loaded[spi_idx])
1529         {
1530             SetRect( &work_area, 0, 0,
1531                      GetSystemMetrics( SM_CXSCREEN ),
1532                      GetSystemMetrics( SM_CYSCREEN ) );
1533             EnumDisplayMonitors( 0, NULL, enum_monitors, (LPARAM)&work_area );
1534             spi_loaded[spi_idx] = TRUE;
1535         }
1536         CopyRect( pvParam, &work_area );
1537         ret = TRUE;
1538         TRACE("work area %s\n", wine_dbgstr_rect( &work_area ));
1539         break;
1540     }
1541
1542     WINE_SPI_FIXME(SPI_SETPENWINDOWS);          /*     49  WINVER >= 0x400 */
1543
1544     case SPI_GETFILTERKEYS:                     /*     50 */
1545     {
1546         LPFILTERKEYS lpFilterKeys = pvParam;
1547         WARN("SPI_GETFILTERKEYS not fully implemented\n");
1548         if (lpFilterKeys && lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1549         {
1550             /* Indicate that no FilterKeys feature available */
1551             lpFilterKeys->dwFlags = 0;
1552             lpFilterKeys->iWaitMSec = 0;
1553             lpFilterKeys->iDelayMSec = 0;
1554             lpFilterKeys->iRepeatMSec = 0;
1555             lpFilterKeys->iBounceMSec = 0;
1556             ret = TRUE;
1557         }
1558         break;
1559     }
1560     WINE_SPI_FIXME(SPI_SETFILTERKEYS);          /*     51 */
1561
1562     case SPI_GETTOGGLEKEYS:                     /*     52 */
1563     {
1564         LPTOGGLEKEYS lpToggleKeys = pvParam;
1565         WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1566         if (lpToggleKeys && lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1567         {
1568             /* Indicate that no ToggleKeys feature available */
1569             lpToggleKeys->dwFlags = 0;
1570             ret = TRUE;
1571         }
1572         break;
1573     }
1574     WINE_SPI_FIXME(SPI_SETTOGGLEKEYS);          /*     53 */
1575
1576     case SPI_GETMOUSEKEYS:                      /*     54 */
1577     {
1578         LPMOUSEKEYS lpMouseKeys = pvParam;
1579         WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1580         if (lpMouseKeys && lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1581         {
1582             /* Indicate that no MouseKeys feature available */
1583             lpMouseKeys->dwFlags = 0;
1584             lpMouseKeys->iMaxSpeed = 360;
1585             lpMouseKeys->iTimeToMaxSpeed = 1000;
1586             lpMouseKeys->iCtrlSpeed = 0;
1587             lpMouseKeys->dwReserved1 = 0;
1588             lpMouseKeys->dwReserved2 = 0;
1589             ret = TRUE;
1590         }
1591         break;
1592     }
1593     WINE_SPI_FIXME(SPI_SETMOUSEKEYS);           /*     55 */
1594
1595     case SPI_GETSHOWSOUNDS:
1596         ret = get_entry( &entry_SHOWSOUNDS, uiParam, pvParam );
1597         break;
1598     case SPI_SETSHOWSOUNDS:
1599         ret = set_entry( &entry_SHOWSOUNDS, uiParam, pvParam, fWinIni );
1600         break;
1601
1602     case SPI_GETSTICKYKEYS:                     /*     58 */
1603     {
1604         LPSTICKYKEYS lpStickyKeys = pvParam;
1605         WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1606         if (lpStickyKeys && lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1607         {
1608             /* Indicate that no StickyKeys feature available */
1609             lpStickyKeys->dwFlags = 0;
1610             ret = TRUE;
1611         }
1612         break;
1613     }
1614     WINE_SPI_FIXME(SPI_SETSTICKYKEYS);          /*     59 */
1615
1616     case SPI_GETACCESSTIMEOUT:                  /*     60 */
1617     {
1618         LPACCESSTIMEOUT lpAccessTimeout = pvParam;
1619         WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1620         if (lpAccessTimeout && lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1621         {
1622             /* Indicate that no accessibility features timeout is available */
1623             lpAccessTimeout->dwFlags = 0;
1624             lpAccessTimeout->iTimeOutMSec = 0;
1625             ret = TRUE;
1626         }
1627         break;
1628     }
1629     WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT);       /*     61 */
1630
1631     case SPI_GETSERIALKEYS:                     /*     62  WINVER >= 0x400 */
1632     {
1633         LPSERIALKEYSW lpSerialKeysW = pvParam;
1634         WARN("SPI_GETSERIALKEYS not fully implemented\n");
1635         if (lpSerialKeysW && lpSerialKeysW->cbSize == sizeof(SERIALKEYSW))
1636         {
1637             /* Indicate that no SerialKeys feature available */
1638             lpSerialKeysW->dwFlags = 0;
1639             lpSerialKeysW->lpszActivePort = NULL;
1640             lpSerialKeysW->lpszPort = NULL;
1641             lpSerialKeysW->iBaudRate = 0;
1642             lpSerialKeysW->iPortState = 0;
1643             ret = TRUE;
1644         }
1645         break;
1646     }
1647     WINE_SPI_FIXME(SPI_SETSERIALKEYS);          /*     63  WINVER >= 0x400 */
1648
1649     case SPI_GETSOUNDSENTRY:                    /*     64 */
1650     {
1651         LPSOUNDSENTRYW lpSoundSentryW = pvParam;
1652         WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1653         if (lpSoundSentryW && lpSoundSentryW->cbSize == sizeof(SOUNDSENTRYW))
1654         {
1655             /* Indicate that no SoundSentry feature available */
1656             lpSoundSentryW->dwFlags = 0;
1657             lpSoundSentryW->iFSTextEffect = 0;
1658             lpSoundSentryW->iFSTextEffectMSec = 0;
1659             lpSoundSentryW->iFSTextEffectColorBits = 0;
1660             lpSoundSentryW->iFSGrafEffect = 0;
1661             lpSoundSentryW->iFSGrafEffectMSec = 0;
1662             lpSoundSentryW->iFSGrafEffectColor = 0;
1663             lpSoundSentryW->iWindowsEffect = 0;
1664             lpSoundSentryW->iWindowsEffectMSec = 0;
1665             lpSoundSentryW->lpszWindowsEffectDLL = 0;
1666             lpSoundSentryW->iWindowsEffectOrdinal = 0;
1667             ret = TRUE;
1668         }
1669         break;
1670     }
1671     WINE_SPI_FIXME(SPI_SETSOUNDSENTRY);         /*     65 */
1672
1673     case SPI_GETHIGHCONTRAST:                   /*     66  WINVER >= 0x400 */
1674     {
1675         LPHIGHCONTRASTW lpHighContrastW = pvParam;
1676         WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1677         if (lpHighContrastW && lpHighContrastW->cbSize == sizeof(HIGHCONTRASTW))
1678         {
1679             /* Indicate that no high contrast feature available */
1680             lpHighContrastW->dwFlags = 0;
1681             lpHighContrastW->lpszDefaultScheme = NULL;
1682             ret = TRUE;
1683         }
1684         break;
1685     }
1686     WINE_SPI_FIXME(SPI_SETHIGHCONTRAST);        /*     67  WINVER >= 0x400 */
1687
1688     case SPI_GETKEYBOARDPREF:
1689         ret = get_entry( &entry_KEYBOARDPREF, uiParam, pvParam );
1690         break;
1691     case SPI_SETKEYBOARDPREF:
1692         ret = set_entry( &entry_KEYBOARDPREF, uiParam, pvParam, fWinIni );
1693         break;
1694     case SPI_GETSCREENREADER:
1695         ret = get_entry( &entry_SCREENREADER, uiParam, pvParam );
1696         break;
1697     case SPI_SETSCREENREADER:
1698         ret = set_entry( &entry_SCREENREADER, uiParam, pvParam, fWinIni );
1699         break;
1700
1701     case SPI_GETANIMATION:                      /*     72  WINVER >= 0x400 */
1702     {
1703         LPANIMATIONINFO lpAnimInfo = pvParam;
1704
1705         /* Tell it "disabled" */
1706         if (lpAnimInfo && lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
1707         {
1708             lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
1709             ret = TRUE;
1710         }
1711         break;
1712     }
1713     WINE_SPI_WARN(SPI_SETANIMATION);            /*     73  WINVER >= 0x400 */
1714
1715     case SPI_GETFONTSMOOTHING:
1716         ret = get_entry( &entry_FONTSMOOTHING, uiParam, pvParam );
1717         if (ret) *(UINT *)pvParam = (*(UINT *)pvParam != 0);
1718         break;
1719     case SPI_SETFONTSMOOTHING:
1720         uiParam = uiParam ? 2 : 0; /* Win NT4/2k/XP behavior */
1721         ret = set_entry( &entry_FONTSMOOTHING, uiParam, pvParam, fWinIni );
1722         break;
1723     case SPI_SETDRAGWIDTH:
1724         ret = set_entry( &entry_DRAGWIDTH, uiParam, pvParam, fWinIni );
1725         break;
1726     case SPI_SETDRAGHEIGHT:
1727         ret = set_entry( &entry_DRAGHEIGHT, uiParam, pvParam, fWinIni );
1728         break;
1729
1730     WINE_SPI_FIXME(SPI_SETHANDHELD);            /*     78  WINVER >= 0x400 */
1731
1732     WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT);     /*     79  WINVER >= 0x400 */
1733     WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT);     /*     80  WINVER >= 0x400 */
1734     WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT);     /*     81  WINVER >= 0x400 */
1735     WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT);     /*     82  WINVER >= 0x400 */
1736
1737     case SPI_GETLOWPOWERACTIVE:
1738         ret = get_entry( &entry_LOWPOWERACTIVE, uiParam, pvParam );
1739         break;
1740     case SPI_SETLOWPOWERACTIVE:
1741         ret = set_entry( &entry_LOWPOWERACTIVE, uiParam, pvParam, fWinIni );
1742         break;
1743     case SPI_GETPOWEROFFACTIVE:
1744         ret = get_entry( &entry_POWEROFFACTIVE, uiParam, pvParam );
1745         break;
1746     case SPI_SETPOWEROFFACTIVE:
1747         ret = set_entry( &entry_POWEROFFACTIVE, uiParam, pvParam, fWinIni );
1748         break;
1749
1750     WINE_SPI_FIXME(SPI_SETCURSORS);             /*     87  WINVER >= 0x400 */
1751     WINE_SPI_FIXME(SPI_SETICONS);               /*     88  WINVER >= 0x400 */
1752
1753     case SPI_GETDEFAULTINPUTLANG:       /*     89  WINVER >= 0x400 */
1754         ret = GetKeyboardLayout(0) != 0;
1755         break;
1756
1757     WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG);    /*     90  WINVER >= 0x400 */
1758
1759     WINE_SPI_FIXME(SPI_SETLANGTOGGLE);          /*     91  WINVER >= 0x400 */
1760
1761     case SPI_GETWINDOWSEXTENSION:               /*     92  WINVER >= 0x400 */
1762         WARN("pretend no support for Win9x Plus! for now.\n");
1763         ret = FALSE; /* yes, this is the result value */
1764         break;
1765     case SPI_SETMOUSETRAILS:
1766         ret = set_entry( &entry_MOUSETRAILS, uiParam, pvParam, fWinIni );
1767         break;
1768     case SPI_GETMOUSETRAILS:
1769         ret = get_entry( &entry_MOUSETRAILS, uiParam, pvParam );
1770         break;
1771     case SPI_GETSNAPTODEFBUTTON:
1772         ret = get_entry( &entry_SNAPTODEFBUTTON, uiParam, pvParam );
1773         break;
1774     case SPI_SETSNAPTODEFBUTTON:
1775         ret = set_entry( &entry_SNAPTODEFBUTTON, uiParam, pvParam, fWinIni );
1776         break;
1777     case SPI_SETSCREENSAVERRUNNING:
1778         ret = set_entry( &entry_SCREENSAVERRUNNING, uiParam, pvParam, fWinIni );
1779         break;
1780     case SPI_GETMOUSEHOVERWIDTH:
1781         ret = get_entry( &entry_MOUSEHOVERWIDTH, uiParam, pvParam );
1782         break;
1783     case SPI_SETMOUSEHOVERWIDTH:
1784         ret = set_entry( &entry_MOUSEHOVERWIDTH, uiParam, pvParam, fWinIni );
1785         break;
1786     case SPI_GETMOUSEHOVERHEIGHT:
1787         ret = get_entry( &entry_MOUSEHOVERHEIGHT, uiParam, pvParam );
1788         break;
1789     case SPI_SETMOUSEHOVERHEIGHT:
1790         ret = set_entry( &entry_MOUSEHOVERHEIGHT, uiParam, pvParam, fWinIni );
1791         break;
1792     case SPI_GETMOUSEHOVERTIME:
1793         ret = get_entry( &entry_MOUSEHOVERTIME, uiParam, pvParam );
1794         break;
1795     case SPI_SETMOUSEHOVERTIME:
1796         ret = set_entry( &entry_MOUSEHOVERTIME, uiParam, pvParam, fWinIni );
1797         break;
1798     case SPI_GETWHEELSCROLLLINES:
1799         ret = get_entry( &entry_WHEELSCROLLLINES, uiParam, pvParam );
1800         break;
1801     case SPI_SETWHEELSCROLLLINES:
1802         ret = set_entry( &entry_WHEELSCROLLLINES, uiParam, pvParam, fWinIni );
1803         break;
1804     case SPI_GETMENUSHOWDELAY:
1805         ret = get_entry( &entry_MENUSHOWDELAY, uiParam, pvParam );
1806         break;
1807     case SPI_SETMENUSHOWDELAY:
1808         ret = set_entry( &entry_MENUSHOWDELAY, uiParam, pvParam, fWinIni );
1809         break;
1810     case SPI_GETWHEELSCROLLCHARS:
1811         ret = get_entry( &entry_WHEELSCROLLCHARS, uiParam, pvParam );
1812         break;
1813     case SPI_SETWHEELSCROLLCHARS:
1814         ret = set_entry( &entry_WHEELSCROLLCHARS, uiParam, pvParam, fWinIni );
1815         break;
1816
1817     WINE_SPI_FIXME(SPI_GETSHOWIMEUI);           /*    110  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1818     WINE_SPI_FIXME(SPI_SETSHOWIMEUI);           /*    111  _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1819
1820     case SPI_GETMOUSESPEED:
1821         ret = get_entry( &entry_MOUSESPEED, uiParam, pvParam );
1822         break;
1823     case SPI_SETMOUSESPEED:
1824         ret = set_entry( &entry_MOUSESPEED, uiParam, pvParam, fWinIni );
1825         break;
1826     case SPI_GETSCREENSAVERRUNNING:
1827         ret = get_entry( &entry_SCREENSAVERRUNNING, uiParam, pvParam );
1828         break;
1829     case SPI_GETDESKWALLPAPER:
1830         ret = get_entry( &entry_DESKWALLPAPER, uiParam, pvParam );
1831         break;
1832     case SPI_GETACTIVEWINDOWTRACKING:
1833         ret = get_entry( &entry_ACTIVEWINDOWTRACKING, uiParam, pvParam );
1834         break;
1835     case SPI_SETACTIVEWINDOWTRACKING:
1836         ret = set_entry( &entry_ACTIVEWINDOWTRACKING, uiParam, pvParam, fWinIni );
1837         break;
1838     case SPI_GETMENUANIMATION:
1839         ret = get_entry( &entry_MENUANIMATION, uiParam, pvParam );
1840         break;
1841     case SPI_SETMENUANIMATION:
1842         ret = set_entry( &entry_MENUANIMATION, uiParam, pvParam, fWinIni );
1843         break;
1844     case SPI_GETCOMBOBOXANIMATION:
1845         ret = get_entry( &entry_COMBOBOXANIMATION, uiParam, pvParam );
1846         break;
1847     case SPI_SETCOMBOBOXANIMATION:
1848         ret = set_entry( &entry_COMBOBOXANIMATION, uiParam, pvParam, fWinIni );
1849         break;
1850     case SPI_GETLISTBOXSMOOTHSCROLLING:
1851         ret = get_entry( &entry_LISTBOXSMOOTHSCROLLING, uiParam, pvParam );
1852         break;
1853     case SPI_SETLISTBOXSMOOTHSCROLLING:
1854         ret = set_entry( &entry_LISTBOXSMOOTHSCROLLING, uiParam, pvParam, fWinIni );
1855         break;
1856     case SPI_GETGRADIENTCAPTIONS:
1857         ret = get_entry( &entry_GRADIENTCAPTIONS, uiParam, pvParam );
1858         break;
1859     case SPI_SETGRADIENTCAPTIONS:
1860         ret = set_entry( &entry_GRADIENTCAPTIONS, uiParam, pvParam, fWinIni );
1861         break;
1862     case SPI_GETKEYBOARDCUES:
1863         ret = get_entry( &entry_KEYBOARDCUES, uiParam, pvParam );
1864         break;
1865     case SPI_SETKEYBOARDCUES:
1866         ret = set_entry( &entry_KEYBOARDCUES, uiParam, pvParam, fWinIni );
1867         break;
1868     case SPI_GETACTIVEWNDTRKZORDER:
1869         ret = get_entry( &entry_ACTIVEWNDTRKZORDER, uiParam, pvParam );
1870         break;
1871     case SPI_SETACTIVEWNDTRKZORDER:
1872         ret = set_entry( &entry_ACTIVEWNDTRKZORDER, uiParam, pvParam, fWinIni );
1873         break;
1874     case SPI_GETHOTTRACKING:
1875         ret = get_entry( &entry_HOTTRACKING, uiParam, pvParam );
1876         break;
1877     case SPI_SETHOTTRACKING:
1878         ret = set_entry( &entry_HOTTRACKING, uiParam, pvParam, fWinIni );
1879         break;
1880     case SPI_GETMENUFADE:
1881         ret = get_entry( &entry_MENUFADE, uiParam, pvParam );
1882         break;
1883     case SPI_SETMENUFADE:
1884         ret = set_entry( &entry_MENUFADE, uiParam, pvParam, fWinIni );
1885         break;
1886     case SPI_GETSELECTIONFADE:
1887         ret = get_entry( &entry_SELECTIONFADE, uiParam, pvParam );
1888         break;
1889     case SPI_SETSELECTIONFADE:
1890         ret = set_entry( &entry_SELECTIONFADE, uiParam, pvParam, fWinIni );
1891         break;
1892     case SPI_GETTOOLTIPANIMATION:
1893         ret = get_entry( &entry_TOOLTIPANIMATION, uiParam, pvParam );
1894         break;
1895     case SPI_SETTOOLTIPANIMATION:
1896         ret = set_entry( &entry_TOOLTIPANIMATION, uiParam, pvParam, fWinIni );
1897         break;
1898     case SPI_GETTOOLTIPFADE:
1899         ret = get_entry( &entry_TOOLTIPFADE, uiParam, pvParam );
1900         break;
1901     case SPI_SETTOOLTIPFADE:
1902         ret = set_entry( &entry_TOOLTIPFADE, uiParam, pvParam, fWinIni );
1903         break;
1904     case SPI_GETCURSORSHADOW:
1905         ret = get_entry( &entry_CURSORSHADOW, uiParam, pvParam );
1906         break;
1907     case SPI_SETCURSORSHADOW:
1908         ret = set_entry( &entry_CURSORSHADOW, uiParam, pvParam, fWinIni );
1909         break;
1910     case SPI_GETMOUSESONAR:
1911         ret = get_entry( &entry_MOUSESONAR, uiParam, pvParam );
1912         break;
1913     case SPI_SETMOUSESONAR:
1914         ret = set_entry( &entry_MOUSESONAR, uiParam, pvParam, fWinIni );
1915         break;
1916     case SPI_GETMOUSECLICKLOCK:
1917         ret = get_entry( &entry_MOUSECLICKLOCK, uiParam, pvParam );
1918         break;
1919     case SPI_SETMOUSECLICKLOCK:
1920         ret = set_entry( &entry_MOUSECLICKLOCK, uiParam, pvParam, fWinIni );
1921         break;
1922     case SPI_GETMOUSEVANISH:
1923         ret = get_entry( &entry_MOUSEVANISH, uiParam, pvParam );
1924         break;
1925     case SPI_SETMOUSEVANISH:
1926         ret = set_entry( &entry_MOUSEVANISH, uiParam, pvParam, fWinIni );
1927         break;
1928     case SPI_GETFLATMENU:
1929         ret = get_entry( &entry_FLATMENU, uiParam, pvParam );
1930         break;
1931     case SPI_SETFLATMENU:
1932         ret = set_entry( &entry_FLATMENU, uiParam, pvParam, fWinIni );
1933         break;
1934     case SPI_GETDROPSHADOW:
1935         ret = get_entry( &entry_DROPSHADOW, uiParam, pvParam );
1936         break;
1937     case SPI_SETDROPSHADOW:
1938         ret = set_entry( &entry_DROPSHADOW, uiParam, pvParam, fWinIni );
1939         break;
1940     case SPI_GETBLOCKSENDINPUTRESETS:
1941         ret = get_entry( &entry_BLOCKSENDINPUTRESETS, uiParam, pvParam );
1942         break;
1943     case SPI_SETBLOCKSENDINPUTRESETS:
1944         ret = set_entry( &entry_BLOCKSENDINPUTRESETS, uiParam, pvParam, fWinIni );
1945         break;
1946     case SPI_GETUIEFFECTS:
1947         ret = get_entry( &entry_UIEFFECTS, uiParam, pvParam );
1948         break;
1949     case SPI_SETUIEFFECTS:
1950         /* FIXME: this probably should mask other UI effect values when unset */
1951         ret = set_entry( &entry_UIEFFECTS, uiParam, pvParam, fWinIni );
1952         break;
1953     case SPI_GETDISABLEOVERLAPPEDCONTENT:
1954         ret = get_entry( &entry_DISABLEOVERLAPPEDCONTENT, uiParam, pvParam );
1955         break;
1956     case SPI_SETDISABLEOVERLAPPEDCONTENT:
1957         ret = set_entry( &entry_DISABLEOVERLAPPEDCONTENT, uiParam, pvParam, fWinIni );
1958         break;
1959     case SPI_GETCLIENTAREAANIMATION:
1960         ret = get_entry( &entry_CLIENTAREAANIMATION, uiParam, pvParam );
1961         break;
1962     case SPI_SETCLIENTAREAANIMATION:
1963         ret = set_entry( &entry_CLIENTAREAANIMATION, uiParam, pvParam, fWinIni );
1964         break;
1965     case SPI_GETCLEARTYPE:
1966         ret = get_entry( &entry_CLEARTYPE, uiParam, pvParam );
1967         break;
1968     case SPI_SETCLEARTYPE:
1969         ret = set_entry( &entry_CLEARTYPE, uiParam, pvParam, fWinIni );
1970         break;
1971     case SPI_GETSPEECHRECOGNITION:
1972         ret = get_entry( &entry_SPEECHRECOGNITION, uiParam, pvParam );
1973         break;
1974     case SPI_SETSPEECHRECOGNITION:
1975         ret = set_entry( &entry_SPEECHRECOGNITION, uiParam, pvParam, fWinIni );
1976         break;
1977     case SPI_GETFOREGROUNDLOCKTIMEOUT:
1978         ret = get_entry( &entry_FOREGROUNDLOCKTIMEOUT, uiParam, pvParam );
1979         break;
1980     case SPI_SETFOREGROUNDLOCKTIMEOUT:
1981         /* FIXME: this should check that the calling thread
1982          * is able to change the foreground window */
1983         ret = set_entry( &entry_FOREGROUNDLOCKTIMEOUT, uiParam, pvParam, fWinIni );
1984         break;
1985     case SPI_GETACTIVEWNDTRKTIMEOUT:
1986         ret = get_entry( &entry_ACTIVEWNDTRKTIMEOUT, uiParam, pvParam );
1987         break;
1988     case SPI_SETACTIVEWNDTRKTIMEOUT:
1989         ret = get_entry( &entry_ACTIVEWNDTRKTIMEOUT, uiParam, pvParam );
1990         break;
1991     case SPI_GETFOREGROUNDFLASHCOUNT:
1992         ret = get_entry( &entry_FOREGROUNDFLASHCOUNT, uiParam, pvParam );
1993         break;
1994     case SPI_SETFOREGROUNDFLASHCOUNT:
1995         ret = set_entry( &entry_FOREGROUNDFLASHCOUNT, uiParam, pvParam, fWinIni );
1996         break;
1997     case SPI_GETCARETWIDTH:
1998         ret = get_entry( &entry_CARETWIDTH, uiParam, pvParam );
1999         break;
2000     case SPI_SETCARETWIDTH:
2001         ret = set_entry( &entry_CARETWIDTH, uiParam, pvParam, fWinIni );
2002         break;
2003     case SPI_GETMOUSECLICKLOCKTIME:
2004         ret = get_entry( &entry_MOUSECLICKLOCKTIME, uiParam, pvParam );
2005         break;
2006     case SPI_SETMOUSECLICKLOCKTIME:
2007         ret = set_entry( &entry_MOUSECLICKLOCKTIME, uiParam, pvParam, fWinIni );
2008         break;
2009     case SPI_GETFONTSMOOTHINGTYPE:
2010         ret = get_entry( &entry_FONTSMOOTHINGTYPE, uiParam, pvParam );
2011         break;
2012     case SPI_SETFONTSMOOTHINGTYPE:
2013         ret = set_entry( &entry_FONTSMOOTHINGTYPE, uiParam, pvParam, fWinIni );
2014         break;
2015     case SPI_GETFONTSMOOTHINGCONTRAST:
2016         ret = get_entry( &entry_FONTSMOOTHINGCONTRAST, uiParam, pvParam );
2017         break;
2018     case SPI_SETFONTSMOOTHINGCONTRAST:
2019         ret = set_entry( &entry_FONTSMOOTHINGCONTRAST, uiParam, pvParam, fWinIni );
2020         break;
2021     case SPI_GETFOCUSBORDERWIDTH:
2022         ret = get_entry( &entry_FOCUSBORDERWIDTH, uiParam, pvParam );
2023         break;
2024     case SPI_GETFOCUSBORDERHEIGHT:
2025         ret = get_entry( &entry_FOCUSBORDERHEIGHT, uiParam, pvParam );
2026         break;
2027     case SPI_SETFOCUSBORDERWIDTH:
2028         ret = set_entry( &entry_FOCUSBORDERWIDTH, uiParam, pvParam, fWinIni );
2029         break;
2030     case SPI_SETFOCUSBORDERHEIGHT:
2031         ret = set_entry( &entry_FOCUSBORDERHEIGHT, uiParam, pvParam, fWinIni );
2032         break;
2033     case SPI_GETFONTSMOOTHINGORIENTATION:
2034         ret = get_entry( &entry_FONTSMOOTHINGORIENTATION, uiParam, pvParam );
2035         break;
2036     case SPI_SETFONTSMOOTHINGORIENTATION:
2037         ret = set_entry( &entry_FONTSMOOTHINGORIENTATION, uiParam, pvParam, fWinIni );
2038         break;
2039
2040     default:
2041         FIXME( "Unknown action: %u\n", uiAction );
2042         SetLastError( ERROR_INVALID_SPI_VALUE );
2043         ret = FALSE;
2044         break;
2045     }
2046
2047     if (ret)
2048         SYSPARAMS_NotifyChange( uiAction, fWinIni );
2049     TRACE("(%u, %u, %p, %u) ret %d\n",
2050             uiAction, uiParam, pvParam, fWinIni, ret);
2051     return ret;
2052
2053 #undef WINE_SPI_FIXME
2054 #undef WINE_SPI_WARN
2055 }
2056
2057
2058 /***********************************************************************
2059  *              SystemParametersInfoA (USER32.@)
2060  */
2061 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
2062                                    PVOID pvParam, UINT fuWinIni )
2063 {
2064     BOOL ret;
2065
2066     TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
2067
2068     switch (uiAction)
2069     {
2070     case SPI_SETDESKWALLPAPER:                  /*     20 */
2071     case SPI_SETDESKPATTERN:                    /*     21 */
2072     {
2073         WCHAR buffer[256];
2074         if (pvParam)
2075             if (!MultiByteToWideChar( CP_ACP, 0, pvParam, -1, buffer,
2076                                       sizeof(buffer)/sizeof(WCHAR) ))
2077                 buffer[sizeof(buffer)/sizeof(WCHAR)-1] = 0;
2078         ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
2079         break;
2080     }
2081
2082     case SPI_GETICONTITLELOGFONT:               /*     31 */
2083     {
2084         LOGFONTW tmp;
2085         ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
2086         if (ret && pvParam)
2087             SYSPARAMS_LogFont32WTo32A( &tmp, pvParam );
2088         break;
2089     }
2090
2091     case SPI_GETNONCLIENTMETRICS:               /*     41  WINVER >= 0x400 */
2092     {
2093         NONCLIENTMETRICSW tmp;
2094         LPNONCLIENTMETRICSA lpnmA = pvParam;
2095         if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
2096                       lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
2097         {
2098             tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2099             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2100             if (ret)
2101                 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
2102         }
2103         else
2104             ret = FALSE;
2105         break;
2106     }
2107
2108     case SPI_SETNONCLIENTMETRICS:               /*     42  WINVER >= 0x400 */
2109     {
2110         NONCLIENTMETRICSW tmp;
2111         LPNONCLIENTMETRICSA lpnmA = pvParam;
2112         if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
2113                       lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
2114         {
2115             tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2116             SYSPARAMS_NonClientMetrics32ATo32W( lpnmA, &tmp );
2117             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2118         }
2119         else
2120             ret = FALSE;
2121         break;
2122     }
2123
2124     case SPI_GETICONMETRICS:                    /*     45  WINVER >= 0x400 */
2125     {
2126         ICONMETRICSW tmp;
2127         LPICONMETRICSA lpimA = pvParam;
2128         if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2129         {
2130             tmp.cbSize = sizeof(ICONMETRICSW);
2131             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2132             if (ret)
2133             {
2134                 lpimA->iHorzSpacing = tmp.iHorzSpacing;
2135                 lpimA->iVertSpacing = tmp.iVertSpacing;
2136                 lpimA->iTitleWrap   = tmp.iTitleWrap;
2137                 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
2138             }
2139         }
2140         else
2141             ret = FALSE;
2142         break;
2143     }
2144
2145     case SPI_SETICONMETRICS:                    /*     46  WINVER >= 0x400 */
2146     {
2147         ICONMETRICSW tmp;
2148         LPICONMETRICSA lpimA = pvParam;
2149         if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2150         {
2151             tmp.cbSize = sizeof(ICONMETRICSW);
2152             tmp.iHorzSpacing = lpimA->iHorzSpacing;
2153             tmp.iVertSpacing = lpimA->iVertSpacing;
2154             tmp.iTitleWrap = lpimA->iTitleWrap;
2155             SYSPARAMS_LogFont32ATo32W(  &lpimA->lfFont, &tmp.lfFont);
2156             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2157         }
2158         else
2159             ret = FALSE;
2160         break;
2161     }
2162
2163     case SPI_GETHIGHCONTRAST:                   /*     66  WINVER >= 0x400 */
2164     {
2165         HIGHCONTRASTW tmp;
2166         LPHIGHCONTRASTA lphcA = pvParam;
2167         if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
2168         {
2169             tmp.cbSize = sizeof(HIGHCONTRASTW);
2170             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2171             if (ret)
2172             {
2173                 lphcA->dwFlags = tmp.dwFlags;
2174                 lphcA->lpszDefaultScheme = NULL;  /* FIXME? */
2175             }
2176         }
2177         else
2178             ret = FALSE;
2179         break;
2180     }
2181
2182     case SPI_GETDESKWALLPAPER:                  /*     115 */
2183     {
2184         WCHAR buffer[MAX_PATH];
2185         ret = (SystemParametersInfoW( SPI_GETDESKWALLPAPER, uiParam, buffer, fuWinIni ) &&
2186                WideCharToMultiByte(CP_ACP, 0, buffer, -1, pvParam, uiParam, NULL, NULL));
2187         break;
2188     }
2189
2190     default:
2191         ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
2192         break;
2193     }
2194     return ret;
2195 }
2196
2197
2198 /***********************************************************************
2199  *              GetSystemMetrics (USER32.@)
2200  */
2201 INT WINAPI GetSystemMetrics( INT index )
2202 {
2203     NONCLIENTMETRICSW ncm;
2204     UINT ret;
2205
2206     /* some metrics are dynamic */
2207     switch (index)
2208     {
2209     case SM_CXSCREEN:
2210         return GetDeviceCaps( get_display_dc(), HORZRES );
2211     case SM_CYSCREEN:
2212         return GetDeviceCaps( get_display_dc(), VERTRES );
2213     case SM_CXVSCROLL:
2214     case SM_CYHSCROLL:
2215         get_entry( &entry_SCROLLWIDTH, 0, &ret );
2216         return max( 8, ret );
2217     case SM_CYCAPTION:
2218         return GetSystemMetrics( SM_CYSIZE ) + 1;
2219     case SM_CXBORDER:
2220     case SM_CYBORDER:
2221         /* SM_C{X,Y}BORDER always returns 1 regardless of 'BorderWidth' value in registry */
2222         return 1;
2223     case SM_CXDLGFRAME:
2224     case SM_CYDLGFRAME:
2225         return 3;
2226     case SM_CYVTHUMB:
2227     case SM_CXHTHUMB:
2228     case SM_CYVSCROLL:
2229     case SM_CXHSCROLL:
2230         get_entry( &entry_SCROLLHEIGHT, 0, &ret );
2231         return max( 8, ret );
2232     case SM_CXICON:
2233     case SM_CYICON:
2234         get_entry( &entry_ICONSIZE, 0, &ret );
2235         return ret;
2236     case SM_CXCURSOR:
2237     case SM_CYCURSOR:
2238         return 32;
2239     case SM_CYMENU:
2240         return GetSystemMetrics(SM_CYMENUSIZE) + 1;
2241     case SM_CXFULLSCREEN:
2242         /* see the remark for SM_CXMAXIMIZED, at least this formulation is
2243          * correct */
2244         return GetSystemMetrics( SM_CXMAXIMIZED) - 2 * GetSystemMetrics( SM_CXFRAME);
2245     case SM_CYFULLSCREEN:
2246         /* see the remark for SM_CYMAXIMIZED, at least this formulation is
2247          * correct */
2248         return GetSystemMetrics( SM_CYMAXIMIZED) - GetSystemMetrics( SM_CYMIN);
2249     case SM_CYKANJIWINDOW:
2250         return 0;
2251     case SM_MOUSEPRESENT:
2252         return 1;
2253     case SM_DEBUG:
2254         return 0;
2255     case SM_SWAPBUTTON:
2256         get_entry( &entry_MOUSEBUTTONSWAP, 0, &ret );
2257         return ret;
2258     case SM_RESERVED1:
2259     case SM_RESERVED2:
2260     case SM_RESERVED3:
2261     case SM_RESERVED4:
2262         return 0;
2263     case SM_CXMIN:
2264         SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
2265         get_text_metr_size( get_display_dc(), &ncm.lfCaptionFont, NULL, &ret );
2266         return 3 * ncm.iCaptionWidth + ncm.iCaptionHeight + 4 * ret + 2 * GetSystemMetrics(SM_CXFRAME) + 4;
2267     case SM_CYMIN:
2268         return GetSystemMetrics( SM_CYCAPTION) + 2 * GetSystemMetrics( SM_CYFRAME);
2269     case SM_CXSIZE:
2270         get_entry( &entry_CAPTIONWIDTH, 0, &ret );
2271         return max( 8, ret );
2272     case SM_CYSIZE:
2273         SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
2274         return ncm.iCaptionHeight;
2275     case SM_CXFRAME:
2276         get_entry( &entry_BORDER, 0, &ret );
2277         return GetSystemMetrics(SM_CXDLGFRAME) + max( 1, ret );
2278     case SM_CYFRAME:
2279         get_entry( &entry_BORDER, 0, &ret );
2280         return GetSystemMetrics(SM_CYDLGFRAME) + max( 1, ret );
2281     case SM_CXMINTRACK:
2282         return GetSystemMetrics(SM_CXMIN);
2283     case SM_CYMINTRACK:
2284         return GetSystemMetrics(SM_CYMIN);
2285     case SM_CXDOUBLECLK:
2286         get_entry( &entry_DOUBLECLKWIDTH, 0, &ret );
2287         return ret;
2288     case SM_CYDOUBLECLK:
2289         get_entry( &entry_DOUBLECLKHEIGHT, 0, &ret );
2290         return ret;
2291     case SM_CXICONSPACING:
2292         get_entry( &entry_ICONHORIZONTALSPACING, 0, &ret );
2293         return ret;
2294     case SM_CYICONSPACING:
2295         get_entry( &entry_ICONVERTICALSPACING, 0, &ret );
2296         return ret;
2297     case SM_MENUDROPALIGNMENT:
2298         get_entry( &entry_MENUDROPALIGNMENT, 0, &ret );
2299         return ret;
2300     case SM_PENWINDOWS:
2301         return 0;
2302     case SM_DBCSENABLED:
2303     {
2304         CPINFO cpinfo;
2305         GetCPInfo( CP_ACP, &cpinfo );
2306         return (cpinfo.MaxCharSize > 1);
2307     }
2308     case SM_CMOUSEBUTTONS:
2309         return 3;
2310     case SM_SECURE:
2311         return 0;
2312     case SM_CXEDGE:
2313         return GetSystemMetrics(SM_CXBORDER) + 1;
2314     case SM_CYEDGE:
2315         return GetSystemMetrics(SM_CYBORDER) + 1;
2316     case SM_CXMINSPACING:
2317         get_entry( &entry_MINHORZGAP, 0, &ret );
2318         return GetSystemMetrics(SM_CXMINIMIZED) + max( 0, (INT)ret );
2319     case SM_CYMINSPACING:
2320         get_entry( &entry_MINVERTGAP, 0, &ret );
2321         return GetSystemMetrics(SM_CYMINIMIZED) + max( 0, (INT)ret );
2322     case SM_CXSMICON:
2323     case SM_CYSMICON:
2324         return 16;
2325     case SM_CYSMCAPTION:
2326         return GetSystemMetrics(SM_CYSMSIZE) + 1;
2327     case SM_CXSMSIZE:
2328         get_entry( &entry_SMCAPTIONWIDTH, 0, &ret );
2329         return ret;
2330     case SM_CYSMSIZE:
2331         SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
2332         return ncm.iSmCaptionHeight;
2333     case SM_CXMENUSIZE:
2334         get_entry( &entry_MENUWIDTH, 0, &ret );
2335         return ret;
2336     case SM_CYMENUSIZE:
2337         SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
2338         return ncm.iMenuHeight;
2339     case SM_ARRANGE:
2340         get_entry( &entry_MINARRANGE, 0, &ret );
2341         return ret & 0x0f;
2342     case SM_CXMINIMIZED:
2343         get_entry( &entry_MINWIDTH, 0, &ret );
2344         return max( 0, (INT)ret ) + 6;
2345     case SM_CYMINIMIZED:
2346         return GetSystemMetrics( SM_CYSIZE ) + 6;
2347     case SM_CXMAXTRACK:
2348         return GetSystemMetrics(SM_CXVIRTUALSCREEN) + 4 + 2 * GetSystemMetrics(SM_CXFRAME);
2349     case SM_CYMAXTRACK:
2350         return GetSystemMetrics(SM_CYVIRTUALSCREEN) + 4 + 2 * GetSystemMetrics(SM_CYFRAME);
2351     case SM_CXMAXIMIZED:
2352         /* FIXME: subtract the width of any vertical application toolbars*/
2353         return GetSystemMetrics(SM_CXSCREEN) + 2 * GetSystemMetrics(SM_CXFRAME);
2354     case SM_CYMAXIMIZED:
2355         /* FIXME: subtract the width of any horizontal application toolbars*/
2356         return GetSystemMetrics(SM_CYSCREEN) + 2 * GetSystemMetrics(SM_CYCAPTION);
2357     case SM_NETWORK:
2358         return 3;  /* FIXME */
2359     case SM_CLEANBOOT:
2360         return 0; /* 0 = ok, 1 = failsafe, 2 = failsafe + network */
2361     case SM_CXDRAG:
2362         get_entry( &entry_DRAGWIDTH, 0, &ret );
2363         return ret;
2364     case SM_CYDRAG:
2365         get_entry( &entry_DRAGHEIGHT, 0, &ret );
2366         return ret;
2367     case SM_SHOWSOUNDS:
2368         get_entry( &entry_SHOWSOUNDS, 0, &ret );
2369         return ret;
2370     case SM_CXMENUCHECK:
2371     case SM_CYMENUCHECK:
2372     {
2373         TEXTMETRICW tm;
2374         SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
2375         get_text_metr_size( get_display_dc(), &ncm.lfMenuFont, &tm, NULL);
2376         return tm.tmHeight <= 0 ? 13 : ((tm.tmHeight + tm.tmExternalLeading + 1) / 2) * 2 - 1;
2377     }
2378     case SM_SLOWMACHINE:
2379         return 0;  /* Never true */
2380     case SM_MIDEASTENABLED:
2381         return 0;  /* FIXME */
2382     case SM_MOUSEWHEELPRESENT:
2383         return 1;
2384     case SM_XVIRTUALSCREEN:
2385     {
2386         RECT rect = get_virtual_screen_rect();
2387         return rect.left;
2388     }
2389     case SM_YVIRTUALSCREEN:
2390     {
2391         RECT rect = get_virtual_screen_rect();
2392         return rect.top;
2393     }
2394     case SM_CXVIRTUALSCREEN:
2395     {
2396         RECT rect = get_virtual_screen_rect();
2397         return rect.right - rect.left;
2398     }
2399     case SM_CYVIRTUALSCREEN:
2400     {
2401         RECT rect = get_virtual_screen_rect();
2402         return rect.bottom - rect.top;
2403     }
2404     case SM_CMONITORS:
2405     {
2406         struct monitor_info info;
2407         get_monitors_info( &info );
2408         return info.count;
2409     }
2410     case SM_SAMEDISPLAYFORMAT:
2411         return 1;
2412     case SM_IMMENABLED:
2413         return 0;  /* FIXME */
2414     case SM_CXFOCUSBORDER:
2415     case SM_CYFOCUSBORDER:
2416         return 1;
2417     case SM_TABLETPC:
2418     case SM_MEDIACENTER:
2419         return 0;
2420     case SM_CMETRICS:
2421         return SM_CMETRICS;
2422     default:
2423         return 0;
2424     }
2425 }
2426
2427
2428 /***********************************************************************
2429  *              SwapMouseButton (USER32.@)
2430  *  Reverse or restore the meaning of the left and right mouse buttons
2431  *  fSwap  [I ] TRUE - reverse, FALSE - original
2432  * RETURN
2433  *   previous state
2434  */
2435 BOOL WINAPI SwapMouseButton( BOOL fSwap )
2436 {
2437     BOOL prev = GetSystemMetrics(SM_SWAPBUTTON);
2438     SystemParametersInfoW(SPI_SETMOUSEBUTTONSWAP, fSwap, 0, 0);
2439     return prev;
2440 }
2441
2442
2443 /**********************************************************************
2444  *              SetDoubleClickTime (USER32.@)
2445  */
2446 BOOL WINAPI SetDoubleClickTime( UINT interval )
2447 {
2448     return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
2449 }
2450
2451
2452 /**********************************************************************
2453  *              GetDoubleClickTime (USER32.@)
2454  */
2455 UINT WINAPI GetDoubleClickTime(void)
2456 {
2457     UINT time = 0;
2458
2459     get_entry( &entry_DOUBLECLICKTIME, 0, &time );
2460     if (!time) time = 500;
2461     return time;
2462 }
2463
2464
2465 /*************************************************************************
2466  *              GetSysColor (USER32.@)
2467  */
2468 COLORREF WINAPI DECLSPEC_HOTPATCH GetSysColor( INT nIndex )
2469 {
2470     if (nIndex >= 0 && nIndex < NUM_SYS_COLORS)
2471         return SysColors[nIndex];
2472     else
2473         return 0;
2474 }
2475
2476
2477 /*************************************************************************
2478  *              SetSysColors (USER32.@)
2479  */
2480 BOOL WINAPI SetSysColors( INT nChanges, const INT *lpSysColor,
2481                               const COLORREF *lpColorValues )
2482 {
2483     int i;
2484
2485     if (IS_INTRESOURCE(lpSysColor)) return FALSE; /* stupid app passes a color instead of an array */
2486
2487     for (i = 0; i < nChanges; i++) SYSPARAMS_SetSysColor( lpSysColor[i], lpColorValues[i] );
2488
2489     /* Send WM_SYSCOLORCHANGE message to all windows */
2490
2491     SendMessageTimeoutW( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0, SMTO_ABORTIFHUNG, 2000, NULL );
2492
2493     /* Repaint affected portions of all visible windows */
2494
2495     RedrawWindow( GetDesktopWindow(), NULL, 0,
2496                 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
2497     return TRUE;
2498 }
2499
2500
2501 /*************************************************************************
2502  *              SetSysColorsTemp (USER32.@)
2503  *
2504  * UNDOCUMENTED !!
2505  *
2506  * Called by W98SE desk.cpl Control Panel Applet:
2507  * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
2508  * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
2509  *
2510  * pPens is an array of COLORREF values, which seems to be used
2511  * to indicate the color values to create new pens with.
2512  *
2513  * pBrushes is an array of solid brush handles (returned by a previous
2514  * CreateSolidBrush), which seems to contain the brush handles to set
2515  * for the system colors.
2516  *
2517  * n seems to be used for
2518  *   a) indicating the number of entries to operate on (length of pPens,
2519  *      pBrushes)
2520  *   b) passing the handle that points to the previously used color settings.
2521  *      I couldn't figure out in hell what kind of handle this is on
2522  *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
2523  *
2524  * RETURNS
2525  *     heap handle of our own copy of the current syscolors in case of
2526  *                 "set" call, i.e. pPens, pBrushes != NULL.
2527  *     TRUE (unconditionally !) in case of "restore" call,
2528  *          i.e. pPens, pBrushes == NULL.
2529  *     FALSE in case of either pPens != NULL and pBrushes == NULL
2530  *          or pPens == NULL and pBrushes != NULL.
2531  *
2532  * I'm not sure whether this implementation is 100% correct. [AM]
2533  */
2534 DWORD_PTR WINAPI SetSysColorsTemp( const COLORREF *pPens, const HBRUSH *pBrushes, DWORD_PTR n)
2535 {
2536     DWORD i;
2537
2538     if (pPens && pBrushes) /* "set" call */
2539     {
2540         /* allocate our structure to remember old colors */
2541         LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
2542         LPVOID p = pOldCol;
2543         *(DWORD *)p = n; p = (char*)p + sizeof(DWORD);
2544         memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
2545         memcpy(p, SysColorBrushes, n*sizeof(HBRUSH));
2546
2547         for (i=0; i < n; i++)
2548         {
2549             SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
2550             SysColorBrushes[i] = pBrushes[i];
2551         }
2552
2553         return (DWORD_PTR)pOldCol;
2554     }
2555     if (!pPens && !pBrushes) /* "restore" call */
2556     {
2557         LPVOID pOldCol = (LPVOID)n; /* FIXME: not 64-bit safe */
2558         LPVOID p = pOldCol;
2559         DWORD nCount = *(DWORD *)p;
2560         p = (char*)p + sizeof(DWORD);
2561
2562         for (i=0; i < nCount; i++)
2563         {
2564             DeleteObject(SysColorPens[i]);
2565             SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
2566         }
2567         for (i=0; i < nCount; i++)
2568         {
2569             SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
2570         }
2571         /* get rid of storage structure */
2572         HeapFree(GetProcessHeap(), 0, pOldCol);
2573
2574         return TRUE;
2575     }
2576     return FALSE;
2577 }
2578
2579
2580 /***********************************************************************
2581  *              GetSysColorBrush (USER32.@)
2582  */
2583 HBRUSH WINAPI DECLSPEC_HOTPATCH GetSysColorBrush( INT index )
2584 {
2585     if (0 <= index && index < NUM_SYS_COLORS) return SysColorBrushes[index];
2586     WARN("Unknown index(%d)\n", index );
2587     return NULL;
2588 }
2589
2590
2591 /***********************************************************************
2592  *              SYSCOLOR_GetPen
2593  */
2594 HPEN SYSCOLOR_GetPen( INT index )
2595 {
2596     /* We can assert here, because this function is internal to Wine */
2597     assert (0 <= index && index < NUM_SYS_COLORS);
2598     return SysColorPens[index];
2599 }
2600
2601
2602 /***********************************************************************
2603  *              ChangeDisplaySettingsA (USER32.@)
2604  */
2605 LONG WINAPI ChangeDisplaySettingsA( LPDEVMODEA devmode, DWORD flags )
2606 {
2607     if (devmode) devmode->dmDriverExtra = 0;
2608
2609     return ChangeDisplaySettingsExA(NULL,devmode,NULL,flags,NULL);
2610 }
2611
2612
2613 /***********************************************************************
2614  *              ChangeDisplaySettingsW (USER32.@)
2615  */
2616 LONG WINAPI ChangeDisplaySettingsW( LPDEVMODEW devmode, DWORD flags )
2617 {
2618     if (devmode) devmode->dmDriverExtra = 0;
2619
2620     return ChangeDisplaySettingsExW(NULL,devmode,NULL,flags,NULL);
2621 }
2622
2623
2624 /***********************************************************************
2625  *              ChangeDisplaySettingsExA (USER32.@)
2626  */
2627 LONG WINAPI ChangeDisplaySettingsExA( LPCSTR devname, LPDEVMODEA devmode, HWND hwnd,
2628                                       DWORD flags, LPVOID lparam )
2629 {
2630     LONG ret;
2631     UNICODE_STRING nameW;
2632
2633     if (devname) RtlCreateUnicodeStringFromAsciiz(&nameW, devname);
2634     else nameW.Buffer = NULL;
2635
2636     if (devmode)
2637     {
2638         DEVMODEW *devmodeW;
2639
2640         devmodeW = GdiConvertToDevmodeW(devmode);
2641         if (devmodeW)
2642         {
2643             ret = ChangeDisplaySettingsExW(nameW.Buffer, devmodeW, hwnd, flags, lparam);
2644             HeapFree(GetProcessHeap(), 0, devmodeW);
2645         }
2646         else
2647             ret = DISP_CHANGE_SUCCESSFUL;
2648     }
2649     else
2650     {
2651         ret = ChangeDisplaySettingsExW(nameW.Buffer, NULL, hwnd, flags, lparam);
2652     }
2653
2654     if (devname) RtlFreeUnicodeString(&nameW);
2655     return ret;
2656 }
2657
2658
2659 /***********************************************************************
2660  *              ChangeDisplaySettingsExW (USER32.@)
2661  */
2662 LONG WINAPI ChangeDisplaySettingsExW( LPCWSTR devname, LPDEVMODEW devmode, HWND hwnd,
2663                                       DWORD flags, LPVOID lparam )
2664 {
2665     /* make sure the desktop window is created before mode changing */
2666     GetDesktopWindow();
2667
2668     return USER_Driver->pChangeDisplaySettingsEx( devname, devmode, hwnd, flags, lparam );
2669 }
2670
2671
2672 /***********************************************************************
2673  *              EnumDisplaySettingsW (USER32.@)
2674  *
2675  * RETURNS
2676  *      TRUE if nth setting exists found (described in the LPDEVMODEW struct)
2677  *      FALSE if we do not have the nth setting
2678  */
2679 BOOL WINAPI EnumDisplaySettingsW( LPCWSTR name, DWORD n, LPDEVMODEW devmode )
2680 {
2681     return EnumDisplaySettingsExW(name, n, devmode, 0);
2682 }
2683
2684
2685 /***********************************************************************
2686  *              EnumDisplaySettingsA (USER32.@)
2687  */
2688 BOOL WINAPI EnumDisplaySettingsA(LPCSTR name,DWORD n,LPDEVMODEA devmode)
2689 {
2690     return EnumDisplaySettingsExA(name, n, devmode, 0);
2691 }
2692
2693
2694 /***********************************************************************
2695  *              EnumDisplaySettingsExA (USER32.@)
2696  */
2697 BOOL WINAPI EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum,
2698                                    LPDEVMODEA lpDevMode, DWORD dwFlags)
2699 {
2700     DEVMODEW devmodeW;
2701     BOOL ret;
2702     UNICODE_STRING nameW;
2703
2704     if (lpszDeviceName) RtlCreateUnicodeStringFromAsciiz(&nameW, lpszDeviceName);
2705     else nameW.Buffer = NULL;
2706
2707     ret = EnumDisplaySettingsExW(nameW.Buffer,iModeNum,&devmodeW,dwFlags);
2708     if (ret)
2709     {
2710         lpDevMode->dmSize = FIELD_OFFSET(DEVMODEA, dmICMMethod);
2711         lpDevMode->dmSpecVersion = devmodeW.dmSpecVersion;
2712         lpDevMode->dmDriverVersion = devmodeW.dmDriverVersion;
2713         WideCharToMultiByte(CP_ACP, 0, devmodeW.dmDeviceName, -1,
2714                             (LPSTR)lpDevMode->dmDeviceName, CCHDEVICENAME, NULL, NULL);
2715         lpDevMode->dmDriverExtra      = 0; /* FIXME */
2716         lpDevMode->dmBitsPerPel       = devmodeW.dmBitsPerPel;
2717         lpDevMode->dmPelsHeight       = devmodeW.dmPelsHeight;
2718         lpDevMode->dmPelsWidth        = devmodeW.dmPelsWidth;
2719         lpDevMode->u2.dmDisplayFlags  = devmodeW.u2.dmDisplayFlags;
2720         lpDevMode->dmDisplayFrequency = devmodeW.dmDisplayFrequency;
2721         lpDevMode->dmFields           = devmodeW.dmFields;
2722
2723         lpDevMode->u1.s2.dmPosition.x = devmodeW.u1.s2.dmPosition.x;
2724         lpDevMode->u1.s2.dmPosition.y = devmodeW.u1.s2.dmPosition.y;
2725         lpDevMode->u1.s2.dmDisplayOrientation = devmodeW.u1.s2.dmDisplayOrientation;
2726         lpDevMode->u1.s2.dmDisplayFixedOutput = devmodeW.u1.s2.dmDisplayFixedOutput;
2727     }
2728     if (lpszDeviceName) RtlFreeUnicodeString(&nameW);
2729     return ret;
2730 }
2731
2732
2733 /***********************************************************************
2734  *              EnumDisplaySettingsExW (USER32.@)
2735  */
2736 BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum,
2737                                    LPDEVMODEW lpDevMode, DWORD dwFlags)
2738 {
2739     /* make sure the desktop window is created before mode enumeration */
2740     GetDesktopWindow();
2741
2742     return USER_Driver->pEnumDisplaySettingsEx(lpszDeviceName, iModeNum, lpDevMode, dwFlags);
2743 }
2744
2745 /***********************************************************************
2746  *              SetProcessDPIAware   (USER32.@)
2747  */
2748 BOOL WINAPI SetProcessDPIAware( VOID )
2749 {
2750     FIXME( "stub!\n");
2751
2752     return TRUE;
2753 }