?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Implement SPI_{GET,SET}POWEROFFACTIVE and SPI_SETLOWPOWERACTIVE.
[wine/multimedia.git] / dlls / user / sysparams.c
blob2f39db9cb0473530b38dcd8dd38314e23b6dfa61
1 /*
2 * System parameters functions
3 *
4 * Copyright 1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winnls.h"
31 #include "wingdi.h"
32 #include "winreg.h"
33 #include "wine/winuser16.h"
34 #include "winerror.h"
35
36 #include "controls.h"
37 #include "user_private.h"
38 #include "wine/unicode.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(system);
42
43 /* System parameter indexes */
44 #define SPI_SETBEEP_IDX 0
45 #define SPI_SETMOUSE_IDX 1
46 #define SPI_SETBORDER_IDX 2
47 #define SPI_SETKEYBOARDSPEED_IDX 3
48 #define SPI_ICONHORIZONTALSPACING_IDX 4
49 #define SPI_SETSCREENSAVETIMEOUT_IDX 5
50 #define SPI_SETGRIDGRANULARITY_IDX 6
51 #define SPI_SETKEYBOARDDELAY_IDX 7
52 #define SPI_ICONVERTICALSPACING_IDX 8
53 #define SPI_SETICONTITLEWRAP_IDX 9
54 #define SPI_SETMENUDROPALIGNMENT_IDX 10
55 #define SPI_SETDOUBLECLKWIDTH_IDX 11
56 #define SPI_SETDOUBLECLKHEIGHT_IDX 12
57 #define SPI_SETDOUBLECLICKTIME_IDX 13
58 #define SPI_SETMOUSEBUTTONSWAP_IDX 14
59 #define SPI_SETDRAGFULLWINDOWS_IDX 15
60 #define SPI_SETWORKAREA_IDX 16
61 #define SPI_SETSHOWSOUNDS_IDX 17
62 #define SPI_SETKEYBOARDPREF_IDX 18
63 #define SPI_SETSCREENREADER_IDX 19
64 #define SPI_SETSCREENSAVERRUNNING_IDX 20
65 #define SPI_SETFONTSMOOTHING_IDX 21
66 #define SPI_SETKEYBOARDCUES_IDX 22
67 #define SPI_SETGRADIENTCAPTIONS_IDX 23
68 #define SPI_SETHOTTRACKING_IDX 24
69 #define SPI_SETLISTBOXSMOOTHSCROLLING_IDX 25
70 #define SPI_SETMOUSEHOVERWIDTH_IDX 26
71 #define SPI_SETMOUSEHOVERHEIGHT_IDX 27
72 #define SPI_SETMOUSEHOVERTIME_IDX 28
73 #define SPI_SETMOUSESCROLLLINES_IDX 29
74 #define SPI_SETMENUSHOWDELAY_IDX 30
75 #define SPI_SETICONTITLELOGFONT_IDX 31
76 #define SPI_SETLOWPOWERACTIVE_IDX 32
77 #define SPI_SETPOWEROFFACTIVE_IDX 33
78
79 #define SPI_WINE_IDX SPI_SETPOWEROFFACTIVE_IDX
80
81 /**
82 * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
83 * for the system parameters.
84 * Names of the keys are created by adding string "_REGKEY" to
85 * "SET" action names, value names are created by adding "_REG_NAME"
86 * to the "SET" action name.
87 */
88 static const WCHAR SPI_SETBEEP_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','S','o','u','n','d',0};
89 static const WCHAR SPI_SETBEEP_VALNAME[]= {'B','e','e','p',0};
90 static const WCHAR SPI_SETMOUSE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
91 static const WCHAR SPI_SETMOUSE_VALNAME1[]= {'M','o','u','s','e','T','h','r','e','s','h','o','l','d','1',0};
92 static const WCHAR SPI_SETMOUSE_VALNAME2[]= {'M','o','u','s','e','T','h','r','e','s','h','o','l','d','2',0};
93 static const WCHAR SPI_SETMOUSE_VALNAME3[]= {'M','o','u','s','e','S','p','e','e','d',0};
94 static const WCHAR SPI_SETBORDER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
95 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
96 static const WCHAR SPI_SETBORDER_VALNAME[]= {'B','o','r','d','e','r','W','i','d','t','h',0};
97 static const WCHAR SPI_SETKEYBOARDSPEED_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
98 static const WCHAR SPI_SETKEYBOARDSPEED_VALNAME[]= {'K','e','y','b','o','a','r','d','S','p','e','e','d',0};
99 static const WCHAR SPI_ICONHORIZONTALSPACING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
100 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
101 static const WCHAR SPI_ICONHORIZONTALSPACING_VALNAME[]= {'I','c','o','n','S','p','a','c','i','n','g',0};
102 static const WCHAR SPI_SETSCREENSAVETIMEOUT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
103 static const WCHAR SPI_SETSCREENSAVETIMEOUT_VALNAME[]= {'S','c','r','e','e','n','S','a','v','e','T','i','m','e','O','u','t',0};
104 static const WCHAR SPI_SETSCREENSAVEACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
105 static const WCHAR SPI_SETSCREENSAVEACTIVE_VALNAME[]= {'S','c','r','e','e','n','S','a','v','e','A','c','t','i','v','e',0};
106 static const WCHAR SPI_SETGRIDGRANULARITY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
107 static const WCHAR SPI_SETGRIDGRANULARITY_VALNAME[]= {'G','r','i','d','G','r','a','n','u','l','a','r','i','t','y',0};
108 static const WCHAR SPI_SETKEYBOARDDELAY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','K','e','y','b','o','a','r','d',0};
109 static const WCHAR SPI_SETKEYBOARDDELAY_VALNAME[]= {'K','e','y','b','o','a','r','d','D','e','l','a','y',0};
110 static const WCHAR SPI_ICONVERTICALSPACING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
111 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
112 static const WCHAR SPI_ICONVERTICALSPACING_VALNAME[]= {'I','c','o','n','V','e','r','t','i','c','a','l','S','p','a','c','i','n','g',0};
113 static const WCHAR SPI_SETICONTITLEWRAP_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
114 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
115 static const WCHAR SPI_SETICONTITLEWRAP_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
116 static const WCHAR SPI_SETICONTITLEWRAP_VALNAME[]= {'I','c','o','n','T','i','t','l','e','W','r','a','p',0};
117 static const WCHAR SPI_SETMENUDROPALIGNMENT_REGKEY1[]= {'S','o','f','t','w','a','r','e','\\',
118 'M','i','c','r','o','s','o','f','t','\\',
119 'W','i','n','d','o','w','s',' ','N','T','\\',
120 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
121 'W','i','n','d','o','w','s',0};
122 static const WCHAR SPI_SETMENUDROPALIGNMENT_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
123 static const WCHAR SPI_SETMENUDROPALIGNMENT_VALNAME[]= {'M','e','n','u','D','r','o','p','A','l','i','g','n','m','e','n','t',0};
124 static const WCHAR SPI_SETDOUBLECLKWIDTH_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
125 static const WCHAR SPI_SETDOUBLECLKWIDTH_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
126 static const WCHAR SPI_SETDOUBLECLKWIDTH_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','W','i','d','t','h',0};
127 static const WCHAR SPI_SETDOUBLECLKHEIGHT_REGKEY1[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
128 static const WCHAR SPI_SETDOUBLECLKHEIGHT_REGKEY2[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
129 static const WCHAR SPI_SETDOUBLECLKHEIGHT_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','H','e','i','g','h','t',0};
130 static const WCHAR SPI_SETDOUBLECLICKTIME_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
131 static const WCHAR SPI_SETDOUBLECLICKTIME_VALNAME[]= {'D','o','u','b','l','e','C','l','i','c','k','S','p','e','e','d',0};
132 static const WCHAR SPI_SETMOUSEBUTTONSWAP_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
133 static const WCHAR SPI_SETMOUSEBUTTONSWAP_VALNAME[]= {'S','w','a','p','M','o','u','s','e','B','u','t','t','o','n','s',0};
134 static const WCHAR SPI_SETDRAGFULLWINDOWS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
135 static const WCHAR SPI_SETDRAGFULLWINDOWS_VALNAME[]= {'D','r','a','g','F','u','l','l','W','i','n','d','o','w','s',0};
136 static const WCHAR SPI_SETSHOWSOUNDS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
137 'A','c','c','e','s','s','i','b','i','l','i','t','y','\\',
138 'S','h','o','w','S','o','u','n','d','s',0};
139 static const WCHAR SPI_SETSHOWSOUNDS_VALNAME[]= {'O','n',0};
140 static const WCHAR SPI_SETDESKWALLPAPER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
141 static const WCHAR SPI_SETDESKWALLPAPER_VALNAME[]= {'W','a','l','l','p','a','p','e','r',0};
142 static const WCHAR SPI_SETFONTSMOOTHING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
143 static const WCHAR SPI_SETFONTSMOOTHING_VALNAME[]= {'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
144 static const WCHAR SPI_SETLOWPOWERACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
145 static const WCHAR SPI_SETLOWPOWERACTIVE_VALNAME[]= {'L','o','w','P','o','w','e','r','A','c','t','i','v','e',0};
146 static const WCHAR SPI_SETPOWEROFFACTIVE_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
147 static const WCHAR SPI_SETPOWEROFFACTIVE_VALNAME[]= {'P','o','w','e','r','O','f','f','A','c','t','i','v','e',0};
148 static const WCHAR SPI_USERPREFERENCEMASK_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
149 static const WCHAR SPI_USERPREFERENCEMASK_VALNAME[]= {'U','s','e','r','P','r','e','f','e','r','e','n','c','e','m','a','s','k',0};
150 static const WCHAR SPI_SETLISTBOXSMOOTHSCROLLING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
151 static const WCHAR SPI_SETLISTBOXSMOOTHSCROLLING_VALNAME[]= {'S','m','o','o','t','h','S','c','r','o','l','l',0};
152 static const WCHAR SPI_SETMOUSEHOVERWIDTH_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
153 static const WCHAR SPI_SETMOUSEHOVERWIDTH_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','W','i','d','t','h',0};
154 static const WCHAR SPI_SETMOUSEHOVERHEIGHT_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
155 static const WCHAR SPI_SETMOUSEHOVERHEIGHT_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','H','e','i','g','h','t',0};
156 static const WCHAR SPI_SETMOUSEHOVERTIME_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','M','o','u','s','e',0};
157 static const WCHAR SPI_SETMOUSEHOVERTIME_VALNAME[]= {'M','o','u','s','e','H','o','v','e','r','T','i','m','e',0};
158 static const WCHAR SPI_SETMOUSESCROLLLINES_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
159 static const WCHAR SPI_SETMOUSESCROLLLINES_VALNAME[]= {'W','h','e','e','l','S','c','r','o','l','l','L','i','n','e','s',0};
160 static const WCHAR SPI_SETMENUSHOWDELAY_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
161 static const WCHAR SPI_SETMENUSHOWDELAY_VALNAME[]= {'M','e','n','u','S','h','o','w','D','e','l','a','y',0};
162
163 /* FIXME - real values */
164 static const WCHAR SPI_SETKEYBOARDPREF_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
165 static const WCHAR SPI_SETKEYBOARDPREF_VALNAME[]= {'W','I','N','E','_','K','e','y','b','o','a','r','d','P','r','e','f',0};
166 static const WCHAR SPI_SETSCREENREADER_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
167 static const WCHAR SPI_SETSCREENREADER_VALNAME[]= {'W','I','N','E','_','S','c','r','e','e','n','R','e','a','d','e','r',0};
168 static const WCHAR SPI_SETSCREENSAVERRUNNING_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p',0};
169 static const WCHAR SPI_SETSCREENSAVERRUNNING_VALNAME[]= {'W','I','N','E','_','S','c','r','e','e','n','S','a','v','e','r','R','u','n','n','i','n','g',0};
170
171 static const WCHAR METRICS_REGKEY[]= {'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\','D','e','s','k','t','o','p','\\',
172 'W','i','n','d','o','w','M','e','t','r','i','c','s',0};
173 static const WCHAR METRICS_SCROLLWIDTH_VALNAME[]= {'S','c','r','o','l','l','W','i','d','t','h',0};
174 static const WCHAR METRICS_SCROLLHEIGHT_VALNAME[]= {'S','c','r','o','l','l','H','e','i','g','h','t',0};
175 static const WCHAR METRICS_CAPTIONWIDTH_VALNAME[]= {'C','a','p','t','i','o','n','W','i','d','t','h',0};
176 static const WCHAR METRICS_CAPTIONHEIGHT_VALNAME[]= {'C','a','p','t','i','o','n','H','e','i','g','h','t',0};
177 static const WCHAR METRICS_SMCAPTIONWIDTH_VALNAME[]= {'S','m','C','a','p','t','i','o','n','W','i','d','t','h',0};
178 static const WCHAR METRICS_SMCAPTIONHEIGHT_VALNAME[]= {'S','m','C','a','p','t','i','o','n','H','e','i','g','h','t',0};
179 static const WCHAR METRICS_MENUWIDTH_VALNAME[]= {'M','e','n','u','W','i','d','t','h',0};
180 static const WCHAR METRICS_MENUHEIGHT_VALNAME[]= {'M','e','n','u','H','e','i','g','h','t',0};
181 static const WCHAR METRICS_ICONSIZE_VALNAME[]= {'S','h','e','l','l',' ','I','c','o','n',' ','S','i','z','e',0};
182 static const WCHAR METRICS_BORDERWIDTH_VALNAME[]= {'B','o','r','d','e','r','W','i','d','t','h',0};
183
184 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
185 static const WCHAR WINE_CURRENT_USER_REGKEY[] = {'W','i','n','e',0};
186
187
188 static const WCHAR Yes[]= {'Y','e','s',0};
189 static const WCHAR No[]= {'N','o',0};
190 static const WCHAR Desktop[]= {'D','e','s','k','t','o','p',0};
191 static const WCHAR Pattern[]= {'P','a','t','t','e','r','n',0};
192 static const WCHAR MenuFont[]= {'M','e','n','u','F','o','n','t',0};
193 static const WCHAR MenuFontSize[]= {'M','e','n','u','F','o','n','t','S','i','z','e',0};
194 static const WCHAR StatusFont[]= {'S','t','a','t','u','s','F','o','n','t',0};
195 static const WCHAR StatusFontSize[]= {'S','t','a','t','u','s','F','o','n','t','S','i','z','e',0};
196 static const WCHAR MessageFont[]= {'M','e','s','s','a','g','e','F','o','n','t',0};
197 static const WCHAR MessageFontSize[]= {'M','e','s','s','a','g','e','F','o','n','t','S','i','z','e',0};
198 static const WCHAR System[]= {'S','y','s','t','e','m',0};
199 static const WCHAR IconTitleSize[]= {'I','c','o','n','T','i','t','l','e','S','i','z','e',0};
200 static const WCHAR IconTitleFaceName[]= {'I','c','o','n','T','i','t','l','e','F','a','c','e','N','a','m','e',0};
201 static const WCHAR defPattern[]= {'1','7','0',' ','8','5',' ','1','7','0',' ','8','5',' ','1','7','0',' ','8','5',
202 ' ','1','7','0',' ','8','5',0};
203 static const WCHAR CSu[]= {'%','u',0};
204 static const WCHAR CSd[]= {'%','d',0};
205 static const WCHAR DISPLAY[]= {'D','I','S','P','L','A','Y',0};
206
207 /* Indicators whether system parameter value is loaded */
208 static char spi_loaded[SPI_WINE_IDX + 1];
209
210 static BOOL notify_change = TRUE;
211
212 /* System parameters storage */
213 static int sysMetrics[SM_CMETRICS+1];
214 static HDC display_dc;
215 static BOOL beep_active = TRUE;
216 static int mouse_threshold1 = 6;
217 static int mouse_threshold2 = 10;
218 static int mouse_speed = 1;
219 static int border = 1;
220 static int keyboard_speed = 31;
221 static int screensave_timeout = 300;
222 static int grid_granularity = 0;
223 static int keyboard_delay = 1;
224 static BOOL icon_title_wrap = TRUE;
225 static int double_click_time = 500;
226 static BOOL drag_full_windows = FALSE;
227 static RECT work_area;
228 static BOOL keyboard_pref = TRUE;
229 static BOOL screen_reader = FALSE;
230 static int mouse_hover_width = 4;
231 static int mouse_hover_height = 4;
232 static int mouse_hover_time = 400;
233 static int mouse_scroll_lines = 3;
234 static int menu_show_delay = 400;
235 static BOOL screensaver_running = FALSE;
236 static BOOL font_smoothing = FALSE;
237 static BOOL lowpoweractive = FALSE;
238 static BOOL poweroffactive = FALSE;
239 static BOOL keyboard_cues = FALSE;
240 static BOOL gradient_captions = FALSE;
241 static BOOL listbox_smoothscrolling = FALSE;
242 static BOOL hot_tracking = FALSE;
243 static LOGFONTW log_font = { -11,0,0,0,FW_NORMAL,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH };
244
245 /***********************************************************************
246 * GetTimerResolution (USER.14)
247 */
248 LONG WINAPI GetTimerResolution16(void)
249 {
250 return (1000);
251 }
252
253 /***********************************************************************
254 * ControlPanelInfo (USER.273)
255 */
256 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
257 {
258 FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
259 }
260
261 /* This function is a copy of the one in objects/font.c */
262 static void SYSPARAMS_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
263 {
264 font16->lfHeight = font32->lfHeight;
265 font16->lfWidth = font32->lfWidth;
266 font16->lfEscapement = font32->lfEscapement;
267 font16->lfOrientation = font32->lfOrientation;
268 font16->lfWeight = font32->lfWeight;
269 font16->lfItalic = font32->lfItalic;
270 font16->lfUnderline = font32->lfUnderline;
271 font16->lfStrikeOut = font32->lfStrikeOut;
272 font16->lfCharSet = font32->lfCharSet;
273 font16->lfOutPrecision = font32->lfOutPrecision;
274 font16->lfClipPrecision = font32->lfClipPrecision;
275 font16->lfQuality = font32->lfQuality;
276 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
277 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
278 }
279
280 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW* font32W, LPLOGFONTA font32A )
281 {
282 font32A->lfHeight = font32W->lfHeight;
283 font32A->lfWidth = font32W->lfWidth;
284 font32A->lfEscapement = font32W->lfEscapement;
285 font32A->lfOrientation = font32W->lfOrientation;
286 font32A->lfWeight = font32W->lfWeight;
287 font32A->lfItalic = font32W->lfItalic;
288 font32A->lfUnderline = font32W->lfUnderline;
289 font32A->lfStrikeOut = font32W->lfStrikeOut;
290 font32A->lfCharSet = font32W->lfCharSet;
291 font32A->lfOutPrecision = font32W->lfOutPrecision;
292 font32A->lfClipPrecision = font32W->lfClipPrecision;
293 font32A->lfQuality = font32W->lfQuality;
294 font32A->lfPitchAndFamily = font32W->lfPitchAndFamily;
295 WideCharToMultiByte( CP_ACP, 0, font32W->lfFaceName, -1, font32A->lfFaceName, LF_FACESIZE, NULL, NULL );
296 font32A->lfFaceName[LF_FACESIZE-1] = 0;
297 }
298
299 static void SYSPARAMS_NonClientMetrics32ATo16( const NONCLIENTMETRICSA* lpnm32, LPNONCLIENTMETRICS16 lpnm16 )
300 {
301 lpnm16->iBorderWidth = lpnm32->iBorderWidth;
302 lpnm16->iScrollWidth = lpnm32->iScrollWidth;
303 lpnm16->iScrollHeight = lpnm32->iScrollHeight;
304 lpnm16->iCaptionWidth = lpnm32->iCaptionWidth;
305 lpnm16->iCaptionHeight = lpnm32->iCaptionHeight;
306 SYSPARAMS_LogFont32ATo16( &lpnm32->lfCaptionFont, &lpnm16->lfCaptionFont );
307 lpnm16->iSmCaptionWidth = lpnm32->iSmCaptionWidth;
308 lpnm16->iSmCaptionHeight = lpnm32->iSmCaptionHeight;
309 SYSPARAMS_LogFont32ATo16( &lpnm32->lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
310 lpnm16->iMenuWidth = lpnm32->iMenuWidth;
311 lpnm16->iMenuHeight = lpnm32->iMenuHeight;
312 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMenuFont, &lpnm16->lfMenuFont );
313 SYSPARAMS_LogFont32ATo16( &lpnm32->lfStatusFont, &lpnm16->lfStatusFont );
314 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMessageFont, &lpnm16->lfMessageFont );
315 }
316
317 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW* lpnm32W, LPNONCLIENTMETRICSA lpnm32A )
318 {
319 lpnm32A->iBorderWidth = lpnm32W->iBorderWidth;
320 lpnm32A->iScrollWidth = lpnm32W->iScrollWidth;
321 lpnm32A->iScrollHeight = lpnm32W->iScrollHeight;
322 lpnm32A->iCaptionWidth = lpnm32W->iCaptionWidth;
323 lpnm32A->iCaptionHeight = lpnm32W->iCaptionHeight;
324 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfCaptionFont, &lpnm32A->lfCaptionFont );
325 lpnm32A->iSmCaptionWidth = lpnm32W->iSmCaptionWidth;
326 lpnm32A->iSmCaptionHeight = lpnm32W->iSmCaptionHeight;
327 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfSmCaptionFont, &lpnm32A->lfSmCaptionFont );
328 lpnm32A->iMenuWidth = lpnm32W->iMenuWidth;
329 lpnm32A->iMenuHeight = lpnm32W->iMenuHeight;
330 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMenuFont, &lpnm32A->lfMenuFont );
331 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfStatusFont, &lpnm32A->lfStatusFont );
332 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMessageFont, &lpnm32A->lfMessageFont );
333 }
334
335 /***********************************************************************
336 * SYSPARAMS_Reset
337 *
338 * Sets the system parameter which should be always loaded to
339 * current value stored in registry.
340 * Invalidates lazy loaded parameter, so it will be loaded the next time
341 * it is requested.
342 *
343 * Parameters:
344 * uiAction - system parameter to reload value for.
345 * Note, only "SET" values can be used for this parameter.
346 * If uiAction is 0 all system parameters are reset.
347 */
348 void SYSPARAMS_Reset( UINT uiAction )
349 {
350 #define WINE_RELOAD_SPI(x) \
351 case x: \
352 spi_loaded[x##_IDX] = FALSE; \
353 SystemParametersInfoA( x, 0, dummy_buf, 0 );\
354 if (uiAction) \
355 break
356
357 #define WINE_IGNORE_SPI(x) \
358 case x: \
359 if (uiAction) \
360 break
361
362 #define WINE_INVALIDATE_SPI(x) \
363 case x: \
364 spi_loaded[x##_IDX] = FALSE; \
365 break
366
367 BOOL not_all_processed = TRUE;
368 char dummy_buf[10];
369
370 /* Execution falls through all the branches for uiAction == 0 */
371 switch (uiAction)
372 {
373 case 0:
374 memset( spi_loaded, 0, sizeof(spi_loaded) );
375
376 WINE_RELOAD_SPI(SPI_SETBORDER);
377 WINE_RELOAD_SPI(SPI_ICONHORIZONTALSPACING);
378 WINE_RELOAD_SPI(SPI_ICONVERTICALSPACING);
379 WINE_IGNORE_SPI(SPI_SETSCREENSAVEACTIVE);
380 WINE_RELOAD_SPI(SPI_SETDOUBLECLKWIDTH);
381 WINE_RELOAD_SPI(SPI_SETDOUBLECLKHEIGHT);
382 WINE_RELOAD_SPI(SPI_SETMOUSEBUTTONSWAP);
383 WINE_RELOAD_SPI(SPI_SETSHOWSOUNDS);
384 WINE_RELOAD_SPI(SPI_SETMENUDROPALIGNMENT);
385
386 default:
387 if (uiAction)
388 {
389 /* lazy loaded parameters */
390 switch (uiAction)
391 {
392 WINE_INVALIDATE_SPI(SPI_SETBEEP);
393 WINE_INVALIDATE_SPI(SPI_SETMOUSE);
394 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDSPEED);
395 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVETIMEOUT);
396 WINE_INVALIDATE_SPI(SPI_SETGRIDGRANULARITY);
397 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDDELAY);
398 WINE_INVALIDATE_SPI(SPI_SETICONTITLEWRAP);
399 WINE_INVALIDATE_SPI(SPI_SETDOUBLECLICKTIME);
400 WINE_INVALIDATE_SPI(SPI_SETDRAGFULLWINDOWS);
401 WINE_INVALIDATE_SPI(SPI_SETWORKAREA);
402 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDPREF);
403 WINE_INVALIDATE_SPI(SPI_SETSCREENREADER);
404 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVERRUNNING);
405 default:
406 FIXME( "Unknown action reset: %u\n", uiAction );
407 break;
408 }
409 }
410 else
411 not_all_processed = FALSE;
412 break;
413 }
414
415 if (!uiAction && not_all_processed)
416 ERR( "Incorrect implementation of SYSPARAMS_Reset. "
417 "Not all params are reloaded.\n" );
418 #undef WINE_INVALIDATE_SPI
419 #undef WINE_IGNORE_SPI
420 #undef WINE_RELOAD_SPI
421 }
422
423 /***********************************************************************
424 * get_volatile_regkey
425 *
426 * Return a handle to the volatile registry key used to store
427 * non-permanently modified parameters.
428 */
429 static HKEY get_volatile_regkey(void)
430 {
431 static HKEY volatile_key;
432
433 if (!volatile_key)
434 {
435 if (RegCreateKeyExW( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
436 0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
437 &volatile_key, 0 ) != ERROR_SUCCESS)
438 ERR("Can't create wine configuration registry branch\n");
439 }
440 return volatile_key;
441 }
442
443 /***********************************************************************
444 * SYSPARAMS_NotifyChange
445 *
446 * Sends notification about system parameter update.
447 */
448 void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
449 {
450 static const WCHAR emptyW[1];
451
452 if (notify_change)
453 {
454 if (fWinIni & SPIF_UPDATEINIFILE)
455 {
456 if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
457 SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE,
458 uiAction, (LPARAM) emptyW,
459 SMTO_ABORTIFHUNG, 2000, NULL );
460 }
461 else
462 {
463 /* FIXME notify other wine processes with internal message */
464 }
465 }
466 }
467
468
469 /***********************************************************************
470 * Loads system parameter from user profile.
471 */
472 static BOOL SYSPARAMS_Load( LPCWSTR lpRegKey, LPCWSTR lpValName, LPWSTR lpBuf, DWORD count )
473 {
474 BOOL ret = FALSE;
475 DWORD type;
476 HKEY hKey;
477
478 if ((RegOpenKeyW( get_volatile_regkey(), lpRegKey, &hKey ) == ERROR_SUCCESS) ||
479 (RegOpenKeyW( HKEY_CURRENT_USER, lpRegKey, &hKey ) == ERROR_SUCCESS))
480 {
481 ret = !RegQueryValueExW( hKey, lpValName, NULL, &type, (LPBYTE)lpBuf, &count);
482 RegCloseKey( hKey );
483 }
484 return ret;
485 }
486
487 /***********************************************************************
488 * Saves system parameter to user profile.
489 */
490 static BOOL SYSPARAMS_Save( LPCWSTR lpRegKey, LPCWSTR lpValName, LPCWSTR lpValue,
491 UINT fWinIni )
492 {
493 HKEY hKey;
494 HKEY hBaseKey;
495 DWORD dwOptions;
496 BOOL ret = FALSE;
497
498 if (fWinIni & SPIF_UPDATEINIFILE)
499 {
500 hBaseKey = HKEY_CURRENT_USER;
501 dwOptions = 0;
502 }
503 else
504 {
505 hBaseKey = get_volatile_regkey();
506 dwOptions = REG_OPTION_VOLATILE;
507 }
508
509 if (RegCreateKeyExW( hBaseKey, lpRegKey,
510 0, 0, dwOptions, KEY_ALL_ACCESS,
511 0, &hKey, 0 ) == ERROR_SUCCESS)
512 {
513 if (RegSetValueExW( hKey, lpValName, 0, REG_SZ,
514 (const BYTE*)lpValue,
515 (strlenW(lpValue) + 1)*sizeof(WCHAR)) == ERROR_SUCCESS)
516 {
517 ret = TRUE;
518 if (hBaseKey == HKEY_CURRENT_USER)
519 RegDeleteKeyW( get_volatile_regkey(), lpRegKey );
520 }
521 RegCloseKey( hKey );
522 }
523 return ret;
524 }
525
526
527 /***********************************************************************
528 * SYSPARAMS_Twips2Pixels
529 *
530 * Convert a dimension value that was obtained from the registry. These are
531 * quoted as being "twips" values if negative and pixels if positive.
532 * See for example
533 * MSDN Library - April 2001 -> Resource Kits ->
534 * Windows 2000 Resource Kit Reference ->
535 * Technical Reference to the Windows 2000 Registry ->
536 * HKEY_CURRENT_USER -> Control Panel -> Desktop -> WindowMetrics
537 */
538 inline static int SYSPARAMS_Twips2Pixels(int x)
539 {
540 if (x < 0)
541 x = (-x+7)/15;
542 return x;
543 }
544
545 /***********************************************************************
546 * SYSPARAMS_GetRegistryMetric
547 *
548 * Get a registry entry from the already open key. This allows us to open the
549 * section once and read several values.
550 *
551 * Of course this function belongs somewhere more usable but here will do
552 * for now.
553 */
554 static int SYSPARAMS_GetRegistryMetric( HKEY hkey, LPCWSTR lpValName, int default_value )
555 {
556 int value = default_value;
557 if (hkey)
558 {
559 WCHAR buffer[128];
560 DWORD type, count = sizeof(buffer);
561 if(!RegQueryValueExW( hkey, lpValName, NULL, &type, (LPBYTE)buffer, &count) )
562 {
563 if (type != REG_SZ)
564 {
565 /* Are there any utilities for converting registry entries
566 * between formats?
567 */
568 /* FIXME_(reg)("We need reg format converter\n"); */
569 }
570 else
571 value = atoiW(buffer);
572 }
573 }
574 return SYSPARAMS_Twips2Pixels(value);
575 }
576
577
578 /***********************************************************************
579 * SYSPARAMS_Init
580 *
581 * Initialisation of the system metrics array.
582 *
583 * Differences in return values between 3.1 and 95 apps under Win95 (FIXME ?):
584 * SM_CXVSCROLL x+1 x Fixed May 24, 1999 - Ronald B. Cemer
585 * SM_CYHSCROLL x+1 x Fixed May 24, 1999 - Ronald B. Cemer
586 * SM_CXDLGFRAME x-1 x Already fixed
587 * SM_CYDLGFRAME x-1 x Already fixed
588 * SM_CYCAPTION x+1 x Fixed May 24, 1999 - Ronald B. Cemer
589 * SM_CYMENU x-1 x Already fixed
590 * SM_CYFULLSCREEN x-1 x
591 * SM_CXFRAME Fixed July 6, 2001 - Bill Medland
592 *
593 * Starting at Win95 there are now a large number or Registry entries in the
594 * [WindowMetrics] section that are probably relevant here.
595 */
596 void SYSPARAMS_Init(void)
597 {
598 HKEY hkey; /* key to the window metrics area of the registry */
599 WCHAR buf[10];
600 INT border;
601
602 display_dc = CreateICW( DISPLAY, NULL, NULL, NULL );
603 assert( display_dc );
604
605 if (RegOpenKeyExW (HKEY_CURRENT_USER, METRICS_REGKEY,
606 0, KEY_QUERY_VALUE, &hkey) != ERROR_SUCCESS) hkey = 0;
607
608 sysMetrics[SM_CXVSCROLL] = SYSPARAMS_GetRegistryMetric( hkey, METRICS_SCROLLWIDTH_VALNAME, 16 );
609 sysMetrics[SM_CYHSCROLL] = sysMetrics[SM_CXVSCROLL];
610
611 /* The Win 2000 resource kit SAYS that this is governed by the ScrollHeight
612 * but on my computer that controls the CYV/CXH values. */
613 sysMetrics[SM_CYCAPTION] = SYSPARAMS_GetRegistryMetric(hkey, METRICS_CAPTIONHEIGHT_VALNAME, 18)
614 + 1; /* for the separator? */
615
616 sysMetrics[SM_CYMENU] = SYSPARAMS_GetRegistryMetric (hkey, METRICS_MENUHEIGHT_VALNAME, 18) + 1;
617
618
619 sysMetrics[SM_CXDLGFRAME] = 3;
620 sysMetrics[SM_CYDLGFRAME] = sysMetrics[SM_CXDLGFRAME];
621
622 SystemParametersInfoW( SPI_GETBORDER, 0, &border, 0 );
623 sysMetrics[SM_CXFRAME] = sysMetrics[SM_CXDLGFRAME] + border;
624 sysMetrics[SM_CYFRAME] = sysMetrics[SM_CYDLGFRAME] + border;
625
626 sysMetrics[SM_CXCURSOR] = 32;
627 sysMetrics[SM_CYCURSOR] = 32;
628
629 /* SM_C{X,Y}BORDER always returns 1 regardless of 'BorderWidth' value in registry. Verified against Win98 and WinXP */
630 sysMetrics[SM_CXBORDER] = 1;
631 sysMetrics[SM_CYBORDER] = sysMetrics[SM_CXBORDER];
632
633 sysMetrics[SM_CYVTHUMB] = sysMetrics[SM_CXVSCROLL];
634 sysMetrics[SM_CXHTHUMB] = sysMetrics[SM_CYVTHUMB];
635 sysMetrics[SM_CXICON] = SYSPARAMS_GetRegistryMetric( hkey, METRICS_ICONSIZE_VALNAME, 32 );
636 sysMetrics[SM_CYICON] = sysMetrics[SM_CXICON];
637 sysMetrics[SM_CYKANJIWINDOW] = 0;
638 sysMetrics[SM_MOUSEPRESENT] = 1;
639 sysMetrics[SM_CYVSCROLL] = SYSPARAMS_GetRegistryMetric (hkey, METRICS_SCROLLHEIGHT_VALNAME, sysMetrics[SM_CXVSCROLL]);
640 sysMetrics[SM_CXHSCROLL] = SYSPARAMS_GetRegistryMetric (hkey, METRICS_SCROLLHEIGHT_VALNAME, sysMetrics[SM_CYHSCROLL]);
641 sysMetrics[SM_DEBUG] = 0;
642
643 sysMetrics[SM_SWAPBUTTON] = 0;
644 if (SYSPARAMS_Load( SPI_SETMOUSEBUTTONSWAP_REGKEY, SPI_SETMOUSEBUTTONSWAP_VALNAME, buf, sizeof(buf) ))
645 sysMetrics[SM_SWAPBUTTON] = atoiW( buf );
646 spi_loaded[SPI_SETMOUSEBUTTONSWAP_IDX] = TRUE;
647
648 sysMetrics[SM_RESERVED1] = 0;
649 sysMetrics[SM_RESERVED2] = 0;
650 sysMetrics[SM_RESERVED3] = 0;
651 sysMetrics[SM_RESERVED4] = 0;
652
653 /* FIXME: The following two are calculated, but how? */
654 sysMetrics[SM_CXMIN] = 112;
655 sysMetrics[SM_CYMIN] = 27;
656
657 sysMetrics[SM_CXSIZE] = SYSPARAMS_GetRegistryMetric (hkey, METRICS_CAPTIONWIDTH_VALNAME, sysMetrics[SM_CYCAPTION] - 1);
658 sysMetrics[SM_CYSIZE] = sysMetrics[SM_CYCAPTION] - 1;
659 sysMetrics[SM_CXMINTRACK] = sysMetrics[SM_CXMIN];
660 sysMetrics[SM_CYMINTRACK] = sysMetrics[SM_CYMIN];
661
662 sysMetrics[SM_CXDOUBLECLK] = 4;
663 sysMetrics[SM_CYDOUBLECLK] = 4;
664
665 if (SYSPARAMS_Load( SPI_SETDOUBLECLKWIDTH_REGKEY1, SPI_SETDOUBLECLKWIDTH_VALNAME, buf, sizeof(buf) ))
666 sysMetrics[SM_CXDOUBLECLK] = atoiW( buf );
667 spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX] = TRUE;
668
669 if (SYSPARAMS_Load( SPI_SETDOUBLECLKHEIGHT_REGKEY1, SPI_SETDOUBLECLKHEIGHT_VALNAME, buf, sizeof(buf) ))
670 sysMetrics[SM_CYDOUBLECLK] = atoiW( buf );
671 spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX] = TRUE;
672
673 sysMetrics[SM_CXICONSPACING] = 75;
674 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0, &sysMetrics[SM_CXICONSPACING], 0 );
675 sysMetrics[SM_CYICONSPACING] = 75;
676 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0, &sysMetrics[SM_CYICONSPACING], 0 );
677
678 SystemParametersInfoW( SPI_GETMENUDROPALIGNMENT, 0, &sysMetrics[SM_MENUDROPALIGNMENT], 0 );
679 sysMetrics[SM_PENWINDOWS] = 0;
680 sysMetrics[SM_DBCSENABLED] = 0;
681
682 /* FIXME: Need to query X for the following */
683 sysMetrics[SM_CMOUSEBUTTONS] = 3;
684
685 sysMetrics[SM_SECURE] = 0;
686 sysMetrics[SM_CXEDGE] = sysMetrics[SM_CXBORDER] + 1;
687 sysMetrics[SM_CYEDGE] = sysMetrics[SM_CXEDGE];
688 sysMetrics[SM_CXMINSPACING] = 160;
689 sysMetrics[SM_CYMINSPACING] = 24;
690 sysMetrics[SM_CXSMICON] = 16;
691 sysMetrics[SM_CYSMICON] = 16;
692 sysMetrics[SM_CYSMCAPTION] = SYSPARAMS_GetRegistryMetric(hkey, METRICS_SMCAPTIONHEIGHT_VALNAME, 15) + 1;
693 sysMetrics[SM_CXSMSIZE] = SYSPARAMS_GetRegistryMetric(hkey, METRICS_SMCAPTIONWIDTH_VALNAME, 13);
694 sysMetrics[SM_CYSMSIZE] = sysMetrics[SM_CYSMCAPTION] - 1;
695 sysMetrics[SM_CXMENUSIZE] = SYSPARAMS_GetRegistryMetric(hkey, METRICS_MENUWIDTH_VALNAME, sysMetrics[SM_CYMENU] - 1);
696 sysMetrics[SM_CYMENUSIZE] = sysMetrics[SM_CYMENU] - 1;
697
698 /* FIXME: What do these mean? */
699 sysMetrics[SM_ARRANGE] = ARW_HIDE;
700 sysMetrics[SM_CXMINIMIZED] = 160;
701 sysMetrics[SM_CYMINIMIZED] = 24;
702
703 /* FIXME: How do I calculate these? */
704 sysMetrics[SM_NETWORK] = 3;
705
706 /* For the following: 0 = ok, 1 = failsafe, 2 = failsafe + network */
707 sysMetrics[SM_CLEANBOOT] = 0;
708
709 sysMetrics[SM_CXDRAG] = 4;
710 sysMetrics[SM_CYDRAG] = 4;
711 sysMetrics[SM_CXMENUCHECK] = 13;
712 sysMetrics[SM_CYMENUCHECK] = 13;
713
714 /* FIXME: Should check the type of processor for the following */
715 sysMetrics[SM_SLOWMACHINE] = 0;
716
717 /* FIXME: Should perform a check */
718 sysMetrics[SM_MIDEASTENABLED] = 0;
719
720 sysMetrics[SM_MOUSEWHEELPRESENT] = 1;
721
722 sysMetrics[SM_XVIRTUALSCREEN] = 0;
723 sysMetrics[SM_YVIRTUALSCREEN] = 0;
724 sysMetrics[SM_CMONITORS] = 1;
725 sysMetrics[SM_SAMEDISPLAYFORMAT] = 1;
726 sysMetrics[SM_CMETRICS] = SM_CMETRICS;
727
728 SystemParametersInfoW( SPI_GETSHOWSOUNDS, 0, &sysMetrics[SM_SHOWSOUNDS], 0 );
729
730 if (hkey) RegCloseKey (hkey);
731
732 SYSCOLOR_Init();
733 }
734
735
736 /***********************************************************************
737 * SystemParametersInfoW (USER32.@)
738 *
739 * Each system parameter has flag which shows whether the parameter
740 * is loaded or not. Parameters, stored directly in SysParametersInfo are
741 * loaded from registry only when they are requested and the flag is
742 * "false", after the loading the flag is set to "true". On interprocess
743 * notification of the parameter change the corresponding parameter flag is
744 * set to "false". The parameter value will be reloaded when it is requested
745 * the next time.
746 * Parameters, backed by or depend on GetSystemMetrics are processed
747 * differently. These parameters are always loaded. They are reloaded right
748 * away on interprocess change notification. We can't do lazy loading because
749 * we don't want to complicate GetSystemMetrics.
750 * Parameters, backed by X settings are read from corresponding setting.
751 * On the parameter change request the setting is changed. Interprocess change
752 * notifications are ignored.
753 * When parameter value is updated the changed value is stored in permanent
754 * registry branch if saving is requested. Otherwise it is stored
755 * in temporary branch
756 *
757 * Some SPI values can also be stored as Twips values in the registry,
758 * don't forget the conversion!
759 */
760 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
761 PVOID pvParam, UINT fWinIni )
762 {
763 #define WINE_SPI_FIXME(x) \
764 case x: \
765 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
766 SetLastError( ERROR_INVALID_SPI_VALUE ); \
767 ret = FALSE; \
768 break
769 #define WINE_SPI_WARN(x) \
770 case x: \
771 WARN( "Ignored action: %u (%s)\n", x, #x ); \
772 break
773
774 BOOL ret = TRUE;
775 unsigned spi_idx = 0;
776
777 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fWinIni);
778
779 switch (uiAction)
780 {
781 case SPI_GETBEEP: /* 1 */
782 if (!pvParam) return FALSE;
783
784 spi_idx = SPI_SETBEEP_IDX;
785 if (!spi_loaded[spi_idx])
786 {
787 WCHAR buf[5];
788
789 if (SYSPARAMS_Load( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME, buf, sizeof(buf) ))
790 beep_active = !lstrcmpiW( Yes, buf );
791 spi_loaded[spi_idx] = TRUE;
792 }
793
794 *(BOOL *)pvParam = beep_active;
795 break;
796
797 case SPI_SETBEEP: /* 2 */
798 spi_idx = SPI_SETBEEP_IDX;
799 if (SYSPARAMS_Save( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME,
800 (uiParam ? Yes : No), fWinIni ))
801 {
802 beep_active = uiParam;
803 spi_loaded[spi_idx] = TRUE;
804 }
805 else
806 ret = FALSE;
807 break;
808
809 case SPI_GETMOUSE: /* 3 */
810 if (!pvParam) return FALSE;
811
812 spi_idx = SPI_SETMOUSE_IDX;
813 if (!spi_loaded[spi_idx])
814 {
815 WCHAR buf[10];
816
817 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
818 buf, sizeof(buf) ))
819 mouse_threshold1 = atoiW( buf );
820 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
821 buf, sizeof(buf) ))
822 mouse_threshold2 = atoiW( buf );
823 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
824 buf, sizeof(buf) ))
825 mouse_speed = atoiW( buf );
826 spi_loaded[spi_idx] = TRUE;
827 }
828 ((INT *)pvParam)[0] = mouse_threshold1;
829 ((INT *)pvParam)[1] = mouse_threshold2;
830 ((INT *)pvParam)[2] = mouse_speed;
831 break;
832
833 case SPI_SETMOUSE: /* 4 */
834 {
835 WCHAR buf[10];
836
837 if (!pvParam) return FALSE;
838
839 spi_idx = SPI_SETMOUSE_IDX;
840 wsprintfW(buf, CSd, ((INT *)pvParam)[0]);
841
842 if (SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
843 buf, fWinIni ))
844 {
845 mouse_threshold1 = ((INT *)pvParam)[0];
846 spi_loaded[spi_idx] = TRUE;
847
848 wsprintfW(buf, CSd, ((INT *)pvParam)[1]);
849 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
850 buf, fWinIni );
851 mouse_threshold2 = ((INT *)pvParam)[1];
852
853 wsprintfW(buf, CSd, ((INT *)pvParam)[2]);
854 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
855 buf, fWinIni );
856 mouse_speed = ((INT *)pvParam)[2];
857 }
858 else
859 ret = FALSE;
860 break;
861 }
862
863 case SPI_GETBORDER: /* 5 */
864 if (!pvParam) return FALSE;
865
866 spi_idx = SPI_SETBORDER_IDX;
867 if (!spi_loaded[spi_idx])
868 {
869 WCHAR buf[10];
870
871 if (SYSPARAMS_Load( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, buf, sizeof(buf) ))
872 border = SYSPARAMS_Twips2Pixels( atoiW(buf) );
873
874 spi_loaded[spi_idx] = TRUE;
875 sysMetrics[SM_CXFRAME] = border + sysMetrics[SM_CXDLGFRAME];
876 sysMetrics[SM_CYFRAME] = border + sysMetrics[SM_CYDLGFRAME];
877 }
878 *(INT *)pvParam = border;
879 break;
880
881 case SPI_SETBORDER: /* 6 */
882 {
883 WCHAR buf[10];
884
885 spi_idx = SPI_SETBORDER_IDX;
886 wsprintfW(buf, CSu, uiParam);
887
888 if (SYSPARAMS_Save( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
889 buf, fWinIni ))
890 {
891 if (uiParam > 0)
892 {
893 border = uiParam;
894 spi_loaded[spi_idx] = TRUE;
895 sysMetrics[SM_CXFRAME] = border + sysMetrics[SM_CXDLGFRAME];
896 sysMetrics[SM_CYFRAME] = border + sysMetrics[SM_CYDLGFRAME];
897 }
898 }
899 else
900 ret = FALSE;
901 break;
902 }
903
904 case SPI_GETKEYBOARDSPEED: /* 10 */
905 if (!pvParam) return FALSE;
906
907 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
908 if (!spi_loaded[spi_idx])
909 {
910 WCHAR buf[10];
911
912 if (SYSPARAMS_Load( SPI_SETKEYBOARDSPEED_REGKEY,
913 SPI_SETKEYBOARDSPEED_VALNAME,
914 buf, sizeof(buf) ))
915 keyboard_speed = atoiW( buf );
916 spi_loaded[spi_idx] = TRUE;
917 }
918 *(INT *)pvParam = keyboard_speed;
919 break;
920
921 case SPI_SETKEYBOARDSPEED: /* 11 */
922 {
923 WCHAR buf[10];
924
925 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
926 if (uiParam > 31)
927 uiParam = 31;
928 wsprintfW(buf, CSu, uiParam);
929
930 if (SYSPARAMS_Save( SPI_SETKEYBOARDSPEED_REGKEY,
931 SPI_SETKEYBOARDSPEED_VALNAME,
932 buf, fWinIni ))
933 {
934 keyboard_speed = uiParam;
935 spi_loaded[spi_idx] = TRUE;
936 }
937 else
938 ret = FALSE;
939 break;
940 }
941
942 /* not implemented in Windows */
943 WINE_SPI_WARN(SPI_LANGDRIVER); /* 12 */
944
945 case SPI_ICONHORIZONTALSPACING: /* 13 */
946 spi_idx = SPI_ICONHORIZONTALSPACING_IDX;
947 if (pvParam != NULL)
948 {
949 if (!spi_loaded[spi_idx])
950 {
951 WCHAR buf[10];
952 int val;
953
954 if (SYSPARAMS_Load( SPI_ICONHORIZONTALSPACING_REGKEY,
955 SPI_ICONHORIZONTALSPACING_VALNAME, buf, sizeof(buf) ))
956 {
957 val = SYSPARAMS_Twips2Pixels( atoiW(buf) );
958 sysMetrics[SM_CXICONSPACING] = val;
959 }
960 spi_loaded[spi_idx] = TRUE;
961 }
962
963 *(INT *)pvParam = sysMetrics[SM_CXICONSPACING];
964 }
965 else
966 {
967 WCHAR buf[10];
968
969 if (uiParam < 32) uiParam = 32;
970
971 wsprintfW(buf, CSu, uiParam);
972 if (SYSPARAMS_Save( SPI_ICONHORIZONTALSPACING_REGKEY,
973 SPI_ICONHORIZONTALSPACING_VALNAME,
974 buf, fWinIni ))
975 {
976 sysMetrics[SM_CXICONSPACING] = uiParam;
977 spi_loaded[spi_idx] = TRUE;
978 }
979 else
980 ret = FALSE;
981 }
982 break;
983
984 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
985 if (!pvParam) return FALSE;
986
987 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
988 if (!spi_loaded[spi_idx])
989 {
990 WCHAR buf[10];
991
992 if (SYSPARAMS_Load( SPI_SETSCREENSAVETIMEOUT_REGKEY,
993 SPI_SETSCREENSAVETIMEOUT_VALNAME,
994 buf, sizeof(buf) ))
995 screensave_timeout = atoiW( buf );
996
997 spi_loaded[spi_idx] = TRUE;
998 }
999 *(INT *)pvParam = screensave_timeout;
1000 break;
1001
1002 case SPI_SETSCREENSAVETIMEOUT: /* 15 */
1003 {
1004 WCHAR buf[10];
1005
1006 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
1007 wsprintfW(buf, CSu, uiParam);
1008
1009 if (SYSPARAMS_Save( SPI_SETSCREENSAVETIMEOUT_REGKEY,
1010 SPI_SETSCREENSAVETIMEOUT_VALNAME,
1011 buf, fWinIni ))
1012 {
1013 screensave_timeout = uiParam;
1014 spi_loaded[spi_idx] = TRUE;
1015 }
1016 else
1017 ret = FALSE;
1018 break;
1019 }
1020
1021 case SPI_GETSCREENSAVEACTIVE: /* 16 */
1022 if (!pvParam) return FALSE;
1023 if (USER_Driver.pGetScreenSaveActive)
1024 *(BOOL *)pvParam = USER_Driver.pGetScreenSaveActive();
1025 else
1026 *(BOOL *)pvParam = FALSE;
1027 break;
1028
1029 case SPI_SETSCREENSAVEACTIVE: /* 17 */
1030 {
1031 WCHAR buf[5];
1032
1033 wsprintfW(buf, CSu, uiParam);
1034 if (USER_Driver.pSetScreenSaveActive)
1035 USER_Driver.pSetScreenSaveActive( uiParam );
1036 /* saved value does not affect Wine */
1037 SYSPARAMS_Save( SPI_SETSCREENSAVEACTIVE_REGKEY,
1038 SPI_SETSCREENSAVEACTIVE_VALNAME,
1039 buf, fWinIni );
1040 break;
1041 }
1042
1043 case SPI_GETGRIDGRANULARITY: /* 18 */
1044 if (!pvParam) return FALSE;
1045
1046 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
1047 if (!spi_loaded[spi_idx])
1048 {
1049 WCHAR buf[10];
1050
1051 if (SYSPARAMS_Load( SPI_SETGRIDGRANULARITY_REGKEY,
1052 SPI_SETGRIDGRANULARITY_VALNAME,
1053 buf, sizeof(buf) ))
1054 grid_granularity = atoiW( buf );
1055
1056 spi_loaded[spi_idx] = TRUE;
1057 }
1058 *(INT *)pvParam = grid_granularity;
1059 break;
1060
1061 case SPI_SETGRIDGRANULARITY: /* 19 */
1062 {
1063 WCHAR buf[10];
1064
1065 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
1066 wsprintfW(buf, CSu, uiParam);
1067
1068 if (SYSPARAMS_Save( SPI_SETGRIDGRANULARITY_REGKEY,
1069 SPI_SETGRIDGRANULARITY_VALNAME,
1070 buf, fWinIni ))
1071 {
1072 grid_granularity = uiParam;
1073 spi_loaded[spi_idx] = TRUE;
1074 }
1075 else
1076 ret = FALSE;
1077 break;
1078 }
1079
1080 case SPI_SETDESKWALLPAPER: /* 20 */
1081 if (!pvParam || !SetDeskWallPaper( (LPSTR)pvParam )) return FALSE;
1082 SYSPARAMS_Save(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, pvParam, fWinIni);
1083 break;
1084
1085 case SPI_SETDESKPATTERN: /* 21 */
1086 /* FIXME: the ability to specify a pattern in pvParam
1087 doesn't seem to be documented for Win32 */
1088 if ((INT16)uiParam == -1)
1089 {
1090 WCHAR buf[256];
1091 GetProfileStringW( Desktop, Pattern,
1092 defPattern,
1093 buf, sizeof(buf)/sizeof(WCHAR) );
1094 ret = DESKTOP_SetPattern( buf );
1095 } else
1096 ret = DESKTOP_SetPattern( (LPWSTR)pvParam );
1097 break;
1098
1099 case SPI_GETKEYBOARDDELAY: /* 22 */
1100 if (!pvParam) return FALSE;
1101
1102 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
1103 if (!spi_loaded[spi_idx])
1104 {
1105 WCHAR buf[10];
1106
1107 if (SYSPARAMS_Load( SPI_SETKEYBOARDDELAY_REGKEY,
1108 SPI_SETKEYBOARDDELAY_VALNAME,
1109 buf, sizeof(buf) ))
1110 {
1111 int i = atoiW( buf );
1112 if ( (i >= 0) && (i <= 3)) keyboard_delay = i;
1113 }
1114
1115 spi_loaded[spi_idx] = TRUE;
1116 }
1117 *(INT *)pvParam = keyboard_delay;
1118 break;
1119
1120 case SPI_SETKEYBOARDDELAY: /* 23 */
1121 {
1122 WCHAR buf[10];
1123
1124 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
1125 wsprintfW(buf, CSu, uiParam);
1126
1127 if (SYSPARAMS_Save( SPI_SETKEYBOARDDELAY_REGKEY,
1128 SPI_SETKEYBOARDDELAY_VALNAME,
1129 buf, fWinIni ))
1130 {
1131 if (uiParam <= 3)
1132 keyboard_delay = uiParam;
1133 spi_loaded[spi_idx] = TRUE;
1134 }
1135 else
1136 ret = FALSE;
1137 break;
1138 }
1139
1140 case SPI_ICONVERTICALSPACING: /* 24 */
1141 spi_idx = SPI_ICONVERTICALSPACING_IDX;
1142 if (pvParam != NULL)
1143 {
1144 if (!spi_loaded[spi_idx])
1145 {
1146 WCHAR buf[10];
1147 int val;
1148
1149 if (SYSPARAMS_Load( SPI_ICONVERTICALSPACING_REGKEY,
1150 SPI_ICONVERTICALSPACING_VALNAME, buf, sizeof(buf) ))
1151 {
1152 val = SYSPARAMS_Twips2Pixels( atoiW(buf) );
1153 sysMetrics[SM_CYICONSPACING] = val;
1154 }
1155 spi_loaded[spi_idx] = TRUE;
1156 }
1157
1158 *(INT *)pvParam = sysMetrics[SM_CYICONSPACING];
1159 }
1160 else
1161 {
1162 WCHAR buf[10];
1163
1164 if (uiParam < 32) uiParam = 32;
1165
1166 wsprintfW(buf, CSu, uiParam);
1167 if (SYSPARAMS_Save( SPI_ICONVERTICALSPACING_REGKEY,
1168 SPI_ICONVERTICALSPACING_VALNAME,
1169 buf, fWinIni ))
1170 {
1171 sysMetrics[SM_CYICONSPACING] = uiParam;
1172 spi_loaded[spi_idx] = TRUE;
1173 }
1174 else
1175 ret = FALSE;
1176 }
1177
1178 break;
1179
1180 case SPI_GETICONTITLEWRAP: /* 25 */
1181 if (!pvParam) return FALSE;
1182
1183 spi_idx = SPI_SETICONTITLEWRAP_IDX;
1184 if (!spi_loaded[spi_idx])
1185 {
1186 WCHAR buf[5];
1187
1188 if (SYSPARAMS_Load( SPI_SETICONTITLEWRAP_REGKEY1,
1189 SPI_SETICONTITLEWRAP_VALNAME, buf, sizeof(buf) ))
1190 icon_title_wrap = atoiW(buf);
1191 spi_loaded[spi_idx] = TRUE;
1192 }
1193
1194 *(BOOL *)pvParam = icon_title_wrap;
1195 break;
1196
1197 case SPI_SETICONTITLEWRAP: /* 26 */
1198 {
1199 WCHAR buf[5];
1200
1201 spi_idx = SPI_SETICONTITLEWRAP_IDX;
1202 wsprintfW(buf, CSu, uiParam);
1203 if (SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY1,
1204 SPI_SETICONTITLEWRAP_VALNAME,
1205 buf, fWinIni ))
1206 {
1207 SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY2,
1208 SPI_SETICONTITLEWRAP_VALNAME,
1209 buf, fWinIni );
1210 icon_title_wrap = uiParam;
1211 spi_loaded[spi_idx] = TRUE;
1212 }
1213 else
1214 ret = FALSE;
1215 break;
1216 }
1217
1218 case SPI_GETMENUDROPALIGNMENT: /* 27 */
1219 if (!pvParam) return FALSE;
1220
1221 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1222
1223 if (!spi_loaded[spi_idx])
1224 {
1225 WCHAR buf[5];
1226
1227 if (SYSPARAMS_Load( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1228 SPI_SETMENUDROPALIGNMENT_VALNAME, buf, sizeof(buf) ))
1229 {
1230 sysMetrics[SM_MENUDROPALIGNMENT] = atoiW( buf );
1231 }
1232 spi_loaded[spi_idx] = TRUE;
1233 }
1234
1235 *(BOOL *)pvParam = sysMetrics[SM_MENUDROPALIGNMENT];
1236 break;
1237
1238 case SPI_SETMENUDROPALIGNMENT: /* 28 */
1239 {
1240 WCHAR buf[5];
1241 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1242
1243 wsprintfW(buf, CSu, uiParam);
1244 if (SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1245 SPI_SETMENUDROPALIGNMENT_VALNAME,
1246 buf, fWinIni ))
1247 {
1248 SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY2,
1249 SPI_SETMENUDROPALIGNMENT_VALNAME,
1250 buf, fWinIni );
1251 sysMetrics[SM_MENUDROPALIGNMENT] = uiParam;
1252 spi_loaded[spi_idx] = TRUE;
1253 }
1254 else
1255 ret = FALSE;
1256 break;
1257 }
1258
1259 case SPI_SETDOUBLECLKWIDTH: /* 29 */
1260 {
1261 WCHAR buf[10];
1262 spi_idx = SPI_SETDOUBLECLKWIDTH_IDX;
1263
1264 wsprintfW(buf, CSu, uiParam);
1265 if (SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY1,
1266 SPI_SETDOUBLECLKWIDTH_VALNAME,
1267 buf, fWinIni ))
1268 {
1269 SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY2,
1270 SPI_SETDOUBLECLKWIDTH_VALNAME,
1271 buf, fWinIni );
1272 sysMetrics[SM_CXDOUBLECLK] = uiParam;
1273 spi_loaded[spi_idx] = TRUE;
1274 }
1275 else
1276 ret = FALSE;
1277 break;
1278 }
1279
1280 case SPI_SETDOUBLECLKHEIGHT: /* 30 */
1281 {
1282 WCHAR buf[10];
1283 spi_idx = SPI_SETDOUBLECLKHEIGHT_IDX;
1284
1285 wsprintfW(buf, CSu, uiParam);
1286 if (SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
1287 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1288 buf, fWinIni ))
1289 {
1290 SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY2,
1291 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1292 buf, fWinIni );
1293 sysMetrics[SM_CYDOUBLECLK] = uiParam;
1294 spi_loaded[spi_idx] = TRUE;
1295 }
1296 else
1297 ret = FALSE;
1298 break;
1299 }
1300
1301 case SPI_GETICONTITLELOGFONT: /* 31 */
1302 {
1303 LOGFONTW lfDefault;
1304
1305 if (!pvParam) return FALSE;
1306
1307 spi_idx = SPI_SETICONTITLELOGFONT_IDX;
1308 if (!spi_loaded[spi_idx])
1309 {
1310 /*
1311 * The 'default GDI fonts' seems to be returned.
1312 * If a returned font is not a correct font in your environment,
1313 * please try to fix objects/gdiobj.c at first.
1314 */
1315 GetObjectW( GetStockObject( DEFAULT_GUI_FONT ), sizeof(LOGFONTW), &lfDefault );
1316
1317 GetProfileStringW( Desktop, IconTitleFaceName,
1318 lfDefault.lfFaceName,
1319 log_font.lfFaceName,
1320 LF_FACESIZE );
1321 log_font.lfHeight = -GetProfileIntW( Desktop, IconTitleSize, 11 );
1322 log_font.lfWidth = 0;
1323 log_font.lfEscapement = log_font.lfOrientation = 0;
1324 log_font.lfWeight = FW_NORMAL;
1325 log_font.lfItalic = FALSE;
1326 log_font.lfStrikeOut = FALSE;
1327 log_font.lfUnderline = FALSE;
1328 log_font.lfCharSet = lfDefault.lfCharSet; /* at least 'charset' should not be hard-coded */
1329 log_font.lfOutPrecision = OUT_DEFAULT_PRECIS;
1330 log_font.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1331 log_font.lfQuality = DEFAULT_QUALITY;
1332 log_font.lfPitchAndFamily = DEFAULT_PITCH;
1333 spi_loaded[spi_idx] = TRUE;
1334 }
1335 *(LOGFONTW *)pvParam = log_font;
1336 break;
1337 }
1338
1339 case SPI_SETDOUBLECLICKTIME: /* 32 */
1340 {
1341 WCHAR buf[10];
1342
1343 spi_idx = SPI_SETDOUBLECLICKTIME_IDX;
1344 wsprintfW(buf, CSu, uiParam);
1345
1346 if (SYSPARAMS_Save( SPI_SETDOUBLECLICKTIME_REGKEY,
1347 SPI_SETDOUBLECLICKTIME_VALNAME,
1348 buf, fWinIni ))
1349 {
1350 if (!uiParam)
1351 uiParam = 500;
1352 double_click_time = uiParam;
1353 spi_loaded[spi_idx] = TRUE;
1354 }
1355 else
1356 ret = FALSE;
1357 break;
1358 }
1359
1360 case SPI_SETMOUSEBUTTONSWAP: /* 33 */
1361 {
1362 WCHAR buf[5];
1363 spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
1364
1365 wsprintfW(buf, CSu, uiParam);
1366 if (SYSPARAMS_Save( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1367 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1368 buf, fWinIni ))
1369 {
1370 sysMetrics[SM_SWAPBUTTON] = uiParam;
1371 spi_loaded[spi_idx] = TRUE;
1372 }
1373 else
1374 ret = FALSE;
1375 break;
1376 }
1377
1378 WINE_SPI_FIXME(SPI_SETICONTITLELOGFONT); /* 34 */
1379
1380 case SPI_GETFASTTASKSWITCH: /* 35 */
1381 if (!pvParam) return FALSE;
1382 *(BOOL *)pvParam = 1;
1383 break;
1384
1385 case SPI_SETFASTTASKSWITCH: /* 36 */
1386 /* the action is disabled */
1387 ret = FALSE;
1388 break;
1389
1390 case SPI_SETDRAGFULLWINDOWS: /* 37 WINVER >= 0x0400 */
1391 {
1392 WCHAR buf[5];
1393
1394 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1395 wsprintfW(buf, CSu, uiParam);
1396 if (SYSPARAMS_Save( SPI_SETDRAGFULLWINDOWS_REGKEY,
1397 SPI_SETDRAGFULLWINDOWS_VALNAME,
1398 buf, fWinIni ))
1399 {
1400 drag_full_windows = uiParam;
1401 spi_loaded[spi_idx] = TRUE;
1402 }
1403 else
1404 ret = FALSE;
1405 break;
1406 }
1407
1408 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1409 if (!pvParam) return FALSE;
1410
1411 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1412 if (!spi_loaded[spi_idx])
1413 {
1414 WCHAR buf[5];
1415
1416 if (SYSPARAMS_Load( SPI_SETDRAGFULLWINDOWS_REGKEY,
1417 SPI_SETDRAGFULLWINDOWS_VALNAME, buf, sizeof(buf) ))
1418 drag_full_windows = atoiW(buf);
1419 spi_loaded[spi_idx] = TRUE;
1420 }
1421
1422 *(BOOL *)pvParam = drag_full_windows;
1423 break;
1424
1425 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1426 {
1427 LPNONCLIENTMETRICSW lpnm = (LPNONCLIENTMETRICSW)pvParam;
1428
1429 if (!pvParam) return FALSE;
1430
1431 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1432 {
1433 /* clear the struct, so we have 'sane' members */
1434 memset(
1435 (char *)pvParam + sizeof(lpnm->cbSize),
1436 0,
1437 lpnm->cbSize - sizeof(lpnm->cbSize)
1438 );
1439
1440 /* initialize geometry entries */
1441 lpnm->iBorderWidth = 1;
1442 lpnm->iScrollWidth = sysMetrics[SM_CXVSCROLL];
1443 lpnm->iScrollHeight = sysMetrics[SM_CYHSCROLL];
1444
1445 /* size of the normal caption buttons */
1446 lpnm->iCaptionWidth = sysMetrics[SM_CXSIZE];
1447 lpnm->iCaptionHeight = sysMetrics[SM_CYSIZE];
1448
1449 /* caption font metrics */
1450 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont), 0 );
1451 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
1452
1453 /* size of the small caption buttons */
1454 lpnm->iSmCaptionWidth = sysMetrics[SM_CXSMSIZE];
1455 lpnm->iSmCaptionHeight = sysMetrics[SM_CYSMSIZE];
1456
1457 /* small caption font metrics */
1458 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont), 0 );
1459
1460 /* menus, FIXME: names of wine.conf entries are bogus */
1461
1462 /* size of the menu (MDI) buttons */
1463 lpnm->iMenuWidth = sysMetrics[SM_CXMENUSIZE];
1464 lpnm->iMenuHeight = sysMetrics[SM_CYMENUSIZE];
1465
1466 /* menu font metrics */
1467 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfMenuFont), 0 );
1468 GetProfileStringW( Desktop, MenuFont, lpnm->lfCaptionFont.lfFaceName,
1469 lpnm->lfMenuFont.lfFaceName, LF_FACESIZE );
1470 lpnm->lfMenuFont.lfHeight = -GetProfileIntW( Desktop, MenuFontSize, 11 );
1471 lpnm->lfMenuFont.lfWeight = FW_NORMAL;
1472
1473 /* status bar font metrics */
1474 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1475 (LPVOID)&(lpnm->lfStatusFont), 0 );
1476 GetProfileStringW( Desktop, StatusFont, lpnm->lfCaptionFont.lfFaceName,
1477 lpnm->lfStatusFont.lfFaceName, LF_FACESIZE );
1478 lpnm->lfStatusFont.lfHeight = -GetProfileIntW( Desktop, StatusFontSize, 11 );
1479 lpnm->lfStatusFont.lfWeight = FW_NORMAL;
1480
1481 /* message font metrics */
1482 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1483 (LPVOID)&(lpnm->lfMessageFont), 0 );
1484 GetProfileStringW( Desktop, MessageFont, lpnm->lfCaptionFont.lfFaceName,
1485 lpnm->lfMessageFont.lfFaceName, LF_FACESIZE );
1486 lpnm->lfMessageFont.lfHeight = -GetProfileIntW( Desktop, MessageFontSize, 11 );
1487 lpnm->lfMessageFont.lfWeight = FW_NORMAL;
1488
1489 }
1490 else
1491 {
1492 WARN("size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSW));
1493 /* FIXME: SetLastError? */
1494 ret = FALSE;
1495 }
1496 break;
1497 }
1498 WINE_SPI_FIXME(SPI_SETNONCLIENTMETRICS); /* 42 WINVER >= 0x400 */
1499
1500 case SPI_GETMINIMIZEDMETRICS: /* 43 WINVER >= 0x400 */
1501 {
1502 MINIMIZEDMETRICS * lpMm = pvParam;
1503 if (lpMm && lpMm->cbSize == sizeof(*lpMm))
1504 {
1505 lpMm->iWidth = sysMetrics[SM_CXMINIMIZED] - 6;
1506 lpMm->iHorzGap = sysMetrics[SM_CXMINSPACING] - sysMetrics[SM_CXMINIMIZED];
1507 lpMm->iVertGap = sysMetrics[SM_CYMINSPACING] - sysMetrics[SM_CYMINIMIZED];
1508 lpMm->iArrange = sysMetrics[SM_ARRANGE];
1509 }
1510 else
1511 ret = FALSE;
1512 break;
1513 }
1514 case SPI_SETMINIMIZEDMETRICS: /* 44 WINVER >= 0x400 */
1515 {
1516 MINIMIZEDMETRICS * lpMm = pvParam;
1517 if (lpMm && lpMm->cbSize == sizeof(*lpMm))
1518 {
1519 sysMetrics[SM_CXMINIMIZED] = lpMm->iWidth + 6;
1520 sysMetrics[SM_CXMINSPACING] = lpMm->iHorzGap + sysMetrics[SM_CXMINIMIZED];
1521 sysMetrics[SM_CYMINSPACING] = lpMm->iVertGap + sysMetrics[SM_CYMINIMIZED];
1522 sysMetrics[SM_ARRANGE] = lpMm->iArrange;
1523 }
1524 else
1525 ret = FALSE;
1526 break;
1527 }
1528
1529 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
1530 {
1531 LPICONMETRICSW lpIcon = pvParam;
1532 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1533 {
1534 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
1535 &lpIcon->iHorzSpacing, FALSE );
1536 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
1537 &lpIcon->iVertSpacing, FALSE );
1538 SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
1539 &lpIcon->iTitleWrap, FALSE );
1540 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1541 &lpIcon->lfFont, FALSE );
1542 }
1543 else
1544 {
1545 ret = FALSE;
1546 }
1547 break;
1548 }
1549
1550 case SPI_SETICONMETRICS: /* 46 WINVER >= 0x400 */
1551 {
1552 LPICONMETRICSW lpIcon = pvParam;
1553 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1554 {
1555 sysMetrics[SM_CXICONSPACING] = lpIcon->iHorzSpacing;
1556 sysMetrics[SM_CYICONSPACING] = lpIcon->iVertSpacing;
1557 icon_title_wrap = lpIcon->iTitleWrap;
1558 log_font = lpIcon->lfFont;
1559 }
1560 else
1561 {
1562 ret = FALSE;
1563 }
1564 break;
1565 }
1566
1567 case SPI_SETWORKAREA: /* 47 WINVER >= 0x400 */
1568 {
1569 if (!pvParam) return FALSE;
1570
1571 spi_idx = SPI_SETWORKAREA_IDX;
1572 CopyRect( &work_area, (RECT *)pvParam );
1573 spi_loaded[spi_idx] = TRUE;
1574
1575 break;
1576 }
1577
1578 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1579 {
1580 if (!pvParam) return FALSE;
1581
1582 spi_idx = SPI_SETWORKAREA_IDX;
1583 if (!spi_loaded[spi_idx])
1584 {
1585 SetRect( &work_area, 0, 0,
1586 GetSystemMetrics( SM_CXSCREEN ),
1587 GetSystemMetrics( SM_CYSCREEN ) );
1588 spi_loaded[spi_idx] = TRUE;
1589 }
1590 CopyRect( (RECT *)pvParam, &work_area );
1591
1592 break;
1593 }
1594
1595 WINE_SPI_FIXME(SPI_SETPENWINDOWS); /* 49 WINVER >= 0x400 */
1596
1597 case SPI_GETFILTERKEYS: /* 50 */
1598 {
1599 LPFILTERKEYS lpFilterKeys = (LPFILTERKEYS)pvParam;
1600 WARN("SPI_GETFILTERKEYS not fully implemented\n");
1601 if (lpFilterKeys && lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1602 {
1603 /* Indicate that no FilterKeys feature available */
1604 lpFilterKeys->dwFlags = 0;
1605 lpFilterKeys->iWaitMSec = 0;
1606 lpFilterKeys->iDelayMSec = 0;
1607 lpFilterKeys->iRepeatMSec = 0;
1608 lpFilterKeys->iBounceMSec = 0;
1609 }
1610 else
1611 {
1612 ret = FALSE;
1613 }
1614 break;
1615 }
1616 WINE_SPI_FIXME(SPI_SETFILTERKEYS); /* 51 */
1617
1618 case SPI_GETTOGGLEKEYS: /* 52 */
1619 {
1620 LPTOGGLEKEYS lpToggleKeys = (LPTOGGLEKEYS)pvParam;
1621 WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1622 if (lpToggleKeys && lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1623 {
1624 /* Indicate that no ToggleKeys feature available */
1625 lpToggleKeys->dwFlags = 0;
1626 }
1627 else
1628 {
1629 ret = FALSE;
1630 }
1631 break;
1632 }
1633 WINE_SPI_FIXME(SPI_SETTOGGLEKEYS); /* 53 */
1634
1635 case SPI_GETMOUSEKEYS: /* 54 */
1636 {
1637 LPMOUSEKEYS lpMouseKeys = (LPMOUSEKEYS)pvParam;
1638 WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1639 if (lpMouseKeys && lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1640 {
1641 /* Indicate that no MouseKeys feature available */
1642 lpMouseKeys->dwFlags = 0;
1643 lpMouseKeys->iMaxSpeed = 360;
1644 lpMouseKeys->iTimeToMaxSpeed = 1000;
1645 lpMouseKeys->iCtrlSpeed = 0;
1646 lpMouseKeys->dwReserved1 = 0;
1647 lpMouseKeys->dwReserved2 = 0;
1648 }
1649 else
1650 {
1651 ret = FALSE;
1652 }
1653 break;
1654 }
1655 WINE_SPI_FIXME(SPI_SETMOUSEKEYS); /* 55 */
1656
1657 case SPI_GETSHOWSOUNDS: /* 56 */
1658 if (!pvParam) return FALSE;
1659
1660 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1661
1662 if (!spi_loaded[spi_idx])
1663 {
1664 WCHAR buf[10];
1665
1666 if (SYSPARAMS_Load( SPI_SETSHOWSOUNDS_REGKEY,
1667 SPI_SETSHOWSOUNDS_VALNAME, buf, sizeof(buf) ))
1668 {
1669 sysMetrics[SM_SHOWSOUNDS] = atoiW( buf );
1670 }
1671 spi_loaded[spi_idx] = TRUE;
1672 }
1673
1674 *(INT *)pvParam = sysMetrics[SM_SHOWSOUNDS];
1675 break;
1676
1677 case SPI_SETSHOWSOUNDS: /* 57 */
1678 {
1679 WCHAR buf[10];
1680 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1681
1682 wsprintfW(buf, CSu, uiParam);
1683 if (SYSPARAMS_Save( SPI_SETSHOWSOUNDS_REGKEY,
1684 SPI_SETSHOWSOUNDS_VALNAME,
1685 buf, fWinIni ))
1686 {
1687 sysMetrics[SM_SHOWSOUNDS] = uiParam;
1688 spi_loaded[spi_idx] = TRUE;
1689 }
1690 else
1691 ret = FALSE;
1692 break;
1693 }
1694
1695 case SPI_GETSTICKYKEYS: /* 58 */
1696 {
1697 LPSTICKYKEYS lpStickyKeys = (LPSTICKYKEYS)pvParam;
1698 WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1699 if (lpStickyKeys && lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1700 {
1701 /* Indicate that no StickyKeys feature available */
1702 lpStickyKeys->dwFlags = 0;
1703 }
1704 else
1705 {
1706 ret = FALSE;
1707 }
1708 break;
1709 }
1710 WINE_SPI_FIXME(SPI_SETSTICKYKEYS); /* 59 */
1711
1712 case SPI_GETACCESSTIMEOUT: /* 60 */
1713 {
1714 LPACCESSTIMEOUT lpAccessTimeout = (LPACCESSTIMEOUT)pvParam;
1715 WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1716 if (lpAccessTimeout && lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1717 {
1718 /* Indicate that no accessibility features timeout is available */
1719 lpAccessTimeout->dwFlags = 0;
1720 lpAccessTimeout->iTimeOutMSec = 0;
1721 }
1722 else
1723 {
1724 ret = FALSE;
1725 }
1726 break;
1727 }
1728 WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT); /* 61 */
1729
1730 case SPI_GETSERIALKEYS: /* 62 WINVER >= 0x400 */
1731 {
1732 LPSERIALKEYSW lpSerialKeysW = (LPSERIALKEYSW)pvParam;
1733 WARN("SPI_GETSERIALKEYS not fully implemented\n");
1734 if (lpSerialKeysW && lpSerialKeysW->cbSize == sizeof(SERIALKEYSW))
1735 {
1736 /* Indicate that no SerialKeys feature available */
1737 lpSerialKeysW->dwFlags = 0;
1738 lpSerialKeysW->lpszActivePort = NULL;
1739 lpSerialKeysW->lpszPort = NULL;
1740 lpSerialKeysW->iBaudRate = 0;
1741 lpSerialKeysW->iPortState = 0;
1742 }
1743 else
1744 {
1745 ret = FALSE;
1746 }
1747 break;
1748 }
1749 WINE_SPI_FIXME(SPI_SETSERIALKEYS); /* 63 WINVER >= 0x400 */
1750
1751 case SPI_GETSOUNDSENTRY: /* 64 */
1752 {
1753 LPSOUNDSENTRYW lpSoundSentryW = (LPSOUNDSENTRYW)pvParam;
1754 WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1755 if (lpSoundSentryW && lpSoundSentryW->cbSize == sizeof(SOUNDSENTRYW))
1756 {
1757 /* Indicate that no SoundSentry feature available */
1758 lpSoundSentryW->dwFlags = 0;
1759 lpSoundSentryW->iFSTextEffect = 0;
1760 lpSoundSentryW->iFSTextEffectMSec = 0;
1761 lpSoundSentryW->iFSTextEffectColorBits = 0;
1762 lpSoundSentryW->iFSGrafEffect = 0;
1763 lpSoundSentryW->iFSGrafEffectMSec = 0;
1764 lpSoundSentryW->iFSGrafEffectColor = 0;
1765 lpSoundSentryW->iWindowsEffect = 0;
1766 lpSoundSentryW->iWindowsEffectMSec = 0;
1767 lpSoundSentryW->lpszWindowsEffectDLL = 0;
1768 lpSoundSentryW->iWindowsEffectOrdinal = 0;
1769 }
1770 else
1771 {
1772 ret = FALSE;
1773 }
1774 break;
1775 }
1776 WINE_SPI_FIXME(SPI_SETSOUNDSENTRY); /* 65 */
1777
1778 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1779 {
1780 LPHIGHCONTRASTW lpHighContrastW = (LPHIGHCONTRASTW)pvParam;
1781 WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1782 if (lpHighContrastW && lpHighContrastW->cbSize == sizeof(HIGHCONTRASTW))
1783 {
1784 /* Indicate that no high contrast feature available */
1785 lpHighContrastW->dwFlags = 0;
1786 lpHighContrastW->lpszDefaultScheme = NULL;
1787 }
1788 else
1789 {
1790 ret = FALSE;
1791 }
1792 break;
1793 }
1794 WINE_SPI_FIXME(SPI_SETHIGHCONTRAST); /* 67 WINVER >= 0x400 */
1795
1796 case SPI_GETKEYBOARDPREF: /* 68 WINVER >= 0x400 */
1797 if (!pvParam) return FALSE;
1798
1799 spi_idx = SPI_SETKEYBOARDPREF_IDX;
1800 if (!spi_loaded[spi_idx])
1801 {
1802 WCHAR buf[5];
1803
1804 if (SYSPARAMS_Load( SPI_SETKEYBOARDPREF_REGKEY,
1805 SPI_SETKEYBOARDPREF_VALNAME, buf, sizeof(buf) ))
1806 keyboard_pref = atoiW(buf);
1807 spi_loaded[spi_idx] = TRUE;
1808 }
1809
1810 *(BOOL *)pvParam = keyboard_pref;
1811 break;
1812
1813 case SPI_SETKEYBOARDPREF: /* 69 WINVER >= 0x400 */
1814 {
1815 WCHAR buf[5];
1816
1817 spi_idx = SPI_SETKEYBOARDPREF_IDX;
1818 wsprintfW(buf, CSu, uiParam);
1819 if (SYSPARAMS_Save( SPI_SETKEYBOARDPREF_REGKEY,
1820 SPI_SETKEYBOARDPREF_VALNAME,
1821 buf, fWinIni ))
1822 {
1823 keyboard_pref = uiParam;
1824 spi_loaded[spi_idx] = TRUE;
1825 }
1826 else
1827 ret = FALSE;
1828 break;
1829 }
1830
1831 case SPI_GETSCREENREADER: /* 70 WINVER >= 0x400 */
1832 if (!pvParam) return FALSE;
1833
1834 spi_idx = SPI_SETSCREENREADER_IDX;
1835 if (!spi_loaded[spi_idx])
1836 {
1837 WCHAR buf[5];
1838
1839 if (SYSPARAMS_Load( SPI_SETSCREENREADER_REGKEY,
1840 SPI_SETSCREENREADER_VALNAME, buf, sizeof(buf) ))
1841 screen_reader = atoiW(buf);
1842 spi_loaded[spi_idx] = TRUE;
1843 }
1844
1845 *(BOOL *)pvParam = screen_reader;
1846 break;
1847
1848 case SPI_SETSCREENREADER: /* 71 WINVER >= 0x400 */
1849 {
1850 WCHAR buf[5];
1851
1852 spi_idx = SPI_SETSCREENREADER_IDX;
1853 wsprintfW(buf, CSu, uiParam);
1854 if (SYSPARAMS_Save( SPI_SETSCREENREADER_REGKEY,
1855 SPI_SETSCREENREADER_VALNAME,
1856 buf, fWinIni ))
1857 {
1858 screen_reader = uiParam;
1859 spi_loaded[spi_idx] = TRUE;
1860 }
1861 else
1862 ret = FALSE;
1863 break;
1864 }
1865
1866 case SPI_GETANIMATION: /* 72 WINVER >= 0x400 */
1867 {
1868 LPANIMATIONINFO lpAnimInfo = (LPANIMATIONINFO)pvParam;
1869
1870 /* Tell it "disabled" */
1871 if (lpAnimInfo && lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
1872 lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
1873 else
1874 ret = FALSE;
1875 break;
1876 }
1877 WINE_SPI_WARN(SPI_SETANIMATION); /* 73 WINVER >= 0x400 */
1878
1879 case SPI_GETFONTSMOOTHING: /* 74 WINVER >= 0x400 */
1880 if (!pvParam) return FALSE;
1881
1882 spi_idx = SPI_SETFONTSMOOTHING_IDX;
1883 if (!spi_loaded[spi_idx])
1884 {
1885 WCHAR buf[5];
1886
1887 if (SYSPARAMS_Load( SPI_SETFONTSMOOTHING_REGKEY,
1888 SPI_SETFONTSMOOTHING_VALNAME, buf, sizeof(buf) ))
1889 {
1890 spi_loaded[spi_idx] = TRUE;
1891 if (buf[0] == 0x01 || buf[0] == 0x02) /* 0x01 for 95/98/NT, 0x02 for 98/ME/2k/XP */
1892 {
1893 font_smoothing = TRUE;
1894 }
1895 }
1896 }
1897
1898 *(BOOL *)pvParam = font_smoothing;
1899
1900 break;
1901
1902 WINE_SPI_FIXME(SPI_SETFONTSMOOTHING); /* 75 WINVER >= 0x400 */
1903
1904 WINE_SPI_FIXME(SPI_SETDRAGWIDTH); /* 76 WINVER >= 0x400 */
1905 WINE_SPI_FIXME(SPI_SETDRAGHEIGHT); /* 77 WINVER >= 0x400 */
1906
1907 WINE_SPI_FIXME(SPI_SETHANDHELD); /* 78 WINVER >= 0x400 */
1908
1909 WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT); /* 79 WINVER >= 0x400 */
1910 WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT); /* 80 WINVER >= 0x400 */
1911 WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT); /* 81 WINVER >= 0x400 */
1912 WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT); /* 82 WINVER >= 0x400 */
1913
1914 case SPI_GETLOWPOWERACTIVE: /* 83 WINVER >= 0x400 */
1915 if (!pvParam)
1916 {
1917 SetLastError(ERROR_INVALID_PARAMETER);
1918 return FALSE;
1919 }
1920
1921 spi_idx = SPI_SETLOWPOWERACTIVE_IDX;
1922 if (!spi_loaded[spi_idx])
1923 {
1924 WCHAR buf[5];
1925 if(SYSPARAMS_Load( SPI_SETLOWPOWERACTIVE_REGKEY,
1926 SPI_SETLOWPOWERACTIVE_VALNAME,
1927 buf, sizeof(buf) ))
1928 lowpoweractive = atoiW(buf);
1929 spi_loaded[spi_idx] = TRUE;
1930 }
1931 *(BOOL *)pvParam = lowpoweractive;
1932 break;
1933
1934 case SPI_GETPOWEROFFACTIVE: /* 84 WINVER >= 0x400 */
1935 if (!pvParam)
1936 {
1937 SetLastError(ERROR_INVALID_PARAMETER);
1938 return FALSE;
1939 }
1940
1941 spi_idx = SPI_SETPOWEROFFACTIVE_IDX;
1942 if (!spi_loaded[spi_idx])
1943 {
1944 WCHAR buf[5];
1945 if(SYSPARAMS_Load( SPI_SETPOWEROFFACTIVE_REGKEY,
1946 SPI_SETPOWEROFFACTIVE_VALNAME,
1947 buf, sizeof(buf) ))
1948 poweroffactive = atoiW(buf);
1949 spi_loaded[spi_idx] = TRUE;
1950 }
1951 *(BOOL *)pvParam = poweroffactive;
1952 break;
1953
1954 case SPI_SETLOWPOWERACTIVE: /* 85 WINVER >= 0x400 */
1955 {
1956 WCHAR buf[5];
1957
1958 spi_idx = SPI_SETLOWPOWERACTIVE_IDX;
1959 wsprintfW(buf, CSu, uiParam);
1960
1961 if (SYSPARAMS_Save( SPI_SETLOWPOWERACTIVE_REGKEY,
1962 SPI_SETLOWPOWERACTIVE_VALNAME,
1963 buf, fWinIni ))
1964 {
1965 lowpoweractive = uiParam;
1966 spi_loaded[spi_idx] = TRUE;
1967 }
1968 else
1969 ret = FALSE;
1970 break;
1971 }
1972
1973 case SPI_SETPOWEROFFACTIVE: /* 86 WINVER >= 0x400 */
1974 {
1975 WCHAR buf[5];
1976
1977 spi_idx = SPI_SETPOWEROFFACTIVE_IDX;
1978 wsprintfW(buf, CSu, uiParam);
1979
1980 if (SYSPARAMS_Save( SPI_SETPOWEROFFACTIVE_REGKEY,
1981 SPI_SETPOWEROFFACTIVE_VALNAME,
1982 buf, fWinIni ))
1983 {
1984 poweroffactive = uiParam;
1985 spi_loaded[spi_idx] = TRUE;
1986 }
1987 else
1988 ret = FALSE;
1989 break;
1990 }
1991
1992 WINE_SPI_FIXME(SPI_SETCURSORS); /* 87 WINVER >= 0x400 */
1993 WINE_SPI_FIXME(SPI_SETICONS); /* 88 WINVER >= 0x400 */
1994
1995 case SPI_GETDEFAULTINPUTLANG: /* 89 WINVER >= 0x400 */
1996 ret = GetKeyboardLayout(0) ? TRUE : FALSE;
1997 break;
1998
1999 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG); /* 90 WINVER >= 0x400 */
2000
2001 WINE_SPI_FIXME(SPI_SETLANGTOGGLE); /* 91 WINVER >= 0x400 */
2002
2003 case SPI_GETWINDOWSEXTENSION: /* 92 WINVER >= 0x400 */
2004 WARN("pretend no support for Win9x Plus! for now.\n");
2005 ret = FALSE; /* yes, this is the result value */
2006 break;
2007
2008 WINE_SPI_FIXME(SPI_SETMOUSETRAILS); /* 93 WINVER >= 0x400 */
2009 WINE_SPI_FIXME(SPI_GETMOUSETRAILS); /* 94 WINVER >= 0x400 */
2010
2011 case SPI_SETSCREENSAVERRUNNING: /* 97 WINVER >= 0x400 */
2012 {
2013 /* SPI_SCREENSAVERRUNNING is an alias for SPI_SETSCREENSAVERRUNNING */
2014 WCHAR buf[5];
2015
2016 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
2017 wsprintfW(buf, CSu, uiParam);
2018
2019 /* save only temporarily */
2020 if (SYSPARAMS_Save( SPI_SETSCREENSAVERRUNNING_REGKEY,
2021 SPI_SETSCREENSAVERRUNNING_VALNAME,
2022 buf, 0 ))
2023 {
2024 screensaver_running = uiParam;
2025 spi_loaded[spi_idx] = TRUE;
2026 }
2027 else
2028 ret = FALSE;
2029 break;
2030 }
2031
2032 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2033 if (!pvParam) return FALSE;
2034
2035 spi_idx = SPI_SETMOUSEHOVERWIDTH_IDX;
2036 if (!spi_loaded[spi_idx])
2037 {
2038 WCHAR buf[10];
2039
2040 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERWIDTH_REGKEY,
2041 SPI_SETMOUSEHOVERWIDTH_VALNAME,
2042 buf, sizeof(buf) ))
2043 mouse_hover_width = atoiW( buf );
2044 spi_loaded[spi_idx] = TRUE;
2045 }
2046 *(INT *)pvParam = mouse_hover_width;
2047 break;
2048
2049 case SPI_SETMOUSEHOVERWIDTH: /* 99 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2050 {
2051 WCHAR buf[10];
2052
2053 spi_idx = SPI_SETMOUSEHOVERWIDTH_IDX;
2054 wsprintfW(buf, CSu, uiParam);
2055
2056 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERWIDTH_REGKEY,
2057 SPI_SETMOUSEHOVERWIDTH_VALNAME,
2058 buf, fWinIni ))
2059 {
2060 mouse_hover_width = uiParam;
2061 spi_loaded[spi_idx] = TRUE;
2062 }
2063 else
2064 ret = FALSE;
2065 break;
2066 }
2067
2068 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2069 if (!pvParam) return FALSE;
2070
2071 spi_idx = SPI_SETMOUSEHOVERHEIGHT_IDX;
2072 if (!spi_loaded[spi_idx])
2073 {
2074 WCHAR buf[10];
2075
2076 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
2077 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
2078 buf, sizeof(buf) ))
2079 mouse_hover_height = atoiW( buf );
2080
2081 spi_loaded[spi_idx] = TRUE;
2082 }
2083 *(INT *)pvParam = mouse_hover_height;
2084 break;
2085
2086 case SPI_SETMOUSEHOVERHEIGHT: /* 101 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2087 {
2088 WCHAR buf[10];
2089
2090 spi_idx = SPI_SETMOUSEHOVERHEIGHT_IDX;
2091 wsprintfW(buf, CSu, uiParam);
2092
2093 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
2094 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
2095 buf, fWinIni ))
2096 {
2097 mouse_hover_height = uiParam;
2098 spi_loaded[spi_idx] = TRUE;
2099 }
2100 else
2101 ret = FALSE;
2102 break;
2103 }
2104
2105 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2106 if (!pvParam) return FALSE;
2107
2108 spi_idx = SPI_SETMOUSEHOVERTIME_IDX;
2109 if (!spi_loaded[spi_idx])
2110 {
2111 WCHAR buf[10];
2112
2113 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERTIME_REGKEY,
2114 SPI_SETMOUSEHOVERTIME_VALNAME,
2115 buf, sizeof(buf) ))
2116 mouse_hover_time = atoiW( buf );
2117
2118 spi_loaded[spi_idx] = TRUE;
2119 }
2120 *(INT *)pvParam = mouse_hover_time;
2121 break;
2122
2123 case SPI_SETMOUSEHOVERTIME: /* 103 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2124 {
2125 WCHAR buf[10];
2126
2127 spi_idx = SPI_SETMOUSEHOVERTIME_IDX;
2128 wsprintfW(buf, CSu, uiParam);
2129
2130 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERTIME_REGKEY,
2131 SPI_SETMOUSEHOVERTIME_VALNAME,
2132 buf, fWinIni ))
2133 {
2134 mouse_hover_time = uiParam;
2135 spi_loaded[spi_idx] = TRUE;
2136 }
2137 else
2138 ret = FALSE;
2139 break;
2140 }
2141
2142 case SPI_GETWHEELSCROLLLINES: /* 104 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2143 if (!pvParam) return FALSE;
2144
2145 spi_idx = SPI_SETMOUSESCROLLLINES_IDX;
2146 if (!spi_loaded[spi_idx])
2147 {
2148 WCHAR buf[10];
2149
2150 if (SYSPARAMS_Load( SPI_SETMOUSESCROLLLINES_REGKEY,
2151 SPI_SETMOUSESCROLLLINES_VALNAME,
2152 buf, sizeof(buf) ))
2153 mouse_scroll_lines = atoiW( buf );
2154
2155 spi_loaded[spi_idx] = TRUE;
2156 }
2157 *(INT *)pvParam = mouse_scroll_lines;
2158 break;
2159
2160 case SPI_SETWHEELSCROLLLINES: /* 105 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2161 {
2162 WCHAR buf[10];
2163
2164 spi_idx = SPI_SETMOUSESCROLLLINES_IDX;
2165 wsprintfW(buf, CSu, uiParam);
2166
2167 if (SYSPARAMS_Save( SPI_SETMOUSESCROLLLINES_REGKEY,
2168 SPI_SETMOUSESCROLLLINES_VALNAME,
2169 buf, fWinIni ))
2170 {
2171 mouse_scroll_lines = uiParam;
2172 spi_loaded[spi_idx] = TRUE;
2173 }
2174 else
2175 ret = FALSE;
2176 break;
2177 }
2178
2179 case SPI_GETMENUSHOWDELAY: /* 106 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2180 if (!pvParam) return FALSE;
2181
2182 spi_idx = SPI_SETMENUSHOWDELAY_IDX;
2183 if (!spi_loaded[spi_idx])
2184 {
2185 WCHAR buf[10];
2186
2187 if (SYSPARAMS_Load( SPI_SETMENUSHOWDELAY_REGKEY,
2188 SPI_SETMENUSHOWDELAY_VALNAME,
2189 buf, sizeof(buf) ))
2190 menu_show_delay = atoiW( buf );
2191
2192 spi_loaded[spi_idx] = TRUE;
2193 }
2194 *(INT *)pvParam = menu_show_delay;
2195 break;
2196
2197 case SPI_SETMENUSHOWDELAY: /* 107 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2198 {
2199 WCHAR buf[10];
2200
2201 spi_idx = SPI_SETMENUSHOWDELAY_IDX;
2202 wsprintfW(buf, CSu, uiParam);
2203
2204 if (SYSPARAMS_Save( SPI_SETMENUSHOWDELAY_REGKEY,
2205 SPI_SETMENUSHOWDELAY_VALNAME,
2206 buf, fWinIni ))
2207 {
2208 menu_show_delay = uiParam;
2209 spi_loaded[spi_idx] = TRUE;
2210 }
2211 else
2212 ret = FALSE;
2213 break;
2214 }
2215
2216 WINE_SPI_FIXME(SPI_GETSHOWIMEUI); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2217 WINE_SPI_FIXME(SPI_SETSHOWIMEUI); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2218 WINE_SPI_FIXME(SPI_GETMOUSESPEED); /* 112 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2219 WINE_SPI_FIXME(SPI_SETMOUSESPEED); /* 113 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2220
2221 case SPI_GETSCREENSAVERRUNNING: /* 114 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2222 if (!pvParam) return FALSE;
2223
2224 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
2225 if (!spi_loaded[spi_idx])
2226 {
2227 WCHAR buf[5];
2228
2229 if (SYSPARAMS_Load( SPI_SETSCREENSAVERRUNNING_REGKEY,
2230 SPI_SETSCREENSAVERRUNNING_VALNAME, buf, sizeof(buf) ))
2231 screensaver_running = atoiW( buf );
2232 spi_loaded[spi_idx] = TRUE;
2233 }
2234
2235 *(BOOL *)pvParam = screensaver_running;
2236 break;
2237
2238 case SPI_GETDESKWALLPAPER: /* 115 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2239 {
2240 WCHAR buf[MAX_PATH];
2241
2242 if (!pvParam) return FALSE;
2243
2244 if (uiParam > MAX_PATH)
2245 {
2246 uiParam = MAX_PATH;
2247 }
2248
2249 if (SYSPARAMS_Load(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, buf, sizeof(buf)))
2250 {
2251 lstrcpynW((WCHAR*)pvParam, buf, uiParam);
2252 }
2253 else
2254 {
2255 /* Return an empty string */
2256 memset((WCHAR*)pvParam, 0, uiParam);
2257 }
2258
2259 break;
2260 }
2261
2262 WINE_SPI_FIXME(SPI_GETACTIVEWINDOWTRACKING);/* 0x1000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2263 WINE_SPI_FIXME(SPI_SETACTIVEWINDOWTRACKING);/* 0x1001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2264 WINE_SPI_FIXME(SPI_GETMENUANIMATION); /* 0x1002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2265 WINE_SPI_FIXME(SPI_SETMENUANIMATION); /* 0x1003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2266 WINE_SPI_FIXME(SPI_GETCOMBOBOXANIMATION); /* 0x1004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2267 WINE_SPI_FIXME(SPI_SETCOMBOBOXANIMATION); /* 0x1005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2268
2269 case SPI_GETLISTBOXSMOOTHSCROLLING: /* 0x1006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2270 if (!pvParam) return FALSE;
2271
2272 spi_idx = SPI_SETLISTBOXSMOOTHSCROLLING_IDX;
2273 if (!spi_loaded[spi_idx])
2274 {
2275 WCHAR buf[5];
2276
2277 if (SYSPARAMS_Load( SPI_SETLISTBOXSMOOTHSCROLLING_REGKEY,
2278 SPI_SETLISTBOXSMOOTHSCROLLING_VALNAME, buf, sizeof(buf) ))
2279 {
2280 if ((buf[0]&0x01) == 0x01)
2281 {
2282 listbox_smoothscrolling = TRUE;
2283 }
2284 }
2285 spi_loaded[spi_idx] = TRUE;
2286 }
2287
2288 *(BOOL *)pvParam = listbox_smoothscrolling;
2289
2290 break;
2291
2292 WINE_SPI_FIXME(SPI_SETLISTBOXSMOOTHSCROLLING);/* 0x1007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2293
2294 case SPI_GETGRADIENTCAPTIONS: /* 0x1008 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2295 if (!pvParam) return FALSE;
2296
2297 spi_idx = SPI_SETGRADIENTCAPTIONS_IDX;
2298 if (!spi_loaded[spi_idx])
2299 {
2300 WCHAR buf[5];
2301
2302 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2303 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2304 {
2305 if ((buf[0]&0x10) == 0x10)
2306 {
2307 gradient_captions = TRUE;
2308 }
2309 }
2310 spi_loaded[spi_idx] = TRUE;
2311 }
2312
2313 *(BOOL *)pvParam = gradient_captions;
2314
2315 break;
2316
2317 WINE_SPI_FIXME(SPI_SETGRADIENTCAPTIONS); /* 0x1009 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2318
2319 case SPI_GETKEYBOARDCUES: /* 0x100A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2320 if (!pvParam) return FALSE;
2321
2322 spi_idx = SPI_SETKEYBOARDCUES_IDX;
2323 if (!spi_loaded[spi_idx])
2324 {
2325 WCHAR buf[5];
2326
2327 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2328 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2329 {
2330 if ((buf[0]&0x20) == 0x20)
2331 {
2332 keyboard_cues = TRUE;
2333 }
2334 }
2335 spi_loaded[spi_idx] = TRUE;
2336 }
2337
2338 *(BOOL *)pvParam = keyboard_cues;
2339
2340 break;
2341
2342 WINE_SPI_FIXME(SPI_SETKEYBOARDCUES); /* 0x100B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2343 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKZORDER); /* 0x100C _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2344 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKZORDER); /* 0x100D _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2345 case SPI_GETHOTTRACKING: /* 0x100E _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2346 if (!pvParam) return FALSE;
2347
2348 spi_idx = SPI_SETHOTTRACKING_IDX;
2349 if (!spi_loaded[spi_idx])
2350 {
2351 WCHAR buf[5];
2352
2353 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2354 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2355 {
2356 if ((buf[0]&0x80) == 0x80)
2357 {
2358 hot_tracking = TRUE;
2359 }
2360 }
2361 spi_loaded[spi_idx] = TRUE;
2362 }
2363
2364 *(BOOL *)pvParam = hot_tracking;
2365
2366 break;
2367
2368 WINE_SPI_FIXME(SPI_SETHOTTRACKING); /* 0x100F _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2369 WINE_SPI_FIXME(SPI_GETSELECTIONFADE); /* 0x1014 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2370 WINE_SPI_FIXME(SPI_SETSELECTIONFADE); /* 0x1015 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2371 WINE_SPI_FIXME(SPI_GETMOUSESONAR); /* 0x101C _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2372 WINE_SPI_FIXME(SPI_SETMOUSESONAR); /* 0x101D _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2373 WINE_SPI_FIXME(SPI_GETMOUSECLICKLOCK); /* 0x101E _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2374 WINE_SPI_FIXME(SPI_SETMOUSECLICKLOCK); /* 0x101F _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2375 WINE_SPI_FIXME(SPI_GETMOUSEVANISH); /* 0x1020 _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2376 WINE_SPI_FIXME(SPI_SETMOUSEVANISH); /* 0x1021 _WIN32_WINNT >= 0x510 || _WIN32_WINDOW >= 0x490*/
2377 WINE_SPI_FIXME(SPI_GETFLATMENU); /* 0x1022 _WIN32_WINNT >= 0x510 */
2378 WINE_SPI_FIXME(SPI_SETFLATMENU); /* 0x1023 _WIN32_WINNT >= 0x510 */
2379 WINE_SPI_FIXME(SPI_GETDROPSHADOW); /* 0x1024 _WIN32_WINNT >= 0x510 */
2380 WINE_SPI_FIXME(SPI_SETDROPSHADOW); /* 0x1025 _WIN32_WINNT >= 0x510 */
2381 WINE_SPI_FIXME(SPI_GETBLOCKSENDINPUTRESETS);
2382 WINE_SPI_FIXME(SPI_SETBLOCKSENDINPUTRESETS);
2383 WINE_SPI_FIXME(SPI_GETUIEFFECTS);
2384 WINE_SPI_FIXME(SPI_SETUIEFFECTS);
2385 WINE_SPI_FIXME(SPI_GETFOREGROUNDLOCKTIMEOUT);/* 0x2000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2386 WINE_SPI_FIXME(SPI_SETFOREGROUNDLOCKTIMEOUT);/* 0x2001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2387 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKTIMEOUT); /* 0x2002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2388 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKTIMEOUT); /* 0x2003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2389 WINE_SPI_FIXME(SPI_GETFOREGROUNDFLASHCOUNT);/* 0x2004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2390 WINE_SPI_FIXME(SPI_SETFOREGROUNDFLASHCOUNT);/* 0x2005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2391 WINE_SPI_FIXME(SPI_GETCARETWIDTH); /* 0x2006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2392 WINE_SPI_FIXME(SPI_SETCARETWIDTH); /* 0x2007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2393 WINE_SPI_FIXME(SPI_GETMOUSECLICKLOCKTIME); /* 0x2008 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2394 WINE_SPI_FIXME(SPI_SETMOUSECLICKLOCKTIME); /* 0x2009 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2395 WINE_SPI_FIXME(SPI_GETFONTSMOOTHINGTYPE); /* 0x200A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2396 WINE_SPI_FIXME(SPI_SETFONTSMOOTHINGTYPE); /* 0x200B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2397 WINE_SPI_FIXME(SPI_GETFONTSMOOTHINGCONTRAST);/* 0x200C _WIN32_WINNT >= 0x510 */
2398 WINE_SPI_FIXME(SPI_SETFONTSMOOTHINGCONTRAST);/* 0x200D _WIN32_WINNT >= 0x510 */
2399 WINE_SPI_FIXME(SPI_GETFOCUSBORDERWIDTH); /* 0x200E _WIN32_WINNT >= 0x510 */
2400 WINE_SPI_FIXME(SPI_SETFOCUSBORDERWIDTH); /* 0x200F _WIN32_WINNT >= 0x510 */
2401 WINE_SPI_FIXME(SPI_GETFOCUSBORDERHEIGHT); /* 0x2010 _WIN32_WINNT >= 0x510 */
2402 WINE_SPI_FIXME(SPI_SETFOCUSBORDERHEIGHT); /* 0x2011 _WIN32_WINNT >= 0x510 */
2403
2404 default:
2405 FIXME( "Unknown action: %u\n", uiAction );
2406 SetLastError( ERROR_INVALID_SPI_VALUE );
2407 ret = FALSE;
2408 break;
2409 }
2410
2411 if (ret)
2412 SYSPARAMS_NotifyChange( uiAction, fWinIni );
2413 return ret;
2414
2415 #undef WINE_SPI_FIXME
2416 #undef WINE_SPI_WARN
2417 }
2418
2419
2420 /***********************************************************************
2421 * SystemParametersInfo (USER.483)
2422 */
2423 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
2424 LPVOID lpvParam, UINT16 fuWinIni )
2425 {
2426 BOOL16 ret;
2427
2428 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
2429
2430 switch (uAction)
2431 {
2432 case SPI_GETBEEP: /* 1 */
2433 case SPI_GETSCREENSAVEACTIVE: /* 16 */
2434 case SPI_GETICONTITLEWRAP: /* 25 */
2435 case SPI_GETMENUDROPALIGNMENT: /* 27 */
2436 case SPI_GETFASTTASKSWITCH: /* 35 */
2437 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
2438 {
2439 BOOL tmp;
2440 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2441 if (ret && lpvParam)
2442 *(BOOL16 *)lpvParam = tmp;
2443 break;
2444 }
2445
2446 case SPI_GETBORDER: /* 5 */
2447 case SPI_ICONHORIZONTALSPACING: /* 13 */
2448 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
2449 case SPI_GETGRIDGRANULARITY: /* 18 */
2450 case SPI_GETKEYBOARDDELAY: /* 22 */
2451 case SPI_ICONVERTICALSPACING: /* 24 */
2452 {
2453 INT tmp;
2454 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2455 if (ret && lpvParam)
2456 *(INT16 *)lpvParam = tmp;
2457 break;
2458 }
2459
2460 case SPI_GETKEYBOARDSPEED: /* 10 */
2461 {
2462 DWORD tmp;
2463 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2464 if (ret && lpvParam)
2465 *(WORD *)lpvParam = tmp;
2466 break;
2467 }
2468
2469 case SPI_GETICONTITLELOGFONT: /* 31 */
2470 {
2471 LOGFONTA tmp;
2472 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2473 if (ret && lpvParam)
2474 SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
2475 break;
2476 }
2477
2478 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2479 {
2480 NONCLIENTMETRICSA tmp;
2481 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
2482 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
2483 {
2484 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
2485 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
2486 if (ret)
2487 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
2488 }
2489 else /* winfile 95 sets cbSize to 340 */
2490 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2491 break;
2492 }
2493
2494 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
2495 {
2496 RECT tmp;
2497 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2498 if (ret && lpvParam)
2499 {
2500 RECT16 *r16 = (RECT16 *)lpvParam;
2501 r16->left = tmp.left;
2502 r16->top = tmp.top;
2503 r16->right = tmp.right;
2504 r16->bottom = tmp.bottom;
2505 }
2506 break;
2507 }
2508
2509 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2510 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2511 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2512 {
2513 UINT tmp;
2514 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2515 if (ret && lpvParam)
2516 *(UINT16 *)lpvParam = tmp;
2517 break;
2518 }
2519
2520 default:
2521 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2522 }
2523
2524 return ret;
2525 }
2526
2527 /***********************************************************************
2528 * SystemParametersInfoA (USER32.@)
2529 */
2530 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
2531 PVOID pvParam, UINT fuWinIni )
2532 {
2533 BOOL ret;
2534
2535 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
2536
2537 switch (uiAction)
2538 {
2539 case SPI_SETDESKWALLPAPER: /* 20 */
2540 case SPI_SETDESKPATTERN: /* 21 */
2541 {
2542 WCHAR buffer[256];
2543 if (pvParam)
2544 if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)pvParam, -1,
2545 buffer, sizeof(buffer)/sizeof(WCHAR) ))
2546 buffer[sizeof(buffer)/sizeof(WCHAR)-1] = 0;
2547 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
2548 break;
2549 }
2550
2551 case SPI_GETICONTITLELOGFONT: /* 31 */
2552 {
2553 LOGFONTW tmp;
2554 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
2555 if (ret && pvParam)
2556 SYSPARAMS_LogFont32WTo32A( &tmp, (LPLOGFONTA)pvParam );
2557 break;
2558 }
2559
2560 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2561 {
2562 NONCLIENTMETRICSW tmp;
2563 LPNONCLIENTMETRICSA lpnmA = (LPNONCLIENTMETRICSA)pvParam;
2564 if (lpnmA && lpnmA->cbSize == sizeof(NONCLIENTMETRICSA))
2565 {
2566 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2567 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2568 if (ret)
2569 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
2570 }
2571 else
2572 ret = FALSE;
2573 break;
2574 }
2575
2576 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
2577 {
2578 ICONMETRICSW tmp;
2579 LPICONMETRICSA lpimA = (LPICONMETRICSA)pvParam;
2580 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2581 {
2582 tmp.cbSize = sizeof(ICONMETRICSW);
2583 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2584 if (ret)
2585 {
2586 lpimA->iHorzSpacing = tmp.iHorzSpacing;
2587 lpimA->iVertSpacing = tmp.iVertSpacing;
2588 lpimA->iTitleWrap = tmp.iTitleWrap;
2589 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
2590 }
2591 }
2592 else
2593 ret = FALSE;
2594 break;
2595 }
2596
2597 case SPI_SETICONMETRICS: /* 46 WINVER >= 0x400 */
2598 {
2599 ICONMETRICSW tmp;
2600 LPICONMETRICSA lpimA = (LPICONMETRICSA)pvParam;
2601 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2602 {
2603 tmp.cbSize = sizeof(ICONMETRICSW);
2604 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2605 if (ret)
2606 {
2607 lpimA->iHorzSpacing = tmp.iHorzSpacing;
2608 lpimA->iVertSpacing = tmp.iVertSpacing;
2609 lpimA->iTitleWrap = tmp.iTitleWrap;
2610 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
2611 }
2612 }
2613 else
2614 ret = FALSE;
2615 break;
2616 }
2617
2618 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
2619 {
2620 HIGHCONTRASTW tmp;
2621 LPHIGHCONTRASTA lphcA = (LPHIGHCONTRASTA)pvParam;
2622 if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
2623 {
2624 tmp.cbSize = sizeof(HIGHCONTRASTW);
2625 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2626 if (ret)
2627 {
2628 lphcA->dwFlags = tmp.dwFlags;
2629 lphcA->lpszDefaultScheme = NULL; /* FIXME? */
2630 }
2631 }
2632 else
2633 ret = FALSE;
2634 break;
2635 }
2636
2637 default:
2638 ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
2639 break;
2640 }
2641 return ret;
2642 }
2643
2644
2645 /***********************************************************************
2646 * GetSystemMetrics (USER32.@)
2647 */
2648 INT WINAPI GetSystemMetrics( INT index )
2649 {
2650 /* some metrics are dynamic */
2651 switch (index)
2652 {
2653 case SM_CXSCREEN:
2654 case SM_CXFULLSCREEN:
2655 case SM_CXVIRTUALSCREEN:
2656 return GetDeviceCaps( display_dc, HORZRES );
2657 case SM_CYSCREEN:
2658 case SM_CYVIRTUALSCREEN:
2659 return GetDeviceCaps( display_dc, VERTRES );
2660 case SM_CYFULLSCREEN:
2661 return GetDeviceCaps( display_dc, VERTRES ) - sysMetrics[SM_CYCAPTION];
2662
2663 /* FIXME: How do I calculate these? */
2664 case SM_CXMAXTRACK:
2665 return GetDeviceCaps( display_dc, HORZRES ) + 4 + 2 * sysMetrics[SM_CXFRAME];
2666 case SM_CYMAXTRACK:
2667 return GetDeviceCaps( display_dc, VERTRES ) + 4 + 2 * sysMetrics[SM_CYFRAME];
2668 case SM_CXMAXIMIZED:
2669 return GetDeviceCaps( display_dc, HORZRES ) + 2 * sysMetrics[SM_CXFRAME];
2670 case SM_CYMAXIMIZED:
2671 return GetDeviceCaps( display_dc, VERTRES ) + 2 * sysMetrics[SM_CYFRAME];
2672
2673 default:
2674 if ((index < 0) || (index > SM_CMETRICS)) return 0;
2675 return sysMetrics[index];
2676 }
2677 }
2678
2679
2680 /**********************************************************************
2681 * SetDoubleClickTime (USER32.@)
2682 */
2683 BOOL WINAPI SetDoubleClickTime( UINT interval )
2684 {
2685 return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
2686 }
2687
2688
2689 /**********************************************************************
2690 * GetDoubleClickTime (USER32.@)
2691 */
2692 UINT WINAPI GetDoubleClickTime(void)
2693 {
2694 WCHAR buf[10];
2695
2696 if (!spi_loaded[SPI_SETDOUBLECLICKTIME_IDX])
2697 {
2698 if (SYSPARAMS_Load( SPI_SETDOUBLECLICKTIME_REGKEY,
2699 SPI_SETDOUBLECLICKTIME_VALNAME,
2700 buf, sizeof(buf) ))
2701 {
2702 double_click_time = atoiW( buf );
2703 if (!double_click_time) double_click_time = 500;
2704 }
2705 spi_loaded[SPI_SETDOUBLECLICKTIME_IDX] = TRUE;
2706 }
2707 return double_click_time;
2708 }
Maarten's multimedia branch