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