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