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