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