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