?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix port enumeration.
[wine/dcerpc.git] / windows / sysparams.c
blob5bf84fde97199eccc00426ac33755d691bd1ef80
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 *(BOOL *)pvParam = USER_Driver.pGetScreenSaveActive();
879 break;
880
881 case SPI_SETSCREENSAVEACTIVE: /* 17 */
882 {
883 WCHAR buf[5];
884
885 wsprintfW(buf, CSu, uiParam);
886 USER_Driver.pSetScreenSaveActive( uiParam );
887 /* saved value does not affect Wine */
888 SYSPARAMS_Save( SPI_SETSCREENSAVEACTIVE_REGKEY,
889 SPI_SETSCREENSAVEACTIVE_VALNAME,
890 buf, fWinIni );
891 break;
892 }
893
894 case SPI_GETGRIDGRANULARITY: /* 18 */
895 if (!pvParam) return FALSE;
896
897 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
898 if (!spi_loaded[spi_idx])
899 {
900 WCHAR buf[10];
901
902 if (SYSPARAMS_Load( SPI_SETGRIDGRANULARITY_REGKEY,
903 SPI_SETGRIDGRANULARITY_VALNAME,
904 buf, sizeof(buf) ))
905 grid_granularity = atoiW( buf );
906
907 spi_loaded[spi_idx] = TRUE;
908 }
909 *(INT *)pvParam = grid_granularity;
910 break;
911
912 case SPI_SETGRIDGRANULARITY: /* 19 */
913 {
914 WCHAR buf[10];
915
916 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
917 wsprintfW(buf, CSu, uiParam);
918
919 if (SYSPARAMS_Save( SPI_SETGRIDGRANULARITY_REGKEY,
920 SPI_SETGRIDGRANULARITY_VALNAME,
921 buf, fWinIni ))
922 {
923 grid_granularity = uiParam;
924 spi_loaded[spi_idx] = TRUE;
925 }
926 else
927 ret = FALSE;
928 break;
929 }
930
931 case SPI_SETDESKWALLPAPER: /* 20 */
932 if (!pvParam || !SetDeskWallPaper( (LPSTR)pvParam )) return FALSE;
933 SYSPARAMS_Save(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, pvParam, fWinIni);
934 break;
935
936 case SPI_SETDESKPATTERN: /* 21 */
937 /* FIXME: the ability to specify a pattern in pvParam
938 doesn't seem to be documented for Win32 */
939 if ((INT16)uiParam == -1)
940 {
941 WCHAR buf[256];
942 GetProfileStringW( Desktop, Pattern,
943 defPattern,
944 buf, sizeof(buf)/sizeof(WCHAR) );
945 ret = DESKTOP_SetPattern( buf );
946 } else
947 ret = DESKTOP_SetPattern( (LPWSTR)pvParam );
948 break;
949
950 case SPI_GETKEYBOARDDELAY: /* 22 */
951 if (!pvParam) return FALSE;
952
953 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
954 if (!spi_loaded[spi_idx])
955 {
956 WCHAR buf[10];
957
958 if (SYSPARAMS_Load( SPI_SETKEYBOARDDELAY_REGKEY,
959 SPI_SETKEYBOARDDELAY_VALNAME,
960 buf, sizeof(buf) ))
961 {
962 int i = atoiW( buf );
963 if ( (i >= 0) && (i <= 3)) keyboard_delay = i;
964 }
965
966 spi_loaded[spi_idx] = TRUE;
967 }
968 *(INT *)pvParam = keyboard_delay;
969 break;
970
971 case SPI_SETKEYBOARDDELAY: /* 23 */
972 {
973 WCHAR buf[10];
974
975 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
976 wsprintfW(buf, CSu, uiParam);
977
978 if (SYSPARAMS_Save( SPI_SETKEYBOARDDELAY_REGKEY,
979 SPI_SETKEYBOARDDELAY_VALNAME,
980 buf, fWinIni ))
981 {
982 if (uiParam <= 3)
983 keyboard_delay = uiParam;
984 spi_loaded[spi_idx] = TRUE;
985 }
986 else
987 ret = FALSE;
988 break;
989 }
990
991 case SPI_ICONVERTICALSPACING: /* 24 */
992 spi_idx = SPI_ICONVERTICALSPACING_IDX;
993 if (pvParam != NULL)
994 {
995 if (!spi_loaded[spi_idx])
996 {
997 WCHAR buf[10];
998 int val;
999
1000 if (SYSPARAMS_Load( SPI_ICONVERTICALSPACING_REGKEY,
1001 SPI_ICONVERTICALSPACING_VALNAME, buf, sizeof(buf) ))
1002 {
1003 val = SYSPARAMS_Twips2Pixels( atoiW(buf) );
1004 SYSMETRICS_Set( SM_CYICONSPACING, val );
1005 }
1006 spi_loaded[spi_idx] = TRUE;
1007 }
1008
1009 *(INT *)pvParam = GetSystemMetrics( SM_CYICONSPACING );
1010 }
1011 else
1012 {
1013 WCHAR buf[10];
1014
1015 if (uiParam < 32) uiParam = 32;
1016
1017 wsprintfW(buf, CSu, uiParam);
1018 if (SYSPARAMS_Save( SPI_ICONVERTICALSPACING_REGKEY,
1019 SPI_ICONVERTICALSPACING_VALNAME,
1020 buf, fWinIni ))
1021 {
1022 SYSMETRICS_Set( SM_CYICONSPACING, uiParam );
1023 spi_loaded[spi_idx] = TRUE;
1024 }
1025 else
1026 ret = FALSE;
1027 }
1028
1029 break;
1030
1031 case SPI_GETICONTITLEWRAP: /* 25 */
1032 if (!pvParam) return FALSE;
1033
1034 spi_idx = SPI_SETICONTITLEWRAP_IDX;
1035 if (!spi_loaded[spi_idx])
1036 {
1037 WCHAR buf[5];
1038
1039 if (SYSPARAMS_Load( SPI_SETICONTITLEWRAP_REGKEY1,
1040 SPI_SETICONTITLEWRAP_VALNAME, buf, sizeof(buf) ))
1041 icon_title_wrap = atoiW(buf);
1042 spi_loaded[spi_idx] = TRUE;
1043 }
1044
1045 *(BOOL *)pvParam = icon_title_wrap;
1046 break;
1047
1048 case SPI_SETICONTITLEWRAP: /* 26 */
1049 {
1050 WCHAR buf[5];
1051
1052 spi_idx = SPI_SETICONTITLEWRAP_IDX;
1053 wsprintfW(buf, CSu, uiParam);
1054 if (SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY1,
1055 SPI_SETICONTITLEWRAP_VALNAME,
1056 buf, fWinIni ))
1057 {
1058 SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY2,
1059 SPI_SETICONTITLEWRAP_VALNAME,
1060 buf, fWinIni );
1061 icon_title_wrap = uiParam;
1062 spi_loaded[spi_idx] = TRUE;
1063 }
1064 else
1065 ret = FALSE;
1066 break;
1067 }
1068
1069 case SPI_GETMENUDROPALIGNMENT: /* 27 */
1070 if (!pvParam) return FALSE;
1071
1072 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1073
1074 if (!spi_loaded[spi_idx])
1075 {
1076 WCHAR buf[5];
1077
1078 if (SYSPARAMS_Load( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1079 SPI_SETMENUDROPALIGNMENT_VALNAME, buf, sizeof(buf) ))
1080 {
1081 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, atoiW( buf ) );
1082 }
1083 spi_loaded[spi_idx] = TRUE;
1084 }
1085
1086 *(BOOL *)pvParam = GetSystemMetrics( SM_MENUDROPALIGNMENT );
1087 break;
1088
1089 case SPI_SETMENUDROPALIGNMENT: /* 28 */
1090 {
1091 WCHAR buf[5];
1092 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
1093
1094 wsprintfW(buf, CSu, uiParam);
1095 if (SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY1,
1096 SPI_SETMENUDROPALIGNMENT_VALNAME,
1097 buf, fWinIni ))
1098 {
1099 SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY2,
1100 SPI_SETMENUDROPALIGNMENT_VALNAME,
1101 buf, fWinIni );
1102 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, uiParam );
1103 spi_loaded[spi_idx] = TRUE;
1104 }
1105 else
1106 ret = FALSE;
1107 break;
1108 }
1109
1110 case SPI_SETDOUBLECLKWIDTH: /* 29 */
1111 {
1112 WCHAR buf[10];
1113 spi_idx = SPI_SETDOUBLECLKWIDTH_IDX;
1114
1115 wsprintfW(buf, CSu, uiParam);
1116 if (SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY1,
1117 SPI_SETDOUBLECLKWIDTH_VALNAME,
1118 buf, fWinIni ))
1119 {
1120 SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY2,
1121 SPI_SETDOUBLECLKWIDTH_VALNAME,
1122 buf, fWinIni );
1123 SYSMETRICS_Set( SM_CXDOUBLECLK, uiParam );
1124 spi_loaded[spi_idx] = TRUE;
1125 }
1126 else
1127 ret = FALSE;
1128 break;
1129 }
1130
1131 case SPI_SETDOUBLECLKHEIGHT: /* 30 */
1132 {
1133 WCHAR buf[10];
1134 spi_idx = SPI_SETDOUBLECLKHEIGHT_IDX;
1135
1136 wsprintfW(buf, CSu, uiParam);
1137 if (SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
1138 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1139 buf, fWinIni ))
1140 {
1141 SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY2,
1142 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1143 buf, fWinIni );
1144 SYSMETRICS_Set( SM_CYDOUBLECLK, uiParam );
1145 spi_loaded[spi_idx] = TRUE;
1146 }
1147 else
1148 ret = FALSE;
1149 break;
1150 }
1151
1152 case SPI_GETICONTITLELOGFONT: /* 31 */
1153 {
1154 LPLOGFONTW lpLogFont = (LPLOGFONTW)pvParam;
1155 LOGFONTW lfDefault;
1156
1157 if (!pvParam) return FALSE;
1158
1159 /*
1160 * The 'default GDI fonts' seems to be returned.
1161 * If a returned font is not a correct font in your environment,
1162 * please try to fix objects/gdiobj.c at first.
1163 */
1164 SYSPARAMS_GetGUIFont( &lfDefault );
1165
1166 GetProfileStringW( Desktop, IconTitleFaceName,
1167 lfDefault.lfFaceName,
1168 lpLogFont->lfFaceName, LF_FACESIZE );
1169 lpLogFont->lfHeight = -GetProfileIntW( Desktop, IconTitleSize, 11 );
1170 lpLogFont->lfWidth = 0;
1171 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1172 lpLogFont->lfWeight = FW_NORMAL;
1173 lpLogFont->lfItalic = FALSE;
1174 lpLogFont->lfStrikeOut = FALSE;
1175 lpLogFont->lfUnderline = FALSE;
1176 lpLogFont->lfCharSet = lfDefault.lfCharSet; /* at least 'charset' should not be hard-coded */
1177 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1178 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1179 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH;
1180 lpLogFont->lfQuality = DEFAULT_QUALITY;
1181 break;
1182 }
1183
1184 case SPI_SETDOUBLECLICKTIME: /* 32 */
1185 {
1186 WCHAR buf[10];
1187
1188 spi_idx = SPI_SETDOUBLECLICKTIME_IDX;
1189 wsprintfW(buf, CSu, uiParam);
1190
1191 if (SYSPARAMS_Save( SPI_SETDOUBLECLICKTIME_REGKEY,
1192 SPI_SETDOUBLECLICKTIME_VALNAME,
1193 buf, fWinIni ))
1194 {
1195 if (!uiParam)
1196 uiParam = 500;
1197 double_click_time = uiParam;
1198 spi_loaded[spi_idx] = TRUE;
1199 }
1200 else
1201 ret = FALSE;
1202 break;
1203 }
1204
1205 case SPI_SETMOUSEBUTTONSWAP: /* 33 */
1206 {
1207 WCHAR buf[5];
1208 spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
1209
1210 wsprintfW(buf, CSu, uiParam);
1211 if (SYSPARAMS_Save( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1212 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1213 buf, fWinIni ))
1214 {
1215 SYSMETRICS_Set( SM_SWAPBUTTON, uiParam );
1216 spi_loaded[spi_idx] = TRUE;
1217 }
1218 else
1219 ret = FALSE;
1220 break;
1221 }
1222
1223 WINE_SPI_FIXME(SPI_SETICONTITLELOGFONT); /* 34 */
1224
1225 case SPI_GETFASTTASKSWITCH: /* 35 */
1226 if (!pvParam) return FALSE;
1227 *(BOOL *)pvParam = 1;
1228 break;
1229
1230 case SPI_SETFASTTASKSWITCH: /* 36 */
1231 /* the action is disabled */
1232 ret = FALSE;
1233 break;
1234
1235 case SPI_SETDRAGFULLWINDOWS: /* 37 WINVER >= 0x0400 */
1236 {
1237 WCHAR buf[5];
1238
1239 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1240 wsprintfW(buf, CSu, uiParam);
1241 if (SYSPARAMS_Save( SPI_SETDRAGFULLWINDOWS_REGKEY,
1242 SPI_SETDRAGFULLWINDOWS_VALNAME,
1243 buf, fWinIni ))
1244 {
1245 drag_full_windows = uiParam;
1246 spi_loaded[spi_idx] = TRUE;
1247 }
1248 else
1249 ret = FALSE;
1250 break;
1251 }
1252
1253 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1254 if (!pvParam) return FALSE;
1255
1256 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1257 if (!spi_loaded[spi_idx])
1258 {
1259 WCHAR buf[5];
1260
1261 if (SYSPARAMS_Load( SPI_SETDRAGFULLWINDOWS_REGKEY,
1262 SPI_SETDRAGFULLWINDOWS_VALNAME, buf, sizeof(buf) ))
1263 drag_full_windows = atoiW(buf);
1264 spi_loaded[spi_idx] = TRUE;
1265 }
1266
1267 *(BOOL *)pvParam = drag_full_windows;
1268 break;
1269
1270 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1271 {
1272 LPNONCLIENTMETRICSW lpnm = (LPNONCLIENTMETRICSW)pvParam;
1273
1274 if (!pvParam) return FALSE;
1275
1276 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSW))
1277 {
1278 /* clear the struct, so we have 'sane' members */
1279 memset(
1280 (char *)pvParam + sizeof(lpnm->cbSize),
1281 0,
1282 lpnm->cbSize - sizeof(lpnm->cbSize)
1283 );
1284
1285 /* initialize geometry entries */
1286 lpnm->iBorderWidth = 1;
1287 lpnm->iScrollWidth = GetSystemMetrics(SM_CXVSCROLL);
1288 lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1289
1290 /* size of the normal caption buttons */
1291 lpnm->iCaptionWidth = GetSystemMetrics(SM_CXSIZE);
1292 lpnm->iCaptionHeight = GetSystemMetrics(SM_CYSIZE);
1293
1294 /* caption font metrics */
1295 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont), 0 );
1296 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
1297
1298 /* size of the small caption buttons */
1299 lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1300 lpnm->iSmCaptionHeight = GetSystemMetrics(SM_CYSMSIZE);
1301
1302 /* small caption font metrics */
1303 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont), 0 );
1304
1305 /* menus, FIXME: names of wine.conf entries are bogus */
1306
1307 /* size of the menu (MDI) buttons */
1308 lpnm->iMenuWidth = GetSystemMetrics(SM_CXMENUSIZE);
1309 lpnm->iMenuHeight = GetSystemMetrics(SM_CYMENUSIZE);
1310
1311 /* menu font metrics */
1312 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfMenuFont), 0 );
1313 GetProfileStringW( Desktop, MenuFont, lpnm->lfCaptionFont.lfFaceName,
1314 lpnm->lfMenuFont.lfFaceName, LF_FACESIZE );
1315 lpnm->lfMenuFont.lfHeight = -GetProfileIntW( Desktop, MenuFontSize, 11 );
1316 lpnm->lfMenuFont.lfWeight = FW_NORMAL;
1317
1318 /* status bar font metrics */
1319 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1320 (LPVOID)&(lpnm->lfStatusFont), 0 );
1321 GetProfileStringW( Desktop, StatusFont, lpnm->lfCaptionFont.lfFaceName,
1322 lpnm->lfStatusFont.lfFaceName, LF_FACESIZE );
1323 lpnm->lfStatusFont.lfHeight = -GetProfileIntW( Desktop, StatusFontSize, 11 );
1324 lpnm->lfStatusFont.lfWeight = FW_NORMAL;
1325
1326 /* message font metrics */
1327 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1328 (LPVOID)&(lpnm->lfMessageFont), 0 );
1329 GetProfileStringW( Desktop, MessageFont, lpnm->lfCaptionFont.lfFaceName,
1330 lpnm->lfMessageFont.lfFaceName, LF_FACESIZE );
1331 lpnm->lfMessageFont.lfHeight = -GetProfileIntW( Desktop, MessageFontSize, 11 );
1332 lpnm->lfMessageFont.lfWeight = FW_NORMAL;
1333
1334 }
1335 else
1336 {
1337 WARN("size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSW));
1338 /* FIXME: SetLastError? */
1339 ret = FALSE;
1340 }
1341 break;
1342 }
1343 WINE_SPI_FIXME(SPI_SETNONCLIENTMETRICS); /* 42 WINVER >= 0x400 */
1344
1345 case SPI_GETMINIMIZEDMETRICS: /* 43 WINVER >= 0x400 */
1346 {
1347 MINIMIZEDMETRICS * lpMm = pvParam;
1348 if (lpMm && lpMm->cbSize == sizeof(*lpMm))
1349 {
1350 /* these taken from Win2k SP3 */
1351 lpMm->iWidth = 154;
1352 lpMm->iHorzGap = 0;
1353 lpMm->iVertGap = 0;
1354 lpMm->iArrange = 8;
1355 }
1356 else
1357 ret = FALSE;
1358 break;
1359 }
1360 WINE_SPI_FIXME(SPI_SETMINIMIZEDMETRICS); /* 44 WINVER >= 0x400 */
1361
1362 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
1363 {
1364 LPICONMETRICSW lpIcon = pvParam;
1365 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1366 {
1367 SystemParametersInfoW( SPI_ICONHORIZONTALSPACING, 0,
1368 &lpIcon->iHorzSpacing, FALSE );
1369 SystemParametersInfoW( SPI_ICONVERTICALSPACING, 0,
1370 &lpIcon->iVertSpacing, FALSE );
1371 SystemParametersInfoW( SPI_GETICONTITLEWRAP, 0,
1372 &lpIcon->iTitleWrap, FALSE );
1373 SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0,
1374 &lpIcon->lfFont, FALSE );
1375 }
1376 else
1377 {
1378 ret = FALSE;
1379 }
1380 break;
1381 }
1382 WINE_SPI_FIXME(SPI_SETICONMETRICS); /* 46 WINVER >= 0x400 */
1383
1384 case SPI_SETWORKAREA: /* 47 WINVER >= 0x400 */
1385 {
1386 static const WCHAR CSld[]={'%','l','d',' ','%','l','d',' ','%','l','d',' ','%','l','d',0};
1387 WCHAR buf[20];
1388 RECT *pr = (RECT *) pvParam;
1389
1390 if (!pvParam) return FALSE;
1391
1392 spi_idx = SPI_SETWORKAREA_IDX;
1393 wsprintfW(buf, CSld, pr->left, pr->top,
1394 pr->right, pr->bottom );
1395
1396 if (SYSPARAMS_Save( SPI_SETWORKAREA_REGKEY,
1397 SPI_SETWORKAREA_VALNAME,
1398 buf, fWinIni ))
1399 {
1400 CopyRect( &work_area, (RECT *)pvParam );
1401 spi_loaded[spi_idx] = TRUE;
1402 }
1403 else
1404 ret = FALSE;
1405 break;
1406 }
1407
1408 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1409 if (!pvParam) return FALSE;
1410
1411 spi_idx = SPI_SETWORKAREA_IDX;
1412 if (!spi_loaded[spi_idx])
1413 {
1414 WCHAR buf[20];
1415
1416 SetRect( &work_area, 0, 0,
1417 GetSystemMetrics( SM_CXSCREEN ),
1418 GetSystemMetrics( SM_CYSCREEN ) );
1419
1420 if (SYSPARAMS_Load( SPI_SETWORKAREA_REGKEY,
1421 SPI_SETWORKAREA_VALNAME,
1422 buf, sizeof(buf) ))
1423 {
1424 char tmpbuf[20];
1425 WideCharToMultiByte( CP_ACP, 0, buf, -1,
1426 tmpbuf, sizeof(tmpbuf), NULL, NULL );
1427 sscanf( tmpbuf, "%ld %ld %ld %ld",
1428 &work_area.left, &work_area.top,
1429 &work_area.right, &work_area.bottom );
1430 }
1431 spi_loaded[spi_idx] = TRUE;
1432 }
1433 CopyRect( (RECT *)pvParam, &work_area );
1434
1435 break;
1436
1437 WINE_SPI_FIXME(SPI_SETPENWINDOWS); /* 49 WINVER >= 0x400 */
1438
1439 case SPI_GETFILTERKEYS: /* 50 */
1440 {
1441 LPFILTERKEYS lpFilterKeys = (LPFILTERKEYS)pvParam;
1442 WARN("SPI_GETFILTERKEYS not fully implemented\n");
1443 if (lpFilterKeys && lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1444 {
1445 /* Indicate that no FilterKeys feature available */
1446 lpFilterKeys->dwFlags = 0;
1447 lpFilterKeys->iWaitMSec = 0;
1448 lpFilterKeys->iDelayMSec = 0;
1449 lpFilterKeys->iRepeatMSec = 0;
1450 lpFilterKeys->iBounceMSec = 0;
1451 }
1452 else
1453 {
1454 ret = FALSE;
1455 }
1456 break;
1457 }
1458 WINE_SPI_FIXME(SPI_SETFILTERKEYS); /* 51 */
1459
1460 case SPI_GETTOGGLEKEYS: /* 52 */
1461 {
1462 LPTOGGLEKEYS lpToggleKeys = (LPTOGGLEKEYS)pvParam;
1463 WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1464 if (lpToggleKeys && lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1465 {
1466 /* Indicate that no ToggleKeys feature available */
1467 lpToggleKeys->dwFlags = 0;
1468 }
1469 else
1470 {
1471 ret = FALSE;
1472 }
1473 break;
1474 }
1475 WINE_SPI_FIXME(SPI_SETTOGGLEKEYS); /* 53 */
1476
1477 case SPI_GETMOUSEKEYS: /* 54 */
1478 {
1479 LPMOUSEKEYS lpMouseKeys = (LPMOUSEKEYS)pvParam;
1480 WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1481 if (lpMouseKeys && lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1482 {
1483 /* Indicate that no MouseKeys feature available */
1484 lpMouseKeys->dwFlags = 0;
1485 lpMouseKeys->iMaxSpeed = 360;
1486 lpMouseKeys->iTimeToMaxSpeed = 1000;
1487 lpMouseKeys->iCtrlSpeed = 0;
1488 lpMouseKeys->dwReserved1 = 0;
1489 lpMouseKeys->dwReserved2 = 0;
1490 }
1491 else
1492 {
1493 ret = FALSE;
1494 }
1495 break;
1496 }
1497 WINE_SPI_FIXME(SPI_SETMOUSEKEYS); /* 55 */
1498
1499 case SPI_GETSHOWSOUNDS: /* 56 */
1500 if (!pvParam) return FALSE;
1501
1502 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1503
1504 if (!spi_loaded[spi_idx])
1505 {
1506 WCHAR buf[10];
1507
1508 if (SYSPARAMS_Load( SPI_SETSHOWSOUNDS_REGKEY,
1509 SPI_SETSHOWSOUNDS_VALNAME, buf, sizeof(buf) ))
1510 {
1511 SYSMETRICS_Set( SM_SHOWSOUNDS, atoiW( buf ) );
1512 }
1513 spi_loaded[spi_idx] = TRUE;
1514 }
1515
1516 *(INT *)pvParam = GetSystemMetrics( SM_SHOWSOUNDS );
1517 break;
1518
1519 case SPI_SETSHOWSOUNDS: /* 57 */
1520 {
1521 WCHAR buf[10];
1522 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1523
1524 wsprintfW(buf, CSu, uiParam);
1525 if (SYSPARAMS_Save( SPI_SETSHOWSOUNDS_REGKEY,
1526 SPI_SETSHOWSOUNDS_VALNAME,
1527 buf, fWinIni ))
1528 {
1529 SYSMETRICS_Set( SM_SHOWSOUNDS, uiParam );
1530 spi_loaded[spi_idx] = TRUE;
1531 }
1532 else
1533 ret = FALSE;
1534 break;
1535 }
1536
1537 case SPI_GETSTICKYKEYS: /* 58 */
1538 {
1539 LPSTICKYKEYS lpStickyKeys = (LPSTICKYKEYS)pvParam;
1540 WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1541 if (lpStickyKeys && lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1542 {
1543 /* Indicate that no StickyKeys feature available */
1544 lpStickyKeys->dwFlags = 0;
1545 }
1546 else
1547 {
1548 ret = FALSE;
1549 }
1550 break;
1551 }
1552 WINE_SPI_FIXME(SPI_SETSTICKYKEYS); /* 59 */
1553
1554 case SPI_GETACCESSTIMEOUT: /* 60 */
1555 {
1556 LPACCESSTIMEOUT lpAccessTimeout = (LPACCESSTIMEOUT)pvParam;
1557 WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1558 if (lpAccessTimeout && lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1559 {
1560 /* Indicate that no accessibility features timeout is available */
1561 lpAccessTimeout->dwFlags = 0;
1562 lpAccessTimeout->iTimeOutMSec = 0;
1563 }
1564 else
1565 {
1566 ret = FALSE;
1567 }
1568 break;
1569 }
1570 WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT); /* 61 */
1571
1572 case SPI_GETSERIALKEYS: /* 62 WINVER >= 0x400 */
1573 {
1574 LPSERIALKEYSW lpSerialKeysW = (LPSERIALKEYSW)pvParam;
1575 WARN("SPI_GETSERIALKEYS not fully implemented\n");
1576 if (lpSerialKeysW && lpSerialKeysW->cbSize == sizeof(SERIALKEYSW))
1577 {
1578 /* Indicate that no SerialKeys feature available */
1579 lpSerialKeysW->dwFlags = 0;
1580 lpSerialKeysW->lpszActivePort = NULL;
1581 lpSerialKeysW->lpszPort = NULL;
1582 lpSerialKeysW->iBaudRate = 0;
1583 lpSerialKeysW->iPortState = 0;
1584 }
1585 else
1586 {
1587 ret = FALSE;
1588 }
1589 break;
1590 }
1591 WINE_SPI_FIXME(SPI_SETSERIALKEYS); /* 63 WINVER >= 0x400 */
1592
1593 case SPI_GETSOUNDSENTRY: /* 64 */
1594 {
1595 LPSOUNDSENTRYW lpSoundSentryW = (LPSOUNDSENTRYW)pvParam;
1596 WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1597 if (lpSoundSentryW && lpSoundSentryW->cbSize == sizeof(SOUNDSENTRYW))
1598 {
1599 /* Indicate that no SoundSentry feature available */
1600 lpSoundSentryW->dwFlags = 0;
1601 lpSoundSentryW->iFSTextEffect = 0;
1602 lpSoundSentryW->iFSTextEffectMSec = 0;
1603 lpSoundSentryW->iFSTextEffectColorBits = 0;
1604 lpSoundSentryW->iFSGrafEffect = 0;
1605 lpSoundSentryW->iFSGrafEffectMSec = 0;
1606 lpSoundSentryW->iFSGrafEffectColor = 0;
1607 lpSoundSentryW->iWindowsEffect = 0;
1608 lpSoundSentryW->iWindowsEffectMSec = 0;
1609 lpSoundSentryW->lpszWindowsEffectDLL = 0;
1610 lpSoundSentryW->iWindowsEffectOrdinal = 0;
1611 }
1612 else
1613 {
1614 ret = FALSE;
1615 }
1616 break;
1617 }
1618 WINE_SPI_FIXME(SPI_SETSOUNDSENTRY); /* 65 */
1619
1620 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1621 {
1622 LPHIGHCONTRASTW lpHighContrastW = (LPHIGHCONTRASTW)pvParam;
1623 WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1624 if (lpHighContrastW && lpHighContrastW->cbSize == sizeof(HIGHCONTRASTW))
1625 {
1626 /* Indicate that no high contrast feature available */
1627 lpHighContrastW->dwFlags = 0;
1628 lpHighContrastW->lpszDefaultScheme = NULL;
1629 }
1630 else
1631 {
1632 ret = FALSE;
1633 }
1634 break;
1635 }
1636 WINE_SPI_FIXME(SPI_SETHIGHCONTRAST); /* 67 WINVER >= 0x400 */
1637
1638 case SPI_GETKEYBOARDPREF: /* 68 WINVER >= 0x400 */
1639 if (!pvParam) return FALSE;
1640
1641 spi_idx = SPI_SETKEYBOARDPREF_IDX;
1642 if (!spi_loaded[spi_idx])
1643 {
1644 WCHAR buf[5];
1645
1646 if (SYSPARAMS_Load( SPI_SETKEYBOARDPREF_REGKEY,
1647 SPI_SETKEYBOARDPREF_VALNAME, buf, sizeof(buf) ))
1648 keyboard_pref = atoiW(buf);
1649 spi_loaded[spi_idx] = TRUE;
1650 }
1651
1652 *(BOOL *)pvParam = keyboard_pref;
1653 break;
1654
1655 case SPI_SETKEYBOARDPREF: /* 69 WINVER >= 0x400 */
1656 {
1657 WCHAR buf[5];
1658
1659 spi_idx = SPI_SETKEYBOARDPREF_IDX;
1660 wsprintfW(buf, CSu, uiParam);
1661 if (SYSPARAMS_Save( SPI_SETKEYBOARDPREF_REGKEY,
1662 SPI_SETKEYBOARDPREF_VALNAME,
1663 buf, fWinIni ))
1664 {
1665 keyboard_pref = uiParam;
1666 spi_loaded[spi_idx] = TRUE;
1667 }
1668 else
1669 ret = FALSE;
1670 break;
1671 }
1672
1673 case SPI_GETSCREENREADER: /* 70 WINVER >= 0x400 */
1674 if (!pvParam) return FALSE;
1675
1676 spi_idx = SPI_SETSCREENREADER_IDX;
1677 if (!spi_loaded[spi_idx])
1678 {
1679 WCHAR buf[5];
1680
1681 if (SYSPARAMS_Load( SPI_SETSCREENREADER_REGKEY,
1682 SPI_SETSCREENREADER_VALNAME, buf, sizeof(buf) ))
1683 screen_reader = atoiW(buf);
1684 spi_loaded[spi_idx] = TRUE;
1685 }
1686
1687 *(BOOL *)pvParam = screen_reader;
1688 break;
1689
1690 case SPI_SETSCREENREADER: /* 71 WINVER >= 0x400 */
1691 {
1692 WCHAR buf[5];
1693
1694 spi_idx = SPI_SETSCREENREADER_IDX;
1695 wsprintfW(buf, CSu, uiParam);
1696 if (SYSPARAMS_Save( SPI_SETSCREENREADER_REGKEY,
1697 SPI_SETSCREENREADER_VALNAME,
1698 buf, fWinIni ))
1699 {
1700 screen_reader = uiParam;
1701 spi_loaded[spi_idx] = TRUE;
1702 }
1703 else
1704 ret = FALSE;
1705 break;
1706 }
1707
1708 case SPI_GETANIMATION: /* 72 WINVER >= 0x400 */
1709 {
1710 LPANIMATIONINFO lpAnimInfo = (LPANIMATIONINFO)pvParam;
1711
1712 /* Tell it "disabled" */
1713 if (lpAnimInfo && lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
1714 lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
1715 else
1716 ret = FALSE;
1717 break;
1718 }
1719 WINE_SPI_WARN(SPI_SETANIMATION); /* 73 WINVER >= 0x400 */
1720
1721 case SPI_GETFONTSMOOTHING: /* 74 WINVER >= 0x400 */
1722 if (!pvParam) return FALSE;
1723
1724 spi_idx = SPI_SETFONTSMOOTHING_IDX;
1725 if (!spi_loaded[spi_idx])
1726 {
1727 WCHAR buf[5];
1728
1729 if (SYSPARAMS_Load( SPI_SETFONTSMOOTHING_REGKEY,
1730 SPI_SETFONTSMOOTHING_VALNAME, buf, sizeof(buf) ))
1731 {
1732 spi_loaded[spi_idx] = TRUE;
1733 if (buf[0] == 0x01 || buf[0] == 0x02) /* 0x01 for 95/98/NT, 0x02 for 98/ME/2k/XP */
1734 {
1735 font_smoothing = TRUE;
1736 }
1737 }
1738 }
1739
1740 *(BOOL *)pvParam = font_smoothing;
1741
1742 break;
1743
1744 WINE_SPI_FIXME(SPI_SETFONTSMOOTHING); /* 75 WINVER >= 0x400 */
1745
1746 WINE_SPI_FIXME(SPI_SETDRAGWIDTH); /* 76 WINVER >= 0x400 */
1747 WINE_SPI_FIXME(SPI_SETDRAGHEIGHT); /* 77 WINVER >= 0x400 */
1748
1749 WINE_SPI_FIXME(SPI_SETHANDHELD); /* 78 WINVER >= 0x400 */
1750
1751 WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT); /* 79 WINVER >= 0x400 */
1752 WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT); /* 80 WINVER >= 0x400 */
1753 WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT); /* 81 WINVER >= 0x400 */
1754 WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT); /* 82 WINVER >= 0x400 */
1755
1756 case SPI_GETLOWPOWERACTIVE: /* 83 WINVER >= 0x400 */
1757 if (!pvParam)
1758 {
1759 SetLastError(ERROR_INVALID_PARAMETER);
1760 return FALSE;
1761 }
1762 if (!spi_loaded[SPI_GETLOWPOWERACTIVE])
1763 {
1764 WCHAR buf[5];
1765 if(SYSPARAMS_Load(SPI_GETLOPOWERACTIVE_REGKEY, SPI_GETLOPOWERACTIVE_VALNAME, buf, sizeof(buf)))
1766 {
1767 spi_loaded[SPI_GETLOWPOWERACTIVE] = TRUE;
1768 lowpoweractive = atoiW(buf);
1769 }
1770 else ret=FALSE;
1771 }
1772 *(BOOL *)pvParam = lowpoweractive;
1773 break;
1774
1775 WINE_SPI_FIXME(SPI_GETPOWEROFFACTIVE); /* 84 WINVER >= 0x400 */
1776 WINE_SPI_FIXME(SPI_SETLOWPOWERACTIVE); /* 85 WINVER >= 0x400 */
1777 WINE_SPI_FIXME(SPI_SETPOWEROFFACTIVE); /* 86 WINVER >= 0x400 */
1778
1779 WINE_SPI_FIXME(SPI_SETCURSORS); /* 87 WINVER >= 0x400 */
1780 WINE_SPI_FIXME(SPI_SETICONS); /* 88 WINVER >= 0x400 */
1781
1782 case SPI_GETDEFAULTINPUTLANG: /* 89 WINVER >= 0x400 */
1783 ret = GetKeyboardLayout(0) ? TRUE : FALSE;
1784 break;
1785
1786 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG); /* 90 WINVER >= 0x400 */
1787
1788 WINE_SPI_FIXME(SPI_SETLANGTOGGLE); /* 91 WINVER >= 0x400 */
1789
1790 case SPI_GETWINDOWSEXTENSION: /* 92 WINVER >= 0x400 */
1791 WARN("pretend no support for Win9x Plus! for now.\n");
1792 ret = FALSE; /* yes, this is the result value */
1793 break;
1794
1795 WINE_SPI_FIXME(SPI_SETMOUSETRAILS); /* 93 WINVER >= 0x400 */
1796 WINE_SPI_FIXME(SPI_GETMOUSETRAILS); /* 94 WINVER >= 0x400 */
1797
1798 case SPI_SETSCREENSAVERRUNNING: /* 97 WINVER >= 0x400 */
1799 {
1800 /* SPI_SCREENSAVERRUNNING is an alias for SPI_SETSCREENSAVERRUNNING */
1801 WCHAR buf[5];
1802
1803 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1804 wsprintfW(buf, CSu, uiParam);
1805
1806 /* save only temporarily */
1807 if (SYSPARAMS_Save( SPI_SETSCREENSAVERRUNNING_REGKEY,
1808 SPI_SETSCREENSAVERRUNNING_VALNAME,
1809 buf, 0 ))
1810 {
1811 screensaver_running = uiParam;
1812 spi_loaded[spi_idx] = TRUE;
1813 }
1814 else
1815 ret = FALSE;
1816 break;
1817 }
1818
1819 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1820 if (!pvParam) return FALSE;
1821
1822 spi_idx = SPI_SETMOUSEHOVERWIDTH_IDX;
1823 if (!spi_loaded[spi_idx])
1824 {
1825 WCHAR buf[10];
1826
1827 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERWIDTH_REGKEY,
1828 SPI_SETMOUSEHOVERWIDTH_VALNAME,
1829 buf, sizeof(buf) ))
1830 mouse_hover_width = atoiW( buf );
1831 spi_loaded[spi_idx] = TRUE;
1832 }
1833 *(INT *)pvParam = mouse_hover_width;
1834 break;
1835
1836 case SPI_SETMOUSEHOVERWIDTH: /* 99 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1837 {
1838 WCHAR buf[10];
1839
1840 spi_idx = SPI_SETMOUSEHOVERWIDTH_IDX;
1841 wsprintfW(buf, CSu, uiParam);
1842
1843 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERWIDTH_REGKEY,
1844 SPI_SETMOUSEHOVERWIDTH_VALNAME,
1845 buf, fWinIni ))
1846 {
1847 mouse_hover_width = uiParam;
1848 spi_loaded[spi_idx] = TRUE;
1849 }
1850 else
1851 ret = FALSE;
1852 break;
1853 }
1854
1855 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1856 if (!pvParam) return FALSE;
1857
1858 spi_idx = SPI_SETMOUSEHOVERHEIGHT_IDX;
1859 if (!spi_loaded[spi_idx])
1860 {
1861 WCHAR buf[10];
1862
1863 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
1864 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
1865 buf, sizeof(buf) ))
1866 mouse_hover_height = atoiW( buf );
1867
1868 spi_loaded[spi_idx] = TRUE;
1869 }
1870 *(INT *)pvParam = mouse_hover_height;
1871 break;
1872
1873 case SPI_SETMOUSEHOVERHEIGHT: /* 101 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1874 {
1875 WCHAR buf[10];
1876
1877 spi_idx = SPI_SETMOUSEHOVERHEIGHT_IDX;
1878 wsprintfW(buf, CSu, uiParam);
1879
1880 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
1881 SPI_SETMOUSEHOVERHEIGHT_VALNAME,
1882 buf, fWinIni ))
1883 {
1884 mouse_hover_height = uiParam;
1885 spi_loaded[spi_idx] = TRUE;
1886 }
1887 else
1888 ret = FALSE;
1889 break;
1890 }
1891
1892 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1893 if (!pvParam) return FALSE;
1894
1895 spi_idx = SPI_SETMOUSEHOVERTIME_IDX;
1896 if (!spi_loaded[spi_idx])
1897 {
1898 WCHAR buf[10];
1899
1900 if (SYSPARAMS_Load( SPI_SETMOUSEHOVERTIME_REGKEY,
1901 SPI_SETMOUSEHOVERTIME_VALNAME,
1902 buf, sizeof(buf) ))
1903 mouse_hover_time = atoiW( buf );
1904
1905 spi_loaded[spi_idx] = TRUE;
1906 }
1907 *(INT *)pvParam = mouse_hover_time;
1908 break;
1909
1910 case SPI_SETMOUSEHOVERTIME: /* 103 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1911 {
1912 WCHAR buf[10];
1913
1914 spi_idx = SPI_SETMOUSEHOVERTIME_IDX;
1915 wsprintfW(buf, CSu, uiParam);
1916
1917 if (SYSPARAMS_Save( SPI_SETMOUSEHOVERTIME_REGKEY,
1918 SPI_SETMOUSEHOVERTIME_VALNAME,
1919 buf, fWinIni ))
1920 {
1921 mouse_hover_time = uiParam;
1922 spi_loaded[spi_idx] = TRUE;
1923 }
1924 else
1925 ret = FALSE;
1926 break;
1927 }
1928
1929 case SPI_GETWHEELSCROLLLINES: /* 104 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1930 if (!pvParam) return FALSE;
1931
1932 spi_idx = SPI_SETMOUSESCROLLLINES_IDX;
1933 if (!spi_loaded[spi_idx])
1934 {
1935 WCHAR buf[10];
1936
1937 if (SYSPARAMS_Load( SPI_SETMOUSESCROLLLINES_REGKEY,
1938 SPI_SETMOUSESCROLLLINES_VALNAME,
1939 buf, sizeof(buf) ))
1940 mouse_scroll_lines = atoiW( buf );
1941
1942 spi_loaded[spi_idx] = TRUE;
1943 }
1944 *(INT *)pvParam = mouse_scroll_lines;
1945 break;
1946
1947 case SPI_SETWHEELSCROLLLINES: /* 105 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1948 {
1949 WCHAR buf[10];
1950
1951 spi_idx = SPI_SETMOUSESCROLLLINES_IDX;
1952 wsprintfW(buf, CSu, uiParam);
1953
1954 if (SYSPARAMS_Save( SPI_SETMOUSESCROLLLINES_REGKEY,
1955 SPI_SETMOUSESCROLLLINES_VALNAME,
1956 buf, fWinIni ))
1957 {
1958 mouse_scroll_lines = uiParam;
1959 spi_loaded[spi_idx] = TRUE;
1960 }
1961 else
1962 ret = FALSE;
1963 break;
1964 }
1965
1966 case SPI_GETMENUSHOWDELAY: /* 106 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1967 if (!pvParam) return FALSE;
1968
1969 spi_idx = SPI_SETMENUSHOWDELAY_IDX;
1970 if (!spi_loaded[spi_idx])
1971 {
1972 WCHAR buf[10];
1973
1974 if (SYSPARAMS_Load( SPI_SETMENUSHOWDELAY_REGKEY,
1975 SPI_SETMENUSHOWDELAY_VALNAME,
1976 buf, sizeof(buf) ))
1977 menu_show_delay = atoiW( buf );
1978
1979 spi_loaded[spi_idx] = TRUE;
1980 }
1981 *(INT *)pvParam = menu_show_delay;
1982 break;
1983
1984 case SPI_SETMENUSHOWDELAY: /* 107 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1985 {
1986 WCHAR buf[10];
1987
1988 spi_idx = SPI_SETMENUSHOWDELAY_IDX;
1989 wsprintfW(buf, CSu, uiParam);
1990
1991 if (SYSPARAMS_Save( SPI_SETMENUSHOWDELAY_REGKEY,
1992 SPI_SETMENUSHOWDELAY_VALNAME,
1993 buf, fWinIni ))
1994 {
1995 menu_show_delay = uiParam;
1996 spi_loaded[spi_idx] = TRUE;
1997 }
1998 else
1999 ret = FALSE;
2000 break;
2001 }
2002
2003 WINE_SPI_FIXME(SPI_GETSHOWIMEUI); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2004 WINE_SPI_FIXME(SPI_SETSHOWIMEUI); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2005 WINE_SPI_FIXME(SPI_GETMOUSESPEED); /* 112 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2006 WINE_SPI_FIXME(SPI_SETMOUSESPEED); /* 113 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2007
2008 case SPI_GETSCREENSAVERRUNNING: /* 114 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2009 if (!pvParam) return FALSE;
2010
2011 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
2012 if (!spi_loaded[spi_idx])
2013 {
2014 WCHAR buf[5];
2015
2016 if (SYSPARAMS_Load( SPI_SETSCREENSAVERRUNNING_REGKEY,
2017 SPI_SETSCREENSAVERRUNNING_VALNAME, buf, sizeof(buf) ))
2018 screensaver_running = atoiW( buf );
2019 spi_loaded[spi_idx] = TRUE;
2020 }
2021
2022 *(BOOL *)pvParam = screensaver_running;
2023 break;
2024
2025 case SPI_GETDESKWALLPAPER: /* 115 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2026 {
2027 WCHAR buf[MAX_PATH];
2028
2029 if (!pvParam) return FALSE;
2030
2031 if (uiParam > MAX_PATH)
2032 {
2033 uiParam = MAX_PATH;
2034 }
2035
2036 if (SYSPARAMS_Load(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, buf, sizeof(buf)))
2037 {
2038 lstrcpynW((WCHAR*)pvParam, buf, uiParam);
2039 }
2040 else
2041 {
2042 /* Return an empty string */
2043 memset((WCHAR*)pvParam, 0, uiParam);
2044 }
2045
2046 break;
2047 }
2048
2049 WINE_SPI_FIXME(SPI_GETACTIVEWINDOWTRACKING);/* 0x1000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2050 WINE_SPI_FIXME(SPI_SETACTIVEWINDOWTRACKING);/* 0x1001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2051 WINE_SPI_FIXME(SPI_GETMENUANIMATION); /* 0x1002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2052 WINE_SPI_FIXME(SPI_SETMENUANIMATION); /* 0x1003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2053 WINE_SPI_FIXME(SPI_GETCOMBOBOXANIMATION); /* 0x1004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2054 WINE_SPI_FIXME(SPI_SETCOMBOBOXANIMATION); /* 0x1005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2055
2056 case SPI_GETLISTBOXSMOOTHSCROLLING: /* 0x1006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2057 if (!pvParam) return FALSE;
2058
2059 spi_idx = SPI_SETLISTBOXSMOOTHSCROLLING_IDX;
2060 if (!spi_loaded[spi_idx])
2061 {
2062 WCHAR buf[5];
2063
2064 if (SYSPARAMS_Load( SPI_SETLISTBOXSMOOTHSCROLLING_REGKEY,
2065 SPI_SETLISTBOXSMOOTHSCROLLING_VALNAME, buf, sizeof(buf) ))
2066 {
2067 if ((buf[0]&0x01) == 0x01)
2068 {
2069 listbox_smoothscrolling = TRUE;
2070 }
2071 }
2072 spi_loaded[spi_idx] = TRUE;
2073 }
2074
2075 *(BOOL *)pvParam = listbox_smoothscrolling;
2076
2077 break;
2078
2079 WINE_SPI_FIXME(SPI_SETLISTBOXSMOOTHSCROLLING);/* 0x1007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2080
2081 case SPI_GETGRADIENTCAPTIONS: /* 0x1008 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2082 if (!pvParam) return FALSE;
2083
2084 spi_idx = SPI_SETGRADIENTCAPTIONS_IDX;
2085 if (!spi_loaded[spi_idx])
2086 {
2087 WCHAR buf[5];
2088
2089 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2090 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2091 {
2092 if ((buf[0]&0x10) == 0x10)
2093 {
2094 gradient_captions = TRUE;
2095 }
2096 }
2097 spi_loaded[spi_idx] = TRUE;
2098 }
2099
2100 *(BOOL *)pvParam = gradient_captions;
2101
2102 break;
2103
2104 WINE_SPI_FIXME(SPI_SETGRADIENTCAPTIONS); /* 0x1009 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2105
2106 case SPI_GETKEYBOARDCUES: /* 0x100A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2107 if (!pvParam) return FALSE;
2108
2109 spi_idx = SPI_SETKEYBOARDCUES_IDX;
2110 if (!spi_loaded[spi_idx])
2111 {
2112 WCHAR buf[5];
2113
2114 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2115 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2116 {
2117 if ((buf[0]&0x20) == 0x20)
2118 {
2119 keyboard_cues = TRUE;
2120 }
2121 }
2122 spi_loaded[spi_idx] = TRUE;
2123 }
2124
2125 *(BOOL *)pvParam = keyboard_cues;
2126
2127 break;
2128
2129 WINE_SPI_FIXME(SPI_SETKEYBOARDCUES); /* 0x100B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2130 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKZORDER); /* 0x100C _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2131 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKZORDER); /* 0x100D _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2132 case SPI_GETHOTTRACKING: /* 0x100E _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2133 if (!pvParam) return FALSE;
2134
2135 spi_idx = SPI_SETHOTTRACKING_IDX;
2136 if (!spi_loaded[spi_idx])
2137 {
2138 WCHAR buf[5];
2139
2140 if (SYSPARAMS_Load( SPI_USERPREFERENCEMASK_REGKEY,
2141 SPI_USERPREFERENCEMASK_VALNAME, buf, sizeof(buf) ))
2142 {
2143 if ((buf[0]&0x80) == 0x80)
2144 {
2145 hot_tracking = TRUE;
2146 }
2147 }
2148 spi_loaded[spi_idx] = TRUE;
2149 }
2150
2151 *(BOOL *)pvParam = hot_tracking;
2152
2153 break;
2154
2155 WINE_SPI_FIXME(SPI_SETHOTTRACKING); /* 0x100F _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2156 WINE_SPI_FIXME(SPI_GETSELECTIONFADE); /* 0x1014 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2157 WINE_SPI_FIXME(SPI_SETSELECTIONFADE); /* 0x1015 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2158 WINE_SPI_FIXME(SPI_GETDROPSHADOW); /* 0x1024 _WIN32_WINNT >= 0x510 */
2159 WINE_SPI_FIXME(SPI_SETDROPSHADOW); /* 0x1025 _WIN32_WINNT >= 0x510 */
2160 WINE_SPI_FIXME(SPI_GETFOREGROUNDLOCKTIMEOUT);/* 0x2000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2161 WINE_SPI_FIXME(SPI_SETFOREGROUNDLOCKTIMEOUT);/* 0x2001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2162 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKTIMEOUT); /* 0x2002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2163 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKTIMEOUT); /* 0x2003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2164 WINE_SPI_FIXME(SPI_GETFOREGROUNDFLASHCOUNT);/* 0x2004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2165 WINE_SPI_FIXME(SPI_SETFOREGROUNDFLASHCOUNT);/* 0x2005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
2166
2167 default:
2168 FIXME( "Unknown action: %u\n", uiAction );
2169 SetLastError( ERROR_INVALID_SPI_VALUE );
2170 ret = FALSE;
2171 break;
2172 }
2173
2174 if (ret)
2175 SYSPARAMS_NotifyChange( uiAction, fWinIni );
2176 return ret;
2177
2178 #undef WINE_SPI_FIXME
2179 #undef WINE_SPI_WARN
2180 }
2181
2182
2183 /***********************************************************************
2184 * SystemParametersInfo (USER.483)
2185 */
2186 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
2187 LPVOID lpvParam, UINT16 fuWinIni )
2188 {
2189 BOOL16 ret;
2190
2191 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
2192
2193 switch (uAction)
2194 {
2195 case SPI_GETBEEP: /* 1 */
2196 case SPI_GETSCREENSAVEACTIVE: /* 16 */
2197 case SPI_GETICONTITLEWRAP: /* 25 */
2198 case SPI_GETMENUDROPALIGNMENT: /* 27 */
2199 case SPI_GETFASTTASKSWITCH: /* 35 */
2200 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
2201 {
2202 BOOL tmp;
2203 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2204 if (ret && lpvParam)
2205 *(BOOL16 *)lpvParam = tmp;
2206 break;
2207 }
2208
2209 case SPI_GETBORDER: /* 5 */
2210 case SPI_ICONHORIZONTALSPACING: /* 13 */
2211 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
2212 case SPI_GETGRIDGRANULARITY: /* 18 */
2213 case SPI_GETKEYBOARDDELAY: /* 22 */
2214 case SPI_ICONVERTICALSPACING: /* 24 */
2215 {
2216 INT tmp;
2217 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2218 if (ret && lpvParam)
2219 *(INT16 *)lpvParam = tmp;
2220 break;
2221 }
2222
2223 case SPI_GETKEYBOARDSPEED: /* 10 */
2224 {
2225 DWORD tmp;
2226 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2227 if (ret && lpvParam)
2228 *(WORD *)lpvParam = tmp;
2229 break;
2230 }
2231
2232 case SPI_GETICONTITLELOGFONT: /* 31 */
2233 {
2234 LOGFONTA tmp;
2235 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2236 if (ret && lpvParam)
2237 SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
2238 break;
2239 }
2240
2241 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2242 {
2243 NONCLIENTMETRICSA tmp;
2244 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
2245 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
2246 {
2247 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
2248 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
2249 if (ret)
2250 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
2251 }
2252 else /* winfile 95 sets cbSize to 340 */
2253 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2254 break;
2255 }
2256
2257 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
2258 {
2259 RECT tmp;
2260 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2261 if (ret && lpvParam)
2262 {
2263 RECT16 *r16 = (RECT16 *)lpvParam;
2264 r16->left = tmp.left;
2265 r16->top = tmp.top;
2266 r16->right = tmp.right;
2267 r16->bottom = tmp.bottom;
2268 }
2269 break;
2270 }
2271
2272 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2273 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2274 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
2275 {
2276 UINT tmp;
2277 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
2278 if (ret && lpvParam)
2279 *(UINT16 *)lpvParam = tmp;
2280 break;
2281 }
2282
2283 default:
2284 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
2285 }
2286
2287 return ret;
2288 }
2289
2290 /***********************************************************************
2291 * SystemParametersInfoA (USER32.@)
2292 */
2293 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
2294 PVOID pvParam, UINT fuWinIni )
2295 {
2296 BOOL ret;
2297
2298 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
2299
2300 switch (uiAction)
2301 {
2302 case SPI_SETDESKWALLPAPER: /* 20 */
2303 case SPI_SETDESKPATTERN: /* 21 */
2304 {
2305 WCHAR buffer[256];
2306 if (pvParam)
2307 if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)pvParam, -1,
2308 buffer, sizeof(buffer)/sizeof(WCHAR) ))
2309 buffer[sizeof(buffer)/sizeof(WCHAR)-1] = 0;
2310 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
2311 break;
2312 }
2313
2314 case SPI_GETICONTITLELOGFONT: /* 31 */
2315 {
2316 LOGFONTW tmp;
2317 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
2318 if (ret && pvParam)
2319 SYSPARAMS_LogFont32WTo32A( &tmp, (LPLOGFONTA)pvParam );
2320 break;
2321 }
2322
2323 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
2324 {
2325 NONCLIENTMETRICSW tmp;
2326 LPNONCLIENTMETRICSA lpnmA = (LPNONCLIENTMETRICSA)pvParam;
2327 if (lpnmA && lpnmA->cbSize == sizeof(NONCLIENTMETRICSA))
2328 {
2329 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
2330 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2331 if (ret)
2332 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
2333 }
2334 else
2335 ret = FALSE;
2336 break;
2337 }
2338
2339 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
2340 {
2341 ICONMETRICSW tmp;
2342 LPICONMETRICSA lpimA = (LPICONMETRICSA)pvParam;
2343 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
2344 {
2345 tmp.cbSize = sizeof(ICONMETRICSW);
2346 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2347 if (ret)
2348 {
2349 lpimA->iHorzSpacing = tmp.iHorzSpacing;
2350 lpimA->iVertSpacing = tmp.iVertSpacing;
2351 lpimA->iTitleWrap = tmp.iTitleWrap;
2352 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
2353 }
2354 }
2355 else
2356 ret = FALSE;
2357 break;
2358 }
2359
2360 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
2361 {
2362 HIGHCONTRASTW tmp;
2363 LPHIGHCONTRASTA lphcA = (LPHIGHCONTRASTA)pvParam;
2364 if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
2365 {
2366 tmp.cbSize = sizeof(HIGHCONTRASTW);
2367 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
2368 if (ret)
2369 {
2370 lphcA->dwFlags = tmp.dwFlags;
2371 lphcA->lpszDefaultScheme = NULL; /* FIXME? */
2372 }
2373 }
2374 else
2375 ret = FALSE;
2376 break;
2377 }
2378
2379 default:
2380 ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
2381 break;
2382 }
2383 return ret;
2384 }
2385
2386
2387 /**********************************************************************
2388 * SetDoubleClickTime (USER32.@)
2389 */
2390 BOOL WINAPI SetDoubleClickTime( UINT interval )
2391 {
2392 return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
2393 }
2394
2395
2396 /**********************************************************************
2397 * GetDoubleClickTime (USER32.@)
2398 */
2399 UINT WINAPI GetDoubleClickTime(void)
2400 {
2401 WCHAR buf[10];
2402
2403 if (!spi_loaded[SPI_SETDOUBLECLICKTIME_IDX])
2404 {
2405 if (SYSPARAMS_Load( SPI_SETDOUBLECLICKTIME_REGKEY,
2406 SPI_SETDOUBLECLICKTIME_VALNAME,
2407 buf, sizeof(buf) ))
2408 {
2409 double_click_time = atoiW( buf );
2410 if (!double_click_time) double_click_time = 500;
2411 }
2412 spi_loaded[SPI_SETDOUBLECLICKTIME_IDX] = TRUE;
2413 }
2414 return double_click_time;
2415 }
widl and rpcrt4 development