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