2 * System parameters functions
4 * Copyright 1994 Alexandre Julliard
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.
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.
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
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
38 #include "wine/wingdi16.h"
43 #include "user_private.h"
44 #include "wine/gdi_driver.h"
45 #include "wine/unicode.h"
46 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(system
);
50 /* System parameter indexes */
58 * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
59 * for the system parameters.
62 /* the various registry keys that are used to store parameters */
79 static const WCHAR COLORS_REGKEY
[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','C','o','l','o','r','s',0};
80 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};
81 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};
82 static const WCHAR MOUSE_REGKEY
[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
83 static const WCHAR METRICS_REGKEY
[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
84 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
85 static const WCHAR SOUND_REGKEY
[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','S','o','u','n','d',0};
86 static const WCHAR VERSION_REGKEY
[] = {'S','o','f','t','w','a','r','e','\\',
87 'M','i','c','r','o','s','o','f','t','\\',
88 'W','i','n','d','o','w','s',' ','N','T','\\',
89 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
90 'W','i','n','d','o','w','s',0};
91 static const WCHAR SHOWSOUNDS_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 'S','h','o','w','S','o','u','n','d','s',0};
94 static const WCHAR KEYBOARDPREF_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 'K','e','y','b','o','a','r','d',' ','P','r','e','f','e','r','e','n','c','e',0};
97 static const WCHAR SCREENREADER_REGKEY
[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
98 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
99 'B','l','i','n','d',' ','A','c','c','e','s','s',0};
100 static const WCHAR AUDIODESC_REGKEY
[] = {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
101 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
102 'A','u','d','i','o','D','e','s','c','r','i','p','t','i','o','n',0};
104 static const WCHAR
*parameter_key_names
[NB_PARAM_KEYS
] =
119 /* parameter key values; the first char is actually an enum parameter_key to specify the key */
120 static const WCHAR BEEP_VALNAME
[]= {SOUND_KEY
,'B','e','e','p',0};
121 static const WCHAR MOUSETHRESHOLD1_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','T','h','r','e','s','h','o','l','d','1',0};
122 static const WCHAR MOUSETHRESHOLD2_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','T','h','r','e','s','h','o','l','d','2',0};
123 static const WCHAR MOUSEACCELERATION_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','S','p','e','e','d',0};
124 static const WCHAR BORDER_VALNAME
[]= {METRICS_KEY
,'B','o','r','d','e','r','W','i','d','t','h',0};
125 static const WCHAR KEYBOARDSPEED_VALNAME
[]= {KEYBOARD_KEY
,'K','e','y','b','o','a','r','d','S','p','e','e','d',0};
126 static const WCHAR ICONHORIZONTALSPACING_VALNAME
[]= {METRICS_KEY
,'I','c','o','n','S','p','a','c','i','n','g',0};
127 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};
128 static const WCHAR SCREENSAVEACTIVE_VALNAME
[]= {DESKTOP_KEY
,'S','c','r','e','e','n','S','a','v','e','A','c','t','i','v','e',0};
129 static const WCHAR GRIDGRANULARITY_VALNAME
[]= {DESKTOP_KEY
,'G','r','i','d','G','r','a','n','u','l','a','r','i','t','y',0};
130 static const WCHAR KEYBOARDDELAY_VALNAME
[]= {KEYBOARD_KEY
,'K','e','y','b','o','a','r','d','D','e','l','a','y',0};
131 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};
132 static const WCHAR ICONTITLEWRAP_VALNAME
[]= {DESKTOP_KEY
,'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
133 static const WCHAR ICONTITLEWRAP_MIRROR
[]= {METRICS_KEY
,'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
134 static const WCHAR ICONTITLELOGFONT_VALNAME
[]= {METRICS_KEY
,'I','c','o','n','F','o','n','t',0};
135 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};
136 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};
137 static const WCHAR MOUSETRAILS_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','T','r','a','i','l','s',0};
138 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};
139 static const WCHAR DOUBLECLKWIDTH_VALNAME
[]= {MOUSE_KEY
,'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
140 static const WCHAR DOUBLECLKWIDTH_MIRROR
[]= {DESKTOP_KEY
,'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
141 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};
142 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};
143 static const WCHAR DOUBLECLICKTIME_VALNAME
[]= {MOUSE_KEY
,'D','o','u','b','l','e','C','l','i','c','k','S','p','e','e','d',0};
144 static const WCHAR MOUSEBUTTONSWAP_VALNAME
[]= {MOUSE_KEY
,'S','w','a','p','M','o','u','s','e','B','u','t','t','o','n','s',0};
145 static const WCHAR DRAGFULLWINDOWS_VALNAME
[]= {DESKTOP_KEY
,'D','r','a','g','F','u','l','l','W','i','n','d','o','w','s',0};
146 static const WCHAR SHOWSOUNDS_VALNAME
[]= {SHOWSOUNDS_KEY
,'O','n',0};
147 static const WCHAR KEYBOARDPREF_VALNAME
[]= {KEYBOARDPREF_KEY
,'O','n',0};
148 static const WCHAR SCREENREADER_VALNAME
[]= {SCREENREADER_KEY
,'O','n',0};
149 static const WCHAR DESKWALLPAPER_VALNAME
[]= {DESKTOP_KEY
,'W','a','l','l','p','a','p','e','r',0};
150 static const WCHAR DESKPATTERN_VALNAME
[]= {DESKTOP_KEY
,'P','a','t','t','e','r','n',0};
151 static const WCHAR FONTSMOOTHING_VALNAME
[]= {DESKTOP_KEY
,'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
152 static const WCHAR DRAGWIDTH_VALNAME
[]= {DESKTOP_KEY
,'D','r','a','g','W','i','d','t','h',0};
153 static const WCHAR DRAGHEIGHT_VALNAME
[]= {DESKTOP_KEY
,'D','r','a','g','H','e','i','g','h','t',0};
154 static const WCHAR DPISCALINGVER_VALNAME
[]= {DESKTOP_KEY
,'D','p','i','S','c','a','l','i','n','g','V','e','r',0};
155 static const WCHAR LOGPIXELS_VALNAME
[]= {DESKTOP_KEY
,'L','o','g','P','i','x','e','l','s',0};
156 static const WCHAR LOWPOWERACTIVE_VALNAME
[]= {DESKTOP_KEY
,'L','o','w','P','o','w','e','r','A','c','t','i','v','e',0};
157 static const WCHAR POWEROFFACTIVE_VALNAME
[]= {DESKTOP_KEY
,'P','o','w','e','r','O','f','f','A','c','t','i','v','e',0};
158 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};
159 static const WCHAR MOUSEHOVERWIDTH_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','H','o','v','e','r','W','i','d','t','h',0};
160 static const WCHAR MOUSEHOVERHEIGHT_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','H','o','v','e','r','H','e','i','g','h','t',0};
161 static const WCHAR MOUSEHOVERTIME_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','H','o','v','e','r','T','i','m','e',0};
162 static const WCHAR WHEELSCROLLCHARS_VALNAME
[]= {DESKTOP_KEY
,'W','h','e','e','l','S','c','r','o','l','l','C','h','a','r','s',0};
163 static const WCHAR WHEELSCROLLLINES_VALNAME
[]= {DESKTOP_KEY
,'W','h','e','e','l','S','c','r','o','l','l','L','i','n','e','s',0};
164 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};
165 static const WCHAR MENUSHOWDELAY_VALNAME
[]= {DESKTOP_KEY
,'M','e','n','u','S','h','o','w','D','e','l','a','y',0};
166 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};
167 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};
168 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};
169 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};
170 static const WCHAR CARETWIDTH_VALNAME
[]= {DESKTOP_KEY
,'C','a','r','e','t','W','i','d','t','h',0};
171 static const WCHAR MOUSECLICKLOCKTIME_VALNAME
[]= {DESKTOP_KEY
,'C','l','i','c','k','L','o','c','k','T','i','m','e',0};
172 static const WCHAR MOUSESPEED_VALNAME
[]= {MOUSE_KEY
,'M','o','u','s','e','S','e','n','s','i','t','i','v','i','t','y',0};
173 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};
174 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};
175 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};
176 static const WCHAR FOCUSBORDERWIDTH_VALNAME
[]= {DESKTOP_KEY
,'F','o','c','u','s','B','o','r','d','e','r','W','i','d','t','h',0};
177 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};
178 static const WCHAR SCROLLWIDTH_VALNAME
[]= {METRICS_KEY
,'S','c','r','o','l','l','W','i','d','t','h',0};
179 static const WCHAR SCROLLHEIGHT_VALNAME
[]= {METRICS_KEY
,'S','c','r','o','l','l','H','e','i','g','h','t',0};
180 static const WCHAR CAPTIONWIDTH_VALNAME
[]= {METRICS_KEY
,'C','a','p','t','i','o','n','W','i','d','t','h',0};
181 static const WCHAR CAPTIONHEIGHT_VALNAME
[]= {METRICS_KEY
,'C','a','p','t','i','o','n','H','e','i','g','h','t',0};
182 static const WCHAR SMCAPTIONWIDTH_VALNAME
[]= {METRICS_KEY
,'S','m','C','a','p','t','i','o','n','W','i','d','t','h',0};
183 static const WCHAR SMCAPTIONHEIGHT_VALNAME
[]= {METRICS_KEY
,'S','m','C','a','p','t','i','o','n','H','e','i','g','h','t',0};
184 static const WCHAR MENUWIDTH_VALNAME
[]= {METRICS_KEY
,'M','e','n','u','W','i','d','t','h',0};
185 static const WCHAR MENUHEIGHT_VALNAME
[]= {METRICS_KEY
,'M','e','n','u','H','e','i','g','h','t',0};
186 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};
187 static const WCHAR CAPTIONLOGFONT_VALNAME
[]= {METRICS_KEY
,'C','a','p','t','i','o','n','F','o','n','t',0};
188 static const WCHAR SMCAPTIONLOGFONT_VALNAME
[]= {METRICS_KEY
,'S','m','C','a','p','t','i','o','n','F','o','n','t',0};
189 static const WCHAR MENULOGFONT_VALNAME
[]= {METRICS_KEY
,'M','e','n','u','F','o','n','t',0};
190 static const WCHAR MESSAGELOGFONT_VALNAME
[]= {METRICS_KEY
,'M','e','s','s','a','g','e','F','o','n','t',0};
191 static const WCHAR STATUSLOGFONT_VALNAME
[]= {METRICS_KEY
,'S','t','a','t','u','s','F','o','n','t',0};
192 static const WCHAR MINWIDTH_VALNAME
[] = {METRICS_KEY
,'M','i','n','W','i','d','t','h',0};
193 static const WCHAR MINHORZGAP_VALNAME
[] = {METRICS_KEY
,'M','i','n','H','o','r','z','G','a','p',0};
194 static const WCHAR MINVERTGAP_VALNAME
[] = {METRICS_KEY
,'M','i','n','V','e','r','t','G','a','p',0};
195 static const WCHAR MINARRANGE_VALNAME
[] = {METRICS_KEY
,'M','i','n','A','r','r','a','n','g','e',0};
196 static const WCHAR COLOR_SCROLLBAR_VALNAME
[] = {COLORS_KEY
,'S','c','r','o','l','l','b','a','r',0};
197 static const WCHAR COLOR_BACKGROUND_VALNAME
[] = {COLORS_KEY
,'B','a','c','k','g','r','o','u','n','d',0};
198 static const WCHAR COLOR_ACTIVECAPTION_VALNAME
[] = {COLORS_KEY
,'A','c','t','i','v','e','T','i','t','l','e',0};
199 static const WCHAR COLOR_INACTIVECAPTION_VALNAME
[] = {COLORS_KEY
,'I','n','a','c','t','i','v','e','T','i','t','l','e',0};
200 static const WCHAR COLOR_MENU_VALNAME
[] = {COLORS_KEY
,'M','e','n','u',0};
201 static const WCHAR COLOR_WINDOW_VALNAME
[] = {COLORS_KEY
,'W','i','n','d','o','w',0};
202 static const WCHAR COLOR_WINDOWFRAME_VALNAME
[] = {COLORS_KEY
,'W','i','n','d','o','w','F','r','a','m','e',0};
203 static const WCHAR COLOR_MENUTEXT_VALNAME
[] = {COLORS_KEY
,'M','e','n','u','T','e','x','t',0};
204 static const WCHAR COLOR_WINDOWTEXT_VALNAME
[] = {COLORS_KEY
,'W','i','n','d','o','w','T','e','x','t',0};
205 static const WCHAR COLOR_CAPTIONTEXT_VALNAME
[] = {COLORS_KEY
,'T','i','t','l','e','T','e','x','t',0};
206 static const WCHAR COLOR_ACTIVEBORDER_VALNAME
[] = {COLORS_KEY
,'A','c','t','i','v','e','B','o','r','d','e','r',0};
207 static const WCHAR COLOR_INACTIVEBORDER_VALNAME
[] = {COLORS_KEY
,'I','n','a','c','t','i','v','e','B','o','r','d','e','r',0};
208 static const WCHAR COLOR_APPWORKSPACE_VALNAME
[] = {COLORS_KEY
,'A','p','p','W','o','r','k','S','p','a','c','e',0};
209 static const WCHAR COLOR_HIGHLIGHT_VALNAME
[] = {COLORS_KEY
,'H','i','l','i','g','h','t',0};
210 static const WCHAR COLOR_HIGHLIGHTTEXT_VALNAME
[] = {COLORS_KEY
,'H','i','l','i','g','h','t','T','e','x','t',0};
211 static const WCHAR COLOR_BTNFACE_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','F','a','c','e',0};
212 static const WCHAR COLOR_BTNSHADOW_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','S','h','a','d','o','w',0};
213 static const WCHAR COLOR_GRAYTEXT_VALNAME
[] = {COLORS_KEY
,'G','r','a','y','T','e','x','t',0};
214 static const WCHAR COLOR_BTNTEXT_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','T','e','x','t',0};
215 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};
216 static const WCHAR COLOR_BTNHIGHLIGHT_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','H','i','l','i','g','h','t',0};
217 static const WCHAR COLOR_3DDKSHADOW_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','D','k','S','h','a','d','o','w',0};
218 static const WCHAR COLOR_3DLIGHT_VALNAME
[] = {COLORS_KEY
,'B','u','t','t','o','n','L','i','g','h','t',0};
219 static const WCHAR COLOR_INFOTEXT_VALNAME
[] = {COLORS_KEY
,'I','n','f','o','T','e','x','t',0};
220 static const WCHAR COLOR_INFOBK_VALNAME
[] = {COLORS_KEY
,'I','n','f','o','W','i','n','d','o','w',0};
221 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};
222 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};
223 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};
224 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};
225 static const WCHAR COLOR_MENUHILIGHT_VALNAME
[] = {COLORS_KEY
,'M','e','n','u','H','i','l','i','g','h','t',0};
226 static const WCHAR COLOR_MENUBAR_VALNAME
[] = {COLORS_KEY
,'M','e','n','u','B','a','r',0};
227 static const WCHAR AUDIODESC_LOCALE_VALNAME
[] = {AUDIODESC_KEY
,'L','o','c','a','l','e',0};
228 static const WCHAR AUDIODESC_ON_VALNAME
[] = {AUDIODESC_KEY
,'O','n',0};
230 /* FIXME - real value */
231 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};
233 static const WCHAR WINE_CURRENT_USER_REGKEY
[] = {'S','o','f','t','w','a','r','e','\\',
236 /* volatile registry branch under WINE_CURRENT_USER_REGKEY for temporary values storage */
237 static const WCHAR WINE_CURRENT_USER_REGKEY_TEMP_PARAMS
[] = {'T','e','m','p','o','r','a','r','y',' ',
238 'S','y','s','t','e','m',' ',
239 'P','a','r','a','m','e','t','e','r','s',0};
241 static const WCHAR Yes
[] = {'Y','e','s',0};
242 static const WCHAR No
[] = {'N','o',0};
243 static const WCHAR CSu
[] = {'%','u',0};
244 static const WCHAR CSd
[] = {'%','d',0};
245 static const WCHAR CSrgb
[] = {'%','u',' ','%','u',' ','%','u',0};
247 static HDC display_dc
;
248 static CRITICAL_SECTION display_dc_section
;
249 static CRITICAL_SECTION_DEBUG critsect_debug
=
251 0, 0, &display_dc_section
,
252 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
253 0, 0, { (DWORD_PTR
)(__FILE__
": display_dc_section") }
255 static CRITICAL_SECTION display_dc_section
= { &critsect_debug
, -1 ,0, 0, 0, 0 };
258 /* Indicators whether system parameter value is loaded */
259 static char spi_loaded
[SPI_INDEX_COUNT
];
261 static BOOL notify_change
= TRUE
;
263 /* System parameters storage */
264 static RECT work_area
;
265 static UINT system_dpi
;
266 static DPI_AWARENESS dpi_awareness
;
267 static DPI_AWARENESS default_awareness
= DPI_AWARENESS_UNAWARE
;
269 static HKEY volatile_base_key
;
271 union sysparam_all_entry
;
273 struct sysparam_entry
275 BOOL (*get
)( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
);
276 BOOL (*set
)( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
);
277 BOOL (*init
)( union sysparam_all_entry
*entry
);
283 struct sysparam_uint_entry
285 struct sysparam_entry hdr
;
289 struct sysparam_bool_entry
291 struct sysparam_entry hdr
;
295 struct sysparam_dword_entry
297 struct sysparam_entry hdr
;
301 struct sysparam_rgb_entry
303 struct sysparam_entry hdr
;
309 struct sysparam_binary_entry
311 struct sysparam_entry hdr
;
316 struct sysparam_path_entry
318 struct sysparam_entry hdr
;
319 WCHAR path
[MAX_PATH
];
322 struct sysparam_font_entry
324 struct sysparam_entry hdr
;
327 WCHAR fullname
[LF_FACESIZE
];
330 struct sysparam_pref_entry
332 struct sysparam_entry hdr
;
333 struct sysparam_binary_entry
*parent
;
338 union sysparam_all_entry
340 struct sysparam_entry hdr
;
341 struct sysparam_uint_entry uint
;
342 struct sysparam_bool_entry
bool;
343 struct sysparam_dword_entry dword
;
344 struct sysparam_rgb_entry rgb
;
345 struct sysparam_binary_entry bin
;
346 struct sysparam_path_entry path
;
347 struct sysparam_font_entry font
;
348 struct sysparam_pref_entry pref
;
351 static void SYSPARAMS_LogFont16To32W( const LOGFONT16
*font16
, LPLOGFONTW font32
)
353 font32
->lfHeight
= font16
->lfHeight
;
354 font32
->lfWidth
= font16
->lfWidth
;
355 font32
->lfEscapement
= font16
->lfEscapement
;
356 font32
->lfOrientation
= font16
->lfOrientation
;
357 font32
->lfWeight
= font16
->lfWeight
;
358 font32
->lfItalic
= font16
->lfItalic
;
359 font32
->lfUnderline
= font16
->lfUnderline
;
360 font32
->lfStrikeOut
= font16
->lfStrikeOut
;
361 font32
->lfCharSet
= font16
->lfCharSet
;
362 font32
->lfOutPrecision
= font16
->lfOutPrecision
;
363 font32
->lfClipPrecision
= font16
->lfClipPrecision
;
364 font32
->lfQuality
= font16
->lfQuality
;
365 font32
->lfPitchAndFamily
= font16
->lfPitchAndFamily
;
366 MultiByteToWideChar( CP_ACP
, 0, font16
->lfFaceName
, -1, font32
->lfFaceName
, LF_FACESIZE
);
367 font32
->lfFaceName
[LF_FACESIZE
-1] = 0;
370 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW
* font32W
, LPLOGFONTA font32A
)
372 font32A
->lfHeight
= font32W
->lfHeight
;
373 font32A
->lfWidth
= font32W
->lfWidth
;
374 font32A
->lfEscapement
= font32W
->lfEscapement
;
375 font32A
->lfOrientation
= font32W
->lfOrientation
;
376 font32A
->lfWeight
= font32W
->lfWeight
;
377 font32A
->lfItalic
= font32W
->lfItalic
;
378 font32A
->lfUnderline
= font32W
->lfUnderline
;
379 font32A
->lfStrikeOut
= font32W
->lfStrikeOut
;
380 font32A
->lfCharSet
= font32W
->lfCharSet
;
381 font32A
->lfOutPrecision
= font32W
->lfOutPrecision
;
382 font32A
->lfClipPrecision
= font32W
->lfClipPrecision
;
383 font32A
->lfQuality
= font32W
->lfQuality
;
384 font32A
->lfPitchAndFamily
= font32W
->lfPitchAndFamily
;
385 WideCharToMultiByte( CP_ACP
, 0, font32W
->lfFaceName
, -1, font32A
->lfFaceName
, LF_FACESIZE
, NULL
, NULL
);
386 font32A
->lfFaceName
[LF_FACESIZE
-1] = 0;
389 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA
* font32A
, LPLOGFONTW font32W
)
391 font32W
->lfHeight
= font32A
->lfHeight
;
392 font32W
->lfWidth
= font32A
->lfWidth
;
393 font32W
->lfEscapement
= font32A
->lfEscapement
;
394 font32W
->lfOrientation
= font32A
->lfOrientation
;
395 font32W
->lfWeight
= font32A
->lfWeight
;
396 font32W
->lfItalic
= font32A
->lfItalic
;
397 font32W
->lfUnderline
= font32A
->lfUnderline
;
398 font32W
->lfStrikeOut
= font32A
->lfStrikeOut
;
399 font32W
->lfCharSet
= font32A
->lfCharSet
;
400 font32W
->lfOutPrecision
= font32A
->lfOutPrecision
;
401 font32W
->lfClipPrecision
= font32A
->lfClipPrecision
;
402 font32W
->lfQuality
= font32A
->lfQuality
;
403 font32W
->lfPitchAndFamily
= font32A
->lfPitchAndFamily
;
404 MultiByteToWideChar( CP_ACP
, 0, font32A
->lfFaceName
, -1, font32W
->lfFaceName
, LF_FACESIZE
);
405 font32W
->lfFaceName
[LF_FACESIZE
-1] = 0;
408 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW
* lpnm32W
, LPNONCLIENTMETRICSA lpnm32A
)
410 lpnm32A
->iBorderWidth
= lpnm32W
->iBorderWidth
;
411 lpnm32A
->iScrollWidth
= lpnm32W
->iScrollWidth
;
412 lpnm32A
->iScrollHeight
= lpnm32W
->iScrollHeight
;
413 lpnm32A
->iCaptionWidth
= lpnm32W
->iCaptionWidth
;
414 lpnm32A
->iCaptionHeight
= lpnm32W
->iCaptionHeight
;
415 SYSPARAMS_LogFont32WTo32A( &lpnm32W
->lfCaptionFont
, &lpnm32A
->lfCaptionFont
);
416 lpnm32A
->iSmCaptionWidth
= lpnm32W
->iSmCaptionWidth
;
417 lpnm32A
->iSmCaptionHeight
= lpnm32W
->iSmCaptionHeight
;
418 SYSPARAMS_LogFont32WTo32A( &lpnm32W
->lfSmCaptionFont
, &lpnm32A
->lfSmCaptionFont
);
419 lpnm32A
->iMenuWidth
= lpnm32W
->iMenuWidth
;
420 lpnm32A
->iMenuHeight
= lpnm32W
->iMenuHeight
;
421 SYSPARAMS_LogFont32WTo32A( &lpnm32W
->lfMenuFont
, &lpnm32A
->lfMenuFont
);
422 SYSPARAMS_LogFont32WTo32A( &lpnm32W
->lfStatusFont
, &lpnm32A
->lfStatusFont
);
423 SYSPARAMS_LogFont32WTo32A( &lpnm32W
->lfMessageFont
, &lpnm32A
->lfMessageFont
);
424 if (lpnm32A
->cbSize
> FIELD_OFFSET(NONCLIENTMETRICSA
, iPaddedBorderWidth
))
426 if (lpnm32W
->cbSize
> FIELD_OFFSET(NONCLIENTMETRICSW
, iPaddedBorderWidth
))
427 lpnm32A
->iPaddedBorderWidth
= lpnm32W
->iPaddedBorderWidth
;
429 lpnm32A
->iPaddedBorderWidth
= 0;
433 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA
* lpnm32A
, LPNONCLIENTMETRICSW lpnm32W
)
435 lpnm32W
->iBorderWidth
= lpnm32A
->iBorderWidth
;
436 lpnm32W
->iScrollWidth
= lpnm32A
->iScrollWidth
;
437 lpnm32W
->iScrollHeight
= lpnm32A
->iScrollHeight
;
438 lpnm32W
->iCaptionWidth
= lpnm32A
->iCaptionWidth
;
439 lpnm32W
->iCaptionHeight
= lpnm32A
->iCaptionHeight
;
440 SYSPARAMS_LogFont32ATo32W( &lpnm32A
->lfCaptionFont
, &lpnm32W
->lfCaptionFont
);
441 lpnm32W
->iSmCaptionWidth
= lpnm32A
->iSmCaptionWidth
;
442 lpnm32W
->iSmCaptionHeight
= lpnm32A
->iSmCaptionHeight
;
443 SYSPARAMS_LogFont32ATo32W( &lpnm32A
->lfSmCaptionFont
, &lpnm32W
->lfSmCaptionFont
);
444 lpnm32W
->iMenuWidth
= lpnm32A
->iMenuWidth
;
445 lpnm32W
->iMenuHeight
= lpnm32A
->iMenuHeight
;
446 SYSPARAMS_LogFont32ATo32W( &lpnm32A
->lfMenuFont
, &lpnm32W
->lfMenuFont
);
447 SYSPARAMS_LogFont32ATo32W( &lpnm32A
->lfStatusFont
, &lpnm32W
->lfStatusFont
);
448 SYSPARAMS_LogFont32ATo32W( &lpnm32A
->lfMessageFont
, &lpnm32W
->lfMessageFont
);
449 if (lpnm32W
->cbSize
> FIELD_OFFSET(NONCLIENTMETRICSW
, iPaddedBorderWidth
))
451 if (lpnm32A
->cbSize
> FIELD_OFFSET(NONCLIENTMETRICSA
, iPaddedBorderWidth
))
452 lpnm32W
->iPaddedBorderWidth
= lpnm32A
->iPaddedBorderWidth
;
454 lpnm32W
->iPaddedBorderWidth
= 0;
459 /* Helper functions to retrieve monitors info */
468 static BOOL CALLBACK
monitor_info_proc( HMONITOR monitor
, HDC hdc
, LPRECT rect
, LPARAM lp
)
471 struct monitor_info
*info
= (struct monitor_info
*)lp
;
473 UnionRect( &info
->virtual_rect
, &info
->virtual_rect
, rect
);
474 mi
.cbSize
= sizeof(mi
);
475 if (GetMonitorInfoW( monitor
, &mi
) && (mi
.dwFlags
& MONITORINFOF_PRIMARY
))
476 info
->primary_rect
= mi
.rcMonitor
;
480 static void get_monitors_info( struct monitor_info
*info
)
483 SetRectEmpty( &info
->primary_rect
);
484 SetRectEmpty( &info
->virtual_rect
);
485 EnumDisplayMonitors( 0, NULL
, monitor_info_proc
, (LPARAM
)info
);
488 RECT
get_virtual_screen_rect(void)
490 struct monitor_info info
;
491 get_monitors_info( &info
);
492 return info
.virtual_rect
;
495 /* get text metrics and/or "average" char width of the specified logfont
496 * for the specified dc */
497 static void get_text_metr_size( HDC hdc
, LOGFONTW
*plf
, TEXTMETRICW
* ptm
, UINT
*psz
)
499 HFONT hfont
, hfontsav
;
502 hfont
= CreateFontIndirectW( plf
);
503 if( !hfont
|| ( hfontsav
= SelectObject( hdc
, hfont
)) == NULL
) {
506 if( hfont
) DeleteObject( hfont
);
509 GetTextMetricsW( hdc
, ptm
);
511 if( !(*psz
= GdiGetCharDimensions( hdc
, ptm
, NULL
)))
513 SelectObject( hdc
, hfontsav
);
514 DeleteObject( hfont
);
517 /***********************************************************************
518 * SYSPARAMS_NotifyChange
520 * Sends notification about system parameter update.
522 static void SYSPARAMS_NotifyChange( UINT uiAction
, UINT fWinIni
)
524 static const WCHAR emptyW
[1];
528 if (fWinIni
& SPIF_UPDATEINIFILE
)
530 if (fWinIni
& (SPIF_SENDWININICHANGE
| SPIF_SENDCHANGE
))
531 SendMessageTimeoutW(HWND_BROADCAST
, WM_SETTINGCHANGE
,
532 uiAction
, (LPARAM
) emptyW
,
533 SMTO_ABORTIFHUNG
, 2000, NULL
);
537 /* FIXME notify other wine processes with internal message */
542 /* retrieve the cached base keys for a given entry */
543 static BOOL
get_base_keys( enum parameter_key index
, HKEY
*base_key
, HKEY
*volatile_key
)
545 static HKEY base_keys
[NB_PARAM_KEYS
];
546 static HKEY volatile_keys
[NB_PARAM_KEYS
];
549 if (!base_keys
[index
] && base_key
)
551 if (RegCreateKeyW( HKEY_CURRENT_USER
, parameter_key_names
[index
], &key
)) return FALSE
;
552 if (InterlockedCompareExchangePointer( (void **)&base_keys
[index
], key
, 0 ))
555 if (!volatile_keys
[index
] && volatile_key
)
557 if (RegCreateKeyExW( volatile_base_key
, parameter_key_names
[index
],
558 0, 0, REG_OPTION_VOLATILE
, KEY_ALL_ACCESS
, NULL
, &key
, 0 )) return FALSE
;
559 if (InterlockedCompareExchangePointer( (void **)&volatile_keys
[index
], key
, 0 ))
562 if (base_key
) *base_key
= base_keys
[index
];
563 if (volatile_key
) *volatile_key
= volatile_keys
[index
];
567 /* load a value to a registry entry */
568 static DWORD
load_entry( struct sysparam_entry
*entry
, void *data
, DWORD size
)
571 HKEY base_key
, volatile_key
;
573 if (!get_base_keys( entry
->regval
[0], &base_key
, &volatile_key
)) return FALSE
;
576 if (RegQueryValueExW( volatile_key
, entry
->regval
+ 1, NULL
, &type
, data
, &count
))
579 if (RegQueryValueExW( base_key
, entry
->regval
+ 1, NULL
, &type
, data
, &count
)) count
= 0;
581 /* make sure strings are null-terminated */
582 if (size
&& count
== size
&& type
== REG_SZ
) ((WCHAR
*)data
)[count
/ sizeof(WCHAR
) - 1] = 0;
583 entry
->loaded
= TRUE
;
587 /* save a value to a registry entry */
588 static BOOL
save_entry( const struct sysparam_entry
*entry
, const void *data
, DWORD size
,
589 DWORD type
, UINT flags
)
591 HKEY base_key
, volatile_key
;
593 if (flags
& SPIF_UPDATEINIFILE
)
595 if (!get_base_keys( entry
->regval
[0], &base_key
, &volatile_key
)) return FALSE
;
596 if (RegSetValueExW( base_key
, entry
->regval
+ 1, 0, type
, data
, size
)) return FALSE
;
597 RegDeleteValueW( volatile_key
, entry
->regval
+ 1 );
599 if (entry
->mirror
&& get_base_keys( entry
->mirror
[0], &base_key
, NULL
))
600 RegSetValueExW( base_key
, entry
->mirror
+ 1, 0, type
, data
, size
);
604 if (!get_base_keys( entry
->regval
[0], NULL
, &volatile_key
)) return FALSE
;
605 if (RegSetValueExW( volatile_key
, entry
->regval
+ 1, 0, type
, data
, size
)) return FALSE
;
610 /* save a string value to a registry entry */
611 static BOOL
save_entry_string( const struct sysparam_entry
*entry
, const WCHAR
*str
, UINT flags
)
613 return save_entry( entry
, str
, (strlenW(str
) + 1) * sizeof(WCHAR
), REG_SZ
, flags
);
616 /* initialize an entry in the registry if missing */
617 static BOOL
init_entry( struct sysparam_entry
*entry
, const void *data
, DWORD size
, DWORD type
)
621 if (!get_base_keys( entry
->regval
[0], &base_key
, NULL
)) return FALSE
;
622 if (!RegQueryValueExW( base_key
, entry
->regval
+ 1, NULL
, NULL
, NULL
, NULL
)) return TRUE
;
623 if (RegSetValueExW( base_key
, entry
->regval
+ 1, 0, type
, data
, size
)) return FALSE
;
624 if (entry
->mirror
&& get_base_keys( entry
->mirror
[0], &base_key
, NULL
))
625 RegSetValueExW( base_key
, entry
->mirror
+ 1, 0, type
, data
, size
);
626 entry
->loaded
= TRUE
;
630 /* initialize a string value in the registry if missing */
631 static BOOL
init_entry_string( struct sysparam_entry
*entry
, const WCHAR
*str
)
633 return init_entry( entry
, str
, (strlenW(str
) + 1) * sizeof(WCHAR
), REG_SZ
);
636 HDC
get_display_dc(void)
638 static const WCHAR DISPLAY
[] = {'D','I','S','P','L','A','Y',0};
639 EnterCriticalSection( &display_dc_section
);
640 if (!display_dc
) display_dc
= CreateDCW( DISPLAY
, NULL
, NULL
, NULL
);
644 void release_display_dc( HDC hdc
)
646 LeaveCriticalSection( &display_dc_section
);
649 /* map value from system dpi to standard 96 dpi for storing in the registry */
650 static int map_from_system_dpi( int val
)
652 return MulDiv( val
, USER_DEFAULT_SCREEN_DPI
, GetDpiForSystem() );
655 /* map value from 96 dpi to system or custom dpi */
656 static int map_to_dpi( int val
, UINT dpi
)
658 if (!dpi
) dpi
= GetDpiForSystem();
659 return MulDiv( val
, dpi
, USER_DEFAULT_SCREEN_DPI
);
662 static INT CALLBACK
real_fontname_proc(const LOGFONTW
*lf
, const TEXTMETRICW
*ntm
, DWORD type
, LPARAM lparam
)
664 const ENUMLOGFONTW
*elf
= (const ENUMLOGFONTW
*)lf
;
665 WCHAR
*fullname
= (WCHAR
*)lparam
;
667 lstrcpynW( fullname
, elf
->elfFullName
, LF_FACESIZE
);
671 static void get_real_fontname( LOGFONTW
*lf
, WCHAR fullname
[LF_FACESIZE
] )
673 HDC hdc
= get_display_dc();
674 strcpyW( fullname
, lf
->lfFaceName
);
675 EnumFontFamiliesExW( hdc
, lf
, real_fontname_proc
, (LPARAM
)fullname
, 0 );
676 release_display_dc( hdc
);
679 /* adjust some of the raw values found in the registry */
680 static void normalize_nonclientmetrics( NONCLIENTMETRICSW
*pncm
)
683 HDC hdc
= get_display_dc();
685 if( pncm
->iBorderWidth
< 1) pncm
->iBorderWidth
= 1;
686 if( pncm
->iCaptionWidth
< 8) pncm
->iCaptionWidth
= 8;
687 if( pncm
->iScrollWidth
< 8) pncm
->iScrollWidth
= 8;
688 if( pncm
->iScrollHeight
< 8) pncm
->iScrollHeight
= 8;
690 /* adjust some heights to the corresponding font */
691 get_text_metr_size( hdc
, &pncm
->lfMenuFont
, &tm
, NULL
);
692 pncm
->iMenuHeight
= max( pncm
->iMenuHeight
, 2 + tm
.tmHeight
+ tm
.tmExternalLeading
);
693 get_text_metr_size( hdc
, &pncm
->lfCaptionFont
, &tm
, NULL
);
694 pncm
->iCaptionHeight
= max( pncm
->iCaptionHeight
, 2 + tm
.tmHeight
);
695 get_text_metr_size( hdc
, &pncm
->lfSmCaptionFont
, &tm
, NULL
);
696 pncm
->iSmCaptionHeight
= max( pncm
->iSmCaptionHeight
, 2 + tm
.tmHeight
);
697 release_display_dc( hdc
);
700 static BOOL CALLBACK
enum_monitors( HMONITOR monitor
, HDC hdc
, LPRECT rect
, LPARAM lp
)
704 mi
.cbSize
= sizeof(mi
);
705 if (GetMonitorInfoW( monitor
, &mi
) && (mi
.dwFlags
& MONITORINFOF_PRIMARY
))
707 LPRECT work
= (LPRECT
)lp
;
714 /* load a uint parameter from the registry */
715 static BOOL
get_uint_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
717 if (!ptr_param
) return FALSE
;
719 if (!entry
->hdr
.loaded
)
723 if (load_entry( &entry
->hdr
, buf
, sizeof(buf
) )) entry
->uint
.val
= atoiW( buf
);
725 *(UINT
*)ptr_param
= entry
->uint
.val
;
729 /* set a uint parameter in the registry */
730 static BOOL
set_uint_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
734 wsprintfW( buf
, CSu
, int_param
);
735 if (!save_entry_string( &entry
->hdr
, buf
, flags
)) return FALSE
;
736 entry
->uint
.val
= int_param
;
737 entry
->hdr
.loaded
= TRUE
;
741 /* initialize a uint parameter */
742 static BOOL
init_uint_entry( union sysparam_all_entry
*entry
)
746 wsprintfW( buf
, CSu
, entry
->uint
.val
);
747 return init_entry_string( &entry
->hdr
, buf
);
750 /* set an int parameter in the registry */
751 static BOOL
set_int_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
755 wsprintfW( buf
, CSd
, int_param
);
756 if (!save_entry_string( &entry
->hdr
, buf
, flags
)) return FALSE
;
757 entry
->uint
.val
= int_param
;
758 entry
->hdr
.loaded
= TRUE
;
762 /* initialize an int parameter */
763 static BOOL
init_int_entry( union sysparam_all_entry
*entry
)
767 wsprintfW( buf
, CSd
, entry
->uint
.val
);
768 return init_entry_string( &entry
->hdr
, buf
);
771 /* load a twips parameter from the registry */
772 static BOOL
get_twips_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
776 if (!ptr_param
) return FALSE
;
778 if (!entry
->hdr
.loaded
)
782 if (load_entry( &entry
->hdr
, buf
, sizeof(buf
) )) entry
->uint
.val
= atoiW( buf
);
785 /* Dimensions are quoted as being "twips" values if negative and pixels if positive.
786 * One inch is 1440 twips.
788 * Technical Reference to the Windows 2000 Registry ->
789 * HKEY_CURRENT_USER -> Control Panel -> Desktop -> WindowMetrics
791 val
= entry
->uint
.val
;
793 val
= MulDiv( -val
, dpi
, 1440 );
795 val
= map_to_dpi( val
, dpi
);
797 *(int *)ptr_param
= val
;
801 /* set a twips parameter in the registry */
802 static BOOL
set_twips_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
805 if (val
> 0) val
= map_from_system_dpi( val
);
806 return set_int_entry( entry
, val
, ptr_param
, flags
);
809 /* load a bool parameter from the registry */
810 static BOOL
get_bool_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
812 if (!ptr_param
) return FALSE
;
814 if (!entry
->hdr
.loaded
)
818 if (load_entry( &entry
->hdr
, buf
, sizeof(buf
) )) entry
->bool.val
= atoiW( buf
) != 0;
820 *(UINT
*)ptr_param
= entry
->bool.val
;
824 /* set a bool parameter in the registry */
825 static BOOL
set_bool_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
829 wsprintfW( buf
, CSu
, int_param
!= 0 );
830 if (!save_entry_string( &entry
->hdr
, buf
, flags
)) return FALSE
;
831 entry
->bool.val
= int_param
!= 0;
832 entry
->hdr
.loaded
= TRUE
;
836 /* initialize a bool parameter */
837 static BOOL
init_bool_entry( union sysparam_all_entry
*entry
)
841 wsprintfW( buf
, CSu
, entry
->bool.val
!= 0 );
842 return init_entry_string( &entry
->hdr
, buf
);
845 /* load a bool parameter using Yes/No strings from the registry */
846 static BOOL
get_yesno_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
848 if (!ptr_param
) return FALSE
;
850 if (!entry
->hdr
.loaded
)
854 if (load_entry( &entry
->hdr
, buf
, sizeof(buf
) )) entry
->bool.val
= !lstrcmpiW( Yes
, buf
);
856 *(UINT
*)ptr_param
= entry
->bool.val
;
860 /* set a bool parameter using Yes/No strings from the registry */
861 static BOOL
set_yesno_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
863 const WCHAR
*str
= int_param
? Yes
: No
;
865 if (!save_entry_string( &entry
->hdr
, str
, flags
)) return FALSE
;
866 entry
->bool.val
= int_param
!= 0;
867 entry
->hdr
.loaded
= TRUE
;
871 /* initialize a bool parameter using Yes/No strings */
872 static BOOL
init_yesno_entry( union sysparam_all_entry
*entry
)
874 return init_entry_string( &entry
->hdr
, entry
->bool.val
? Yes
: No
);
877 /* load a dword (binary) parameter from the registry */
878 static BOOL
get_dword_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
880 if (!ptr_param
) return FALSE
;
882 if (!entry
->hdr
.loaded
)
885 if (load_entry( &entry
->hdr
, &val
, sizeof(val
) ) == sizeof(DWORD
)) entry
->dword
.val
= val
;
887 *(DWORD
*)ptr_param
= entry
->dword
.val
;
891 /* set a dword (binary) parameter in the registry */
892 static BOOL
set_dword_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
894 DWORD val
= PtrToUlong( ptr_param
);
896 if (!save_entry( &entry
->hdr
, &val
, sizeof(val
), REG_DWORD
, flags
)) return FALSE
;
897 entry
->dword
.val
= val
;
898 entry
->hdr
.loaded
= TRUE
;
902 /* initialize a dword parameter */
903 static BOOL
init_dword_entry( union sysparam_all_entry
*entry
)
905 return init_entry( &entry
->hdr
, &entry
->dword
.val
, sizeof(entry
->dword
.val
), REG_DWORD
);
908 /* load an RGB parameter from the registry */
909 static BOOL
get_rgb_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
911 if (!ptr_param
) return FALSE
;
913 if (!entry
->hdr
.loaded
)
917 if (load_entry( &entry
->hdr
, buf
, sizeof(buf
) ))
920 WCHAR
*end
, *str
= buf
;
922 r
= strtoulW( str
, &end
, 10 );
923 if (end
== str
|| !*end
) goto done
;
925 g
= strtoulW( str
, &end
, 10 );
926 if (end
== str
|| !*end
) goto done
;
928 b
= strtoulW( str
, &end
, 10 );
929 if (end
== str
) goto done
;
930 if (r
> 255 || g
> 255 || b
> 255) goto done
;
931 entry
->rgb
.val
= RGB( r
, g
, b
);
935 *(COLORREF
*)ptr_param
= entry
->rgb
.val
;
939 /* set an RGB parameter in the registry */
940 static BOOL
set_rgb_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
946 wsprintfW( buf
, CSrgb
, GetRValue(int_param
), GetGValue(int_param
), GetBValue(int_param
) );
947 if (!save_entry_string( &entry
->hdr
, buf
, flags
)) return FALSE
;
948 entry
->rgb
.val
= int_param
;
949 entry
->hdr
.loaded
= TRUE
;
950 if ((brush
= InterlockedExchangePointer( (void **)&entry
->rgb
.brush
, 0 )))
952 __wine_make_gdi_object_system( brush
, FALSE
);
953 DeleteObject( brush
);
955 if ((pen
= InterlockedExchangePointer( (void **)&entry
->rgb
.pen
, 0 )))
957 __wine_make_gdi_object_system( pen
, FALSE
);
963 /* initialize an RGB parameter */
964 static BOOL
init_rgb_entry( union sysparam_all_entry
*entry
)
968 wsprintfW( buf
, CSrgb
, GetRValue(entry
->rgb
.val
), GetGValue(entry
->rgb
.val
), GetBValue(entry
->rgb
.val
) );
969 return init_entry_string( &entry
->hdr
, buf
);
972 /* load a font (binary) parameter from the registry */
973 static BOOL
get_font_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
977 if (!ptr_param
) return FALSE
;
979 if (!entry
->hdr
.loaded
)
981 switch (load_entry( &entry
->hdr
, &font
, sizeof(font
) ))
984 if (font
.lfHeight
> 0) /* positive height value means points ( inch/72 ) */
985 font
.lfHeight
= -MulDiv( font
.lfHeight
, USER_DEFAULT_SCREEN_DPI
, 72 );
986 entry
->font
.val
= font
;
988 case sizeof(LOGFONT16
): /* win9x-winME format */
989 SYSPARAMS_LogFont16To32W( (LOGFONT16
*)&font
, &entry
->font
.val
);
990 if (entry
->font
.val
.lfHeight
> 0)
991 entry
->font
.val
.lfHeight
= -MulDiv( entry
->font
.val
.lfHeight
, USER_DEFAULT_SCREEN_DPI
, 72 );
994 WARN( "Unknown format in key %s value %s\n",
995 debugstr_w( parameter_key_names
[entry
->hdr
.regval
[0]] ),
996 debugstr_w( entry
->hdr
.regval
+ 1 ));
998 case 0: /* use the default GUI font */
999 GetObjectW( GetStockObject( DEFAULT_GUI_FONT
), sizeof(font
), &font
);
1000 font
.lfHeight
= map_from_system_dpi( font
.lfHeight
);
1001 font
.lfWeight
= entry
->font
.weight
;
1002 entry
->font
.val
= font
;
1005 get_real_fontname( &entry
->font
.val
, entry
->font
.fullname
);
1006 entry
->hdr
.loaded
= TRUE
;
1008 font
= entry
->font
.val
;
1009 font
.lfHeight
= map_to_dpi( font
.lfHeight
, dpi
);
1010 strcpyW( font
.lfFaceName
, entry
->font
.fullname
);
1011 *(LOGFONTW
*)ptr_param
= font
;
1015 /* set a font (binary) parameter in the registry */
1016 static BOOL
set_font_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
1021 memcpy( &font
, ptr_param
, sizeof(font
) );
1022 /* zero pad the end of lfFaceName so we don't save uninitialised data */
1023 ptr
= memchrW( font
.lfFaceName
, 0, LF_FACESIZE
);
1024 if (ptr
) memset( ptr
, 0, (font
.lfFaceName
+ LF_FACESIZE
- ptr
) * sizeof(WCHAR
) );
1025 if (font
.lfHeight
< 0) font
.lfHeight
= map_from_system_dpi( font
.lfHeight
);
1027 if (!save_entry( &entry
->hdr
, &font
, sizeof(font
), REG_BINARY
, flags
)) return FALSE
;
1028 entry
->font
.val
= font
;
1029 get_real_fontname( &entry
->font
.val
, entry
->font
.fullname
);
1030 entry
->hdr
.loaded
= TRUE
;
1034 /* initialize a font (binary) parameter */
1035 static BOOL
init_font_entry( union sysparam_all_entry
*entry
)
1037 GetObjectW( GetStockObject( DEFAULT_GUI_FONT
), sizeof(entry
->font
.val
), &entry
->font
.val
);
1038 entry
->font
.val
.lfHeight
= map_from_system_dpi( entry
->font
.val
.lfHeight
);
1039 entry
->font
.val
.lfWeight
= entry
->font
.weight
;
1040 get_real_fontname( &entry
->font
.val
, entry
->font
.fullname
);
1041 return init_entry( &entry
->hdr
, &entry
->font
.val
, sizeof(entry
->font
.val
), REG_BINARY
);
1044 /* get a path parameter in the registry */
1045 static BOOL
get_path_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
1047 if (!ptr_param
) return FALSE
;
1049 if (!entry
->hdr
.loaded
)
1051 WCHAR buffer
[MAX_PATH
];
1053 if (load_entry( &entry
->hdr
, buffer
, sizeof(buffer
) ))
1054 lstrcpynW( entry
->path
.path
, buffer
, MAX_PATH
);
1056 lstrcpynW( ptr_param
, entry
->path
.path
, int_param
);
1060 /* set a path parameter in the registry */
1061 static BOOL
set_path_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
1063 WCHAR buffer
[MAX_PATH
];
1066 lstrcpynW( buffer
, ptr_param
, MAX_PATH
);
1067 ret
= save_entry_string( &entry
->hdr
, buffer
, flags
);
1070 strcpyW( entry
->path
.path
, buffer
);
1071 entry
->hdr
.loaded
= TRUE
;
1076 /* initialize a path parameter */
1077 static BOOL
init_path_entry( union sysparam_all_entry
*entry
)
1079 return init_entry_string( &entry
->hdr
, entry
->path
.path
);
1082 /* get a binary parameter in the registry */
1083 static BOOL
get_binary_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
1085 if (!ptr_param
) return FALSE
;
1087 if (!entry
->hdr
.loaded
)
1089 void *buffer
= HeapAlloc( GetProcessHeap(), 0, entry
->bin
.size
);
1090 DWORD len
= load_entry( &entry
->hdr
, buffer
, entry
->bin
.size
);
1094 memcpy( entry
->bin
.ptr
, buffer
, entry
->bin
.size
);
1095 memset( (char *)entry
->bin
.ptr
+ len
, 0, entry
->bin
.size
- len
);
1097 HeapFree( GetProcessHeap(), 0, buffer
);
1099 memcpy( ptr_param
, entry
->bin
.ptr
, min( int_param
, entry
->bin
.size
) );
1103 /* set a binary parameter in the registry */
1104 static BOOL
set_binary_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
1107 void *buffer
= HeapAlloc( GetProcessHeap(), 0, entry
->bin
.size
);
1109 memcpy( buffer
, entry
->bin
.ptr
, entry
->bin
.size
);
1110 memcpy( buffer
, ptr_param
, min( int_param
, entry
->bin
.size
));
1111 ret
= save_entry( &entry
->hdr
, buffer
, entry
->bin
.size
, REG_BINARY
, flags
);
1114 memcpy( entry
->bin
.ptr
, buffer
, entry
->bin
.size
);
1115 entry
->hdr
.loaded
= TRUE
;
1117 HeapFree( GetProcessHeap(), 0, buffer
);
1121 /* initialize a binary parameter */
1122 static BOOL
init_binary_entry( union sysparam_all_entry
*entry
)
1124 return init_entry( &entry
->hdr
, entry
->bin
.ptr
, entry
->bin
.size
, REG_BINARY
);
1127 /* get a user pref parameter in the registry */
1128 static BOOL
get_userpref_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT dpi
)
1130 union sysparam_all_entry
*parent_entry
= (union sysparam_all_entry
*)entry
->pref
.parent
;
1133 if (!ptr_param
) return FALSE
;
1135 if (!parent_entry
->hdr
.get( parent_entry
, sizeof(prefs
), prefs
, dpi
)) return FALSE
;
1136 *(BOOL
*)ptr_param
= (prefs
[entry
->pref
.offset
] & entry
->pref
.mask
) != 0;
1140 /* set a user pref parameter in the registry */
1141 static BOOL
set_userpref_entry( union sysparam_all_entry
*entry
, UINT int_param
, void *ptr_param
, UINT flags
)
1143 union sysparam_all_entry
*parent_entry
= (union sysparam_all_entry
*)entry
->pref
.parent
;
1146 parent_entry
->hdr
.loaded
= FALSE
; /* force loading it again */
1147 if (!parent_entry
->hdr
.get( parent_entry
, sizeof(prefs
), prefs
, GetDpiForSystem() )) return FALSE
;
1149 if (PtrToUlong( ptr_param
)) prefs
[entry
->pref
.offset
] |= entry
->pref
.mask
;
1150 else prefs
[entry
->pref
.offset
] &= ~entry
->pref
.mask
;
1152 return parent_entry
->hdr
.set( parent_entry
, sizeof(prefs
), prefs
, flags
);
1155 static BOOL
get_entry_dpi( void *ptr
, UINT int_param
, void *ptr_param
, UINT dpi
)
1157 union sysparam_all_entry
*entry
= ptr
;
1158 return entry
->hdr
.get( entry
, int_param
, ptr_param
, dpi
);
1161 static BOOL
get_entry( void *ptr
, UINT int_param
, void *ptr_param
)
1163 return get_entry_dpi( ptr
, int_param
, ptr_param
, GetDpiForSystem() );
1166 static BOOL
set_entry( void *ptr
, UINT int_param
, void *ptr_param
, UINT flags
)
1168 union sysparam_all_entry
*entry
= ptr
;
1169 return entry
->hdr
.set( entry
, int_param
, ptr_param
, flags
);
1172 #define UINT_ENTRY(name,val) \
1173 struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_uint_entry, init_uint_entry, \
1174 name ##_VALNAME }, (val) }
1176 #define UINT_ENTRY_MIRROR(name,val) \
1177 struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_uint_entry, init_uint_entry, \
1178 name ##_VALNAME, name ##_MIRROR }, (val) }
1180 #define INT_ENTRY(name,val) \
1181 struct sysparam_uint_entry entry_##name = { { get_uint_entry, set_int_entry, init_int_entry, \
1182 name ##_VALNAME }, (val) }
1184 #define BOOL_ENTRY(name,val) \
1185 struct sysparam_bool_entry entry_##name = { { get_bool_entry, set_bool_entry, init_bool_entry, \
1186 name ##_VALNAME }, (val) }
1188 #define BOOL_ENTRY_MIRROR(name,val) \
1189 struct sysparam_bool_entry entry_##name = { { get_bool_entry, set_bool_entry, init_bool_entry, \
1190 name ##_VALNAME, name ##_MIRROR }, (val) }
1192 #define YESNO_ENTRY(name,val) \
1193 struct sysparam_bool_entry entry_##name = { { get_yesno_entry, set_yesno_entry, init_yesno_entry, \
1194 name ##_VALNAME }, (val) }
1196 #define TWIPS_ENTRY(name,val) \
1197 struct sysparam_uint_entry entry_##name = { { get_twips_entry, set_twips_entry, init_int_entry, \
1198 name ##_VALNAME }, (val) }
1200 #define DWORD_ENTRY(name,val) \
1201 struct sysparam_dword_entry entry_##name = { { get_dword_entry, set_dword_entry, init_dword_entry, \
1202 name ##_VALNAME }, (val) }
1204 #define BINARY_ENTRY(name,data) \
1205 struct sysparam_binary_entry entry_##name = { { get_binary_entry, set_binary_entry, init_binary_entry, \
1206 name ##_VALNAME }, data, sizeof(data) }
1208 #define PATH_ENTRY(name) \
1209 struct sysparam_path_entry entry_##name = { { get_path_entry, set_path_entry, init_path_entry, \
1212 #define FONT_ENTRY(name,weight) \
1213 struct sysparam_font_entry entry_##name = { { get_font_entry, set_font_entry, init_font_entry, \
1214 name ##_VALNAME }, (weight) }
1216 #define USERPREF_ENTRY(name,offset,mask) \
1217 struct sysparam_pref_entry entry_##name = { { get_userpref_entry, set_userpref_entry }, \
1218 &entry_USERPREFERENCESMASK, (offset), (mask) }
1220 static UINT_ENTRY( DRAGWIDTH
, 4 );
1221 static UINT_ENTRY( DRAGHEIGHT
, 4 );
1222 static UINT_ENTRY( DOUBLECLICKTIME
, 500 );
1223 static UINT_ENTRY( FONTSMOOTHING
, 2 );
1224 static UINT_ENTRY( GRIDGRANULARITY
, 0 );
1225 static UINT_ENTRY( KEYBOARDDELAY
, 1 );
1226 static UINT_ENTRY( KEYBOARDSPEED
, 31 );
1227 static UINT_ENTRY( MENUSHOWDELAY
, 400 );
1228 static UINT_ENTRY( MINARRANGE
, ARW_HIDE
);
1229 static UINT_ENTRY( MINHORZGAP
, 0 );
1230 static UINT_ENTRY( MINVERTGAP
, 0 );
1231 static UINT_ENTRY( MINWIDTH
, 154 );
1232 static UINT_ENTRY( MOUSEHOVERHEIGHT
, 4 );
1233 static UINT_ENTRY( MOUSEHOVERTIME
, 400 );
1234 static UINT_ENTRY( MOUSEHOVERWIDTH
, 4 );
1235 static UINT_ENTRY( MOUSESPEED
, 10 );
1236 static UINT_ENTRY( MOUSETRAILS
, 0 );
1237 static UINT_ENTRY( SCREENSAVETIMEOUT
, 300 );
1238 static UINT_ENTRY( WHEELSCROLLCHARS
, 3 );
1239 static UINT_ENTRY( WHEELSCROLLLINES
, 3 );
1240 static UINT_ENTRY_MIRROR( DOUBLECLKHEIGHT
, 4 );
1241 static UINT_ENTRY_MIRROR( DOUBLECLKWIDTH
, 4 );
1242 static UINT_ENTRY_MIRROR( MENUDROPALIGNMENT
, 0 );
1244 static INT_ENTRY( MOUSETHRESHOLD1
, 6 );
1245 static INT_ENTRY( MOUSETHRESHOLD2
, 10 );
1246 static INT_ENTRY( MOUSEACCELERATION
, 1 );
1248 static BOOL_ENTRY( BLOCKSENDINPUTRESETS
, FALSE
);
1249 static BOOL_ENTRY( DRAGFULLWINDOWS
, FALSE
);
1250 static BOOL_ENTRY( KEYBOARDPREF
, TRUE
);
1251 static BOOL_ENTRY( LOWPOWERACTIVE
, FALSE
);
1252 static BOOL_ENTRY( MOUSEBUTTONSWAP
, FALSE
);
1253 static BOOL_ENTRY( POWEROFFACTIVE
, FALSE
);
1254 static BOOL_ENTRY( SCREENREADER
, FALSE
);
1255 static BOOL_ENTRY( SCREENSAVEACTIVE
, TRUE
);
1256 static BOOL_ENTRY( SCREENSAVERRUNNING
, FALSE
);
1257 static BOOL_ENTRY( SHOWSOUNDS
, FALSE
);
1258 static BOOL_ENTRY( SNAPTODEFBUTTON
, FALSE
);
1259 static BOOL_ENTRY_MIRROR( ICONTITLEWRAP
, TRUE
);
1260 static BOOL_ENTRY( AUDIODESC_ON
, FALSE
);
1262 static YESNO_ENTRY( BEEP
, TRUE
);
1264 static TWIPS_ENTRY( BORDER
, -15 );
1265 static TWIPS_ENTRY( CAPTIONHEIGHT
, -270 );
1266 static TWIPS_ENTRY( CAPTIONWIDTH
, -270 );
1267 static TWIPS_ENTRY( ICONHORIZONTALSPACING
, -1125 );
1268 static TWIPS_ENTRY( ICONVERTICALSPACING
, -1125 );
1269 static TWIPS_ENTRY( MENUHEIGHT
, -270 );
1270 static TWIPS_ENTRY( MENUWIDTH
, -270 );
1271 static TWIPS_ENTRY( PADDEDBORDERWIDTH
, 0 );
1272 static TWIPS_ENTRY( SCROLLHEIGHT
, -240 );
1273 static TWIPS_ENTRY( SCROLLWIDTH
, -240 );
1274 static TWIPS_ENTRY( SMCAPTIONHEIGHT
, -225 );
1275 static TWIPS_ENTRY( SMCAPTIONWIDTH
, -225 );
1277 static DWORD_ENTRY( ACTIVEWINDOWTRACKING
, 0 );
1278 static DWORD_ENTRY( ACTIVEWNDTRKTIMEOUT
, 0 );
1279 static DWORD_ENTRY( CARETWIDTH
, 1 );
1280 static DWORD_ENTRY( DPISCALINGVER
, 0 );
1281 static DWORD_ENTRY( FOCUSBORDERHEIGHT
, 1 );
1282 static DWORD_ENTRY( FOCUSBORDERWIDTH
, 1 );
1283 static DWORD_ENTRY( FONTSMOOTHINGCONTRAST
, 0 );
1284 static DWORD_ENTRY( FONTSMOOTHINGORIENTATION
, FE_FONTSMOOTHINGORIENTATIONRGB
);
1285 static DWORD_ENTRY( FONTSMOOTHINGTYPE
, FE_FONTSMOOTHINGSTANDARD
);
1286 static DWORD_ENTRY( FOREGROUNDFLASHCOUNT
, 3 );
1287 static DWORD_ENTRY( FOREGROUNDLOCKTIMEOUT
, 0 );
1288 static DWORD_ENTRY( LOGPIXELS
, 0 );
1289 static DWORD_ENTRY( MOUSECLICKLOCKTIME
, 1200 );
1290 static DWORD_ENTRY( AUDIODESC_LOCALE
, 0 );
1292 static PATH_ENTRY( DESKPATTERN
);
1293 static PATH_ENTRY( DESKWALLPAPER
);
1295 static BYTE user_prefs
[8] = { 0x30, 0x00, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00 };
1296 static BINARY_ENTRY( USERPREFERENCESMASK
, user_prefs
);
1298 static FONT_ENTRY( CAPTIONLOGFONT
, FW_BOLD
);
1299 static FONT_ENTRY( ICONTITLELOGFONT
, FW_NORMAL
);
1300 static FONT_ENTRY( MENULOGFONT
, FW_NORMAL
);
1301 static FONT_ENTRY( MESSAGELOGFONT
, FW_NORMAL
);
1302 static FONT_ENTRY( SMCAPTIONLOGFONT
, FW_NORMAL
);
1303 static FONT_ENTRY( STATUSLOGFONT
, FW_NORMAL
);
1305 static USERPREF_ENTRY( MENUANIMATION
, 0, 0x02 );
1306 static USERPREF_ENTRY( COMBOBOXANIMATION
, 0, 0x04 );
1307 static USERPREF_ENTRY( LISTBOXSMOOTHSCROLLING
, 0, 0x08 );
1308 static USERPREF_ENTRY( GRADIENTCAPTIONS
, 0, 0x10 );
1309 static USERPREF_ENTRY( KEYBOARDCUES
, 0, 0x20 );
1310 static USERPREF_ENTRY( ACTIVEWNDTRKZORDER
, 0, 0x40 );
1311 static USERPREF_ENTRY( HOTTRACKING
, 0, 0x80 );
1312 static USERPREF_ENTRY( MENUFADE
, 1, 0x02 );
1313 static USERPREF_ENTRY( SELECTIONFADE
, 1, 0x04 );
1314 static USERPREF_ENTRY( TOOLTIPANIMATION
, 1, 0x08 );
1315 static USERPREF_ENTRY( TOOLTIPFADE
, 1, 0x10 );
1316 static USERPREF_ENTRY( CURSORSHADOW
, 1, 0x20 );
1317 static USERPREF_ENTRY( MOUSESONAR
, 1, 0x40 );
1318 static USERPREF_ENTRY( MOUSECLICKLOCK
, 1, 0x80 );
1319 static USERPREF_ENTRY( MOUSEVANISH
, 2, 0x01 );
1320 static USERPREF_ENTRY( FLATMENU
, 2, 0x02 );
1321 static USERPREF_ENTRY( DROPSHADOW
, 2, 0x04 );
1322 static USERPREF_ENTRY( UIEFFECTS
, 3, 0x80 );
1323 static USERPREF_ENTRY( DISABLEOVERLAPPEDCONTENT
, 4, 0x01 );
1324 static USERPREF_ENTRY( CLIENTAREAANIMATION
, 4, 0x02 );
1325 static USERPREF_ENTRY( CLEARTYPE
, 4, 0x10 );
1326 static USERPREF_ENTRY( SPEECHRECOGNITION
, 4, 0x20 );
1328 static struct sysparam_rgb_entry system_colors
[] =
1330 #define RGB_ENTRY(name,val) { { get_rgb_entry, set_rgb_entry, init_rgb_entry, name ##_VALNAME }, (val) }
1331 RGB_ENTRY( COLOR_SCROLLBAR
, RGB(212, 208, 200) ),
1332 RGB_ENTRY( COLOR_BACKGROUND
, RGB(58, 110, 165) ),
1333 RGB_ENTRY( COLOR_ACTIVECAPTION
, RGB(10, 36, 106) ),
1334 RGB_ENTRY( COLOR_INACTIVECAPTION
, RGB(128, 128, 128) ),
1335 RGB_ENTRY( COLOR_MENU
, RGB(212, 208, 200) ),
1336 RGB_ENTRY( COLOR_WINDOW
, RGB(255, 255, 255) ),
1337 RGB_ENTRY( COLOR_WINDOWFRAME
, RGB(0, 0, 0) ),
1338 RGB_ENTRY( COLOR_MENUTEXT
, RGB(0, 0, 0) ),
1339 RGB_ENTRY( COLOR_WINDOWTEXT
, RGB(0, 0, 0) ),
1340 RGB_ENTRY( COLOR_CAPTIONTEXT
, RGB(255, 255, 255) ),
1341 RGB_ENTRY( COLOR_ACTIVEBORDER
, RGB(212, 208, 200) ),
1342 RGB_ENTRY( COLOR_INACTIVEBORDER
, RGB(212, 208, 200) ),
1343 RGB_ENTRY( COLOR_APPWORKSPACE
, RGB(128, 128, 128) ),
1344 RGB_ENTRY( COLOR_HIGHLIGHT
, RGB(10, 36, 106) ),
1345 RGB_ENTRY( COLOR_HIGHLIGHTTEXT
, RGB(255, 255, 255) ),
1346 RGB_ENTRY( COLOR_BTNFACE
, RGB(212, 208, 200) ),
1347 RGB_ENTRY( COLOR_BTNSHADOW
, RGB(128, 128, 128) ),
1348 RGB_ENTRY( COLOR_GRAYTEXT
, RGB(128, 128, 128) ),
1349 RGB_ENTRY( COLOR_BTNTEXT
, RGB(0, 0, 0) ),
1350 RGB_ENTRY( COLOR_INACTIVECAPTIONTEXT
, RGB(212, 208, 200) ),
1351 RGB_ENTRY( COLOR_BTNHIGHLIGHT
, RGB(255, 255, 255) ),
1352 RGB_ENTRY( COLOR_3DDKSHADOW
, RGB(64, 64, 64) ),
1353 RGB_ENTRY( COLOR_3DLIGHT
, RGB(212, 208, 200) ),
1354 RGB_ENTRY( COLOR_INFOTEXT
, RGB(0, 0, 0) ),
1355 RGB_ENTRY( COLOR_INFOBK
, RGB(255, 255, 225) ),
1356 RGB_ENTRY( COLOR_ALTERNATEBTNFACE
, RGB(181, 181, 181) ),
1357 RGB_ENTRY( COLOR_HOTLIGHT
, RGB(0, 0, 200) ),
1358 RGB_ENTRY( COLOR_GRADIENTACTIVECAPTION
, RGB(166, 202, 240) ),
1359 RGB_ENTRY( COLOR_GRADIENTINACTIVECAPTION
, RGB(192, 192, 192) ),
1360 RGB_ENTRY( COLOR_MENUHILIGHT
, RGB(10, 36, 106) ),
1361 RGB_ENTRY( COLOR_MENUBAR
, RGB(212, 208, 200) )
1365 /* entries that are initialized by default in the registry */
1366 static union sysparam_all_entry
* const default_entries
[] =
1368 (union sysparam_all_entry
*)&entry_ACTIVEWINDOWTRACKING
,
1369 (union sysparam_all_entry
*)&entry_ACTIVEWNDTRKTIMEOUT
,
1370 (union sysparam_all_entry
*)&entry_BEEP
,
1371 (union sysparam_all_entry
*)&entry_BLOCKSENDINPUTRESETS
,
1372 (union sysparam_all_entry
*)&entry_BORDER
,
1373 (union sysparam_all_entry
*)&entry_CAPTIONHEIGHT
,
1374 (union sysparam_all_entry
*)&entry_CAPTIONWIDTH
,
1375 (union sysparam_all_entry
*)&entry_CARETWIDTH
,
1376 (union sysparam_all_entry
*)&entry_DESKWALLPAPER
,
1377 (union sysparam_all_entry
*)&entry_DOUBLECLICKTIME
,
1378 (union sysparam_all_entry
*)&entry_DOUBLECLKHEIGHT
,
1379 (union sysparam_all_entry
*)&entry_DOUBLECLKWIDTH
,
1380 (union sysparam_all_entry
*)&entry_DRAGFULLWINDOWS
,
1381 (union sysparam_all_entry
*)&entry_DRAGHEIGHT
,
1382 (union sysparam_all_entry
*)&entry_DRAGWIDTH
,
1383 (union sysparam_all_entry
*)&entry_FOCUSBORDERHEIGHT
,
1384 (union sysparam_all_entry
*)&entry_FOCUSBORDERWIDTH
,
1385 (union sysparam_all_entry
*)&entry_FONTSMOOTHING
,
1386 (union sysparam_all_entry
*)&entry_FONTSMOOTHINGCONTRAST
,
1387 (union sysparam_all_entry
*)&entry_FONTSMOOTHINGORIENTATION
,
1388 (union sysparam_all_entry
*)&entry_FONTSMOOTHINGTYPE
,
1389 (union sysparam_all_entry
*)&entry_FOREGROUNDFLASHCOUNT
,
1390 (union sysparam_all_entry
*)&entry_FOREGROUNDLOCKTIMEOUT
,
1391 (union sysparam_all_entry
*)&entry_ICONHORIZONTALSPACING
,
1392 (union sysparam_all_entry
*)&entry_ICONTITLEWRAP
,
1393 (union sysparam_all_entry
*)&entry_ICONVERTICALSPACING
,
1394 (union sysparam_all_entry
*)&entry_KEYBOARDDELAY
,
1395 (union sysparam_all_entry
*)&entry_KEYBOARDPREF
,
1396 (union sysparam_all_entry
*)&entry_KEYBOARDSPEED
,
1397 (union sysparam_all_entry
*)&entry_LOWPOWERACTIVE
,
1398 (union sysparam_all_entry
*)&entry_MENUHEIGHT
,
1399 (union sysparam_all_entry
*)&entry_MENUSHOWDELAY
,
1400 (union sysparam_all_entry
*)&entry_MENUWIDTH
,
1401 (union sysparam_all_entry
*)&entry_MOUSEACCELERATION
,
1402 (union sysparam_all_entry
*)&entry_MOUSEBUTTONSWAP
,
1403 (union sysparam_all_entry
*)&entry_MOUSECLICKLOCKTIME
,
1404 (union sysparam_all_entry
*)&entry_MOUSEHOVERHEIGHT
,
1405 (union sysparam_all_entry
*)&entry_MOUSEHOVERTIME
,
1406 (union sysparam_all_entry
*)&entry_MOUSEHOVERWIDTH
,
1407 (union sysparam_all_entry
*)&entry_MOUSESPEED
,
1408 (union sysparam_all_entry
*)&entry_MOUSETHRESHOLD1
,
1409 (union sysparam_all_entry
*)&entry_MOUSETHRESHOLD2
,
1410 (union sysparam_all_entry
*)&entry_PADDEDBORDERWIDTH
,
1411 (union sysparam_all_entry
*)&entry_SCREENREADER
,
1412 (union sysparam_all_entry
*)&entry_SCROLLHEIGHT
,
1413 (union sysparam_all_entry
*)&entry_SCROLLWIDTH
,
1414 (union sysparam_all_entry
*)&entry_SHOWSOUNDS
,
1415 (union sysparam_all_entry
*)&entry_SMCAPTIONHEIGHT
,
1416 (union sysparam_all_entry
*)&entry_SMCAPTIONWIDTH
,
1417 (union sysparam_all_entry
*)&entry_SNAPTODEFBUTTON
,
1418 (union sysparam_all_entry
*)&entry_USERPREFERENCESMASK
,
1419 (union sysparam_all_entry
*)&entry_WHEELSCROLLCHARS
,
1420 (union sysparam_all_entry
*)&entry_WHEELSCROLLLINES
,
1421 (union sysparam_all_entry
*)&entry_AUDIODESC_LOCALE
,
1422 (union sysparam_all_entry
*)&entry_AUDIODESC_ON
,
1425 /***********************************************************************
1428 void SYSPARAMS_Init(void)
1430 static const WCHAR def_key_name
[] = {'S','o','f','t','w','a','r','e','\\','F','o','n','t','s',0};
1431 static const WCHAR def_value_name
[] = {'L','o','g','P','i','x','e','l','s',0};
1433 DWORD i
, dispos
, dpi_scaling
;
1435 /* this one must be non-volatile */
1436 if (RegCreateKeyW( HKEY_CURRENT_USER
, WINE_CURRENT_USER_REGKEY
, &key
))
1438 ERR("Can't create wine registry branch\n");
1442 /* @@ Wine registry key: HKCU\Software\Wine\Temporary System Parameters */
1443 if (RegCreateKeyExW( key
, WINE_CURRENT_USER_REGKEY_TEMP_PARAMS
, 0, 0,
1444 REG_OPTION_VOLATILE
, KEY_ALL_ACCESS
, 0, &volatile_base_key
, &dispos
))
1445 ERR("Can't create non-permanent wine registry branch\n");
1449 get_dword_entry( (union sysparam_all_entry
*)&entry_LOGPIXELS
, 0, &system_dpi
, 0 );
1450 if (!system_dpi
) /* check fallback key */
1452 if (!RegOpenKeyW( HKEY_CURRENT_CONFIG
, def_key_name
, &key
))
1454 DWORD type
, size
= sizeof(system_dpi
);
1455 if (RegQueryValueExW( key
, def_value_name
, NULL
, &type
, (void *)&system_dpi
, &size
) ||
1461 if (!system_dpi
) system_dpi
= USER_DEFAULT_SCREEN_DPI
;
1463 /* FIXME: what do the DpiScalingVer flags mean? */
1464 get_dword_entry( (union sysparam_all_entry
*)&entry_DPISCALINGVER
, 0, &dpi_scaling
, 0 );
1467 default_awareness
= DPI_AWARENESS_PER_MONITOR_AWARE
;
1468 dpi_awareness
= 0x10 | default_awareness
;
1471 if (volatile_base_key
&& dispos
== REG_CREATED_NEW_KEY
) /* first process, initialize entries */
1473 for (i
= 0; i
< ARRAY_SIZE( default_entries
); i
++)
1474 default_entries
[i
]->hdr
.init( default_entries
[i
] );
1478 static BOOL
update_desktop_wallpaper(void)
1482 if (GetWindowThreadProcessId( GetDesktopWindow(), &pid
) && pid
== GetCurrentProcessId())
1484 WCHAR wallpaper
[MAX_PATH
], pattern
[256];
1486 entry_DESKWALLPAPER
.hdr
.loaded
= entry_DESKPATTERN
.hdr
.loaded
= FALSE
;
1487 if (get_entry( &entry_DESKWALLPAPER
, MAX_PATH
, wallpaper
) &&
1488 get_entry( &entry_DESKPATTERN
, 256, pattern
))
1489 update_wallpaper( wallpaper
, pattern
);
1491 else SendMessageW( GetDesktopWindow(), WM_SETTINGCHANGE
, SPI_SETDESKWALLPAPER
, 0 );
1496 /***********************************************************************
1497 * SystemParametersInfoForDpi (USER32.@)
1499 BOOL WINAPI
SystemParametersInfoForDpi( UINT action
, UINT val
, PVOID ptr
, UINT winini
, UINT dpi
)
1505 case SPI_GETICONTITLELOGFONT
:
1506 ret
= get_entry_dpi( &entry_ICONTITLELOGFONT
, val
, ptr
, dpi
);
1508 case SPI_GETNONCLIENTMETRICS
:
1510 NONCLIENTMETRICSW
*ncm
= ptr
;
1513 ret
= get_entry_dpi( &entry_BORDER
, 0, &ncm
->iBorderWidth
, dpi
) &&
1514 get_entry_dpi( &entry_SCROLLWIDTH
, 0, &ncm
->iScrollWidth
, dpi
) &&
1515 get_entry_dpi( &entry_SCROLLHEIGHT
, 0, &ncm
->iScrollHeight
, dpi
) &&
1516 get_entry_dpi( &entry_CAPTIONWIDTH
, 0, &ncm
->iCaptionWidth
, dpi
) &&
1517 get_entry_dpi( &entry_CAPTIONHEIGHT
, 0, &ncm
->iCaptionHeight
, dpi
) &&
1518 get_entry_dpi( &entry_CAPTIONLOGFONT
, 0, &ncm
->lfCaptionFont
, dpi
) &&
1519 get_entry_dpi( &entry_SMCAPTIONWIDTH
, 0, &ncm
->iSmCaptionWidth
, dpi
) &&
1520 get_entry_dpi( &entry_SMCAPTIONHEIGHT
, 0, &ncm
->iSmCaptionHeight
, dpi
) &&
1521 get_entry_dpi( &entry_SMCAPTIONLOGFONT
, 0, &ncm
->lfSmCaptionFont
, dpi
) &&
1522 get_entry_dpi( &entry_MENUWIDTH
, 0, &ncm
->iMenuWidth
, dpi
) &&
1523 get_entry_dpi( &entry_MENUHEIGHT
, 0, &ncm
->iMenuHeight
, dpi
) &&
1524 get_entry_dpi( &entry_MENULOGFONT
, 0, &ncm
->lfMenuFont
, dpi
) &&
1525 get_entry_dpi( &entry_STATUSLOGFONT
, 0, &ncm
->lfStatusFont
, dpi
) &&
1526 get_entry_dpi( &entry_MESSAGELOGFONT
, 0, &ncm
->lfMessageFont
, dpi
);
1527 if (ret
&& ncm
->cbSize
== sizeof(NONCLIENTMETRICSW
))
1528 ret
= get_entry_dpi( &entry_PADDEDBORDERWIDTH
, 0, &ncm
->iPaddedBorderWidth
, dpi
);
1529 normalize_nonclientmetrics( ncm
);
1532 case SPI_GETICONMETRICS
:
1534 ICONMETRICSW
*im
= ptr
;
1535 if (im
&& im
->cbSize
== sizeof(*im
))
1536 ret
= get_entry_dpi( &entry_ICONHORIZONTALSPACING
, 0, &im
->iHorzSpacing
, dpi
) &&
1537 get_entry_dpi( &entry_ICONVERTICALSPACING
, 0, &im
->iVertSpacing
, dpi
) &&
1538 get_entry_dpi( &entry_ICONTITLEWRAP
, 0, &im
->iTitleWrap
, dpi
) &&
1539 get_entry_dpi( &entry_ICONTITLELOGFONT
, 0, &im
->lfFont
, dpi
);
1543 SetLastError( ERROR_INVALID_PARAMETER
);
1550 /***********************************************************************
1551 * SystemParametersInfoW (USER32.@)
1553 * Each system parameter has flag which shows whether the parameter
1554 * is loaded or not. Parameters, stored directly in SysParametersInfo are
1555 * loaded from registry only when they are requested and the flag is
1556 * "false", after the loading the flag is set to "true". On interprocess
1557 * notification of the parameter change the corresponding parameter flag is
1558 * set to "false". The parameter value will be reloaded when it is requested
1560 * Parameters, backed by or depend on GetSystemMetrics are processed
1561 * differently. These parameters are always loaded. They are reloaded right
1562 * away on interprocess change notification. We can't do lazy loading because
1563 * we don't want to complicate GetSystemMetrics.
1564 * Parameters, backed by X settings are read from corresponding setting.
1565 * On the parameter change request the setting is changed. Interprocess change
1566 * notifications are ignored.
1567 * When parameter value is updated the changed value is stored in permanent
1568 * registry branch if saving is requested. Otherwise it is stored
1569 * in temporary branch
1571 * Some SPI values can also be stored as Twips values in the registry,
1572 * don't forget the conversion!
1574 BOOL WINAPI
SystemParametersInfoW( UINT uiAction
, UINT uiParam
,
1575 PVOID pvParam
, UINT fWinIni
)
1577 #define WINE_SPI_FIXME(x) \
1580 static BOOL warn = TRUE; \
1584 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
1587 SetLastError( ERROR_INVALID_SPI_VALUE ); \
1590 #define WINE_SPI_WARN(x) \
1592 WARN( "Ignored action: %u (%s)\n", x, #x ); \
1596 BOOL ret
= USER_Driver
->pSystemParametersInfo( uiAction
, uiParam
, pvParam
, fWinIni
);
1597 unsigned spi_idx
= 0;
1599 if (!ret
) switch (uiAction
)
1602 ret
= get_entry( &entry_BEEP
, uiParam
, pvParam
);
1605 ret
= set_entry( &entry_BEEP
, uiParam
, pvParam
, fWinIni
);
1608 ret
= get_entry( &entry_MOUSETHRESHOLD1
, uiParam
, (INT
*)pvParam
) &&
1609 get_entry( &entry_MOUSETHRESHOLD2
, uiParam
, (INT
*)pvParam
+ 1 ) &&
1610 get_entry( &entry_MOUSEACCELERATION
, uiParam
, (INT
*)pvParam
+ 2 );
1613 ret
= set_entry( &entry_MOUSETHRESHOLD1
, ((INT
*)pvParam
)[0], pvParam
, fWinIni
) &&
1614 set_entry( &entry_MOUSETHRESHOLD2
, ((INT
*)pvParam
)[1], pvParam
, fWinIni
) &&
1615 set_entry( &entry_MOUSEACCELERATION
, ((INT
*)pvParam
)[2], pvParam
, fWinIni
);
1618 ret
= get_entry( &entry_BORDER
, uiParam
, pvParam
);
1619 if (*(INT
*)pvParam
< 1) *(INT
*)pvParam
= 1;
1622 ret
= set_entry( &entry_BORDER
, uiParam
, pvParam
, fWinIni
);
1624 case SPI_GETKEYBOARDSPEED
:
1625 ret
= get_entry( &entry_KEYBOARDSPEED
, uiParam
, pvParam
);
1627 case SPI_SETKEYBOARDSPEED
:
1628 if (uiParam
> 31) uiParam
= 31;
1629 ret
= set_entry( &entry_KEYBOARDSPEED
, uiParam
, pvParam
, fWinIni
);
1632 /* not implemented in Windows */
1633 WINE_SPI_WARN(SPI_LANGDRIVER
); /* 12 */
1635 case SPI_ICONHORIZONTALSPACING
:
1636 if (pvParam
!= NULL
)
1637 ret
= get_entry( &entry_ICONHORIZONTALSPACING
, uiParam
, pvParam
);
1640 int min_val
= map_to_dpi( 32, GetDpiForSystem() );
1641 ret
= set_entry( &entry_ICONHORIZONTALSPACING
, max( min_val
, uiParam
), pvParam
, fWinIni
);
1644 case SPI_GETSCREENSAVETIMEOUT
:
1645 ret
= get_entry( &entry_SCREENSAVETIMEOUT
, uiParam
, pvParam
);
1647 case SPI_SETSCREENSAVETIMEOUT
:
1648 ret
= set_entry( &entry_SCREENSAVETIMEOUT
, uiParam
, pvParam
, fWinIni
);
1650 case SPI_GETSCREENSAVEACTIVE
:
1651 ret
= get_entry( &entry_SCREENSAVEACTIVE
, uiParam
, pvParam
);
1653 case SPI_SETSCREENSAVEACTIVE
:
1654 ret
= set_entry( &entry_SCREENSAVEACTIVE
, uiParam
, pvParam
, fWinIni
);
1656 case SPI_GETGRIDGRANULARITY
:
1657 ret
= get_entry( &entry_GRIDGRANULARITY
, uiParam
, pvParam
);
1659 case SPI_SETGRIDGRANULARITY
:
1660 ret
= set_entry( &entry_GRIDGRANULARITY
, uiParam
, pvParam
, fWinIni
);
1662 case SPI_SETDESKWALLPAPER
:
1663 if (!pvParam
|| set_entry( &entry_DESKWALLPAPER
, uiParam
, pvParam
, fWinIni
))
1664 ret
= update_desktop_wallpaper();
1666 case SPI_SETDESKPATTERN
:
1667 if (!pvParam
|| set_entry( &entry_DESKPATTERN
, uiParam
, pvParam
, fWinIni
))
1668 ret
= update_desktop_wallpaper();
1670 case SPI_GETKEYBOARDDELAY
:
1671 ret
= get_entry( &entry_KEYBOARDDELAY
, uiParam
, pvParam
);
1673 case SPI_SETKEYBOARDDELAY
:
1674 ret
= set_entry( &entry_KEYBOARDDELAY
, uiParam
, pvParam
, fWinIni
);
1676 case SPI_ICONVERTICALSPACING
:
1677 if (pvParam
!= NULL
)
1678 ret
= get_entry( &entry_ICONVERTICALSPACING
, uiParam
, pvParam
);
1681 int min_val
= map_to_dpi( 32, GetDpiForSystem() );
1682 ret
= set_entry( &entry_ICONVERTICALSPACING
, max( min_val
, uiParam
), pvParam
, fWinIni
);
1685 case SPI_GETICONTITLEWRAP
:
1686 ret
= get_entry( &entry_ICONTITLEWRAP
, uiParam
, pvParam
);
1688 case SPI_SETICONTITLEWRAP
:
1689 ret
= set_entry( &entry_ICONTITLEWRAP
, uiParam
, pvParam
, fWinIni
);
1691 case SPI_GETMENUDROPALIGNMENT
:
1692 ret
= get_entry( &entry_MENUDROPALIGNMENT
, uiParam
, pvParam
);
1694 case SPI_SETMENUDROPALIGNMENT
:
1695 ret
= set_entry( &entry_MENUDROPALIGNMENT
, uiParam
, pvParam
, fWinIni
);
1697 case SPI_SETDOUBLECLKWIDTH
:
1698 ret
= set_entry( &entry_DOUBLECLKWIDTH
, uiParam
, pvParam
, fWinIni
);
1700 case SPI_SETDOUBLECLKHEIGHT
:
1701 ret
= set_entry( &entry_DOUBLECLKHEIGHT
, uiParam
, pvParam
, fWinIni
);
1703 case SPI_GETICONTITLELOGFONT
:
1704 ret
= get_entry( &entry_ICONTITLELOGFONT
, uiParam
, pvParam
);
1706 case SPI_SETDOUBLECLICKTIME
:
1707 ret
= set_entry( &entry_DOUBLECLICKTIME
, uiParam
, pvParam
, fWinIni
);
1709 case SPI_SETMOUSEBUTTONSWAP
:
1710 ret
= set_entry( &entry_MOUSEBUTTONSWAP
, uiParam
, pvParam
, fWinIni
);
1712 case SPI_SETICONTITLELOGFONT
:
1713 ret
= set_entry( &entry_ICONTITLELOGFONT
, uiParam
, pvParam
, fWinIni
);
1716 case SPI_GETFASTTASKSWITCH
: /* 35 */
1717 if (!pvParam
) return FALSE
;
1718 *(BOOL
*)pvParam
= TRUE
;
1722 case SPI_SETFASTTASKSWITCH
: /* 36 */
1723 /* the action is disabled */
1727 case SPI_SETDRAGFULLWINDOWS
:
1728 ret
= set_entry( &entry_DRAGFULLWINDOWS
, uiParam
, pvParam
, fWinIni
);
1730 case SPI_GETDRAGFULLWINDOWS
:
1731 ret
= get_entry( &entry_DRAGFULLWINDOWS
, uiParam
, pvParam
);
1733 case SPI_GETNONCLIENTMETRICS
:
1735 LPNONCLIENTMETRICSW lpnm
= pvParam
;
1738 if (!pvParam
) return FALSE
;
1740 ret
= get_entry( &entry_BORDER
, 0, &lpnm
->iBorderWidth
) &&
1741 get_entry( &entry_PADDEDBORDERWIDTH
, 0, &padded_border
) &&
1742 get_entry( &entry_SCROLLWIDTH
, 0, &lpnm
->iScrollWidth
) &&
1743 get_entry( &entry_SCROLLHEIGHT
, 0, &lpnm
->iScrollHeight
) &&
1744 get_entry( &entry_CAPTIONWIDTH
, 0, &lpnm
->iCaptionWidth
) &&
1745 get_entry( &entry_CAPTIONHEIGHT
, 0, &lpnm
->iCaptionHeight
) &&
1746 get_entry( &entry_CAPTIONLOGFONT
, 0, &lpnm
->lfCaptionFont
) &&
1747 get_entry( &entry_SMCAPTIONWIDTH
, 0, &lpnm
->iSmCaptionWidth
) &&
1748 get_entry( &entry_SMCAPTIONHEIGHT
, 0, &lpnm
->iSmCaptionHeight
) &&
1749 get_entry( &entry_SMCAPTIONLOGFONT
, 0, &lpnm
->lfSmCaptionFont
) &&
1750 get_entry( &entry_MENUWIDTH
, 0, &lpnm
->iMenuWidth
) &&
1751 get_entry( &entry_MENUHEIGHT
, 0, &lpnm
->iMenuHeight
) &&
1752 get_entry( &entry_MENULOGFONT
, 0, &lpnm
->lfMenuFont
) &&
1753 get_entry( &entry_STATUSLOGFONT
, 0, &lpnm
->lfStatusFont
) &&
1754 get_entry( &entry_MESSAGELOGFONT
, 0, &lpnm
->lfMessageFont
);
1755 lpnm
->iBorderWidth
+= padded_border
;
1756 if (ret
&& lpnm
->cbSize
== sizeof(NONCLIENTMETRICSW
)) lpnm
->iPaddedBorderWidth
= 0;
1757 normalize_nonclientmetrics( lpnm
);
1760 case SPI_SETNONCLIENTMETRICS
:
1762 LPNONCLIENTMETRICSW lpnm
= pvParam
;
1765 if (lpnm
&& (lpnm
->cbSize
== sizeof(NONCLIENTMETRICSW
) ||
1766 lpnm
->cbSize
== FIELD_OFFSET(NONCLIENTMETRICSW
, iPaddedBorderWidth
)))
1768 get_entry( &entry_PADDEDBORDERWIDTH
, 0, &padded_border
);
1770 ret
= set_entry( &entry_BORDER
, lpnm
->iBorderWidth
- padded_border
, NULL
, fWinIni
) &&
1771 set_entry( &entry_SCROLLWIDTH
, lpnm
->iScrollWidth
, NULL
, fWinIni
) &&
1772 set_entry( &entry_SCROLLHEIGHT
, lpnm
->iScrollHeight
, NULL
, fWinIni
) &&
1773 set_entry( &entry_CAPTIONWIDTH
, lpnm
->iCaptionWidth
, NULL
, fWinIni
) &&
1774 set_entry( &entry_CAPTIONHEIGHT
, lpnm
->iCaptionHeight
, NULL
, fWinIni
) &&
1775 set_entry( &entry_SMCAPTIONWIDTH
, lpnm
->iSmCaptionWidth
, NULL
, fWinIni
) &&
1776 set_entry( &entry_SMCAPTIONHEIGHT
, lpnm
->iSmCaptionHeight
, NULL
, fWinIni
) &&
1777 set_entry( &entry_MENUWIDTH
, lpnm
->iMenuWidth
, NULL
, fWinIni
) &&
1778 set_entry( &entry_MENUHEIGHT
, lpnm
->iMenuHeight
, NULL
, fWinIni
) &&
1779 set_entry( &entry_MENULOGFONT
, 0, &lpnm
->lfMenuFont
, fWinIni
) &&
1780 set_entry( &entry_CAPTIONLOGFONT
, 0, &lpnm
->lfCaptionFont
, fWinIni
) &&
1781 set_entry( &entry_SMCAPTIONLOGFONT
, 0, &lpnm
->lfSmCaptionFont
, fWinIni
) &&
1782 set_entry( &entry_STATUSLOGFONT
, 0, &lpnm
->lfStatusFont
, fWinIni
) &&
1783 set_entry( &entry_MESSAGELOGFONT
, 0, &lpnm
->lfMessageFont
, fWinIni
);
1787 case SPI_GETMINIMIZEDMETRICS
:
1789 MINIMIZEDMETRICS
* lpMm
= pvParam
;
1790 if (lpMm
&& lpMm
->cbSize
== sizeof(*lpMm
)) {
1791 ret
= get_entry( &entry_MINWIDTH
, 0, &lpMm
->iWidth
) &&
1792 get_entry( &entry_MINHORZGAP
, 0, &lpMm
->iHorzGap
) &&
1793 get_entry( &entry_MINVERTGAP
, 0, &lpMm
->iVertGap
) &&
1794 get_entry( &entry_MINARRANGE
, 0, &lpMm
->iArrange
);
1795 lpMm
->iWidth
= max( 0, lpMm
->iWidth
);
1796 lpMm
->iHorzGap
= max( 0, lpMm
->iHorzGap
);
1797 lpMm
->iVertGap
= max( 0, lpMm
->iVertGap
);
1798 lpMm
->iArrange
&= 0x0f;
1802 case SPI_SETMINIMIZEDMETRICS
:
1804 MINIMIZEDMETRICS
* lpMm
= pvParam
;
1805 if (lpMm
&& lpMm
->cbSize
== sizeof(*lpMm
))
1806 ret
= set_entry( &entry_MINWIDTH
, max( 0, lpMm
->iWidth
), NULL
, fWinIni
) &&
1807 set_entry( &entry_MINHORZGAP
, max( 0, lpMm
->iHorzGap
), NULL
, fWinIni
) &&
1808 set_entry( &entry_MINVERTGAP
, max( 0, lpMm
->iVertGap
), NULL
, fWinIni
) &&
1809 set_entry( &entry_MINARRANGE
, lpMm
->iArrange
& 0x0f, NULL
, fWinIni
);
1812 case SPI_GETICONMETRICS
:
1814 LPICONMETRICSW lpIcon
= pvParam
;
1815 if(lpIcon
&& lpIcon
->cbSize
== sizeof(*lpIcon
))
1817 ret
= get_entry( &entry_ICONHORIZONTALSPACING
, 0, &lpIcon
->iHorzSpacing
) &&
1818 get_entry( &entry_ICONVERTICALSPACING
, 0, &lpIcon
->iVertSpacing
) &&
1819 get_entry( &entry_ICONTITLEWRAP
, 0, &lpIcon
->iTitleWrap
) &&
1820 get_entry( &entry_ICONTITLELOGFONT
, 0, &lpIcon
->lfFont
);
1824 case SPI_SETICONMETRICS
:
1826 LPICONMETRICSW lpIcon
= pvParam
;
1827 if (lpIcon
&& lpIcon
->cbSize
== sizeof(*lpIcon
))
1828 ret
= set_entry( &entry_ICONVERTICALSPACING
, max(32,lpIcon
->iVertSpacing
), NULL
, fWinIni
) &&
1829 set_entry( &entry_ICONHORIZONTALSPACING
, max(32,lpIcon
->iHorzSpacing
), NULL
, fWinIni
) &&
1830 set_entry( &entry_ICONTITLEWRAP
, lpIcon
->iTitleWrap
, NULL
, fWinIni
) &&
1831 set_entry( &entry_ICONTITLELOGFONT
, 0, &lpIcon
->lfFont
, fWinIni
);
1835 case SPI_SETWORKAREA
: /* 47 WINVER >= 0x400 */
1837 if (!pvParam
) return FALSE
;
1839 spi_idx
= SPI_SETWORKAREA_IDX
;
1840 work_area
= *(RECT
*)pvParam
;
1841 spi_loaded
[spi_idx
] = TRUE
;
1846 case SPI_GETWORKAREA
: /* 48 WINVER >= 0x400 */
1848 if (!pvParam
) return FALSE
;
1850 spi_idx
= SPI_SETWORKAREA_IDX
;
1851 if (!spi_loaded
[spi_idx
])
1853 SetRect( &work_area
, 0, 0,
1854 GetSystemMetrics( SM_CXSCREEN
),
1855 GetSystemMetrics( SM_CYSCREEN
) );
1856 EnumDisplayMonitors( 0, NULL
, enum_monitors
, (LPARAM
)&work_area
);
1857 spi_loaded
[spi_idx
] = TRUE
;
1859 *(RECT
*)pvParam
= work_area
;
1861 TRACE("work area %s\n", wine_dbgstr_rect( &work_area
));
1865 WINE_SPI_FIXME(SPI_SETPENWINDOWS
); /* 49 WINVER >= 0x400 */
1867 case SPI_GETFILTERKEYS
: /* 50 */
1869 LPFILTERKEYS lpFilterKeys
= pvParam
;
1870 WARN("SPI_GETFILTERKEYS not fully implemented\n");
1871 if (lpFilterKeys
&& lpFilterKeys
->cbSize
== sizeof(FILTERKEYS
))
1873 /* Indicate that no FilterKeys feature available */
1874 lpFilterKeys
->dwFlags
= 0;
1875 lpFilterKeys
->iWaitMSec
= 0;
1876 lpFilterKeys
->iDelayMSec
= 0;
1877 lpFilterKeys
->iRepeatMSec
= 0;
1878 lpFilterKeys
->iBounceMSec
= 0;
1883 WINE_SPI_FIXME(SPI_SETFILTERKEYS
); /* 51 */
1885 case SPI_GETTOGGLEKEYS
: /* 52 */
1887 LPTOGGLEKEYS lpToggleKeys
= pvParam
;
1888 WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1889 if (lpToggleKeys
&& lpToggleKeys
->cbSize
== sizeof(TOGGLEKEYS
))
1891 /* Indicate that no ToggleKeys feature available */
1892 lpToggleKeys
->dwFlags
= 0;
1897 WINE_SPI_FIXME(SPI_SETTOGGLEKEYS
); /* 53 */
1899 case SPI_GETMOUSEKEYS
: /* 54 */
1901 LPMOUSEKEYS lpMouseKeys
= pvParam
;
1902 WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1903 if (lpMouseKeys
&& lpMouseKeys
->cbSize
== sizeof(MOUSEKEYS
))
1905 /* Indicate that no MouseKeys feature available */
1906 lpMouseKeys
->dwFlags
= 0;
1907 lpMouseKeys
->iMaxSpeed
= 360;
1908 lpMouseKeys
->iTimeToMaxSpeed
= 1000;
1909 lpMouseKeys
->iCtrlSpeed
= 0;
1910 lpMouseKeys
->dwReserved1
= 0;
1911 lpMouseKeys
->dwReserved2
= 0;
1916 WINE_SPI_FIXME(SPI_SETMOUSEKEYS
); /* 55 */
1918 case SPI_GETSHOWSOUNDS
:
1919 ret
= get_entry( &entry_SHOWSOUNDS
, uiParam
, pvParam
);
1921 case SPI_SETSHOWSOUNDS
:
1922 ret
= set_entry( &entry_SHOWSOUNDS
, uiParam
, pvParam
, fWinIni
);
1925 case SPI_GETSTICKYKEYS
: /* 58 */
1927 LPSTICKYKEYS lpStickyKeys
= pvParam
;
1928 WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1929 if (lpStickyKeys
&& lpStickyKeys
->cbSize
== sizeof(STICKYKEYS
))
1931 /* Indicate that no StickyKeys feature available */
1932 lpStickyKeys
->dwFlags
= 0;
1937 WINE_SPI_FIXME(SPI_SETSTICKYKEYS
); /* 59 */
1939 case SPI_GETACCESSTIMEOUT
: /* 60 */
1941 LPACCESSTIMEOUT lpAccessTimeout
= pvParam
;
1942 WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1943 if (lpAccessTimeout
&& lpAccessTimeout
->cbSize
== sizeof(ACCESSTIMEOUT
))
1945 /* Indicate that no accessibility features timeout is available */
1946 lpAccessTimeout
->dwFlags
= 0;
1947 lpAccessTimeout
->iTimeOutMSec
= 0;
1952 WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT
); /* 61 */
1954 case SPI_GETSERIALKEYS
: /* 62 WINVER >= 0x400 */
1956 LPSERIALKEYSW lpSerialKeysW
= pvParam
;
1957 WARN("SPI_GETSERIALKEYS not fully implemented\n");
1958 if (lpSerialKeysW
&& lpSerialKeysW
->cbSize
== sizeof(SERIALKEYSW
))
1960 /* Indicate that no SerialKeys feature available */
1961 lpSerialKeysW
->dwFlags
= 0;
1962 lpSerialKeysW
->lpszActivePort
= NULL
;
1963 lpSerialKeysW
->lpszPort
= NULL
;
1964 lpSerialKeysW
->iBaudRate
= 0;
1965 lpSerialKeysW
->iPortState
= 0;
1970 WINE_SPI_FIXME(SPI_SETSERIALKEYS
); /* 63 WINVER >= 0x400 */
1972 case SPI_GETSOUNDSENTRY
: /* 64 */
1974 LPSOUNDSENTRYW lpSoundSentryW
= pvParam
;
1975 WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1976 if (lpSoundSentryW
&& lpSoundSentryW
->cbSize
== sizeof(SOUNDSENTRYW
))
1978 /* Indicate that no SoundSentry feature available */
1979 lpSoundSentryW
->dwFlags
= 0;
1980 lpSoundSentryW
->iFSTextEffect
= 0;
1981 lpSoundSentryW
->iFSTextEffectMSec
= 0;
1982 lpSoundSentryW
->iFSTextEffectColorBits
= 0;
1983 lpSoundSentryW
->iFSGrafEffect
= 0;
1984 lpSoundSentryW
->iFSGrafEffectMSec
= 0;
1985 lpSoundSentryW
->iFSGrafEffectColor
= 0;
1986 lpSoundSentryW
->iWindowsEffect
= 0;
1987 lpSoundSentryW
->iWindowsEffectMSec
= 0;
1988 lpSoundSentryW
->lpszWindowsEffectDLL
= 0;
1989 lpSoundSentryW
->iWindowsEffectOrdinal
= 0;
1994 WINE_SPI_FIXME(SPI_SETSOUNDSENTRY
); /* 65 */
1996 case SPI_GETHIGHCONTRAST
: /* 66 WINVER >= 0x400 */
1998 LPHIGHCONTRASTW lpHighContrastW
= pvParam
;
1999 WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
2000 if (lpHighContrastW
&& lpHighContrastW
->cbSize
== sizeof(HIGHCONTRASTW
))
2002 /* Indicate that no high contrast feature available */
2003 lpHighContrastW
->dwFlags
= 0;
2004 lpHighContrastW
->lpszDefaultScheme
= NULL
;
2009 WINE_SPI_FIXME(SPI_SETHIGHCONTRAST
); /* 67 WINVER >= 0x400 */
2011 case SPI_GETKEYBOARDPREF
:
2012 ret
= get_entry( &entry_KEYBOARDPREF
, uiParam
, pvParam
);
2014 case SPI_SETKEYBOARDPREF
:
2015 ret
= set_entry( &entry_KEYBOARDPREF
, uiParam
, pvParam
, fWinIni
);
2017 case SPI_GETSCREENREADER
:
2018 ret
= get_entry( &entry_SCREENREADER
, uiParam
, pvParam
);
2020 case SPI_SETSCREENREADER
:
2021 ret
= set_entry( &entry_SCREENREADER
, uiParam
, pvParam
, fWinIni
);
2024 case SPI_GETANIMATION
: /* 72 WINVER >= 0x400 */
2026 LPANIMATIONINFO lpAnimInfo
= pvParam
;
2028 /* Tell it "disabled" */
2029 if (lpAnimInfo
&& lpAnimInfo
->cbSize
== sizeof(ANIMATIONINFO
))
2031 lpAnimInfo
->iMinAnimate
= 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
2036 WINE_SPI_WARN(SPI_SETANIMATION
); /* 73 WINVER >= 0x400 */
2038 case SPI_GETFONTSMOOTHING
:
2039 ret
= get_entry( &entry_FONTSMOOTHING
, uiParam
, pvParam
);
2040 if (ret
) *(UINT
*)pvParam
= (*(UINT
*)pvParam
!= 0);
2042 case SPI_SETFONTSMOOTHING
:
2043 uiParam
= uiParam
? 2 : 0; /* Win NT4/2k/XP behavior */
2044 ret
= set_entry( &entry_FONTSMOOTHING
, uiParam
, pvParam
, fWinIni
);
2046 case SPI_SETDRAGWIDTH
:
2047 ret
= set_entry( &entry_DRAGWIDTH
, uiParam
, pvParam
, fWinIni
);
2049 case SPI_SETDRAGHEIGHT
:
2050 ret
= set_entry( &entry_DRAGHEIGHT
, uiParam
, pvParam
, fWinIni
);
2053 WINE_SPI_FIXME(SPI_SETHANDHELD
); /* 78 WINVER >= 0x400 */
2055 WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT
); /* 79 WINVER >= 0x400 */
2056 WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT
); /* 80 WINVER >= 0x400 */
2057 WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT
); /* 81 WINVER >= 0x400 */
2058 WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT
); /* 82 WINVER >= 0x400 */
2060 case SPI_GETLOWPOWERACTIVE
:
2061 ret
= get_entry( &entry_LOWPOWERACTIVE
, uiParam
, pvParam
);
2063 case SPI_SETLOWPOWERACTIVE
:
2064 ret
= set_entry( &entry_LOWPOWERACTIVE
, uiParam
, pvParam
, fWinIni
);
2066 case SPI_GETPOWEROFFACTIVE
:
2067 ret
= get_entry( &entry_POWEROFFACTIVE
, uiParam
, pvParam
);
2069 case SPI_SETPOWEROFFACTIVE
:
2070 ret
= set_entry( &entry_POWEROFFACTIVE
, uiParam
, pvParam
, fWinIni
);
2073 WINE_SPI_FIXME(SPI_SETCURSORS
); /* 87 WINVER >= 0x400 */
2074 WINE_SPI_FIXME(SPI_SETICONS
); /* 88 WINVER >= 0x400 */
2076 case SPI_GETDEFAULTINPUTLANG
: /* 89 WINVER >= 0x400 */
2077 ret
= GetKeyboardLayout(0) != 0;
2080 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG
); /* 90 WINVER >= 0x400 */
2082 WINE_SPI_FIXME(SPI_SETLANGTOGGLE
); /* 91 WINVER >= 0x400 */
2084 case SPI_GETWINDOWSEXTENSION
: /* 92 WINVER >= 0x400 */
2085 WARN("pretend no support for Win9x Plus! for now.\n");
2086 ret
= FALSE
; /* yes, this is the result value */
2088 case SPI_SETMOUSETRAILS
:
2089 ret
= set_entry( &entry_MOUSETRAILS
, uiParam
, pvParam
, fWinIni
);
2091 case SPI_GETMOUSETRAILS
:
2092 ret
= get_entry( &entry_MOUSETRAILS
, uiParam
, pvParam
);
2094 case SPI_GETSNAPTODEFBUTTON
:
2095 ret
= get_entry( &entry_SNAPTODEFBUTTON
, uiParam
, pvParam
);
2097 case SPI_SETSNAPTODEFBUTTON
:
2098 ret
= set_entry( &entry_SNAPTODEFBUTTON
, uiParam
, pvParam
, fWinIni
);
2100 case SPI_SETSCREENSAVERRUNNING
:
2101 ret
= set_entry( &entry_SCREENSAVERRUNNING
, uiParam
, pvParam
, fWinIni
);
2103 case SPI_GETMOUSEHOVERWIDTH
:
2104 ret
= get_entry( &entry_MOUSEHOVERWIDTH
, uiParam
, pvParam
);
2106 case SPI_SETMOUSEHOVERWIDTH
:
2107 ret
= set_entry( &entry_MOUSEHOVERWIDTH
, uiParam
, pvParam
, fWinIni
);
2109 case SPI_GETMOUSEHOVERHEIGHT
:
2110 ret
= get_entry( &entry_MOUSEHOVERHEIGHT
, uiParam
, pvParam
);
2112 case SPI_SETMOUSEHOVERHEIGHT
:
2113 ret
= set_entry( &entry_MOUSEHOVERHEIGHT
, uiParam
, pvParam
, fWinIni
);
2115 case SPI_GETMOUSEHOVERTIME
:
2116 ret
= get_entry( &entry_MOUSEHOVERTIME
, uiParam
, pvParam
);
2118 case SPI_SETMOUSEHOVERTIME
:
2119 ret
= set_entry( &entry_MOUSEHOVERTIME
, uiParam
, pvParam
, fWinIni
);
2121 case SPI_GETWHEELSCROLLLINES
:
2122 ret
= get_entry( &entry_WHEELSCROLLLINES
, uiParam
, pvParam
);
2124 case SPI_SETWHEELSCROLLLINES
:
2125 ret
= set_entry( &entry_WHEELSCROLLLINES
, uiParam
, pvParam
, fWinIni
);
2127 case SPI_GETMENUSHOWDELAY
:
2128 ret
= get_entry( &entry_MENUSHOWDELAY
, uiParam
, pvParam
);
2130 case SPI_SETMENUSHOWDELAY
:
2131 ret
= set_entry( &entry_MENUSHOWDELAY
, uiParam
, pvParam
, fWinIni
);
2133 case SPI_GETWHEELSCROLLCHARS
:
2134 ret
= get_entry( &entry_WHEELSCROLLCHARS
, uiParam
, pvParam
);
2136 case SPI_SETWHEELSCROLLCHARS
:
2137 ret
= set_entry( &entry_WHEELSCROLLCHARS
, uiParam
, pvParam
, fWinIni
);
2140 WINE_SPI_FIXME(SPI_GETSHOWIMEUI
); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2141 WINE_SPI_FIXME(SPI_SETSHOWIMEUI
); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2143 case SPI_GETMOUSESPEED
:
2144 ret
= get_entry( &entry_MOUSESPEED
, uiParam
, pvParam
);
2146 case SPI_SETMOUSESPEED
:
2147 ret
= set_entry( &entry_MOUSESPEED
, uiParam
, pvParam
, fWinIni
);
2149 case SPI_GETSCREENSAVERRUNNING
:
2150 ret
= get_entry( &entry_SCREENSAVERRUNNING
, uiParam
, pvParam
);
2152 case SPI_GETDESKWALLPAPER
:
2153 ret
= get_entry( &entry_DESKWALLPAPER
, uiParam
, pvParam
);
2155 case SPI_GETACTIVEWINDOWTRACKING
:
2156 ret
= get_entry( &entry_ACTIVEWINDOWTRACKING
, uiParam
, pvParam
);
2158 case SPI_SETACTIVEWINDOWTRACKING
:
2159 ret
= set_entry( &entry_ACTIVEWINDOWTRACKING
, uiParam
, pvParam
, fWinIni
);
2161 case SPI_GETMENUANIMATION
:
2162 ret
= get_entry( &entry_MENUANIMATION
, uiParam
, pvParam
);
2164 case SPI_SETMENUANIMATION
:
2165 ret
= set_entry( &entry_MENUANIMATION
, uiParam
, pvParam
, fWinIni
);
2167 case SPI_GETCOMBOBOXANIMATION
:
2168 ret
= get_entry( &entry_COMBOBOXANIMATION
, uiParam
, pvParam
);
2170 case SPI_SETCOMBOBOXANIMATION
:
2171 ret
= set_entry( &entry_COMBOBOXANIMATION
, uiParam
, pvParam
, fWinIni
);
2173 case SPI_GETLISTBOXSMOOTHSCROLLING
:
2174 ret
= get_entry( &entry_LISTBOXSMOOTHSCROLLING
, uiParam
, pvParam
);
2176 case SPI_SETLISTBOXSMOOTHSCROLLING
:
2177 ret
= set_entry( &entry_LISTBOXSMOOTHSCROLLING
, uiParam
, pvParam
, fWinIni
);
2179 case SPI_GETGRADIENTCAPTIONS
:
2180 ret
= get_entry( &entry_GRADIENTCAPTIONS
, uiParam
, pvParam
);
2182 case SPI_SETGRADIENTCAPTIONS
:
2183 ret
= set_entry( &entry_GRADIENTCAPTIONS
, uiParam
, pvParam
, fWinIni
);
2185 case SPI_GETKEYBOARDCUES
:
2186 ret
= get_entry( &entry_KEYBOARDCUES
, uiParam
, pvParam
);
2188 case SPI_SETKEYBOARDCUES
:
2189 ret
= set_entry( &entry_KEYBOARDCUES
, uiParam
, pvParam
, fWinIni
);
2191 case SPI_GETACTIVEWNDTRKZORDER
:
2192 ret
= get_entry( &entry_ACTIVEWNDTRKZORDER
, uiParam
, pvParam
);
2194 case SPI_SETACTIVEWNDTRKZORDER
:
2195 ret
= set_entry( &entry_ACTIVEWNDTRKZORDER
, uiParam
, pvParam
, fWinIni
);
2197 case SPI_GETHOTTRACKING
:
2198 ret
= get_entry( &entry_HOTTRACKING
, uiParam
, pvParam
);
2200 case SPI_SETHOTTRACKING
:
2201 ret
= set_entry( &entry_HOTTRACKING
, uiParam
, pvParam
, fWinIni
);
2203 case SPI_GETMENUFADE
:
2204 ret
= get_entry( &entry_MENUFADE
, uiParam
, pvParam
);
2206 case SPI_SETMENUFADE
:
2207 ret
= set_entry( &entry_MENUFADE
, uiParam
, pvParam
, fWinIni
);
2209 case SPI_GETSELECTIONFADE
:
2210 ret
= get_entry( &entry_SELECTIONFADE
, uiParam
, pvParam
);
2212 case SPI_SETSELECTIONFADE
:
2213 ret
= set_entry( &entry_SELECTIONFADE
, uiParam
, pvParam
, fWinIni
);
2215 case SPI_GETTOOLTIPANIMATION
:
2216 ret
= get_entry( &entry_TOOLTIPANIMATION
, uiParam
, pvParam
);
2218 case SPI_SETTOOLTIPANIMATION
:
2219 ret
= set_entry( &entry_TOOLTIPANIMATION
, uiParam
, pvParam
, fWinIni
);
2221 case SPI_GETTOOLTIPFADE
:
2222 ret
= get_entry( &entry_TOOLTIPFADE
, uiParam
, pvParam
);
2224 case SPI_SETTOOLTIPFADE
:
2225 ret
= set_entry( &entry_TOOLTIPFADE
, uiParam
, pvParam
, fWinIni
);
2227 case SPI_GETCURSORSHADOW
:
2228 ret
= get_entry( &entry_CURSORSHADOW
, uiParam
, pvParam
);
2230 case SPI_SETCURSORSHADOW
:
2231 ret
= set_entry( &entry_CURSORSHADOW
, uiParam
, pvParam
, fWinIni
);
2233 case SPI_GETMOUSESONAR
:
2234 ret
= get_entry( &entry_MOUSESONAR
, uiParam
, pvParam
);
2236 case SPI_SETMOUSESONAR
:
2237 ret
= set_entry( &entry_MOUSESONAR
, uiParam
, pvParam
, fWinIni
);
2239 case SPI_GETMOUSECLICKLOCK
:
2240 ret
= get_entry( &entry_MOUSECLICKLOCK
, uiParam
, pvParam
);
2242 case SPI_SETMOUSECLICKLOCK
:
2243 ret
= set_entry( &entry_MOUSECLICKLOCK
, uiParam
, pvParam
, fWinIni
);
2245 case SPI_GETMOUSEVANISH
:
2246 ret
= get_entry( &entry_MOUSEVANISH
, uiParam
, pvParam
);
2248 case SPI_SETMOUSEVANISH
:
2249 ret
= set_entry( &entry_MOUSEVANISH
, uiParam
, pvParam
, fWinIni
);
2251 case SPI_GETFLATMENU
:
2252 ret
= get_entry( &entry_FLATMENU
, uiParam
, pvParam
);
2254 case SPI_SETFLATMENU
:
2255 ret
= set_entry( &entry_FLATMENU
, uiParam
, pvParam
, fWinIni
);
2257 case SPI_GETDROPSHADOW
:
2258 ret
= get_entry( &entry_DROPSHADOW
, uiParam
, pvParam
);
2260 case SPI_SETDROPSHADOW
:
2261 ret
= set_entry( &entry_DROPSHADOW
, uiParam
, pvParam
, fWinIni
);
2263 case SPI_GETBLOCKSENDINPUTRESETS
:
2264 ret
= get_entry( &entry_BLOCKSENDINPUTRESETS
, uiParam
, pvParam
);
2266 case SPI_SETBLOCKSENDINPUTRESETS
:
2267 ret
= set_entry( &entry_BLOCKSENDINPUTRESETS
, uiParam
, pvParam
, fWinIni
);
2269 case SPI_GETUIEFFECTS
:
2270 ret
= get_entry( &entry_UIEFFECTS
, uiParam
, pvParam
);
2272 case SPI_SETUIEFFECTS
:
2273 /* FIXME: this probably should mask other UI effect values when unset */
2274 ret
= set_entry( &entry_UIEFFECTS
, uiParam
, pvParam
, fWinIni
);
2276 case SPI_GETDISABLEOVERLAPPEDCONTENT
:
2277 ret
= get_entry( &entry_DISABLEOVERLAPPEDCONTENT
, uiParam
, pvParam
);
2279 case SPI_SETDISABLEOVERLAPPEDCONTENT
:
2280 ret
= set_entry( &entry_DISABLEOVERLAPPEDCONTENT
, uiParam
, pvParam
, fWinIni
);
2282 case SPI_GETCLIENTAREAANIMATION
:
2283 ret
= get_entry( &entry_CLIENTAREAANIMATION
, uiParam
, pvParam
);
2285 case SPI_SETCLIENTAREAANIMATION
:
2286 ret
= set_entry( &entry_CLIENTAREAANIMATION
, uiParam
, pvParam
, fWinIni
);
2288 case SPI_GETCLEARTYPE
:
2289 ret
= get_entry( &entry_CLEARTYPE
, uiParam
, pvParam
);
2291 case SPI_SETCLEARTYPE
:
2292 ret
= set_entry( &entry_CLEARTYPE
, uiParam
, pvParam
, fWinIni
);
2294 case SPI_GETSPEECHRECOGNITION
:
2295 ret
= get_entry( &entry_SPEECHRECOGNITION
, uiParam
, pvParam
);
2297 case SPI_SETSPEECHRECOGNITION
:
2298 ret
= set_entry( &entry_SPEECHRECOGNITION
, uiParam
, pvParam
, fWinIni
);
2300 case SPI_GETFOREGROUNDLOCKTIMEOUT
:
2301 ret
= get_entry( &entry_FOREGROUNDLOCKTIMEOUT
, uiParam
, pvParam
);
2303 case SPI_SETFOREGROUNDLOCKTIMEOUT
:
2304 /* FIXME: this should check that the calling thread
2305 * is able to change the foreground window */
2306 ret
= set_entry( &entry_FOREGROUNDLOCKTIMEOUT
, uiParam
, pvParam
, fWinIni
);
2308 case SPI_GETACTIVEWNDTRKTIMEOUT
:
2309 ret
= get_entry( &entry_ACTIVEWNDTRKTIMEOUT
, uiParam
, pvParam
);
2311 case SPI_SETACTIVEWNDTRKTIMEOUT
:
2312 ret
= get_entry( &entry_ACTIVEWNDTRKTIMEOUT
, uiParam
, pvParam
);
2314 case SPI_GETFOREGROUNDFLASHCOUNT
:
2315 ret
= get_entry( &entry_FOREGROUNDFLASHCOUNT
, uiParam
, pvParam
);
2317 case SPI_SETFOREGROUNDFLASHCOUNT
:
2318 ret
= set_entry( &entry_FOREGROUNDFLASHCOUNT
, uiParam
, pvParam
, fWinIni
);
2320 case SPI_GETCARETWIDTH
:
2321 ret
= get_entry( &entry_CARETWIDTH
, uiParam
, pvParam
);
2323 case SPI_SETCARETWIDTH
:
2324 ret
= set_entry( &entry_CARETWIDTH
, uiParam
, pvParam
, fWinIni
);
2326 case SPI_GETMOUSECLICKLOCKTIME
:
2327 ret
= get_entry( &entry_MOUSECLICKLOCKTIME
, uiParam
, pvParam
);
2329 case SPI_SETMOUSECLICKLOCKTIME
:
2330 ret
= set_entry( &entry_MOUSECLICKLOCKTIME
, uiParam
, pvParam
, fWinIni
);
2332 case SPI_GETFONTSMOOTHINGTYPE
:
2333 ret
= get_entry( &entry_FONTSMOOTHINGTYPE
, uiParam
, pvParam
);
2335 case SPI_SETFONTSMOOTHINGTYPE
:
2336 ret
= set_entry( &entry_FONTSMOOTHINGTYPE
, uiParam
, pvParam
, fWinIni
);
2338 case SPI_GETFONTSMOOTHINGCONTRAST
:
2339 ret
= get_entry( &entry_FONTSMOOTHINGCONTRAST
, uiParam
, pvParam
);
2341 case SPI_SETFONTSMOOTHINGCONTRAST
:
2342 ret
= set_entry( &entry_FONTSMOOTHINGCONTRAST
, uiParam
, pvParam
, fWinIni
);
2344 case SPI_GETFOCUSBORDERWIDTH
:
2345 ret
= get_entry( &entry_FOCUSBORDERWIDTH
, uiParam
, pvParam
);
2347 case SPI_GETFOCUSBORDERHEIGHT
:
2348 ret
= get_entry( &entry_FOCUSBORDERHEIGHT
, uiParam
, pvParam
);
2350 case SPI_SETFOCUSBORDERWIDTH
:
2351 ret
= set_entry( &entry_FOCUSBORDERWIDTH
, uiParam
, pvParam
, fWinIni
);
2353 case SPI_SETFOCUSBORDERHEIGHT
:
2354 ret
= set_entry( &entry_FOCUSBORDERHEIGHT
, uiParam
, pvParam
, fWinIni
);
2356 case SPI_GETFONTSMOOTHINGORIENTATION
:
2357 ret
= get_entry( &entry_FONTSMOOTHINGORIENTATION
, uiParam
, pvParam
);
2359 case SPI_SETFONTSMOOTHINGORIENTATION
:
2360 ret
= set_entry( &entry_FONTSMOOTHINGORIENTATION
, uiParam
, pvParam
, fWinIni
);
2362 case SPI_GETAUDIODESCRIPTION
:
2364 AUDIODESCRIPTION
*audio
= pvParam
;
2365 if (audio
&& audio
->cbSize
== sizeof(AUDIODESCRIPTION
) && uiParam
== sizeof(AUDIODESCRIPTION
) )
2367 ret
= get_entry( &entry_AUDIODESC_ON
, 0, &audio
->Enabled
) &&
2368 get_entry( &entry_AUDIODESC_LOCALE
, 0, &audio
->Locale
);
2372 case SPI_SETAUDIODESCRIPTION
:
2374 AUDIODESCRIPTION
*audio
= pvParam
;
2375 if (audio
&& audio
->cbSize
== sizeof(AUDIODESCRIPTION
) && uiParam
== sizeof(AUDIODESCRIPTION
) )
2377 ret
= set_entry( &entry_AUDIODESC_ON
, 0, &audio
->Enabled
, fWinIni
) &&
2378 set_entry( &entry_AUDIODESC_LOCALE
, 0, &audio
->Locale
, fWinIni
);
2383 FIXME( "Unknown action: %u\n", uiAction
);
2384 SetLastError( ERROR_INVALID_SPI_VALUE
);
2390 SYSPARAMS_NotifyChange( uiAction
, fWinIni
);
2391 TRACE("(%u, %u, %p, %u) ret %d\n",
2392 uiAction
, uiParam
, pvParam
, fWinIni
, ret
);
2395 #undef WINE_SPI_FIXME
2396 #undef WINE_SPI_WARN
2400 /***********************************************************************
2401 * SystemParametersInfoA (USER32.@)
2403 BOOL WINAPI
SystemParametersInfoA( UINT uiAction
, UINT uiParam
,
2404 PVOID pvParam
, UINT fuWinIni
)
2408 TRACE("(%u, %u, %p, %u)\n", uiAction
, uiParam
, pvParam
, fuWinIni
);
2412 case SPI_SETDESKWALLPAPER
: /* 20 */
2413 case SPI_SETDESKPATTERN
: /* 21 */
2417 if (!MultiByteToWideChar( CP_ACP
, 0, pvParam
, -1, buffer
, ARRAY_SIZE( buffer
)))
2418 buffer
[ARRAY_SIZE(buffer
)-1] = 0;
2419 ret
= SystemParametersInfoW( uiAction
, uiParam
, pvParam
? buffer
: NULL
, fuWinIni
);
2423 case SPI_GETICONTITLELOGFONT
: /* 31 */
2426 ret
= SystemParametersInfoW( uiAction
, uiParam
, pvParam
? &tmp
: NULL
, fuWinIni
);
2428 SYSPARAMS_LogFont32WTo32A( &tmp
, pvParam
);
2432 case SPI_GETNONCLIENTMETRICS
: /* 41 WINVER >= 0x400 */
2434 NONCLIENTMETRICSW tmp
;
2435 LPNONCLIENTMETRICSA lpnmA
= pvParam
;
2436 if (lpnmA
&& (lpnmA
->cbSize
== sizeof(NONCLIENTMETRICSA
) ||
2437 lpnmA
->cbSize
== FIELD_OFFSET(NONCLIENTMETRICSA
, iPaddedBorderWidth
)))
2439 tmp
.cbSize
= sizeof(NONCLIENTMETRICSW
);
2440 ret
= SystemParametersInfoW( uiAction
, uiParam
, &tmp
, fuWinIni
);
2442 SYSPARAMS_NonClientMetrics32WTo32A( &tmp
, lpnmA
);
2449 case SPI_SETNONCLIENTMETRICS
: /* 42 WINVER >= 0x400 */
2451 NONCLIENTMETRICSW tmp
;
2452 LPNONCLIENTMETRICSA lpnmA
= pvParam
;
2453 if (lpnmA
&& (lpnmA
->cbSize
== sizeof(NONCLIENTMETRICSA
) ||
2454 lpnmA
->cbSize
== FIELD_OFFSET(NONCLIENTMETRICSA
, iPaddedBorderWidth
)))
2456 tmp
.cbSize
= sizeof(NONCLIENTMETRICSW
);
2457 SYSPARAMS_NonClientMetrics32ATo32W( lpnmA
, &tmp
);
2458 ret
= SystemParametersInfoW( uiAction
, uiParam
, &tmp
, fuWinIni
);
2465 case SPI_GETICONMETRICS
: /* 45 WINVER >= 0x400 */
2468 LPICONMETRICSA lpimA
= pvParam
;
2469 if (lpimA
&& lpimA
->cbSize
== sizeof(ICONMETRICSA
))
2471 tmp
.cbSize
= sizeof(ICONMETRICSW
);
2472 ret
= SystemParametersInfoW( uiAction
, uiParam
, &tmp
, fuWinIni
);
2475 lpimA
->iHorzSpacing
= tmp
.iHorzSpacing
;
2476 lpimA
->iVertSpacing
= tmp
.iVertSpacing
;
2477 lpimA
->iTitleWrap
= tmp
.iTitleWrap
;
2478 SYSPARAMS_LogFont32WTo32A( &tmp
.lfFont
, &lpimA
->lfFont
);
2486 case SPI_SETICONMETRICS
: /* 46 WINVER >= 0x400 */
2489 LPICONMETRICSA lpimA
= pvParam
;
2490 if (lpimA
&& lpimA
->cbSize
== sizeof(ICONMETRICSA
))
2492 tmp
.cbSize
= sizeof(ICONMETRICSW
);
2493 tmp
.iHorzSpacing
= lpimA
->iHorzSpacing
;
2494 tmp
.iVertSpacing
= lpimA
->iVertSpacing
;
2495 tmp
.iTitleWrap
= lpimA
->iTitleWrap
;
2496 SYSPARAMS_LogFont32ATo32W( &lpimA
->lfFont
, &tmp
.lfFont
);
2497 ret
= SystemParametersInfoW( uiAction
, uiParam
, &tmp
, fuWinIni
);
2504 case SPI_GETHIGHCONTRAST
: /* 66 WINVER >= 0x400 */
2507 LPHIGHCONTRASTA lphcA
= pvParam
;
2508 if (lphcA
&& lphcA
->cbSize
== sizeof(HIGHCONTRASTA
))
2510 tmp
.cbSize
= sizeof(HIGHCONTRASTW
);
2511 ret
= SystemParametersInfoW( uiAction
, uiParam
, &tmp
, fuWinIni
);
2514 lphcA
->dwFlags
= tmp
.dwFlags
;
2515 lphcA
->lpszDefaultScheme
= NULL
; /* FIXME? */
2523 case SPI_GETDESKWALLPAPER
: /* 115 */
2525 WCHAR buffer
[MAX_PATH
];
2526 ret
= (SystemParametersInfoW( SPI_GETDESKWALLPAPER
, uiParam
, buffer
, fuWinIni
) &&
2527 WideCharToMultiByte(CP_ACP
, 0, buffer
, -1, pvParam
, uiParam
, NULL
, NULL
));
2532 ret
= SystemParametersInfoW( uiAction
, uiParam
, pvParam
, fuWinIni
);
2539 /***********************************************************************
2540 * GetSystemMetrics (USER32.@)
2542 INT WINAPI
GetSystemMetrics( INT index
)
2544 struct monitor_info info
;
2545 NONCLIENTMETRICSW ncm
;
2546 MINIMIZEDMETRICS mm
;
2551 /* some metrics are dynamic */
2556 ncm
.cbSize
= sizeof(ncm
);
2557 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2558 return ncm
.iScrollWidth
;
2560 ncm
.cbSize
= sizeof(ncm
);
2561 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2562 return ncm
.iCaptionHeight
+ 1;
2565 /* SM_C{X,Y}BORDER always returns 1 regardless of 'BorderWidth' value in registry */
2574 ncm
.cbSize
= sizeof(ncm
);
2575 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2576 return ncm
.iScrollHeight
;
2579 return map_to_dpi( 32, GetDpiForSystem() );
2582 ret
= map_to_dpi( 32, GetDpiForSystem() );
2583 if (ret
>= 64) return 64;
2584 if (ret
>= 48) return 48;
2587 ncm
.cbSize
= sizeof(ncm
);
2588 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2589 return ncm
.iMenuHeight
+ 1;
2590 case SM_CXFULLSCREEN
:
2591 /* see the remark for SM_CXMAXIMIZED, at least this formulation is
2593 return GetSystemMetrics( SM_CXMAXIMIZED
) - 2 * GetSystemMetrics( SM_CXFRAME
);
2594 case SM_CYFULLSCREEN
:
2595 /* see the remark for SM_CYMAXIMIZED, at least this formulation is
2597 return GetSystemMetrics( SM_CYMAXIMIZED
) - GetSystemMetrics( SM_CYMIN
);
2598 case SM_CYKANJIWINDOW
:
2600 case SM_MOUSEPRESENT
:
2605 get_entry( &entry_MOUSEBUTTONSWAP
, 0, &ret
);
2613 ncm
.cbSize
= sizeof(ncm
);
2614 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2615 hdc
= get_display_dc();
2616 get_text_metr_size( hdc
, &ncm
.lfCaptionFont
, NULL
, &ret
);
2617 release_display_dc( hdc
);
2618 return 3 * ncm
.iCaptionWidth
+ ncm
.iCaptionHeight
+ 4 * ret
+ 2 * GetSystemMetrics(SM_CXFRAME
) + 4;
2620 return GetSystemMetrics( SM_CYCAPTION
) + 2 * GetSystemMetrics( SM_CYFRAME
);
2622 ncm
.cbSize
= sizeof(ncm
);
2623 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2624 return ncm
.iCaptionWidth
;
2626 ncm
.cbSize
= sizeof(ncm
);
2627 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2628 return ncm
.iCaptionHeight
;
2630 ncm
.cbSize
= sizeof(ncm
);
2631 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2632 return GetSystemMetrics(SM_CXDLGFRAME
) + ncm
.iBorderWidth
;
2634 ncm
.cbSize
= sizeof(ncm
);
2635 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2636 return GetSystemMetrics(SM_CYDLGFRAME
) + ncm
.iBorderWidth
;
2638 return GetSystemMetrics(SM_CXMIN
);
2640 return GetSystemMetrics(SM_CYMIN
);
2641 case SM_CXDOUBLECLK
:
2642 get_entry( &entry_DOUBLECLKWIDTH
, 0, &ret
);
2644 case SM_CYDOUBLECLK
:
2645 get_entry( &entry_DOUBLECLKHEIGHT
, 0, &ret
);
2647 case SM_CXICONSPACING
:
2648 im
.cbSize
= sizeof(im
);
2649 SystemParametersInfoW( SPI_GETICONMETRICS
, sizeof(im
), &im
, 0 );
2650 return im
.iHorzSpacing
;
2651 case SM_CYICONSPACING
:
2652 im
.cbSize
= sizeof(im
);
2653 SystemParametersInfoW( SPI_GETICONMETRICS
, sizeof(im
), &im
, 0 );
2654 return im
.iVertSpacing
;
2655 case SM_MENUDROPALIGNMENT
:
2656 SystemParametersInfoW( SPI_GETMENUDROPALIGNMENT
, 0, &ret
, 0 );
2660 case SM_DBCSENABLED
:
2663 GetCPInfo( CP_ACP
, &cpinfo
);
2664 return (cpinfo
.MaxCharSize
> 1);
2666 case SM_CMOUSEBUTTONS
:
2671 return GetSystemMetrics(SM_CXBORDER
) + 1;
2673 return GetSystemMetrics(SM_CYBORDER
) + 1;
2674 case SM_CXMINSPACING
:
2675 mm
.cbSize
= sizeof(mm
);
2676 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS
, sizeof(mm
), &mm
, 0 );
2677 return GetSystemMetrics(SM_CXMINIMIZED
) + mm
.iHorzGap
;
2678 case SM_CYMINSPACING
:
2679 mm
.cbSize
= sizeof(mm
);
2680 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS
, sizeof(mm
), &mm
, 0 );
2681 return GetSystemMetrics(SM_CYMINIMIZED
) + mm
.iVertGap
;
2684 return map_to_dpi( 16, GetDpiForSystem() ) & ~1;
2685 case SM_CYSMCAPTION
:
2686 ncm
.cbSize
= sizeof(ncm
);
2687 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2688 return ncm
.iSmCaptionHeight
+ 1;
2690 ncm
.cbSize
= sizeof(ncm
);
2691 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2692 return ncm
.iSmCaptionWidth
;
2694 ncm
.cbSize
= sizeof(ncm
);
2695 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2696 return ncm
.iSmCaptionHeight
;
2698 ncm
.cbSize
= sizeof(ncm
);
2699 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2700 return ncm
.iMenuWidth
;
2702 ncm
.cbSize
= sizeof(ncm
);
2703 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2704 return ncm
.iMenuHeight
;
2706 mm
.cbSize
= sizeof(mm
);
2707 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS
, sizeof(mm
), &mm
, 0 );
2709 case SM_CXMINIMIZED
:
2710 mm
.cbSize
= sizeof(mm
);
2711 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS
, sizeof(mm
), &mm
, 0 );
2712 return mm
.iWidth
+ 6;
2713 case SM_CYMINIMIZED
:
2714 ncm
.cbSize
= sizeof(ncm
);
2715 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2716 return ncm
.iCaptionHeight
+ 6;
2718 return GetSystemMetrics(SM_CXVIRTUALSCREEN
) + 4 + 2 * GetSystemMetrics(SM_CXFRAME
);
2720 return GetSystemMetrics(SM_CYVIRTUALSCREEN
) + 4 + 2 * GetSystemMetrics(SM_CYFRAME
);
2721 case SM_CXMAXIMIZED
:
2722 /* FIXME: subtract the width of any vertical application toolbars*/
2723 return GetSystemMetrics(SM_CXSCREEN
) + 2 * GetSystemMetrics(SM_CXFRAME
);
2724 case SM_CYMAXIMIZED
:
2725 /* FIXME: subtract the width of any horizontal application toolbars*/
2726 return GetSystemMetrics(SM_CYSCREEN
) + 2 * GetSystemMetrics(SM_CYCAPTION
);
2728 return 3; /* FIXME */
2730 return 0; /* 0 = ok, 1 = failsafe, 2 = failsafe + network */
2732 get_entry( &entry_DRAGWIDTH
, 0, &ret
);
2735 get_entry( &entry_DRAGHEIGHT
, 0, &ret
);
2738 get_entry( &entry_SHOWSOUNDS
, 0, &ret
);
2740 case SM_CXMENUCHECK
:
2741 case SM_CYMENUCHECK
:
2744 ncm
.cbSize
= sizeof(ncm
);
2745 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0 );
2746 hdc
= get_display_dc();
2747 get_text_metr_size( hdc
, &ncm
.lfMenuFont
, &tm
, NULL
);
2748 release_display_dc( hdc
);
2749 return tm
.tmHeight
<= 0 ? 13 : ((tm
.tmHeight
+ tm
.tmExternalLeading
+ 1) / 2) * 2 - 1;
2751 case SM_SLOWMACHINE
:
2752 return 0; /* Never true */
2753 case SM_MIDEASTENABLED
:
2754 return 0; /* FIXME */
2755 case SM_MOUSEWHEELPRESENT
:
2758 get_monitors_info( &info
);
2759 return info
.primary_rect
.right
- info
.primary_rect
.left
;
2761 get_monitors_info( &info
);
2762 return info
.primary_rect
.bottom
- info
.primary_rect
.top
;
2763 case SM_XVIRTUALSCREEN
:
2764 get_monitors_info( &info
);
2765 return info
.virtual_rect
.left
;
2766 case SM_YVIRTUALSCREEN
:
2767 get_monitors_info( &info
);
2768 return info
.virtual_rect
.top
;
2769 case SM_CXVIRTUALSCREEN
:
2770 get_monitors_info( &info
);
2771 return info
.virtual_rect
.right
- info
.virtual_rect
.left
;
2772 case SM_CYVIRTUALSCREEN
:
2773 get_monitors_info( &info
);
2774 return info
.virtual_rect
.bottom
- info
.virtual_rect
.top
;
2776 get_monitors_info( &info
);
2778 case SM_SAMEDISPLAYFORMAT
:
2781 return 0; /* FIXME */
2782 case SM_CXFOCUSBORDER
:
2783 case SM_CYFOCUSBORDER
:
2786 case SM_MEDIACENTER
:
2796 /***********************************************************************
2797 * GetSystemMetricsForDpi (USER32.@)
2799 INT WINAPI
GetSystemMetricsForDpi( INT index
, UINT dpi
)
2801 NONCLIENTMETRICSW ncm
;
2806 /* some metrics are dynamic */
2811 ncm
.cbSize
= sizeof(ncm
);
2812 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2813 return ncm
.iScrollWidth
;
2815 ncm
.cbSize
= sizeof(ncm
);
2816 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2817 return ncm
.iCaptionHeight
+ 1;
2822 ncm
.cbSize
= sizeof(ncm
);
2823 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2824 return ncm
.iScrollHeight
;
2827 return map_to_dpi( 32, dpi
);
2830 ret
= map_to_dpi( 32, dpi
);
2831 if (ret
>= 64) return 64;
2832 if (ret
>= 48) return 48;
2835 ncm
.cbSize
= sizeof(ncm
);
2836 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2837 return ncm
.iMenuHeight
+ 1;
2839 ncm
.cbSize
= sizeof(ncm
);
2840 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2841 return ncm
.iCaptionWidth
;
2843 ncm
.cbSize
= sizeof(ncm
);
2844 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2845 return ncm
.iCaptionHeight
;
2847 ncm
.cbSize
= sizeof(ncm
);
2848 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2849 return GetSystemMetricsForDpi( SM_CXDLGFRAME
, dpi
) + ncm
.iBorderWidth
;
2851 ncm
.cbSize
= sizeof(ncm
);
2852 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2853 return GetSystemMetricsForDpi( SM_CYDLGFRAME
, dpi
) + ncm
.iBorderWidth
;
2854 case SM_CXICONSPACING
:
2855 im
.cbSize
= sizeof(im
);
2856 SystemParametersInfoForDpi( SPI_GETICONMETRICS
, sizeof(im
), &im
, 0, dpi
);
2857 return im
.iHorzSpacing
;
2858 case SM_CYICONSPACING
:
2859 im
.cbSize
= sizeof(im
);
2860 SystemParametersInfoForDpi( SPI_GETICONMETRICS
, sizeof(im
), &im
, 0, dpi
);
2861 return im
.iVertSpacing
;
2864 return map_to_dpi( 16, dpi
) & ~1;
2865 case SM_CYSMCAPTION
:
2866 ncm
.cbSize
= sizeof(ncm
);
2867 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2868 return ncm
.iSmCaptionHeight
+ 1;
2870 ncm
.cbSize
= sizeof(ncm
);
2871 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2872 return ncm
.iSmCaptionWidth
;
2874 ncm
.cbSize
= sizeof(ncm
);
2875 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2876 return ncm
.iSmCaptionHeight
;
2878 ncm
.cbSize
= sizeof(ncm
);
2879 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2880 return ncm
.iMenuWidth
;
2882 ncm
.cbSize
= sizeof(ncm
);
2883 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2884 return ncm
.iMenuHeight
;
2885 case SM_CXMENUCHECK
:
2886 case SM_CYMENUCHECK
:
2889 ncm
.cbSize
= sizeof(ncm
);
2890 SystemParametersInfoForDpi( SPI_GETNONCLIENTMETRICS
, 0, &ncm
, 0, dpi
);
2891 hdc
= get_display_dc();
2892 get_text_metr_size( hdc
, &ncm
.lfMenuFont
, &tm
, NULL
);
2893 release_display_dc( hdc
);
2894 return tm
.tmHeight
<= 0 ? 13 : ((tm
.tmHeight
+ tm
.tmExternalLeading
- 1) | 1);
2897 return GetSystemMetrics( index
);
2902 /***********************************************************************
2903 * SwapMouseButton (USER32.@)
2904 * Reverse or restore the meaning of the left and right mouse buttons
2905 * fSwap [I ] TRUE - reverse, FALSE - original
2909 BOOL WINAPI
SwapMouseButton( BOOL fSwap
)
2911 BOOL prev
= GetSystemMetrics(SM_SWAPBUTTON
);
2912 SystemParametersInfoW(SPI_SETMOUSEBUTTONSWAP
, fSwap
, 0, 0);
2917 /**********************************************************************
2918 * SetDoubleClickTime (USER32.@)
2920 BOOL WINAPI
SetDoubleClickTime( UINT interval
)
2922 return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME
, interval
, 0, 0);
2926 /**********************************************************************
2927 * GetDoubleClickTime (USER32.@)
2929 UINT WINAPI
GetDoubleClickTime(void)
2933 get_entry( &entry_DOUBLECLICKTIME
, 0, &time
);
2934 if (!time
) time
= 500;
2939 /*************************************************************************
2940 * GetSysColor (USER32.@)
2942 COLORREF WINAPI DECLSPEC_HOTPATCH
GetSysColor( INT nIndex
)
2946 if (nIndex
>= 0 && nIndex
< ARRAY_SIZE( system_colors
))
2947 get_entry( &system_colors
[nIndex
], 0, &ret
);
2952 /*************************************************************************
2953 * SetSysColors (USER32.@)
2955 BOOL WINAPI
SetSysColors( INT count
, const INT
*colors
, const COLORREF
*values
)
2959 if (IS_INTRESOURCE(colors
)) return FALSE
; /* stupid app passes a color instead of an array */
2961 for (i
= 0; i
< count
; i
++)
2962 if (colors
[i
] >= 0 && colors
[i
] <= ARRAY_SIZE( system_colors
))
2963 set_entry( &system_colors
[colors
[i
]], values
[i
], 0, 0 );
2965 /* Send WM_SYSCOLORCHANGE message to all windows */
2967 SendMessageTimeoutW( HWND_BROADCAST
, WM_SYSCOLORCHANGE
, 0, 0, SMTO_ABORTIFHUNG
, 2000, NULL
);
2969 /* Repaint affected portions of all visible windows */
2971 RedrawWindow( 0, NULL
, 0, RDW_INVALIDATE
| RDW_ERASE
| RDW_UPDATENOW
| RDW_ALLCHILDREN
);
2976 /*************************************************************************
2977 * SetSysColorsTemp (USER32.@)
2979 DWORD_PTR WINAPI
SetSysColorsTemp( const COLORREF
*pPens
, const HBRUSH
*pBrushes
, DWORD_PTR n
)
2981 FIXME( "no longer supported\n" );
2986 /***********************************************************************
2987 * GetSysColorBrush (USER32.@)
2989 HBRUSH WINAPI DECLSPEC_HOTPATCH
GetSysColorBrush( INT index
)
2991 if (index
< 0 || index
>= ARRAY_SIZE( system_colors
)) return 0;
2993 if (!system_colors
[index
].brush
)
2995 HBRUSH brush
= CreateSolidBrush( GetSysColor( index
));
2996 __wine_make_gdi_object_system( brush
, TRUE
);
2997 if (InterlockedCompareExchangePointer( (void **)&system_colors
[index
].brush
, brush
, 0 ))
2999 __wine_make_gdi_object_system( brush
, FALSE
);
3000 DeleteObject( brush
);
3003 return system_colors
[index
].brush
;
3007 /***********************************************************************
3010 HPEN
SYSCOLOR_GetPen( INT index
)
3012 /* We can assert here, because this function is internal to Wine */
3013 assert (0 <= index
&& index
< ARRAY_SIZE( system_colors
));
3015 if (!system_colors
[index
].pen
)
3017 HPEN pen
= CreatePen( PS_SOLID
, 1, GetSysColor( index
));
3018 __wine_make_gdi_object_system( pen
, TRUE
);
3019 if (InterlockedCompareExchangePointer( (void **)&system_colors
[index
].pen
, pen
, 0 ))
3021 __wine_make_gdi_object_system( pen
, FALSE
);
3022 DeleteObject( pen
);
3025 return system_colors
[index
].pen
;
3029 /***********************************************************************
3030 * SYSCOLOR_Get55AABrush
3032 HBRUSH
SYSCOLOR_Get55AABrush(void)
3034 static const WORD pattern
[] = { 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa };
3035 static HBRUSH brush_55aa
;
3039 HBITMAP bitmap
= CreateBitmap( 8, 8, 1, 1, pattern
);
3040 HBRUSH brush
= CreatePatternBrush( bitmap
);
3041 DeleteObject( bitmap
);
3042 __wine_make_gdi_object_system( brush
, TRUE
);
3043 if (InterlockedCompareExchangePointer( (void **)&brush_55aa
, brush
, 0 ))
3045 __wine_make_gdi_object_system( brush
, FALSE
);
3046 DeleteObject( brush
);
3052 /***********************************************************************
3053 * ChangeDisplaySettingsA (USER32.@)
3055 LONG WINAPI
ChangeDisplaySettingsA( LPDEVMODEA devmode
, DWORD flags
)
3057 if (devmode
) devmode
->dmDriverExtra
= 0;
3059 return ChangeDisplaySettingsExA(NULL
,devmode
,NULL
,flags
,NULL
);
3063 /***********************************************************************
3064 * ChangeDisplaySettingsW (USER32.@)
3066 LONG WINAPI
ChangeDisplaySettingsW( LPDEVMODEW devmode
, DWORD flags
)
3068 if (devmode
) devmode
->dmDriverExtra
= 0;
3070 return ChangeDisplaySettingsExW(NULL
,devmode
,NULL
,flags
,NULL
);
3074 /***********************************************************************
3075 * ChangeDisplaySettingsExA (USER32.@)
3077 LONG WINAPI
ChangeDisplaySettingsExA( LPCSTR devname
, LPDEVMODEA devmode
, HWND hwnd
,
3078 DWORD flags
, LPVOID lparam
)
3081 UNICODE_STRING nameW
;
3083 if (devname
) RtlCreateUnicodeStringFromAsciiz(&nameW
, devname
);
3084 else nameW
.Buffer
= NULL
;
3090 devmodeW
= GdiConvertToDevmodeW(devmode
);
3093 ret
= ChangeDisplaySettingsExW(nameW
.Buffer
, devmodeW
, hwnd
, flags
, lparam
);
3094 HeapFree(GetProcessHeap(), 0, devmodeW
);
3097 ret
= DISP_CHANGE_SUCCESSFUL
;
3101 ret
= ChangeDisplaySettingsExW(nameW
.Buffer
, NULL
, hwnd
, flags
, lparam
);
3104 if (devname
) RtlFreeUnicodeString(&nameW
);
3109 /***********************************************************************
3110 * ChangeDisplaySettingsExW (USER32.@)
3112 LONG WINAPI
ChangeDisplaySettingsExW( LPCWSTR devname
, LPDEVMODEW devmode
, HWND hwnd
,
3113 DWORD flags
, LPVOID lparam
)
3115 return USER_Driver
->pChangeDisplaySettingsEx( devname
, devmode
, hwnd
, flags
, lparam
);
3119 /***********************************************************************
3120 * DisplayConfigGetDeviceInfo (USER32.@)
3122 LONG WINAPI
DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_HEADER
*packet
)
3124 FIXME("stub: %p\n", packet
);
3125 return ERROR_NOT_SUPPORTED
;
3128 /***********************************************************************
3129 * EnumDisplaySettingsW (USER32.@)
3132 * TRUE if nth setting exists found (described in the LPDEVMODEW struct)
3133 * FALSE if we do not have the nth setting
3135 BOOL WINAPI
EnumDisplaySettingsW( LPCWSTR name
, DWORD n
, LPDEVMODEW devmode
)
3137 return EnumDisplaySettingsExW(name
, n
, devmode
, 0);
3141 /***********************************************************************
3142 * EnumDisplaySettingsA (USER32.@)
3144 BOOL WINAPI
EnumDisplaySettingsA(LPCSTR name
,DWORD n
,LPDEVMODEA devmode
)
3146 return EnumDisplaySettingsExA(name
, n
, devmode
, 0);
3150 /***********************************************************************
3151 * EnumDisplaySettingsExA (USER32.@)
3153 BOOL WINAPI
EnumDisplaySettingsExA(LPCSTR lpszDeviceName
, DWORD iModeNum
,
3154 LPDEVMODEA lpDevMode
, DWORD dwFlags
)
3158 UNICODE_STRING nameW
;
3160 if (lpszDeviceName
) RtlCreateUnicodeStringFromAsciiz(&nameW
, lpszDeviceName
);
3161 else nameW
.Buffer
= NULL
;
3163 ret
= EnumDisplaySettingsExW(nameW
.Buffer
,iModeNum
,&devmodeW
,dwFlags
);
3166 lpDevMode
->dmSize
= FIELD_OFFSET(DEVMODEA
, dmICMMethod
);
3167 lpDevMode
->dmSpecVersion
= devmodeW
.dmSpecVersion
;
3168 lpDevMode
->dmDriverVersion
= devmodeW
.dmDriverVersion
;
3169 WideCharToMultiByte(CP_ACP
, 0, devmodeW
.dmDeviceName
, -1,
3170 (LPSTR
)lpDevMode
->dmDeviceName
, CCHDEVICENAME
, NULL
, NULL
);
3171 lpDevMode
->dmDriverExtra
= 0; /* FIXME */
3172 lpDevMode
->dmBitsPerPel
= devmodeW
.dmBitsPerPel
;
3173 lpDevMode
->dmPelsHeight
= devmodeW
.dmPelsHeight
;
3174 lpDevMode
->dmPelsWidth
= devmodeW
.dmPelsWidth
;
3175 lpDevMode
->u2
.dmDisplayFlags
= devmodeW
.u2
.dmDisplayFlags
;
3176 lpDevMode
->dmDisplayFrequency
= devmodeW
.dmDisplayFrequency
;
3177 lpDevMode
->dmFields
= devmodeW
.dmFields
;
3179 lpDevMode
->u1
.s2
.dmPosition
.x
= devmodeW
.u1
.s2
.dmPosition
.x
;
3180 lpDevMode
->u1
.s2
.dmPosition
.y
= devmodeW
.u1
.s2
.dmPosition
.y
;
3181 lpDevMode
->u1
.s2
.dmDisplayOrientation
= devmodeW
.u1
.s2
.dmDisplayOrientation
;
3182 lpDevMode
->u1
.s2
.dmDisplayFixedOutput
= devmodeW
.u1
.s2
.dmDisplayFixedOutput
;
3184 if (lpszDeviceName
) RtlFreeUnicodeString(&nameW
);
3189 /***********************************************************************
3190 * EnumDisplaySettingsExW (USER32.@)
3192 BOOL WINAPI
EnumDisplaySettingsExW(LPCWSTR lpszDeviceName
, DWORD iModeNum
,
3193 LPDEVMODEW lpDevMode
, DWORD dwFlags
)
3195 return USER_Driver
->pEnumDisplaySettingsEx(lpszDeviceName
, iModeNum
, lpDevMode
, dwFlags
);
3199 /**********************************************************************
3202 UINT
get_monitor_dpi( HMONITOR monitor
)
3204 /* FIXME: use the monitor DPI instead */
3208 /**********************************************************************
3209 * get_win_monitor_dpi
3211 UINT
get_win_monitor_dpi( HWND hwnd
)
3213 /* FIXME: use the monitor DPI instead */
3217 /**********************************************************************
3220 UINT
get_thread_dpi(void)
3222 switch (GetAwarenessFromDpiAwarenessContext( GetThreadDpiAwarenessContext() ))
3224 case DPI_AWARENESS_UNAWARE
: return USER_DEFAULT_SCREEN_DPI
;
3225 case DPI_AWARENESS_SYSTEM_AWARE
: return system_dpi
;
3226 default: return 0; /* no scaling */
3230 /**********************************************************************
3233 POINT
map_dpi_point( POINT pt
, UINT dpi_from
, UINT dpi_to
)
3235 if (dpi_from
&& dpi_to
&& dpi_from
!= dpi_to
)
3237 pt
.x
= MulDiv( pt
.x
, dpi_to
, dpi_from
);
3238 pt
.y
= MulDiv( pt
.y
, dpi_to
, dpi_from
);
3243 /**********************************************************************
3244 * point_win_to_phys_dpi
3246 POINT
point_win_to_phys_dpi( HWND hwnd
, POINT pt
)
3248 return map_dpi_point( pt
, GetDpiForWindow( hwnd
), get_win_monitor_dpi( hwnd
) );
3251 /**********************************************************************
3252 * point_phys_to_win_dpi
3254 POINT
point_phys_to_win_dpi( HWND hwnd
, POINT pt
)
3256 return map_dpi_point( pt
, get_win_monitor_dpi( hwnd
), GetDpiForWindow( hwnd
));
3259 /**********************************************************************
3260 * point_win_to_thread_dpi
3262 POINT
point_win_to_thread_dpi( HWND hwnd
, POINT pt
)
3264 UINT dpi
= get_thread_dpi();
3265 if (!dpi
) dpi
= get_win_monitor_dpi( hwnd
);
3266 return map_dpi_point( pt
, GetDpiForWindow( hwnd
), dpi
);
3269 /**********************************************************************
3270 * point_thread_to_win_dpi
3272 POINT
point_thread_to_win_dpi( HWND hwnd
, POINT pt
)
3274 UINT dpi
= get_thread_dpi();
3275 if (!dpi
) dpi
= get_win_monitor_dpi( hwnd
);
3276 return map_dpi_point( pt
, dpi
, GetDpiForWindow( hwnd
));
3279 /**********************************************************************
3282 RECT
map_dpi_rect( RECT rect
, UINT dpi_from
, UINT dpi_to
)
3284 if (dpi_from
&& dpi_to
&& dpi_from
!= dpi_to
)
3286 rect
.left
= MulDiv( rect
.left
, dpi_to
, dpi_from
);
3287 rect
.top
= MulDiv( rect
.top
, dpi_to
, dpi_from
);
3288 rect
.right
= MulDiv( rect
.right
, dpi_to
, dpi_from
);
3289 rect
.bottom
= MulDiv( rect
.bottom
, dpi_to
, dpi_from
);
3294 /**********************************************************************
3295 * rect_win_to_thread_dpi
3297 RECT
rect_win_to_thread_dpi( HWND hwnd
, RECT rect
)
3299 UINT dpi
= get_thread_dpi();
3300 if (!dpi
) dpi
= get_win_monitor_dpi( hwnd
);
3301 return map_dpi_rect( rect
, GetDpiForWindow( hwnd
), dpi
);
3304 /**********************************************************************
3305 * rect_thread_to_win_dpi
3307 RECT
rect_thread_to_win_dpi( HWND hwnd
, RECT rect
)
3309 UINT dpi
= get_thread_dpi();
3310 if (!dpi
) dpi
= get_win_monitor_dpi( hwnd
);
3311 return map_dpi_rect( rect
, dpi
, GetDpiForWindow( hwnd
) );
3314 /**********************************************************************
3315 * SetProcessDpiAwarenessContext (USER32.@)
3317 BOOL WINAPI
SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT context
)
3319 DPI_AWARENESS val
= GetAwarenessFromDpiAwarenessContext( context
);
3321 if (val
== DPI_AWARENESS_INVALID
)
3323 SetLastError( ERROR_INVALID_PARAMETER
);
3326 val
|= 0x10; /* avoid 0 value */
3327 if (InterlockedCompareExchange( &dpi_awareness
, val
, 0 ))
3329 SetLastError( ERROR_ACCESS_DENIED
);
3332 TRACE( "set to %p\n", context
);
3336 /**********************************************************************
3337 * GetProcessDpiAwarenessInternal (USER32.@)
3339 BOOL WINAPI
GetProcessDpiAwarenessInternal( HANDLE process
, DPI_AWARENESS
*awareness
)
3341 if (process
&& process
!= GetCurrentProcess())
3343 WARN( "not supported on other process %p\n", process
);
3344 *awareness
= DPI_AWARENESS_UNAWARE
;
3346 else *awareness
= dpi_awareness
& 3;
3350 /**********************************************************************
3351 * SetProcessDpiAwarenessInternal (USER32.@)
3353 BOOL WINAPI
SetProcessDpiAwarenessInternal( DPI_AWARENESS awareness
)
3355 static const DPI_AWARENESS_CONTEXT contexts
[3] = { DPI_AWARENESS_CONTEXT_UNAWARE
,
3356 DPI_AWARENESS_CONTEXT_SYSTEM_AWARE
,
3357 DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE
};
3359 if (awareness
< DPI_AWARENESS_UNAWARE
|| awareness
> DPI_AWARENESS_PER_MONITOR_AWARE
)
3361 SetLastError( ERROR_INVALID_PARAMETER
);
3364 return SetProcessDpiAwarenessContext( contexts
[awareness
] );
3367 /***********************************************************************
3368 * AreDpiAwarenessContextsEqual (USER32.@)
3370 BOOL WINAPI
AreDpiAwarenessContextsEqual( DPI_AWARENESS_CONTEXT ctx1
, DPI_AWARENESS_CONTEXT ctx2
)
3372 DPI_AWARENESS aware1
= GetAwarenessFromDpiAwarenessContext( ctx1
);
3373 DPI_AWARENESS aware2
= GetAwarenessFromDpiAwarenessContext( ctx2
);
3374 return aware1
!= DPI_AWARENESS_INVALID
&& aware1
== aware2
;
3377 /***********************************************************************
3378 * GetAwarenessFromDpiAwarenessContext (USER32.@)
3380 DPI_AWARENESS WINAPI
GetAwarenessFromDpiAwarenessContext( DPI_AWARENESS_CONTEXT context
)
3382 switch ((ULONG_PTR
)context
)
3390 return (ULONG_PTR
)context
& 3;
3391 case (ULONG_PTR
)DPI_AWARENESS_CONTEXT_UNAWARE
:
3392 case (ULONG_PTR
)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE
:
3393 case (ULONG_PTR
)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE
:
3394 return ~(ULONG_PTR
)context
;
3396 return DPI_AWARENESS_INVALID
;
3400 /***********************************************************************
3401 * IsValidDpiAwarenessContext (USER32.@)
3403 BOOL WINAPI
IsValidDpiAwarenessContext( DPI_AWARENESS_CONTEXT context
)
3405 return GetAwarenessFromDpiAwarenessContext( context
) != DPI_AWARENESS_INVALID
;
3408 /***********************************************************************
3409 * SetProcessDPIAware (USER32.@)
3411 BOOL WINAPI
SetProcessDPIAware(void)
3414 InterlockedCompareExchange( &dpi_awareness
, 0x11, 0 );
3418 /***********************************************************************
3419 * IsProcessDPIAware (USER32.@)
3421 BOOL WINAPI
IsProcessDPIAware(void)
3423 return GetAwarenessFromDpiAwarenessContext( GetThreadDpiAwarenessContext() ) != DPI_AWARENESS_UNAWARE
;
3426 /***********************************************************************
3427 * GetDpiForSystem (USER32.@)
3429 UINT WINAPI
GetDpiForSystem(void)
3431 if (!IsProcessDPIAware()) return USER_DEFAULT_SCREEN_DPI
;
3435 /***********************************************************************
3436 * GetDpiForMonitorInternal (USER32.@)
3438 BOOL WINAPI
GetDpiForMonitorInternal( HMONITOR monitor
, UINT type
, UINT
*x
, UINT
*y
)
3442 SetLastError( ERROR_BAD_ARGUMENTS
);
3447 SetLastError( ERROR_INVALID_ADDRESS
);
3450 switch (GetAwarenessFromDpiAwarenessContext( GetThreadDpiAwarenessContext() ))
3452 case DPI_AWARENESS_UNAWARE
: *x
= *y
= USER_DEFAULT_SCREEN_DPI
; break;
3453 case DPI_AWARENESS_SYSTEM_AWARE
: *x
= *y
= system_dpi
; break;
3454 default: *x
= *y
= get_monitor_dpi( monitor
); break;
3459 /**********************************************************************
3460 * GetThreadDpiAwarenessContext (USER32.@)
3462 DPI_AWARENESS_CONTEXT WINAPI
GetThreadDpiAwarenessContext(void)
3464 struct user_thread_info
*info
= get_user_thread_info();
3466 if (info
->dpi_awareness
) return ULongToHandle( info
->dpi_awareness
);
3467 if (dpi_awareness
) return ULongToHandle( dpi_awareness
);
3468 return ULongToHandle( 0x10 | default_awareness
);
3471 /**********************************************************************
3472 * SetThreadDpiAwarenessContext (USER32.@)
3474 DPI_AWARENESS_CONTEXT WINAPI
SetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT context
)
3476 struct user_thread_info
*info
= get_user_thread_info();
3477 DPI_AWARENESS prev
, val
= GetAwarenessFromDpiAwarenessContext( context
);
3479 if (val
== DPI_AWARENESS_INVALID
)
3481 SetLastError( ERROR_INVALID_PARAMETER
);
3484 if (!(prev
= info
->dpi_awareness
))
3486 prev
= dpi_awareness
;
3487 if (!prev
) prev
= 0x10 | DPI_AWARENESS_UNAWARE
;
3488 prev
|= 0x80000000; /* restore to process default */
3490 if (((ULONG_PTR
)context
& ~(ULONG_PTR
)0x13) == 0x80000000) info
->dpi_awareness
= 0;
3491 else info
->dpi_awareness
= val
| 0x10;
3492 return ULongToHandle( prev
);
3495 /**********************************************************************
3496 * LogicalToPhysicalPointForPerMonitorDPI (USER32.@)
3498 BOOL WINAPI
LogicalToPhysicalPointForPerMonitorDPI( HWND hwnd
, POINT
*pt
)
3502 if (!GetWindowRect( hwnd
, &rect
)) return FALSE
;
3503 if (pt
->x
< rect
.left
|| pt
->y
< rect
.top
|| pt
->x
> rect
.right
|| pt
->y
> rect
.bottom
) return FALSE
;
3504 *pt
= point_win_to_phys_dpi( hwnd
, *pt
);
3508 /**********************************************************************
3509 * PhysicalToLogicalPointForPerMonitorDPI (USER32.@)
3511 BOOL WINAPI
PhysicalToLogicalPointForPerMonitorDPI( HWND hwnd
, POINT
*pt
)
3513 DPI_AWARENESS_CONTEXT context
;
3517 context
= SetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE
);
3518 if (GetWindowRect( hwnd
, &rect
) &&
3519 pt
->x
>= rect
.left
&& pt
->y
>= rect
.top
&& pt
->x
<= rect
.right
&& pt
->y
<= rect
.bottom
)
3521 *pt
= point_phys_to_win_dpi( hwnd
, *pt
);
3524 SetThreadDpiAwarenessContext( context
);
3528 struct monitor_enum_info
3538 /* helper callback for MonitorFromRect */
3539 static BOOL CALLBACK
monitor_enum( HMONITOR monitor
, HDC hdc
, LPRECT rect
, LPARAM lp
)
3541 struct monitor_enum_info
*info
= (struct monitor_enum_info
*)lp
;
3544 if (IntersectRect( &intersect
, rect
, &info
->rect
))
3546 /* check for larger intersecting area */
3547 UINT area
= (intersect
.right
- intersect
.left
) * (intersect
.bottom
- intersect
.top
);
3548 if (area
> info
->max_area
)
3550 info
->max_area
= area
;
3551 info
->ret
= monitor
;
3554 else if (!info
->max_area
) /* if not intersecting, check for min distance */
3559 if (info
->rect
.right
<= rect
->left
) x
= rect
->left
- info
->rect
.right
;
3560 else if (rect
->right
<= info
->rect
.left
) x
= info
->rect
.left
- rect
->right
;
3562 if (info
->rect
.bottom
<= rect
->top
) y
= rect
->top
- info
->rect
.bottom
;
3563 else if (rect
->bottom
<= info
->rect
.top
) y
= info
->rect
.top
- rect
->bottom
;
3565 distance
= x
* x
+ y
* y
;
3566 if (distance
< info
->min_distance
)
3568 info
->min_distance
= distance
;
3569 info
->nearest
= monitor
;
3574 MONITORINFO mon_info
;
3575 mon_info
.cbSize
= sizeof(mon_info
);
3576 GetMonitorInfoW( monitor
, &mon_info
);
3577 if (mon_info
.dwFlags
& MONITORINFOF_PRIMARY
) info
->primary
= monitor
;
3582 /***********************************************************************
3583 * MonitorFromRect (USER32.@)
3585 HMONITOR WINAPI
MonitorFromRect( const RECT
*rect
, DWORD flags
)
3587 struct monitor_enum_info info
;
3591 info
.min_distance
= ~0u;
3596 if (IsRectEmpty(&info
.rect
))
3598 info
.rect
.right
= info
.rect
.left
+ 1;
3599 info
.rect
.bottom
= info
.rect
.top
+ 1;
3602 if (!EnumDisplayMonitors( 0, NULL
, monitor_enum
, (LPARAM
)&info
)) return 0;
3605 if (flags
& MONITOR_DEFAULTTOPRIMARY
) info
.ret
= info
.primary
;
3606 else if (flags
& MONITOR_DEFAULTTONEAREST
) info
.ret
= info
.nearest
;
3609 TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect
), flags
, info
.ret
);
3613 /***********************************************************************
3614 * MonitorFromPoint (USER32.@)
3616 HMONITOR WINAPI
MonitorFromPoint( POINT pt
, DWORD flags
)
3620 SetRect( &rect
, pt
.x
, pt
.y
, pt
.x
+ 1, pt
.y
+ 1 );
3621 return MonitorFromRect( &rect
, flags
);
3624 /***********************************************************************
3625 * MonitorFromWindow (USER32.@)
3627 HMONITOR WINAPI
MonitorFromWindow(HWND hWnd
, DWORD dwFlags
)
3632 TRACE("(%p, 0x%08x)\n", hWnd
, dwFlags
);
3634 wp
.length
= sizeof(wp
);
3635 if (IsIconic(hWnd
) && GetWindowPlacement(hWnd
, &wp
))
3636 return MonitorFromRect( &wp
.rcNormalPosition
, dwFlags
);
3638 if (GetWindowRect( hWnd
, &rect
))
3639 return MonitorFromRect( &rect
, dwFlags
);
3641 if (!(dwFlags
& (MONITOR_DEFAULTTOPRIMARY
|MONITOR_DEFAULTTONEAREST
))) return 0;
3642 /* retrieve the primary */
3643 SetRect( &rect
, 0, 0, 1, 1 );
3644 return MonitorFromRect( &rect
, dwFlags
);
3647 /***********************************************************************
3648 * GetMonitorInfoA (USER32.@)
3650 BOOL WINAPI
GetMonitorInfoA( HMONITOR monitor
, LPMONITORINFO info
)
3655 if (info
->cbSize
== sizeof(MONITORINFO
)) return GetMonitorInfoW( monitor
, info
);
3656 if (info
->cbSize
!= sizeof(MONITORINFOEXA
)) return FALSE
;
3658 miW
.cbSize
= sizeof(miW
);
3659 ret
= GetMonitorInfoW( monitor
, (MONITORINFO
*)&miW
);
3662 MONITORINFOEXA
*miA
= (MONITORINFOEXA
*)info
;
3663 miA
->rcMonitor
= miW
.rcMonitor
;
3664 miA
->rcWork
= miW
.rcWork
;
3665 miA
->dwFlags
= miW
.dwFlags
;
3666 WideCharToMultiByte(CP_ACP
, 0, miW
.szDevice
, -1, miA
->szDevice
, sizeof(miA
->szDevice
), NULL
, NULL
);
3671 /***********************************************************************
3672 * GetMonitorInfoW (USER32.@)
3674 BOOL WINAPI
GetMonitorInfoW( HMONITOR monitor
, LPMONITORINFO info
)
3677 UINT dpi_from
, dpi_to
;
3679 if (info
->cbSize
!= sizeof(MONITORINFOEXW
) && info
->cbSize
!= sizeof(MONITORINFO
)) return FALSE
;
3681 ret
= USER_Driver
->pGetMonitorInfo( monitor
, info
);
3684 if ((dpi_to
= get_thread_dpi()))
3686 dpi_from
= get_monitor_dpi( monitor
);
3687 info
->rcMonitor
= map_dpi_rect( info
->rcMonitor
, dpi_from
, dpi_to
);
3688 info
->rcWork
= map_dpi_rect( info
->rcWork
, dpi_from
, dpi_to
);
3690 TRACE( "flags %04x, monitor %s, work %s\n", info
->dwFlags
,
3691 wine_dbgstr_rect(&info
->rcMonitor
), wine_dbgstr_rect(&info
->rcWork
));
3696 struct enum_mon_data
3698 MONITORENUMPROC proc
;
3706 /* Some apps pass a non-stdcall callback to EnumDisplayMonitors,
3707 * so we need a small assembly wrapper to call it.
3708 * MJ's Help Diagnostic expects that %ecx contains the address to the rect.
3710 extern BOOL
enum_mon_callback_wrapper( HMONITOR monitor
, LPRECT rect
, struct enum_mon_data
*data
);
3711 __ASM_GLOBAL_FUNC( enum_mon_callback_wrapper
,
3713 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
3714 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
3715 "movl %esp,%ebp\n\t"
3716 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
3718 "movl 16(%ebp),%eax\n\t" /* data */
3719 "movl 12(%ebp),%ecx\n\t" /* rect */
3720 "pushl 4(%eax)\n\t" /* data->lparam */
3721 "pushl %ecx\n\t" /* rect */
3722 "pushl 8(%eax)\n\t" /* data->hdc */
3723 "pushl 8(%ebp)\n\t" /* monitor */
3724 "call *(%eax)\n\t" /* data->proc */
3726 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
3727 __ASM_CFI(".cfi_same_value %ebp\n\t")
3729 #endif /* __i386__ */
3731 static BOOL CALLBACK
enum_mon_callback( HMONITOR monitor
, HDC hdc
, LPRECT rect
, LPARAM lp
)
3733 struct enum_mon_data
*data
= (struct enum_mon_data
*)lp
;
3734 RECT monrect
= map_dpi_rect( *rect
, get_monitor_dpi( monitor
), get_thread_dpi() );
3736 OffsetRect( &monrect
, -data
->origin
.x
, -data
->origin
.y
);
3737 if (!IntersectRect( &monrect
, &monrect
, &data
->limit
)) return TRUE
;
3739 return enum_mon_callback_wrapper( monitor
, &monrect
, data
);
3741 return data
->proc( monitor
, data
->hdc
, &monrect
, data
->lparam
);
3745 /***********************************************************************
3746 * EnumDisplayMonitors (USER32.@)
3748 BOOL WINAPI
EnumDisplayMonitors( HDC hdc
, LPRECT rect
, MONITORENUMPROC proc
, LPARAM lp
)
3750 struct enum_mon_data data
;
3758 if (!GetDCOrgEx( hdc
, &data
.origin
)) return FALSE
;
3759 if (GetClipBox( hdc
, &data
.limit
) == ERROR
) return FALSE
;
3763 data
.origin
.x
= data
.origin
.y
= 0;
3764 data
.limit
.left
= data
.limit
.top
= INT_MIN
;
3765 data
.limit
.right
= data
.limit
.bottom
= INT_MAX
;
3767 if (rect
&& !IntersectRect( &data
.limit
, &data
.limit
, rect
)) return TRUE
;
3768 return USER_Driver
->pEnumDisplayMonitors( 0, NULL
, enum_mon_callback
, (LPARAM
)&data
);
3772 /**********************************************************************
3773 * GetAutoRotationState [USER32.@]
3775 BOOL WINAPI
GetAutoRotationState( AR_STATE
*state
)
3777 TRACE("(%p)\n", state
);
3781 SetLastError(ERROR_INVALID_PARAMETER
);
3785 *state
= AR_NOSENSOR
;
3789 /**********************************************************************
3790 * GetDisplayAutoRotationPreferences [USER32.@]
3792 BOOL WINAPI
GetDisplayAutoRotationPreferences( ORIENTATION_PREFERENCE
*orientation
)
3794 FIXME("(%p): stub\n", orientation
);
3795 *orientation
= ORIENTATION_PREFERENCE_NONE
;
3799 /* physical<->logical mapping functions from win8 that are nops in later versions */
3801 /***********************************************************************
3802 * GetPhysicalCursorPos (USER32.@)
3804 BOOL WINAPI
GetPhysicalCursorPos( POINT
*point
)
3806 return GetCursorPos( point
);
3809 /***********************************************************************
3810 * SetPhysicalCursorPos (USER32.@)
3812 BOOL WINAPI
SetPhysicalCursorPos( INT x
, INT y
)
3814 return SetCursorPos( x
, y
);
3817 /***********************************************************************
3818 * LogicalToPhysicalPoint (USER32.@)
3820 BOOL WINAPI
LogicalToPhysicalPoint( HWND hwnd
, POINT
*point
)
3825 /***********************************************************************
3826 * PhysicalToLogicalPoint (USER32.@)
3828 BOOL WINAPI
PhysicalToLogicalPoint( HWND hwnd
, POINT
*point
)