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