?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't check the checksum of the original echo request packet in the
[wine/dcerpc.git] / windows / sysparams.c
blob80b991ebe1735a124f7752f2d2e49db477293c29
1 /*
2 * System parameters functions
3 *
4 * Copyright 1994 Alexandre Julliard
5 */
6
7 #include "config.h"
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include "windef.h"
13 #include "winbase.h"
14 #include "winnls.h"
15 #include "wingdi.h"
16 #include "winreg.h"
17 #include "wine/winuser16.h"
18 #include "winerror.h"
19
20 #include "controls.h"
21 #include "user.h"
22 #include "debugtools.h"
23 #include "sysmetrics.h"
24
25 DEFAULT_DEBUG_CHANNEL(system);
26
27 /* System parameter indexes */
28 #define SPI_SETBEEP_IDX 0
29 #define SPI_SETMOUSE_IDX 1
30 #define SPI_SETBORDER_IDX 2
31 #define SPI_SETKEYBOARDSPEED_IDX 3
32 #define SPI_ICONHORIZONTALSPACING_IDX 4
33 #define SPI_SETSCREENSAVETIMEOUT_IDX 5
34 #define SPI_SETGRIDGRANULARITY_IDX 6
35 #define SPI_SETKEYBOARDDELAY_IDX 7
36 #define SPI_ICONVERTICALSPACING_IDX 8
37 #define SPI_SETICONTITLEWRAP_IDX 9
38 #define SPI_SETMENUDROPALIGNMENT_IDX 10
39 #define SPI_SETDOUBLECLKWIDTH_IDX 11
40 #define SPI_SETDOUBLECLKHEIGHT_IDX 12
41 #define SPI_SETDOUBLECLICKTIME_IDX 13
42 #define SPI_SETMOUSEBUTTONSWAP_IDX 14
43 #define SPI_SETFASTTASKSWITCH_IDX 15
44 #define SPI_SETDRAGFULLWINDOWS_IDX 16
45 #define SPI_SETWORKAREA_IDX 17
46 #define SPI_SETSHOWSOUNDS_IDX 18
47 #define SPI_SETSCREENSAVERRUNNING_IDX 19
48 #define SPI_WINE_IDX SPI_SETSCREENSAVERRUNNING_IDX
49
50 /**
51 * Names of the registry subkeys of HKEY_CURRENT_USER key and value names
52 * for the system parameters.
53 * Names of the keys are created by adding string "_REGKEY" to
54 * "SET" action names, value names are created by adding "_REG_NAME"
55 * to the "SET" action name.
56 */
57 #define SPI_SETBEEP_REGKEY "Control Panel\\Sound"
58 #define SPI_SETBEEP_VALNAME "Beep"
59 #define SPI_SETMOUSE_REGKEY "Control Panel\\Mouse"
60 #define SPI_SETMOUSE_VALNAME1 "MouseThreshold1"
61 #define SPI_SETMOUSE_VALNAME2 "MouseThreshold2"
62 #define SPI_SETMOUSE_VALNAME3 "MouseSpeed"
63 #define SPI_SETBORDER_REGKEY "Control Panel\\Desktop"
64 #define SPI_SETBORDER_VALNAME "BorderWidth"
65 #define SPI_SETKEYBOARDSPEED_REGKEY "Control Panel\\Keyboard"
66 #define SPI_SETKEYBOARDSPEED_VALNAME "KeyboardSpeed"
67 #define SPI_ICONHORIZONTALSPACING_REGKEY "Control Panel\\Desktop"
68 #define SPI_ICONHORIZONTALSPACING_VALNAME "IconSpacing"
69 #define SPI_SETSCREENSAVETIMEOUT_REGKEY "Control Panel\\Desktop"
70 #define SPI_SETSCREENSAVETIMEOUT_VALNAME "ScreenSaveTimeOut"
71 #define SPI_SETGRIDGRANULARITY_REGKEY "Control Panel\\Desktop"
72 #define SPI_SETGRIDGRANULARITY_VALNAME "GridGranularity"
73 #define SPI_SETKEYBOARDDELAY_REGKEY "Control Panel\\Keyboard"
74 #define SPI_SETKEYBOARDDELAY_VALNAME "KeyboardDelay"
75 #define SPI_ICONVERTICALSPACING_REGKEY "Control Panel\\Desktop"
76 #define SPI_ICONVERTICALSPACING_VALNAME "IconVerticalSpacing"
77 #define SPI_SETICONTITLEWRAP_REGKEY "Control Panel\\Desktop"
78 #define SPI_SETICONTITLEWRAP_VALNAME "IconTitleWrap"
79 #define SPI_SETMENUDROPALIGNMENT_REGKEY "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
80 #define SPI_SETMENUDROPALIGNMENT_VALNAME "MenuDropAlignment"
81 #define SPI_SETDOUBLECLKWIDTH_REGKEY "Control Panel\\Mouse"
82 #define SPI_SETDOUBLECLKWIDTH_VALNAME "DoubleClickWidth"
83 #define SPI_SETDOUBLECLKHEIGHT_REGKEY "Control Panel\\Mouse"
84 #define SPI_SETDOUBLECLKHEIGHT_VALNAME "DoubleClickHeight"
85 #define SPI_SETDOUBLECLICKTIME_REGKEY "Control Panel\\Mouse"
86 #define SPI_SETDOUBLECLICKTIME_VALNAME "DoubleClickSpeed"
87 #define SPI_SETMOUSEBUTTONSWAP_REGKEY "Control Panel\\Mouse"
88 #define SPI_SETMOUSEBUTTONSWAP_VALNAME "SwapMouseButtons"
89 #define SPI_SETFASTTASKSWITCH_REGKEY "Control Panel\\Desktop"
90 #define SPI_SETFASTTASKSWITCH_VALNAME "CoolSwitch"
91 #define SPI_SETDRAGFULLWINDOWS_REGKEY "Control Panel\\Desktop"
92 #define SPI_SETDRAGFULLWINDOWS_VALNAME "DragFullWindows"
93 #define SPI_SETWORKAREA_REGKEY "Control Panel\\Desktop"
94 #define SPI_SETWORKAREA_VALNAME "WINE_WorkArea"
95 #define SPI_SETSHOWSOUNDS_REGKEY "Control Panel\\Accessibility\\ShowSounds"
96 #define SPI_SETSHOWSOUNDS_VALNAME "On"
97 #define SPI_SETSCREENSAVERRUNNING_REGKEY "Control Panel\\Desktop"
98 #define SPI_SETSCREENSAVERRUNNING_VALNAME "WINE_ScreenSaverRunning"
99
100 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
101 #define WINE_CURRENT_USER_REGKEY "Wine"
102
103 /* Indicators whether system parameter value is loaded */
104 static char spi_loaded[SPI_WINE_IDX + 1];
105
106 static BOOL notify_change = TRUE;
107
108 /* System parameters storage */
109 static BOOL beep_active = TRUE;
110 static int mouse_threshold1 = 6;
111 static int mouse_threshold2 = 10;
112 static int mouse_speed = 1;
113 static int border = 1;
114 static int keyboard_speed = 31;
115 static int screensave_timeout = 300;
116 static int grid_granularity = 0;
117 static int keyboard_delay = 1;
118 static BOOL icon_title_wrap = TRUE;
119 static int double_click_time = 500;
120 static BOOL fast_task_switch = TRUE;
121 static BOOL drag_full_windows = FALSE;
122 static RECT work_area;
123 static BOOL screensaver_running = FALSE;
124
125 /***********************************************************************
126 * GetTimerResolution (USER.14)
127 */
128 LONG WINAPI GetTimerResolution16(void)
129 {
130 return (1000);
131 }
132
133 /***********************************************************************
134 * ControlPanelInfo (USER.273)
135 */
136 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
137 {
138 FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
139 }
140
141 /* This function is a copy of the one in objects/font.c */
142 static void SYSPARAMS_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
143 {
144 font16->lfHeight = font32->lfHeight;
145 font16->lfWidth = font32->lfWidth;
146 font16->lfEscapement = font32->lfEscapement;
147 font16->lfOrientation = font32->lfOrientation;
148 font16->lfWeight = font32->lfWeight;
149 font16->lfItalic = font32->lfItalic;
150 font16->lfUnderline = font32->lfUnderline;
151 font16->lfStrikeOut = font32->lfStrikeOut;
152 font16->lfCharSet = font32->lfCharSet;
153 font16->lfOutPrecision = font32->lfOutPrecision;
154 font16->lfClipPrecision = font32->lfClipPrecision;
155 font16->lfQuality = font32->lfQuality;
156 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
157 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
158 }
159
160 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
161 {
162 font32W->lfHeight = font32A->lfHeight;
163 font32W->lfWidth = font32A->lfWidth;
164 font32W->lfEscapement = font32A->lfEscapement;
165 font32W->lfOrientation = font32A->lfOrientation;
166 font32W->lfWeight = font32A->lfWeight;
167 font32W->lfItalic = font32A->lfItalic;
168 font32W->lfUnderline = font32A->lfUnderline;
169 font32W->lfStrikeOut = font32A->lfStrikeOut;
170 font32W->lfCharSet = font32A->lfCharSet;
171 font32W->lfOutPrecision = font32A->lfOutPrecision;
172 font32W->lfClipPrecision = font32A->lfClipPrecision;
173 font32W->lfQuality = font32A->lfQuality;
174 font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
175 MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
176 font32W->lfFaceName[LF_FACESIZE-1] = 0;
177 }
178
179 static void SYSPARAMS_NonClientMetrics32ATo16( const NONCLIENTMETRICSA* lpnm32, LPNONCLIENTMETRICS16 lpnm16 )
180 {
181 lpnm16->iBorderWidth = lpnm32->iBorderWidth;
182 lpnm16->iScrollWidth = lpnm32->iScrollWidth;
183 lpnm16->iScrollHeight = lpnm32->iScrollHeight;
184 lpnm16->iCaptionWidth = lpnm32->iCaptionWidth;
185 lpnm16->iCaptionHeight = lpnm32->iCaptionHeight;
186 SYSPARAMS_LogFont32ATo16( &lpnm32->lfCaptionFont, &lpnm16->lfCaptionFont );
187 lpnm16->iSmCaptionWidth = lpnm32->iSmCaptionWidth;
188 lpnm16->iSmCaptionHeight = lpnm32->iSmCaptionHeight;
189 SYSPARAMS_LogFont32ATo16( &lpnm32->lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
190 lpnm16->iMenuWidth = lpnm32->iMenuWidth;
191 lpnm16->iMenuHeight = lpnm32->iMenuHeight;
192 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMenuFont, &lpnm16->lfMenuFont );
193 SYSPARAMS_LogFont32ATo16( &lpnm32->lfStatusFont, &lpnm16->lfStatusFont );
194 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMessageFont, &lpnm16->lfMessageFont );
195 }
196
197 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
198 {
199 lpnm32W->iBorderWidth = lpnm32A->iBorderWidth;
200 lpnm32W->iScrollWidth = lpnm32A->iScrollWidth;
201 lpnm32W->iScrollHeight = lpnm32A->iScrollHeight;
202 lpnm32W->iCaptionWidth = lpnm32A->iCaptionWidth;
203 lpnm32W->iCaptionHeight = lpnm32A->iCaptionHeight;
204 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfCaptionFont, &lpnm32W->lfCaptionFont );
205 lpnm32W->iSmCaptionWidth = lpnm32A->iSmCaptionWidth;
206 lpnm32W->iSmCaptionHeight = lpnm32A->iSmCaptionHeight;
207 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont, &lpnm32W->lfSmCaptionFont );
208 lpnm32W->iMenuWidth = lpnm32A->iMenuWidth;
209 lpnm32W->iMenuHeight = lpnm32A->iMenuHeight;
210 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont, &lpnm32W->lfMenuFont );
211 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont, &lpnm32W->lfStatusFont );
212 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont, &lpnm32W->lfMessageFont );
213 }
214
215 /***********************************************************************
216 * SYSPARAMS_Reset
217 *
218 * Sets the system parameter which should be always loaded to
219 * current value stored in registry.
220 * Invalidates lazy loaded parameter, so it will be loaded the next time
221 * it is requested.
222 *
223 * Parameters:
224 * uiAction - system parameter to reload value for.
225 * Note, only "SET" values can be used for this parameter.
226 * If uiAction is 0 all system parameters are reset.
227 */
228 void SYSPARAMS_Reset( UINT uiAction )
229 {
230 #define WINE_RELOAD_SPI(x) \
231 case x: \
232 spi_loaded[x##_IDX] = FALSE; \
233 SystemParametersInfoA( x, 0, dummy_buf, 0 );\
234 if (uiAction) \
235 break
236
237 #define WINE_IGNORE_SPI(x) \
238 case x: \
239 if (uiAction) \
240 break
241
242 #define WINE_INVALIDATE_SPI(x) \
243 case x: \
244 spi_loaded[x##_IDX] = FALSE; \
245 break
246
247 BOOL not_all_processed = TRUE;
248 char dummy_buf[10];
249
250 /* Execution falls through all the branches for uiAction == 0 */
251 switch (uiAction)
252 {
253 case 0:
254 memset( spi_loaded, 0, sizeof(spi_loaded) );
255
256 WINE_RELOAD_SPI(SPI_SETBORDER);
257 WINE_RELOAD_SPI(SPI_ICONHORIZONTALSPACING);
258 WINE_RELOAD_SPI(SPI_ICONVERTICALSPACING);
259 WINE_IGNORE_SPI(SPI_SETSCREENSAVEACTIVE);
260 WINE_RELOAD_SPI(SPI_SETDOUBLECLKWIDTH);
261 WINE_RELOAD_SPI(SPI_SETDOUBLECLKHEIGHT);
262 WINE_RELOAD_SPI(SPI_SETMOUSEBUTTONSWAP);
263 WINE_RELOAD_SPI(SPI_SETSHOWSOUNDS);
264 WINE_RELOAD_SPI(SPI_SETMENUDROPALIGNMENT);
265
266 default:
267 if (uiAction)
268 {
269 /* lazy loaded parameters */
270 switch (uiAction)
271 {
272 WINE_INVALIDATE_SPI(SPI_SETBEEP);
273 WINE_INVALIDATE_SPI(SPI_SETMOUSE);
274 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDSPEED);
275 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVETIMEOUT);
276 WINE_INVALIDATE_SPI(SPI_SETGRIDGRANULARITY);
277 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDDELAY);
278 WINE_INVALIDATE_SPI(SPI_SETICONTITLEWRAP);
279 WINE_INVALIDATE_SPI(SPI_SETDOUBLECLICKTIME);
280 WINE_INVALIDATE_SPI(SPI_SETFASTTASKSWITCH);
281 WINE_INVALIDATE_SPI(SPI_SETDRAGFULLWINDOWS);
282 WINE_INVALIDATE_SPI(SPI_SETWORKAREA);
283 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVERRUNNING);
284 default:
285 FIXME( "Unknown action reset: %u\n", uiAction );
286 break;
287 }
288 }
289 else
290 not_all_processed = FALSE;
291 break;
292 }
293
294 if (!uiAction && not_all_processed)
295 ERR( "Incorrect implementation of SYSPARAMS_Reset. "
296 "Not all params are reloaded.\n" );
297 #undef WINE_INVALIDATE_SPI
298 #undef WINE_IGNORE_SPI
299 #undef WINE_RELOAD_SPI
300 }
301
302 /***********************************************************************
303 * get_volatile_regkey
304 *
305 * Return a handle to the volatile registry key used to store
306 * non-permanently modified parameters.
307 */
308 static HKEY get_volatile_regkey(void)
309 {
310 static HKEY volatile_key;
311
312 if (!volatile_key)
313 {
314 if (RegCreateKeyExA( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
315 0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
316 &volatile_key, 0 ) != ERROR_SUCCESS)
317 ERR("Can't create wine configuration registry branch");
318 }
319 return volatile_key;
320 }
321
322 /***********************************************************************
323 * SYSPARAMS_NotifyChange
324 *
325 * Sends notification about system parameter update.
326 */
327 void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
328 {
329 if (notify_change)
330 {
331 if (fWinIni & SPIF_UPDATEINIFILE)
332 {
333 if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
334 SendMessageA(HWND_BROADCAST, WM_SETTINGCHANGE,
335 uiAction, (LPARAM) "");
336 }
337 else
338 {
339 /* FIXME notify other wine processes with internal message */
340 }
341 }
342 }
343
344
345 /***********************************************************************
346 * Loads system parameter from user profile.
347 */
348 BOOL SYSPARAMS_Load( LPSTR lpRegKey, LPSTR lpValName, LPSTR lpBuf )
349 {
350 BOOL ret = FALSE;
351 DWORD type;
352 HKEY hKey;
353 DWORD count;
354
355 if ((RegOpenKeyA( get_volatile_regkey(), lpRegKey,
356 &hKey ) == ERROR_SUCCESS) ||
357 (RegOpenKeyA( HKEY_CURRENT_USER, lpRegKey,
358 &hKey ) == ERROR_SUCCESS))
359 {
360 ret = !RegQueryValueExA( hKey, lpValName, NULL, &type, lpBuf, &count );
361 RegCloseKey( hKey );
362 }
363 return ret;
364 }
365
366 /***********************************************************************
367 * Saves system parameter to user profile.
368 */
369 BOOL SYSPARAMS_Save( LPSTR lpRegKey, LPSTR lpValName, LPSTR lpValue,
370 UINT fWinIni )
371 {
372 HKEY hKey;
373 HKEY hBaseKey;
374 DWORD dwOptions;
375 BOOL ret = FALSE;
376
377 if (fWinIni & SPIF_UPDATEINIFILE)
378 {
379 hBaseKey = HKEY_CURRENT_USER;
380 dwOptions = 0;
381 }
382 else
383 {
384 hBaseKey = get_volatile_regkey();
385 dwOptions = REG_OPTION_VOLATILE;
386 }
387
388 if (RegCreateKeyExA( hBaseKey, lpRegKey,
389 0, 0, dwOptions, KEY_ALL_ACCESS,
390 0, &hKey, 0 ) == ERROR_SUCCESS)
391 {
392 if (RegSetValueExA( hKey, lpValName, 0, REG_SZ,
393 lpValue, strlen(lpValue) + 1 ) == ERROR_SUCCESS)
394 {
395 ret = TRUE;
396 if (hBaseKey == HKEY_CURRENT_USER)
397 RegDeleteKeyA( get_volatile_regkey(), lpRegKey );
398 }
399 RegCloseKey( hKey );
400 }
401 return ret;
402 }
403
404
405 /***********************************************************************
406 * SYSPARAMS_GetDoubleClickSize
407 *
408 * There is no SPI_GETDOUBLECLK* so we export this function instead.
409 */
410 void SYSPARAMS_GetDoubleClickSize( INT *width, INT *height )
411 {
412 char buf[10];
413
414 if (!spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX])
415 {
416 char buf[10];
417
418 if (SYSPARAMS_Load( SPI_SETDOUBLECLKWIDTH_REGKEY,
419 SPI_SETDOUBLECLKWIDTH_VALNAME, buf ))
420 {
421 SYSMETRICS_Set( SM_CXDOUBLECLK, atoi( buf ) );
422 }
423 spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX] = TRUE;
424 }
425 if (!spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX])
426 {
427 if (SYSPARAMS_Load( SPI_SETDOUBLECLKHEIGHT_REGKEY,
428 SPI_SETDOUBLECLKHEIGHT_VALNAME, buf ))
429 {
430 SYSMETRICS_Set( SM_CYDOUBLECLK, atoi( buf ) );
431 }
432 spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX] = TRUE;
433 }
434 *width = GetSystemMetrics( SM_CXDOUBLECLK );
435 *height = GetSystemMetrics( SM_CYDOUBLECLK );
436 }
437
438
439 /***********************************************************************
440 * SYSPARAMS_GetMouseButtonSwap
441 *
442 * There is no SPI_GETMOUSEBUTTONSWAP so we export this function instead.
443 */
444 INT SYSPARAMS_GetMouseButtonSwap( void )
445 {
446 int spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
447
448 if (!spi_loaded[spi_idx])
449 {
450 char buf[5];
451
452 if (SYSPARAMS_Load( SPI_SETMOUSEBUTTONSWAP_REGKEY,
453 SPI_SETMOUSEBUTTONSWAP_VALNAME, buf ))
454 {
455 SYSMETRICS_Set( SM_SWAPBUTTON, atoi( buf ) );
456 }
457 spi_loaded[spi_idx] = TRUE;
458 }
459
460 return GetSystemMetrics( SM_SWAPBUTTON );
461 }
462
463 /***********************************************************************
464 * SystemParametersInfoA (USER32.@)
465 *
466 * Each system parameter has flag which shows whether the parameter
467 * is loaded or not. Parameters, stored directly in SysParametersInfo are
468 * loaded from registry only when they are requested and the flag is
469 * "false", after the loading the flag is set to "true". On interprocess
470 * notification of the parameter change the corresponding parameter flag is
471 * set to "false". The parameter value will be reloaded when it is requested
472 * the next time.
473 * Parameters, backed by or depend on GetSystemMetrics are processed
474 * differently. These parameters are always loaded. They are reloaded right
475 * away on interprocess change notification. We can't do lazy loading because
476 * we don't want to complicate GetSystemMetrics.
477 * Parameters, backed by X settings are read from corresponding setting.
478 * On the parameter change request the setting is changed. Interprocess change
479 * notifications are ignored.
480 * When parameter value is updated the changed value is stored in permanent
481 * registry branch if saving is requested. Otherwise it is stored
482 * in temporary branch
483 *
484 */
485 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
486 PVOID pvParam, UINT fWinIni )
487 {
488 #define WINE_SPI_FIXME(x) \
489 case x: \
490 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
491 SetLastError( ERROR_INVALID_SPI_VALUE ); \
492 ret = FALSE; \
493 break
494 #define WINE_SPI_WARN(x) \
495 case x: \
496 WARN( "Ignored action: %u (%s)\n", x, #x ); \
497 break
498
499 BOOL ret = TRUE;
500 unsigned spi_idx = 0;
501
502 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fWinIni);
503
504 switch (uiAction)
505 {
506 case SPI_GETBEEP: /* 1 */
507 spi_idx = SPI_SETBEEP_IDX;
508 if (!spi_loaded[spi_idx])
509 {
510 char buf[5];
511
512 if (SYSPARAMS_Load( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME, buf ))
513 beep_active = !strcasecmp( "Yes", buf );
514 spi_loaded[spi_idx] = TRUE;
515 }
516
517 *(BOOL *)pvParam = beep_active;
518 break;
519
520 case SPI_SETBEEP: /* 2 */
521 spi_idx = SPI_SETBEEP_IDX;
522 if (SYSPARAMS_Save( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME,
523 (uiParam ? "Yes" : "No"), fWinIni ))
524 {
525 beep_active = uiParam;
526 spi_loaded[spi_idx] = TRUE;
527 }
528 else
529 ret = FALSE;
530 break;
531
532 case SPI_GETMOUSE: /* 3 */
533 spi_idx = SPI_SETMOUSE_IDX;
534 if (!spi_loaded[spi_idx])
535 {
536 char buf[10];
537
538 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
539 buf ))
540 mouse_threshold1 = atoi( buf );
541 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
542 buf ))
543 mouse_threshold2 = atoi( buf );
544 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
545 buf ))
546 mouse_speed = atoi( buf );
547 spi_loaded[spi_idx] = TRUE;
548 }
549 ((INT *)pvParam)[0] = mouse_threshold1;
550 ((INT *)pvParam)[1] = mouse_threshold2;
551 ((INT *)pvParam)[2] = mouse_speed;
552 break;
553
554 case SPI_SETMOUSE: /* 4 */
555 {
556 char buf[10];
557
558 spi_idx = SPI_SETMOUSE_IDX;
559 sprintf(buf, "%d", ((INT *)pvParam)[0]);
560
561 if (SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
562 buf, fWinIni ))
563 {
564 mouse_threshold1 = ((INT *)pvParam)[0];
565 spi_loaded[spi_idx] = TRUE;
566
567 sprintf(buf, "%d", ((INT *)pvParam)[1]);
568 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
569 buf, fWinIni );
570 mouse_threshold2 = ((INT *)pvParam)[1];
571
572 sprintf(buf, "%d", ((INT *)pvParam)[2]);
573 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
574 buf, fWinIni );
575 mouse_speed = ((INT *)pvParam)[2];
576 }
577 else
578 ret = FALSE;
579 break;
580 }
581
582 case SPI_GETBORDER: /* 5 */
583 spi_idx = SPI_SETBORDER_IDX;
584 if (!spi_loaded[spi_idx])
585 {
586 char buf[10];
587
588 if (SYSPARAMS_Load( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
589 buf ))
590 {
591 int i = atoi( buf );
592 if (i > 0) border = i;
593 }
594 spi_loaded[spi_idx] = TRUE;
595 if (TWEAK_WineLook > WIN31_LOOK)
596 {
597 SYSMETRICS_Set( SM_CXFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
598 SYSMETRICS_Set( SM_CYFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
599 }
600 }
601 *(INT *)pvParam = border;
602 break;
603
604 case SPI_SETBORDER: /* 6 */
605 {
606 char buf[10];
607
608 spi_idx = SPI_SETBORDER_IDX;
609 sprintf(buf, "%u", uiParam);
610
611 if (SYSPARAMS_Save( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
612 buf, fWinIni ))
613 {
614 if (uiParam > 0)
615 {
616 border = uiParam;
617 spi_loaded[spi_idx] = TRUE;
618 if (TWEAK_WineLook > WIN31_LOOK)
619 {
620 SYSMETRICS_Set( SM_CXFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
621 SYSMETRICS_Set( SM_CYFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
622 }
623 }
624 }
625 else
626 ret = FALSE;
627 break;
628 }
629
630 case SPI_GETKEYBOARDSPEED: /* 10 */
631 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
632 if (!spi_loaded[spi_idx])
633 {
634 char buf[10];
635
636 if (SYSPARAMS_Load( SPI_SETKEYBOARDSPEED_REGKEY,
637 SPI_SETKEYBOARDSPEED_VALNAME,
638 buf ))
639 keyboard_speed = atoi( buf );
640 spi_loaded[spi_idx] = TRUE;
641 }
642 *(INT *)pvParam = keyboard_speed;
643 break;
644
645 case SPI_SETKEYBOARDSPEED: /* 11 */
646 {
647 char buf[10];
648
649 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
650 if (uiParam > 31)
651 uiParam = 31;
652 sprintf(buf, "%u", uiParam);
653
654 if (SYSPARAMS_Save( SPI_SETKEYBOARDSPEED_REGKEY,
655 SPI_SETKEYBOARDSPEED_VALNAME,
656 buf, fWinIni ))
657 {
658 keyboard_speed = uiParam;
659 spi_loaded[spi_idx] = TRUE;
660 }
661 else
662 ret = FALSE;
663 break;
664 }
665
666 /* not implemented in Windows */
667 WINE_SPI_WARN(SPI_LANGDRIVER); /* 12 */
668
669 case SPI_ICONHORIZONTALSPACING: /* 13 */
670 spi_idx = SPI_ICONHORIZONTALSPACING_IDX;
671 if (pvParam != NULL)
672 {
673 if (!spi_loaded[spi_idx])
674 {
675 char buf[10];
676
677 if (SYSPARAMS_Load( SPI_ICONHORIZONTALSPACING_REGKEY,
678 SPI_ICONHORIZONTALSPACING_VALNAME, buf ))
679 {
680 SYSMETRICS_Set( SM_CXICONSPACING, atoi( buf ) );
681 }
682 spi_loaded[spi_idx] = TRUE;
683 }
684
685 *(INT *)pvParam = GetSystemMetrics( SM_CXICONSPACING );
686 }
687 else
688 {
689 char buf[10];
690
691 if (uiParam < 32) uiParam = 32;
692
693 sprintf(buf, "%u", uiParam);
694 if (SYSPARAMS_Save( SPI_ICONHORIZONTALSPACING_REGKEY,
695 SPI_ICONHORIZONTALSPACING_VALNAME,
696 buf, fWinIni ))
697 {
698 SYSMETRICS_Set( SM_CXICONSPACING, uiParam );
699 spi_loaded[spi_idx] = TRUE;
700 }
701 else
702 ret = FALSE;
703 }
704 break;
705
706 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
707 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
708 if (!spi_loaded[spi_idx])
709 {
710 char buf[10];
711
712 if (SYSPARAMS_Load( SPI_SETSCREENSAVETIMEOUT_REGKEY,
713 SPI_SETSCREENSAVETIMEOUT_VALNAME,
714 buf ))
715 screensave_timeout = atoi( buf );
716
717 spi_loaded[spi_idx] = TRUE;
718 }
719 *(INT *)pvParam = screensave_timeout;
720 break;
721
722 case SPI_SETSCREENSAVETIMEOUT: /* 15 */
723 {
724 char buf[10];
725
726 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
727 sprintf(buf, "%u", uiParam);
728
729 if (SYSPARAMS_Save( SPI_SETSCREENSAVETIMEOUT_REGKEY,
730 SPI_SETSCREENSAVETIMEOUT_VALNAME,
731 buf, fWinIni ))
732 {
733 screensave_timeout = uiParam;
734 spi_loaded[spi_idx] = TRUE;
735 }
736 else
737 ret = FALSE;
738 break;
739 }
740
741 case SPI_GETSCREENSAVEACTIVE: /* 16 */
742 *(BOOL *)pvParam = USER_Driver.pGetScreenSaveActive();
743 break;
744
745 case SPI_SETSCREENSAVEACTIVE: /* 17 */
746 {
747 char buf[5];
748
749 sprintf(buf, "%u", uiParam);
750 USER_Driver.pSetScreenSaveActive( uiParam );
751 break;
752 }
753
754 case SPI_GETGRIDGRANULARITY: /* 18 */
755 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
756 if (!spi_loaded[spi_idx])
757 {
758 char buf[10];
759
760 if (SYSPARAMS_Load( SPI_SETGRIDGRANULARITY_REGKEY,
761 SPI_SETGRIDGRANULARITY_VALNAME,
762 buf ))
763 grid_granularity = atoi( buf );
764
765 spi_loaded[spi_idx] = TRUE;
766 }
767 *(INT *)pvParam = grid_granularity;
768 break;
769
770 case SPI_SETGRIDGRANULARITY: /* 19 */
771 {
772 char buf[10];
773
774 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
775 sprintf(buf, "%u", uiParam);
776
777 if (SYSPARAMS_Save( SPI_SETGRIDGRANULARITY_REGKEY,
778 SPI_SETGRIDGRANULARITY_VALNAME,
779 buf, fWinIni ))
780 {
781 grid_granularity = uiParam;
782 spi_loaded[spi_idx] = TRUE;
783 }
784 else
785 ret = FALSE;
786 break;
787 }
788
789 case SPI_SETDESKWALLPAPER: /* 20 */
790 ret = SetDeskWallPaper( (LPSTR)pvParam );
791 break;
792 case SPI_SETDESKPATTERN: /* 21 */
793 /* FIXME: the ability to specify a pattern in pvParam
794 doesn't seem to be documented for Win32 */
795 if ((INT16)uiParam == -1)
796 {
797 char buffer[256];
798 GetProfileStringA( "Desktop", "Pattern",
799 "170 85 170 85 170 85 170 85",
800 buffer, sizeof(buffer) );
801 ret = DESKTOP_SetPattern( (LPSTR)buffer );
802 } else
803 ret = DESKTOP_SetPattern( (LPSTR)pvParam );
804 break;
805
806 case SPI_GETKEYBOARDDELAY: /* 22 */
807 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
808 if (!spi_loaded[spi_idx])
809 {
810 char buf[10];
811
812 if (SYSPARAMS_Load( SPI_SETKEYBOARDDELAY_REGKEY,
813 SPI_SETKEYBOARDDELAY_VALNAME,
814 buf ))
815 {
816 int i = atoi( buf );
817 if ( (i >= 0) && (i <= 3)) keyboard_delay = i;
818 }
819
820 spi_loaded[spi_idx] = TRUE;
821 }
822 *(INT *)pvParam = keyboard_delay;
823 break;
824
825 case SPI_SETKEYBOARDDELAY: /* 23 */
826 {
827 char buf[10];
828
829 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
830 sprintf(buf, "%u", uiParam);
831
832 if (SYSPARAMS_Save( SPI_SETKEYBOARDDELAY_REGKEY,
833 SPI_SETKEYBOARDDELAY_VALNAME,
834 buf, fWinIni ))
835 {
836 if (uiParam <= 3)
837 keyboard_delay = uiParam;
838 spi_loaded[spi_idx] = TRUE;
839 }
840 else
841 ret = FALSE;
842 break;
843 }
844
845 case SPI_ICONVERTICALSPACING: /* 24 */
846 spi_idx = SPI_ICONVERTICALSPACING_IDX;
847 if (pvParam != NULL)
848 {
849 if (!spi_loaded[spi_idx])
850 {
851 char buf[10];
852
853 if (SYSPARAMS_Load( SPI_ICONVERTICALSPACING_REGKEY,
854 SPI_ICONVERTICALSPACING_VALNAME, buf ))
855 {
856 SYSMETRICS_Set( SM_CYICONSPACING, atoi( buf ) );
857 }
858 spi_loaded[spi_idx] = TRUE;
859 }
860
861 *(INT *)pvParam = GetSystemMetrics( SM_CYICONSPACING );
862 }
863 else
864 {
865 char buf[10];
866
867 if (uiParam < 32) uiParam = 32;
868
869 sprintf(buf, "%u", uiParam);
870 if (SYSPARAMS_Save( SPI_ICONVERTICALSPACING_REGKEY,
871 SPI_ICONVERTICALSPACING_VALNAME,
872 buf, fWinIni ))
873 {
874 SYSMETRICS_Set( SM_CYICONSPACING, uiParam );
875 spi_loaded[spi_idx] = TRUE;
876 }
877 else
878 ret = FALSE;
879 }
880
881 break;
882
883 case SPI_GETICONTITLEWRAP: /* 25 */
884 spi_idx = SPI_SETICONTITLEWRAP_IDX;
885 if (!spi_loaded[spi_idx])
886 {
887 char buf[5];
888
889 if (SYSPARAMS_Load( SPI_SETICONTITLEWRAP_REGKEY,
890 SPI_SETICONTITLEWRAP_VALNAME, buf ))
891 icon_title_wrap = atoi(buf);
892 spi_loaded[spi_idx] = TRUE;
893 }
894
895 *(BOOL *)pvParam = icon_title_wrap;
896 break;
897
898 case SPI_SETICONTITLEWRAP: /* 26 */
899 {
900 char buf[5];
901
902 spi_idx = SPI_SETICONTITLEWRAP_IDX;
903 sprintf(buf, "%u", uiParam);
904 if (SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY,
905 SPI_SETICONTITLEWRAP_VALNAME,
906 buf, fWinIni ))
907 {
908 icon_title_wrap = uiParam;
909 spi_loaded[spi_idx] = TRUE;
910 }
911 else
912 ret = FALSE;
913 break;
914 }
915
916 case SPI_GETMENUDROPALIGNMENT: /* 27 */
917 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
918
919 if (!spi_loaded[spi_idx])
920 {
921 char buf[5];
922
923 if (SYSPARAMS_Load( SPI_SETMENUDROPALIGNMENT_REGKEY,
924 SPI_SETMENUDROPALIGNMENT_VALNAME, buf ))
925 {
926 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, atoi( buf ) );
927 }
928 spi_loaded[spi_idx] = TRUE;
929 }
930
931
932 *(BOOL *)pvParam = GetSystemMetrics( SM_MENUDROPALIGNMENT );
933 break;
934
935 case SPI_SETMENUDROPALIGNMENT: /* 28 */
936 {
937 char buf[5];
938 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
939
940 sprintf(buf, "%u", uiParam);
941 if (SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY,
942 SPI_SETMENUDROPALIGNMENT_VALNAME,
943 buf, fWinIni ))
944 {
945 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, uiParam );
946 spi_loaded[spi_idx] = TRUE;
947 }
948 else
949 ret = FALSE;
950 break;
951 }
952
953 case SPI_SETDOUBLECLKWIDTH: /* 29 */
954 {
955 char buf[10];
956 spi_idx = SPI_SETDOUBLECLKWIDTH_IDX;
957
958 sprintf(buf, "%u", uiParam);
959 if (SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY,
960 SPI_SETDOUBLECLKWIDTH_VALNAME,
961 buf, fWinIni ))
962 {
963 SYSMETRICS_Set( SM_CXDOUBLECLK, uiParam );
964 spi_loaded[spi_idx] = TRUE;
965 }
966 else
967 ret = FALSE;
968 break;
969 }
970
971 case SPI_SETDOUBLECLKHEIGHT: /* 30 */
972 {
973 char buf[10];
974 spi_idx = SPI_SETDOUBLECLKHEIGHT_IDX;
975
976 sprintf(buf, "%u", uiParam);
977 if (SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY,
978 SPI_SETDOUBLECLKHEIGHT_VALNAME,
979 buf, fWinIni ))
980 {
981 SYSMETRICS_Set( SM_CYDOUBLECLK, uiParam );
982 spi_loaded[spi_idx] = TRUE;
983 }
984 else
985 ret = FALSE;
986 break;
987 }
988
989 case SPI_GETICONTITLELOGFONT: /* 31 */
990 {
991 LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
992
993 /* from now on we always have an alias for MS Sans Serif */
994
995 GetProfileStringA( "Desktop", "IconTitleFaceName", "MS Sans Serif",
996 lpLogFont->lfFaceName, LF_FACESIZE );
997 lpLogFont->lfHeight = -GetProfileIntA( "Desktop", "IconTitleSize", 13 );
998 lpLogFont->lfWidth = 0;
999 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1000 lpLogFont->lfWeight = FW_NORMAL;
1001 lpLogFont->lfItalic = FALSE;
1002 lpLogFont->lfStrikeOut = FALSE;
1003 lpLogFont->lfUnderline = FALSE;
1004 lpLogFont->lfCharSet = ANSI_CHARSET;
1005 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1006 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1007 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1008 break;
1009 }
1010
1011 case SPI_SETDOUBLECLICKTIME: /* 32 */
1012 {
1013 char buf[10];
1014
1015 spi_idx = SPI_SETDOUBLECLICKTIME_IDX;
1016 sprintf(buf, "%u", uiParam);
1017
1018 if (SYSPARAMS_Save( SPI_SETDOUBLECLICKTIME_REGKEY,
1019 SPI_SETDOUBLECLICKTIME_VALNAME,
1020 buf, fWinIni ))
1021 {
1022 if (!uiParam)
1023 uiParam = 500;
1024 double_click_time = uiParam;
1025 spi_loaded[spi_idx] = TRUE;
1026 }
1027 else
1028 ret = FALSE;
1029 break;
1030 }
1031
1032 case SPI_SETMOUSEBUTTONSWAP: /* 33 */
1033 {
1034 char buf[5];
1035 spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
1036
1037 sprintf(buf, "%u", uiParam);
1038 if (SYSPARAMS_Save( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1039 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1040 buf, fWinIni ))
1041 {
1042 SYSMETRICS_Set( SM_SWAPBUTTON, uiParam );
1043 spi_loaded[spi_idx] = TRUE;
1044 }
1045 else
1046 ret = FALSE;
1047 break;
1048 }
1049
1050 WINE_SPI_FIXME(SPI_SETICONTITLELOGFONT); /* 34 */
1051
1052 case SPI_GETFASTTASKSWITCH: /* 35 */
1053 spi_idx = SPI_SETFASTTASKSWITCH_IDX;
1054 if (!spi_loaded[spi_idx])
1055 {
1056 char buf[5];
1057
1058 if (SYSPARAMS_Load( SPI_SETFASTTASKSWITCH_REGKEY,
1059 SPI_SETFASTTASKSWITCH_VALNAME, buf ))
1060 fast_task_switch = atoi(buf);
1061 spi_loaded[spi_idx] = TRUE;
1062 }
1063
1064 *(BOOL *)pvParam = fast_task_switch;
1065 break;
1066
1067 case SPI_SETFASTTASKSWITCH: /* 36 */
1068 {
1069 char buf[5];
1070
1071 spi_idx = SPI_SETFASTTASKSWITCH_IDX;
1072 sprintf(buf, "%u", uiParam);
1073 if (SYSPARAMS_Save( SPI_SETFASTTASKSWITCH_REGKEY,
1074 SPI_SETFASTTASKSWITCH_VALNAME,
1075 buf, fWinIni ))
1076 {
1077 fast_task_switch = uiParam;
1078 spi_loaded[spi_idx] = TRUE;
1079 }
1080 else
1081 ret = FALSE;
1082 break;
1083 }
1084
1085 case SPI_SETDRAGFULLWINDOWS: /* 37 WINVER >= 0x0400 */
1086 {
1087 char buf[5];
1088
1089 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1090 sprintf(buf, "%u", uiParam);
1091 if (SYSPARAMS_Save( SPI_SETDRAGFULLWINDOWS_REGKEY,
1092 SPI_SETDRAGFULLWINDOWS_VALNAME,
1093 buf, fWinIni ))
1094 {
1095 drag_full_windows = uiParam;
1096 spi_loaded[spi_idx] = TRUE;
1097 }
1098 else
1099 ret = FALSE;
1100 break;
1101 }
1102
1103 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1104 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1105 if (!spi_loaded[spi_idx])
1106 {
1107 char buf[5];
1108
1109 if (SYSPARAMS_Load( SPI_SETDRAGFULLWINDOWS_REGKEY,
1110 SPI_SETDRAGFULLWINDOWS_VALNAME, buf ))
1111 drag_full_windows = atoi(buf);
1112 spi_loaded[spi_idx] = TRUE;
1113 }
1114
1115 *(BOOL *)pvParam = drag_full_windows;
1116 break;
1117
1118 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1119 {
1120 LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
1121
1122 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA))
1123 {
1124 LPLOGFONTA lpLogFont = &(lpnm->lfMenuFont);
1125
1126 /* clear the struct, so we have 'sane' members */
1127 memset(
1128 (char *)pvParam + sizeof(lpnm->cbSize),
1129 0,
1130 lpnm->cbSize - sizeof(lpnm->cbSize)
1131 );
1132
1133 /* FIXME: initialize geometry entries */
1134 /* FIXME: As these values are presumably in device units,
1135 * we should calculate the defaults based on the screen dpi
1136 */
1137 /* caption */
1138 lpnm->iCaptionWidth = ((TWEAK_WineLook > WIN31_LOOK) ? 32 : 20);
1139 lpnm->iCaptionHeight = lpnm->iCaptionWidth;
1140 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont), 0 );
1141 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
1142
1143 /* small caption */
1144 lpnm->iSmCaptionWidth = ((TWEAK_WineLook > WIN31_LOOK) ? 32 : 17);
1145 lpnm->iSmCaptionHeight = lpnm->iSmCaptionWidth;
1146 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont), 0 );
1147
1148 /* menus, FIXME: names of wine.conf entries are bogus */
1149
1150 lpnm->iMenuWidth = GetProfileIntA( "Desktop", "MenuWidth", 13 ); /* size of the menu buttons*/
1151 lpnm->iMenuHeight = GetProfileIntA( "Desktop", "MenuHeight",
1152 (TWEAK_WineLook > WIN31_LOOK) ? 13 : 27 );
1153
1154 GetProfileStringA( "Desktop", "MenuFont",
1155 (TWEAK_WineLook > WIN31_LOOK) ? "MS Sans Serif": "System",
1156 lpLogFont->lfFaceName, LF_FACESIZE );
1157
1158 lpLogFont->lfHeight = -GetProfileIntA( "Desktop", "MenuFontSize", 13 );
1159 lpLogFont->lfWidth = 0;
1160 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1161 lpLogFont->lfWeight = (TWEAK_WineLook > WIN31_LOOK) ? FW_NORMAL : FW_BOLD;
1162 lpLogFont->lfItalic = FALSE;
1163 lpLogFont->lfStrikeOut = FALSE;
1164 lpLogFont->lfUnderline = FALSE;
1165 lpLogFont->lfCharSet = ANSI_CHARSET;
1166 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1167 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1168 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1169
1170 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1171 (LPVOID)&(lpnm->lfStatusFont), 0 );
1172 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1173 (LPVOID)&(lpnm->lfMessageFont), 0 );
1174 }
1175 else
1176 {
1177 WARN("size mismatch !! (is %d; should be %d)\n", lpnm->cbSize, sizeof(NONCLIENTMETRICSA));
1178 /* FIXME: SetLastError? */
1179 ret = FALSE;
1180 }
1181 break;
1182 }
1183 WINE_SPI_FIXME(SPI_SETNONCLIENTMETRICS); /* 42 WINVER >= 0x400 */
1184
1185 WINE_SPI_FIXME(SPI_GETMINIMIZEDMETRICS); /* 43 WINVER >= 0x400 */
1186 WINE_SPI_FIXME(SPI_SETMINIMIZEDMETRICS); /* 44 WINVER >= 0x400 */
1187
1188 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
1189 {
1190 LPICONMETRICSA lpIcon = pvParam;
1191 if(lpIcon && lpIcon->cbSize == sizeof(*lpIcon))
1192 {
1193 SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0,
1194 &lpIcon->iHorzSpacing, FALSE );
1195 SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0,
1196 &lpIcon->iVertSpacing, FALSE );
1197 SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0,
1198 &lpIcon->iTitleWrap, FALSE );
1199 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1200 &lpIcon->lfFont, FALSE );
1201 }
1202 else
1203 {
1204 ret = FALSE;
1205 }
1206 break;
1207 }
1208 WINE_SPI_FIXME(SPI_SETICONMETRICS); /* 46 WINVER >= 0x400 */
1209
1210 case SPI_SETWORKAREA: /* 47 WINVER >= 0x400 */
1211 {
1212 char buf[20];
1213 RECT *pr = (RECT *) pvParam;
1214
1215 spi_idx = SPI_SETWORKAREA_IDX;
1216 sprintf(buf, "%d %d %d %d",
1217 pr->left, pr->top,
1218 pr->right, pr->bottom );
1219
1220 if (SYSPARAMS_Save( SPI_SETWORKAREA_REGKEY,
1221 SPI_SETWORKAREA_VALNAME,
1222 buf, fWinIni ))
1223 {
1224 CopyRect( &work_area, (RECT *)pvParam );
1225 spi_loaded[spi_idx] = TRUE;
1226 }
1227 else
1228 ret = FALSE;
1229 break;
1230 }
1231
1232 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1233 spi_idx = SPI_SETWORKAREA_IDX;
1234 if (!spi_loaded[spi_idx])
1235 {
1236 char buf[20];
1237
1238 SetRect( &work_area, 0, 0,
1239 GetSystemMetrics( SM_CXSCREEN ),
1240 GetSystemMetrics( SM_CYSCREEN ) );
1241
1242 if (SYSPARAMS_Load( SPI_SETWORKAREA_REGKEY,
1243 SPI_SETWORKAREA_VALNAME,
1244 buf ))
1245 {
1246 sscanf( buf, "%d %d %d %d",
1247 &work_area.left, &work_area.top,
1248 &work_area.right, &work_area.bottom );
1249 }
1250 spi_loaded[spi_idx] = TRUE;
1251 }
1252 CopyRect( (RECT *)pvParam, &work_area );
1253
1254 break;
1255
1256 WINE_SPI_FIXME(SPI_SETPENWINDOWS); /* 49 WINVER >= 0x400 */
1257
1258 case SPI_GETFILTERKEYS: /* 50 */
1259 {
1260 LPFILTERKEYS lpFilterKeys = (LPFILTERKEYS)pvParam;
1261 WARN("SPI_GETFILTERKEYS not fully implemented\n");
1262 if (lpFilterKeys->cbSize == sizeof(FILTERKEYS))
1263 {
1264 /* Indicate that no FilterKeys feature available */
1265 lpFilterKeys->dwFlags = 0;
1266 lpFilterKeys->iWaitMSec = 0;
1267 lpFilterKeys->iDelayMSec = 0;
1268 lpFilterKeys->iRepeatMSec = 0;
1269 lpFilterKeys->iBounceMSec = 0;
1270 }
1271 else
1272 {
1273 ret = FALSE;
1274 }
1275 break;
1276 }
1277 WINE_SPI_FIXME(SPI_SETFILTERKEYS); /* 51 */
1278
1279 case SPI_GETTOGGLEKEYS: /* 52 */
1280 {
1281 LPTOGGLEKEYS lpToggleKeys = (LPTOGGLEKEYS)pvParam;
1282 WARN("SPI_GETTOGGLEKEYS not fully implemented\n");
1283 if (lpToggleKeys->cbSize == sizeof(TOGGLEKEYS))
1284 {
1285 /* Indicate that no ToggleKeys feature available */
1286 lpToggleKeys->dwFlags = 0;
1287 }
1288 else
1289 {
1290 ret = FALSE;
1291 }
1292 break;
1293 }
1294 WINE_SPI_FIXME(SPI_SETTOGGLEKEYS); /* 53 */
1295
1296 case SPI_GETMOUSEKEYS: /* 54 */
1297 {
1298 LPMOUSEKEYS lpMouseKeys = (LPMOUSEKEYS)pvParam;
1299 WARN("SPI_GETMOUSEKEYS not fully implemented\n");
1300 if (lpMouseKeys->cbSize == sizeof(MOUSEKEYS))
1301 {
1302 /* Indicate that no MouseKeys feature available */
1303 lpMouseKeys->dwFlags = 0;
1304 lpMouseKeys->iMaxSpeed = 360;
1305 lpMouseKeys->iTimeToMaxSpeed = 1000;
1306 lpMouseKeys->iCtrlSpeed = 0;
1307 lpMouseKeys->dwReserved1 = 0;
1308 lpMouseKeys->dwReserved2 = 0;
1309 }
1310 else
1311 {
1312 ret = FALSE;
1313 }
1314 break;
1315 }
1316 WINE_SPI_FIXME(SPI_SETMOUSEKEYS); /* 55 */
1317
1318 case SPI_GETSHOWSOUNDS: /* 56 */
1319 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1320
1321 if (!spi_loaded[spi_idx])
1322 {
1323 char buf[10];
1324
1325 if (SYSPARAMS_Load( SPI_SETSHOWSOUNDS_REGKEY,
1326 SPI_SETSHOWSOUNDS_VALNAME, buf ))
1327 {
1328 SYSMETRICS_Set( SM_SHOWSOUNDS, atoi( buf ) );
1329 }
1330 spi_loaded[spi_idx] = TRUE;
1331 }
1332
1333
1334 *(INT *)pvParam = GetSystemMetrics( SM_SHOWSOUNDS );
1335 break;
1336
1337 case SPI_SETSHOWSOUNDS: /* 57 */
1338 {
1339 char buf[10];
1340 spi_idx = SPI_SETSHOWSOUNDS_IDX;
1341
1342 sprintf(buf, "%u", uiParam);
1343 if (SYSPARAMS_Save( SPI_SETSHOWSOUNDS_REGKEY,
1344 SPI_SETSHOWSOUNDS_VALNAME,
1345 buf, fWinIni ))
1346 {
1347 SYSMETRICS_Set( SM_SHOWSOUNDS, uiParam );
1348 spi_loaded[spi_idx] = TRUE;
1349 }
1350 else
1351 ret = FALSE;
1352 break;
1353 }
1354
1355 case SPI_GETSTICKYKEYS: /* 58 */
1356 {
1357 LPSTICKYKEYS lpStickyKeys = (LPSTICKYKEYS)pvParam;
1358 WARN("SPI_GETSTICKYKEYS not fully implemented\n");
1359 if (lpStickyKeys->cbSize == sizeof(STICKYKEYS))
1360 {
1361 /* Indicate that no StickyKeys feature available */
1362 lpStickyKeys->dwFlags = 0;
1363 }
1364 else
1365 {
1366 ret = FALSE;
1367 }
1368 break;
1369 }
1370 WINE_SPI_FIXME(SPI_SETSTICKYKEYS); /* 59 */
1371
1372 case SPI_GETACCESSTIMEOUT: /* 60 */
1373 {
1374 LPACCESSTIMEOUT lpAccessTimeout = (LPACCESSTIMEOUT)pvParam;
1375 WARN("SPI_GETACCESSTIMEOUT not fully implemented\n");
1376 if (lpAccessTimeout->cbSize == sizeof(ACCESSTIMEOUT))
1377 {
1378 /* Indicate that no accessibility features timeout is available */
1379 lpAccessTimeout->dwFlags = 0;
1380 lpAccessTimeout->iTimeOutMSec = 0;
1381 }
1382 else
1383 {
1384 ret = FALSE;
1385 }
1386 break;
1387 }
1388 WINE_SPI_FIXME(SPI_SETACCESSTIMEOUT); /* 61 */
1389
1390 case SPI_GETSERIALKEYS: /* 62 WINVER >= 0x400 */
1391 {
1392 LPSERIALKEYSA lpSerialKeysA = (LPSERIALKEYSA)pvParam;
1393 WARN("SPI_GETSERIALKEYS not fully implemented\n");
1394 if (lpSerialKeysA->cbSize == sizeof(SERIALKEYSA))
1395 {
1396 /* Indicate that no SerialKeys feature available */
1397 lpSerialKeysA->dwFlags = 0;
1398 lpSerialKeysA->lpszActivePort = NULL;
1399 lpSerialKeysA->lpszPort = NULL;
1400 lpSerialKeysA->iBaudRate = 0;
1401 lpSerialKeysA->iPortState = 0;
1402 }
1403 else
1404 {
1405 ret = FALSE;
1406 }
1407 break;
1408 }
1409 WINE_SPI_FIXME(SPI_SETSERIALKEYS); /* 63 WINVER >= 0x400 */
1410
1411 case SPI_GETSOUNDSENTRY: /* 64 */
1412 {
1413 LPSOUNDSENTRYA lpSoundSentryA = (LPSOUNDSENTRYA)pvParam;
1414 WARN("SPI_GETSOUNDSENTRY not fully implemented\n");
1415 if (lpSoundSentryA->cbSize == sizeof(SOUNDSENTRYA))
1416 {
1417 /* Indicate that no SoundSentry feature available */
1418 lpSoundSentryA->dwFlags = 0;
1419 lpSoundSentryA->iFSTextEffect = 0;
1420 lpSoundSentryA->iFSTextEffectMSec = 0;
1421 lpSoundSentryA->iFSTextEffectColorBits = 0;
1422 lpSoundSentryA->iFSGrafEffect = 0;
1423 lpSoundSentryA->iFSGrafEffectMSec = 0;
1424 lpSoundSentryA->iFSGrafEffectColor = 0;
1425 lpSoundSentryA->iWindowsEffect = 0;
1426 lpSoundSentryA->iWindowsEffectMSec = 0;
1427 lpSoundSentryA->lpszWindowsEffectDLL = 0;
1428 lpSoundSentryA->iWindowsEffectOrdinal = 0;
1429 }
1430 else
1431 {
1432 ret = FALSE;
1433 }
1434 break;
1435 }
1436 WINE_SPI_FIXME(SPI_SETSOUNDSENTRY); /* 65 */
1437
1438 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1439 {
1440 LPHIGHCONTRASTA lpHighContrastA = (LPHIGHCONTRASTA)pvParam;
1441 WARN("SPI_GETHIGHCONTRAST not fully implemented\n");
1442 if (lpHighContrastA->cbSize == sizeof(HIGHCONTRASTA))
1443 {
1444 /* Indicate that no high contrast feature available */
1445 lpHighContrastA->dwFlags = 0;
1446 lpHighContrastA->lpszDefaultScheme = NULL;
1447 }
1448 else
1449 {
1450 ret = FALSE;
1451 }
1452 break;
1453 }
1454 WINE_SPI_FIXME(SPI_SETHIGHCONTRAST); /* 67 WINVER >= 0x400 */
1455
1456 WINE_SPI_FIXME(SPI_GETKEYBOARDPREF); /* 68 WINVER >= 0x400 */
1457 WINE_SPI_FIXME(SPI_SETKEYBOARDPREF); /* 69 WINVER >= 0x400 */
1458
1459 case SPI_GETSCREENREADER:
1460 {
1461 LPBOOL bool = (LPBOOL)pvParam;
1462 *bool = FALSE;
1463 break;
1464 }
1465
1466 WINE_SPI_FIXME(SPI_SETSCREENREADER); /* 71 WINVER >= 0x400 */
1467
1468 case SPI_GETANIMATION: /* 72 WINVER >= 0x400 */
1469 {
1470 LPANIMATIONINFO lpAnimInfo = (LPANIMATIONINFO)pvParam;
1471
1472 /* Tell it "disabled" */
1473 if (lpAnimInfo->cbSize == sizeof(ANIMATIONINFO))
1474 lpAnimInfo->iMinAnimate = 0; /* Minimise and restore animation is disabled (nonzero == enabled) */
1475 else
1476 ret = FALSE;
1477 break;
1478 }
1479 WINE_SPI_WARN(SPI_SETANIMATION); /* 73 WINVER >= 0x400 */
1480
1481 WINE_SPI_FIXME(SPI_GETFONTSMOOTHING); /* 74 WINVER >= 0x400 */
1482 WINE_SPI_FIXME(SPI_SETFONTSMOOTHING); /* 75 WINVER >= 0x400 */
1483
1484 WINE_SPI_FIXME(SPI_SETDRAGWIDTH); /* 76 WINVER >= 0x400 */
1485 WINE_SPI_FIXME(SPI_SETDRAGHEIGHT); /* 77 WINVER >= 0x400 */
1486
1487 WINE_SPI_FIXME(SPI_SETHANDHELD); /* 78 WINVER >= 0x400 */
1488
1489 WINE_SPI_FIXME(SPI_GETLOWPOWERTIMEOUT); /* 79 WINVER >= 0x400 */
1490 WINE_SPI_FIXME(SPI_GETPOWEROFFTIMEOUT); /* 80 WINVER >= 0x400 */
1491 WINE_SPI_FIXME(SPI_SETLOWPOWERTIMEOUT); /* 81 WINVER >= 0x400 */
1492 WINE_SPI_FIXME(SPI_SETPOWEROFFTIMEOUT); /* 82 WINVER >= 0x400 */
1493 WINE_SPI_FIXME(SPI_GETLOWPOWERACTIVE); /* 83 WINVER >= 0x400 */
1494 WINE_SPI_FIXME(SPI_GETPOWEROFFACTIVE); /* 84 WINVER >= 0x400 */
1495 WINE_SPI_FIXME(SPI_SETLOWPOWERACTIVE); /* 85 WINVER >= 0x400 */
1496 WINE_SPI_FIXME(SPI_SETPOWEROFFACTIVE); /* 86 WINVER >= 0x400 */
1497
1498 WINE_SPI_FIXME(SPI_SETCURSORS); /* 87 WINVER >= 0x400 */
1499 WINE_SPI_FIXME(SPI_SETICONS); /* 88 WINVER >= 0x400 */
1500
1501 WINE_SPI_FIXME(SPI_GETDEFAULTINPUTLANG); /* 89 WINVER >= 0x400 */
1502 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG); /* 90 WINVER >= 0x400 */
1503
1504 WINE_SPI_FIXME(SPI_SETLANGTOGGLE); /* 91 WINVER >= 0x400 */
1505
1506 case SPI_GETWINDOWSEXTENSION: /* 92 WINVER >= 0x400 */
1507 WARN("pretend no support for Win9x Plus! for now.\n");
1508 ret = FALSE; /* yes, this is the result value */
1509 break;
1510
1511 WINE_SPI_FIXME(SPI_SETMOUSETRAILS); /* 93 WINVER >= 0x400 */
1512 WINE_SPI_FIXME(SPI_GETMOUSETRAILS); /* 94 WINVER >= 0x400 */
1513
1514 case SPI_SETSCREENSAVERRUNNING: /* 97 WINVER >= 0x400 */
1515 {
1516 /* SPI_SCREENSAVERRUNNING is an alias for SPI_SETSCREENSAVERRUNNING */
1517 char buf[5];
1518
1519 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1520 sprintf(buf, "%u", uiParam);
1521
1522 /* save only temporarily */
1523 if (SYSPARAMS_Save( SPI_SETSCREENSAVERRUNNING_REGKEY,
1524 SPI_SETSCREENSAVERRUNNING_VALNAME,
1525 buf, 0 ))
1526 {
1527 screensaver_running = uiParam;
1528 spi_loaded[spi_idx] = TRUE;
1529 }
1530 else
1531 ret = FALSE;
1532 break;
1533 }
1534
1535 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1536 *(UINT *)pvParam = 4;
1537 break;
1538 WINE_SPI_FIXME(SPI_SETMOUSEHOVERWIDTH); /* 99 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1539
1540 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1541 *(UINT *)pvParam = 4;
1542 break;
1543 WINE_SPI_FIXME(SPI_SETMOUSEHOVERHEIGHT); /* 101 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1544
1545 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1546 *(UINT *)pvParam = 400; /* default for menu dropdowns */
1547 break;
1548 WINE_SPI_FIXME(SPI_SETMOUSEHOVERTIME); /* 103 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1549
1550 case SPI_GETWHEELSCROLLLINES: /* 104 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1551 *(UINT *)pvParam = 3; /* default for num scroll lines */
1552 break;
1553
1554 WINE_SPI_FIXME(SPI_SETWHEELSCROLLLINES); /* 105 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1555
1556 case SPI_GETMENUSHOWDELAY: /* 106 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1557 *(UINT *)pvParam = 400; /* Tested against Windows NT 4.0 and Windows 2000 */
1558 break;
1559
1560 WINE_SPI_FIXME(SPI_GETSHOWIMEUI); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1561 WINE_SPI_FIXME(SPI_SETSHOWIMEUI); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1562
1563 case SPI_GETSCREENSAVERRUNNING: /* 114 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1564 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1565 if (!spi_loaded[spi_idx])
1566 {
1567 char buf[5];
1568
1569 if (SYSPARAMS_Load( SPI_SETSCREENSAVERRUNNING_REGKEY,
1570 SPI_SETSCREENSAVERRUNNING_VALNAME, buf ))
1571 screensaver_running = atoi( buf );
1572 spi_loaded[spi_idx] = TRUE;
1573 }
1574
1575 *(BOOL *)pvParam = screensaver_running;
1576 break;
1577
1578 default:
1579 FIXME( "Unknown action: %u\n", uiAction );
1580 SetLastError( ERROR_INVALID_SPI_VALUE );
1581 ret = FALSE;
1582 break;
1583 }
1584
1585 if (ret)
1586 SYSPARAMS_NotifyChange( uiAction, fWinIni );
1587 return ret;
1588
1589 #undef WINE_SPI_FIXME
1590 #undef WINE_SPI_WARN
1591 }
1592
1593
1594 /***********************************************************************
1595 * SystemParametersInfo (USER.483)
1596 */
1597 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
1598 LPVOID lpvParam, UINT16 fuWinIni )
1599 {
1600 BOOL16 ret;
1601
1602 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
1603
1604 switch (uAction)
1605 {
1606 case SPI_GETBEEP: /* 1 */
1607 case SPI_GETSCREENSAVEACTIVE: /* 16 */
1608 case SPI_GETICONTITLEWRAP: /* 25 */
1609 case SPI_GETMENUDROPALIGNMENT: /* 27 */
1610 case SPI_GETFASTTASKSWITCH: /* 35 */
1611 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1612 {
1613 BOOL tmp;
1614 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1615 if (ret && lpvParam)
1616 *(BOOL16 *)lpvParam = tmp;
1617 break;
1618 }
1619
1620 case SPI_GETBORDER: /* 5 */
1621 case SPI_ICONHORIZONTALSPACING: /* 13 */
1622 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
1623 case SPI_GETGRIDGRANULARITY: /* 18 */
1624 case SPI_GETKEYBOARDDELAY: /* 22 */
1625 case SPI_ICONVERTICALSPACING: /* 24 */
1626 {
1627 INT tmp;
1628 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1629 if (ret && lpvParam)
1630 *(INT16 *)lpvParam = tmp;
1631 break;
1632 }
1633
1634 case SPI_GETKEYBOARDSPEED: /* 10 */
1635 {
1636 DWORD tmp;
1637 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1638 if (ret && lpvParam)
1639 *(WORD *)lpvParam = tmp;
1640 break;
1641 }
1642
1643 case SPI_GETICONTITLELOGFONT: /* 31 */
1644 {
1645 LOGFONTA tmp;
1646 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1647 if (ret && lpvParam)
1648 SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
1649 break;
1650 }
1651
1652 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1653 {
1654 NONCLIENTMETRICSA tmp;
1655 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
1656 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
1657 {
1658 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1659 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
1660 if (ret)
1661 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
1662 }
1663 else /* winfile 95 sets cbSize to 340 */
1664 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1665 break;
1666 }
1667
1668 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1669 {
1670 RECT tmp;
1671 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1672 if (ret && lpvParam)
1673 CONV_RECT32TO16( &tmp, (RECT16 *)lpvParam );
1674 break;
1675 }
1676
1677 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1678 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1679 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1680 {
1681 UINT tmp;
1682 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1683 if (ret && lpvParam)
1684 *(UINT16 *)lpvParam = tmp;
1685 break;
1686 }
1687
1688 default:
1689 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1690 }
1691
1692 return ret;
1693 }
1694
1695 /***********************************************************************
1696 * SystemParametersInfoW (USER32.@)
1697 */
1698 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
1699 PVOID pvParam, UINT fuWinIni )
1700 {
1701 BOOL ret;
1702
1703 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
1704
1705 switch (uiAction)
1706 {
1707 case SPI_SETDESKWALLPAPER: /* 20 */
1708 case SPI_SETDESKPATTERN: /* 21 */
1709 {
1710 char buffer[256];
1711 if (pvParam)
1712 if (!WideCharToMultiByte( CP_ACP, 0, (LPWSTR)pvParam, -1,
1713 buffer, sizeof(buffer), NULL, NULL ))
1714 buffer[sizeof(buffer)-1] = 0;
1715 ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
1716 break;
1717 }
1718
1719 case SPI_GETICONTITLELOGFONT: /* 31 */
1720 {
1721 LOGFONTA tmp;
1722 ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
1723 if (ret && pvParam)
1724 SYSPARAMS_LogFont32ATo32W( &tmp, (LPLOGFONTW)pvParam );
1725 break;
1726 }
1727
1728 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1729 {
1730 NONCLIENTMETRICSA tmp;
1731 LPNONCLIENTMETRICSW lpnmW = (LPNONCLIENTMETRICSW)pvParam;
1732 if (lpnmW && lpnmW->cbSize == sizeof(NONCLIENTMETRICSW))
1733 {
1734 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1735 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1736 if (ret)
1737 SYSPARAMS_NonClientMetrics32ATo32W( &tmp, lpnmW );
1738 }
1739 else
1740 ret = FALSE;
1741 break;
1742 }
1743
1744 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
1745 {
1746 ICONMETRICSA tmp;
1747 LPICONMETRICSW lpimW = (LPICONMETRICSW)pvParam;
1748 if (lpimW && lpimW->cbSize == sizeof(ICONMETRICSW))
1749 {
1750 tmp.cbSize = sizeof(ICONMETRICSA);
1751 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1752 if (ret)
1753 {
1754 lpimW->iHorzSpacing = tmp.iHorzSpacing;
1755 lpimW->iVertSpacing = tmp.iVertSpacing;
1756 lpimW->iTitleWrap = tmp.iTitleWrap;
1757 SYSPARAMS_LogFont32ATo32W( &tmp.lfFont, &lpimW->lfFont );
1758 }
1759 }
1760 else
1761 ret = FALSE;
1762 break;
1763 }
1764
1765 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1766 {
1767 HIGHCONTRASTA tmp;
1768 LPHIGHCONTRASTW lphcW = (LPHIGHCONTRASTW)pvParam;
1769 if (lphcW && lphcW->cbSize == sizeof(HIGHCONTRASTW))
1770 {
1771 tmp.cbSize = sizeof(HIGHCONTRASTA);
1772 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1773 if (ret)
1774 {
1775 lphcW->dwFlags = tmp.dwFlags;
1776 lphcW->lpszDefaultScheme = NULL; /* FIXME? */
1777 }
1778 }
1779 else
1780 ret = FALSE;
1781 break;
1782 }
1783
1784 default:
1785 ret = SystemParametersInfoA( uiAction, uiParam, pvParam, fuWinIni );
1786 break;
1787 }
1788 return ret;
1789 }
1790
1791
1792 /**********************************************************************
1793 * SetDoubleClickTime (USER32.@)
1794 */
1795 BOOL WINAPI SetDoubleClickTime( UINT interval )
1796 {
1797 return SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
1798 }
1799
1800
1801 /**********************************************************************
1802 * GetDoubleClickTime (USER32.@)
1803 */
1804 UINT WINAPI GetDoubleClickTime(void)
1805 {
1806 char buf[10];
1807
1808 if (!spi_loaded[SPI_SETDOUBLECLICKTIME_IDX])
1809 {
1810 if (SYSPARAMS_Load( SPI_SETDOUBLECLICKTIME_REGKEY,
1811 SPI_SETDOUBLECLICKTIME_VALNAME,
1812 buf ))
1813 {
1814 double_click_time = atoi( buf );
1815 if (!double_click_time) double_click_time = 500;
1816 }
1817 spi_loaded[SPI_SETDOUBLECLICKTIME_IDX] = TRUE;
1818 }
1819 return double_click_time;
1820 }
widl and rpcrt4 development