?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
French translation of the README file.
[wine.git] / windows / sysparams.c
bloba23f61cb175769e0f0baff3c071d28ff6f4deaca
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 /* FIXME - real values */
113 #define SPI_SETKEYBOARDPREF_REGKEY "Control Panel\\Desktop"
114 #define SPI_SETKEYBOARDPREF_VALNAME "WINE_KeyboardPref"
115 #define SPI_SETSCREENREADER_REGKEY "Control Panel\\Desktop"
116 #define SPI_SETSCREENREADER_VALNAME "WINE_ScreenReader"
117 #define SPI_SETSCREENSAVERRUNNING_REGKEY "Control Panel\\Desktop"
118 #define SPI_SETSCREENSAVERRUNNING_VALNAME "WINE_ScreenSaverRunning"
119
120 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
121 #define WINE_CURRENT_USER_REGKEY "Wine"
122
123 /* Indicators whether system parameter value is loaded */
124 static char spi_loaded[SPI_WINE_IDX + 1];
125
126 static BOOL notify_change = TRUE;
127
128 /* System parameters storage */
129 static BOOL beep_active = TRUE;
130 static int mouse_threshold1 = 6;
131 static int mouse_threshold2 = 10;
132 static int mouse_speed = 1;
133 static int border = 1;
134 static int keyboard_speed = 31;
135 static int screensave_timeout = 300;
136 static int grid_granularity = 0;
137 static int keyboard_delay = 1;
138 static BOOL icon_title_wrap = TRUE;
139 static int double_click_time = 500;
140 static BOOL drag_full_windows = FALSE;
141 static RECT work_area;
142 static BOOL keyboard_pref = TRUE;
143 static BOOL screen_reader = FALSE;
144 static BOOL screensaver_running = FALSE;
145
146 /***********************************************************************
147 * GetTimerResolution (USER.14)
148 */
149 LONG WINAPI GetTimerResolution16(void)
150 {
151 return (1000);
152 }
153
154 /***********************************************************************
155 * ControlPanelInfo (USER.273)
156 */
157 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
158 {
159 FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
160 }
161
162 /* This function is a copy of the one in objects/font.c */
163 static void SYSPARAMS_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
164 {
165 font16->lfHeight = font32->lfHeight;
166 font16->lfWidth = font32->lfWidth;
167 font16->lfEscapement = font32->lfEscapement;
168 font16->lfOrientation = font32->lfOrientation;
169 font16->lfWeight = font32->lfWeight;
170 font16->lfItalic = font32->lfItalic;
171 font16->lfUnderline = font32->lfUnderline;
172 font16->lfStrikeOut = font32->lfStrikeOut;
173 font16->lfCharSet = font32->lfCharSet;
174 font16->lfOutPrecision = font32->lfOutPrecision;
175 font16->lfClipPrecision = font32->lfClipPrecision;
176 font16->lfQuality = font32->lfQuality;
177 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
178 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
179 }
180
181 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
182 {
183 font32W->lfHeight = font32A->lfHeight;
184 font32W->lfWidth = font32A->lfWidth;
185 font32W->lfEscapement = font32A->lfEscapement;
186 font32W->lfOrientation = font32A->lfOrientation;
187 font32W->lfWeight = font32A->lfWeight;
188 font32W->lfItalic = font32A->lfItalic;
189 font32W->lfUnderline = font32A->lfUnderline;
190 font32W->lfStrikeOut = font32A->lfStrikeOut;
191 font32W->lfCharSet = font32A->lfCharSet;
192 font32W->lfOutPrecision = font32A->lfOutPrecision;
193 font32W->lfClipPrecision = font32A->lfClipPrecision;
194 font32W->lfQuality = font32A->lfQuality;
195 font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
196 MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
197 font32W->lfFaceName[LF_FACESIZE-1] = 0;
198 }
199
200 static void SYSPARAMS_NonClientMetrics32ATo16( const NONCLIENTMETRICSA* lpnm32, LPNONCLIENTMETRICS16 lpnm16 )
201 {
202 lpnm16->iBorderWidth = lpnm32->iBorderWidth;
203 lpnm16->iScrollWidth = lpnm32->iScrollWidth;
204 lpnm16->iScrollHeight = lpnm32->iScrollHeight;
205 lpnm16->iCaptionWidth = lpnm32->iCaptionWidth;
206 lpnm16->iCaptionHeight = lpnm32->iCaptionHeight;
207 SYSPARAMS_LogFont32ATo16( &lpnm32->lfCaptionFont, &lpnm16->lfCaptionFont );
208 lpnm16->iSmCaptionWidth = lpnm32->iSmCaptionWidth;
209 lpnm16->iSmCaptionHeight = lpnm32->iSmCaptionHeight;
210 SYSPARAMS_LogFont32ATo16( &lpnm32->lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
211 lpnm16->iMenuWidth = lpnm32->iMenuWidth;
212 lpnm16->iMenuHeight = lpnm32->iMenuHeight;
213 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMenuFont, &lpnm16->lfMenuFont );
214 SYSPARAMS_LogFont32ATo16( &lpnm32->lfStatusFont, &lpnm16->lfStatusFont );
215 SYSPARAMS_LogFont32ATo16( &lpnm32->lfMessageFont, &lpnm16->lfMessageFont );
216 }
217
218 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
219 {
220 lpnm32W->iBorderWidth = lpnm32A->iBorderWidth;
221 lpnm32W->iScrollWidth = lpnm32A->iScrollWidth;
222 lpnm32W->iScrollHeight = lpnm32A->iScrollHeight;
223 lpnm32W->iCaptionWidth = lpnm32A->iCaptionWidth;
224 lpnm32W->iCaptionHeight = lpnm32A->iCaptionHeight;
225 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfCaptionFont, &lpnm32W->lfCaptionFont );
226 lpnm32W->iSmCaptionWidth = lpnm32A->iSmCaptionWidth;
227 lpnm32W->iSmCaptionHeight = lpnm32A->iSmCaptionHeight;
228 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont, &lpnm32W->lfSmCaptionFont );
229 lpnm32W->iMenuWidth = lpnm32A->iMenuWidth;
230 lpnm32W->iMenuHeight = lpnm32A->iMenuHeight;
231 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont, &lpnm32W->lfMenuFont );
232 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont, &lpnm32W->lfStatusFont );
233 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont, &lpnm32W->lfMessageFont );
234 }
235
236 /***********************************************************************
237 * SYSPARAMS_Reset
238 *
239 * Sets the system parameter which should be always loaded to
240 * current value stored in registry.
241 * Invalidates lazy loaded parameter, so it will be loaded the next time
242 * it is requested.
243 *
244 * Parameters:
245 * uiAction - system parameter to reload value for.
246 * Note, only "SET" values can be used for this parameter.
247 * If uiAction is 0 all system parameters are reset.
248 */
249 void SYSPARAMS_Reset( UINT uiAction )
250 {
251 #define WINE_RELOAD_SPI(x) \
252 case x: \
253 spi_loaded[x##_IDX] = FALSE; \
254 SystemParametersInfoA( x, 0, dummy_buf, 0 );\
255 if (uiAction) \
256 break
257
258 #define WINE_IGNORE_SPI(x) \
259 case x: \
260 if (uiAction) \
261 break
262
263 #define WINE_INVALIDATE_SPI(x) \
264 case x: \
265 spi_loaded[x##_IDX] = FALSE; \
266 break
267
268 BOOL not_all_processed = TRUE;
269 char dummy_buf[10];
270
271 /* Execution falls through all the branches for uiAction == 0 */
272 switch (uiAction)
273 {
274 case 0:
275 memset( spi_loaded, 0, sizeof(spi_loaded) );
276
277 WINE_RELOAD_SPI(SPI_SETBORDER);
278 WINE_RELOAD_SPI(SPI_ICONHORIZONTALSPACING);
279 WINE_RELOAD_SPI(SPI_ICONVERTICALSPACING);
280 WINE_IGNORE_SPI(SPI_SETSCREENSAVEACTIVE);
281 WINE_RELOAD_SPI(SPI_SETDOUBLECLKWIDTH);
282 WINE_RELOAD_SPI(SPI_SETDOUBLECLKHEIGHT);
283 WINE_RELOAD_SPI(SPI_SETMOUSEBUTTONSWAP);
284 WINE_RELOAD_SPI(SPI_SETSHOWSOUNDS);
285 WINE_RELOAD_SPI(SPI_SETMENUDROPALIGNMENT);
286
287 default:
288 if (uiAction)
289 {
290 /* lazy loaded parameters */
291 switch (uiAction)
292 {
293 WINE_INVALIDATE_SPI(SPI_SETBEEP);
294 WINE_INVALIDATE_SPI(SPI_SETMOUSE);
295 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDSPEED);
296 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVETIMEOUT);
297 WINE_INVALIDATE_SPI(SPI_SETGRIDGRANULARITY);
298 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDDELAY);
299 WINE_INVALIDATE_SPI(SPI_SETICONTITLEWRAP);
300 WINE_INVALIDATE_SPI(SPI_SETDOUBLECLICKTIME);
301 WINE_INVALIDATE_SPI(SPI_SETDRAGFULLWINDOWS);
302 WINE_INVALIDATE_SPI(SPI_SETWORKAREA);
303 WINE_INVALIDATE_SPI(SPI_SETKEYBOARDPREF);
304 WINE_INVALIDATE_SPI(SPI_SETSCREENREADER);
305 WINE_INVALIDATE_SPI(SPI_SETSCREENSAVERRUNNING);
306 default:
307 FIXME( "Unknown action reset: %u\n", uiAction );
308 break;
309 }
310 }
311 else
312 not_all_processed = FALSE;
313 break;
314 }
315
316 if (!uiAction && not_all_processed)
317 ERR( "Incorrect implementation of SYSPARAMS_Reset. "
318 "Not all params are reloaded.\n" );
319 #undef WINE_INVALIDATE_SPI
320 #undef WINE_IGNORE_SPI
321 #undef WINE_RELOAD_SPI
322 }
323
324 /***********************************************************************
325 * get_volatile_regkey
326 *
327 * Return a handle to the volatile registry key used to store
328 * non-permanently modified parameters.
329 */
330 static HKEY get_volatile_regkey(void)
331 {
332 static HKEY volatile_key;
333
334 if (!volatile_key)
335 {
336 if (RegCreateKeyExA( HKEY_CURRENT_USER, WINE_CURRENT_USER_REGKEY,
337 0, 0, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, 0,
338 &volatile_key, 0 ) != ERROR_SUCCESS)
339 ERR("Can't create wine configuration registry branch\n");
340 }
341 return volatile_key;
342 }
343
344 /***********************************************************************
345 * SYSPARAMS_NotifyChange
346 *
347 * Sends notification about system parameter update.
348 */
349 void SYSPARAMS_NotifyChange( UINT uiAction, UINT fWinIni )
350 {
351 if (notify_change)
352 {
353 if (fWinIni & SPIF_UPDATEINIFILE)
354 {
355 if (fWinIni & (SPIF_SENDWININICHANGE | SPIF_SENDCHANGE))
356 SendMessageA(HWND_BROADCAST, WM_SETTINGCHANGE,
357 uiAction, (LPARAM) "");
358 }
359 else
360 {
361 /* FIXME notify other wine processes with internal message */
362 }
363 }
364 }
365
366
367 /***********************************************************************
368 * Loads system parameter from user profile.
369 */
370 BOOL SYSPARAMS_Load( LPSTR lpRegKey, LPSTR lpValName, LPSTR lpBuf )
371 {
372 BOOL ret = FALSE;
373 DWORD type;
374 HKEY hKey;
375 DWORD count;
376
377 if ((RegOpenKeyA( get_volatile_regkey(), lpRegKey,
378 &hKey ) == ERROR_SUCCESS) ||
379 (RegOpenKeyA( HKEY_CURRENT_USER, lpRegKey,
380 &hKey ) == ERROR_SUCCESS))
381 {
382 ret = !RegQueryValueExA( hKey, lpValName, NULL, &type, lpBuf, &count );
383 RegCloseKey( hKey );
384 }
385 return ret;
386 }
387
388 /***********************************************************************
389 * Saves system parameter to user profile.
390 */
391 BOOL SYSPARAMS_Save( LPSTR lpRegKey, LPSTR lpValName, LPSTR lpValue,
392 UINT fWinIni )
393 {
394 HKEY hKey;
395 HKEY hBaseKey;
396 DWORD dwOptions;
397 BOOL ret = FALSE;
398
399 if (fWinIni & SPIF_UPDATEINIFILE)
400 {
401 hBaseKey = HKEY_CURRENT_USER;
402 dwOptions = 0;
403 }
404 else
405 {
406 hBaseKey = get_volatile_regkey();
407 dwOptions = REG_OPTION_VOLATILE;
408 }
409
410 if (RegCreateKeyExA( hBaseKey, lpRegKey,
411 0, 0, dwOptions, KEY_ALL_ACCESS,
412 0, &hKey, 0 ) == ERROR_SUCCESS)
413 {
414 if (RegSetValueExA( hKey, lpValName, 0, REG_SZ,
415 lpValue, strlen(lpValue) + 1 ) == ERROR_SUCCESS)
416 {
417 ret = TRUE;
418 if (hBaseKey == HKEY_CURRENT_USER)
419 RegDeleteKeyA( get_volatile_regkey(), lpRegKey );
420 }
421 RegCloseKey( hKey );
422 }
423 return ret;
424 }
425
426
427 /***********************************************************************
428 * SYSPARAMS_GetDoubleClickSize
429 *
430 * There is no SPI_GETDOUBLECLK* so we export this function instead.
431 */
432 void SYSPARAMS_GetDoubleClickSize( INT *width, INT *height )
433 {
434 char buf[10];
435
436 if (!spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX])
437 {
438 char buf[10];
439
440 if (SYSPARAMS_Load( SPI_SETDOUBLECLKWIDTH_REGKEY,
441 SPI_SETDOUBLECLKWIDTH_VALNAME, buf ))
442 {
443 SYSMETRICS_Set( SM_CXDOUBLECLK, atoi( buf ) );
444 }
445 spi_loaded[SPI_SETDOUBLECLKWIDTH_IDX] = TRUE;
446 }
447 if (!spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX])
448 {
449 if (SYSPARAMS_Load( SPI_SETDOUBLECLKHEIGHT_REGKEY,
450 SPI_SETDOUBLECLKHEIGHT_VALNAME, buf ))
451 {
452 SYSMETRICS_Set( SM_CYDOUBLECLK, atoi( buf ) );
453 }
454 spi_loaded[SPI_SETDOUBLECLKHEIGHT_IDX] = TRUE;
455 }
456 *width = GetSystemMetrics( SM_CXDOUBLECLK );
457 *height = GetSystemMetrics( SM_CYDOUBLECLK );
458 }
459
460
461 /***********************************************************************
462 * SYSPARAMS_GetMouseButtonSwap
463 *
464 * There is no SPI_GETMOUSEBUTTONSWAP so we export this function instead.
465 */
466 INT SYSPARAMS_GetMouseButtonSwap( void )
467 {
468 int spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
469
470 if (!spi_loaded[spi_idx])
471 {
472 char buf[5];
473
474 if (SYSPARAMS_Load( SPI_SETMOUSEBUTTONSWAP_REGKEY,
475 SPI_SETMOUSEBUTTONSWAP_VALNAME, buf ))
476 {
477 SYSMETRICS_Set( SM_SWAPBUTTON, atoi( buf ) );
478 }
479 spi_loaded[spi_idx] = TRUE;
480 }
481
482 return GetSystemMetrics( SM_SWAPBUTTON );
483 }
484
485 /***********************************************************************
486 *
487 * SYSPARAMS_GetGUIFont
488 *
489 * fills LOGFONT with 'default GUI font'.
490 */
491
492 static void SYSPARAMS_GetGUIFont( LOGFONTA* plf )
493 {
494 HFONT hf;
495
496 memset( plf, 0, sizeof(LOGFONTA) );
497 hf = (HFONT)GetStockObject( DEFAULT_GUI_FONT );
498 if ( GetObjectA( hf, sizeof(LOGFONTA), plf ) != sizeof(LOGFONTA) )
499 {
500 /*
501 * GetObjectA() would be succeeded always
502 * since this is a stock object
503 */
504 ERR("GetObjectA() failed\n");
505 }
506 }
507
508 /***********************************************************************
509 * SystemParametersInfoA (USER32.@)
510 *
511 * Each system parameter has flag which shows whether the parameter
512 * is loaded or not. Parameters, stored directly in SysParametersInfo are
513 * loaded from registry only when they are requested and the flag is
514 * "false", after the loading the flag is set to "true". On interprocess
515 * notification of the parameter change the corresponding parameter flag is
516 * set to "false". The parameter value will be reloaded when it is requested
517 * the next time.
518 * Parameters, backed by or depend on GetSystemMetrics are processed
519 * differently. These parameters are always loaded. They are reloaded right
520 * away on interprocess change notification. We can't do lazy loading because
521 * we don't want to complicate GetSystemMetrics.
522 * Parameters, backed by X settings are read from corresponding setting.
523 * On the parameter change request the setting is changed. Interprocess change
524 * notifications are ignored.
525 * When parameter value is updated the changed value is stored in permanent
526 * registry branch if saving is requested. Otherwise it is stored
527 * in temporary branch
528 *
529 */
530 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
531 PVOID pvParam, UINT fWinIni )
532 {
533 #define WINE_SPI_FIXME(x) \
534 case x: \
535 FIXME( "Unimplemented action: %u (%s)\n", x, #x ); \
536 SetLastError( ERROR_INVALID_SPI_VALUE ); \
537 ret = FALSE; \
538 break
539 #define WINE_SPI_WARN(x) \
540 case x: \
541 WARN( "Ignored action: %u (%s)\n", x, #x ); \
542 break
543
544 BOOL ret = TRUE;
545 unsigned spi_idx = 0;
546
547 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fWinIni);
548
549 switch (uiAction)
550 {
551 case SPI_GETBEEP: /* 1 */
552 spi_idx = SPI_SETBEEP_IDX;
553 if (!spi_loaded[spi_idx])
554 {
555 char buf[5];
556
557 if (SYSPARAMS_Load( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME, buf ))
558 beep_active = !strcasecmp( "Yes", buf );
559 spi_loaded[spi_idx] = TRUE;
560 }
561
562 *(BOOL *)pvParam = beep_active;
563 break;
564
565 case SPI_SETBEEP: /* 2 */
566 spi_idx = SPI_SETBEEP_IDX;
567 if (SYSPARAMS_Save( SPI_SETBEEP_REGKEY, SPI_SETBEEP_VALNAME,
568 (uiParam ? "Yes" : "No"), fWinIni ))
569 {
570 beep_active = uiParam;
571 spi_loaded[spi_idx] = TRUE;
572 }
573 else
574 ret = FALSE;
575 break;
576
577 case SPI_GETMOUSE: /* 3 */
578 spi_idx = SPI_SETMOUSE_IDX;
579 if (!spi_loaded[spi_idx])
580 {
581 char buf[10];
582
583 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
584 buf ))
585 mouse_threshold1 = atoi( buf );
586 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
587 buf ))
588 mouse_threshold2 = atoi( buf );
589 if (SYSPARAMS_Load( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
590 buf ))
591 mouse_speed = atoi( buf );
592 spi_loaded[spi_idx] = TRUE;
593 }
594 ((INT *)pvParam)[0] = mouse_threshold1;
595 ((INT *)pvParam)[1] = mouse_threshold2;
596 ((INT *)pvParam)[2] = mouse_speed;
597 break;
598
599 case SPI_SETMOUSE: /* 4 */
600 {
601 char buf[10];
602
603 spi_idx = SPI_SETMOUSE_IDX;
604 sprintf(buf, "%d", ((INT *)pvParam)[0]);
605
606 if (SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME1,
607 buf, fWinIni ))
608 {
609 mouse_threshold1 = ((INT *)pvParam)[0];
610 spi_loaded[spi_idx] = TRUE;
611
612 sprintf(buf, "%d", ((INT *)pvParam)[1]);
613 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME2,
614 buf, fWinIni );
615 mouse_threshold2 = ((INT *)pvParam)[1];
616
617 sprintf(buf, "%d", ((INT *)pvParam)[2]);
618 SYSPARAMS_Save( SPI_SETMOUSE_REGKEY, SPI_SETMOUSE_VALNAME3,
619 buf, fWinIni );
620 mouse_speed = ((INT *)pvParam)[2];
621 }
622 else
623 ret = FALSE;
624 break;
625 }
626
627 case SPI_GETBORDER: /* 5 */
628 spi_idx = SPI_SETBORDER_IDX;
629 if (!spi_loaded[spi_idx])
630 {
631 char buf[10];
632
633 if (SYSPARAMS_Load( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
634 buf ))
635 {
636 int i = atoi( buf );
637 if (i > 0) border = i;
638 }
639 spi_loaded[spi_idx] = TRUE;
640 if (TWEAK_WineLook > WIN31_LOOK)
641 {
642 SYSMETRICS_Set( SM_CXFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
643 SYSMETRICS_Set( SM_CYFRAME, border + GetSystemMetrics( SM_CXDLGFRAME ) );
644 }
645 }
646 *(INT *)pvParam = border;
647 break;
648
649 case SPI_SETBORDER: /* 6 */
650 {
651 char buf[10];
652
653 spi_idx = SPI_SETBORDER_IDX;
654 sprintf(buf, "%u", uiParam);
655
656 if (SYSPARAMS_Save( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME,
657 buf, fWinIni ))
658 {
659 if (uiParam > 0)
660 {
661 border = uiParam;
662 spi_loaded[spi_idx] = TRUE;
663 if (TWEAK_WineLook > WIN31_LOOK)
664 {
665 SYSMETRICS_Set( SM_CXFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
666 SYSMETRICS_Set( SM_CYFRAME, uiParam + GetSystemMetrics( SM_CXDLGFRAME ) );
667 }
668 }
669 }
670 else
671 ret = FALSE;
672 break;
673 }
674
675 case SPI_GETKEYBOARDSPEED: /* 10 */
676 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
677 if (!spi_loaded[spi_idx])
678 {
679 char buf[10];
680
681 if (SYSPARAMS_Load( SPI_SETKEYBOARDSPEED_REGKEY,
682 SPI_SETKEYBOARDSPEED_VALNAME,
683 buf ))
684 keyboard_speed = atoi( buf );
685 spi_loaded[spi_idx] = TRUE;
686 }
687 *(INT *)pvParam = keyboard_speed;
688 break;
689
690 case SPI_SETKEYBOARDSPEED: /* 11 */
691 {
692 char buf[10];
693
694 spi_idx = SPI_SETKEYBOARDSPEED_IDX;
695 if (uiParam > 31)
696 uiParam = 31;
697 sprintf(buf, "%u", uiParam);
698
699 if (SYSPARAMS_Save( SPI_SETKEYBOARDSPEED_REGKEY,
700 SPI_SETKEYBOARDSPEED_VALNAME,
701 buf, fWinIni ))
702 {
703 keyboard_speed = uiParam;
704 spi_loaded[spi_idx] = TRUE;
705 }
706 else
707 ret = FALSE;
708 break;
709 }
710
711 /* not implemented in Windows */
712 WINE_SPI_WARN(SPI_LANGDRIVER); /* 12 */
713
714 case SPI_ICONHORIZONTALSPACING: /* 13 */
715 spi_idx = SPI_ICONHORIZONTALSPACING_IDX;
716 if (pvParam != NULL)
717 {
718 if (!spi_loaded[spi_idx])
719 {
720 char buf[10];
721
722 if (SYSPARAMS_Load( SPI_ICONHORIZONTALSPACING_REGKEY,
723 SPI_ICONHORIZONTALSPACING_VALNAME, buf ))
724 {
725 SYSMETRICS_Set( SM_CXICONSPACING, atoi( buf ) );
726 }
727 spi_loaded[spi_idx] = TRUE;
728 }
729
730 *(INT *)pvParam = GetSystemMetrics( SM_CXICONSPACING );
731 }
732 else
733 {
734 char buf[10];
735
736 if (uiParam < 32) uiParam = 32;
737
738 sprintf(buf, "%u", uiParam);
739 if (SYSPARAMS_Save( SPI_ICONHORIZONTALSPACING_REGKEY,
740 SPI_ICONHORIZONTALSPACING_VALNAME,
741 buf, fWinIni ))
742 {
743 SYSMETRICS_Set( SM_CXICONSPACING, uiParam );
744 spi_loaded[spi_idx] = TRUE;
745 }
746 else
747 ret = FALSE;
748 }
749 break;
750
751 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
752 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
753 if (!spi_loaded[spi_idx])
754 {
755 char buf[10];
756
757 if (SYSPARAMS_Load( SPI_SETSCREENSAVETIMEOUT_REGKEY,
758 SPI_SETSCREENSAVETIMEOUT_VALNAME,
759 buf ))
760 screensave_timeout = atoi( buf );
761
762 spi_loaded[spi_idx] = TRUE;
763 }
764 *(INT *)pvParam = screensave_timeout;
765 break;
766
767 case SPI_SETSCREENSAVETIMEOUT: /* 15 */
768 {
769 char buf[10];
770
771 spi_idx = SPI_SETSCREENSAVETIMEOUT_IDX;
772 sprintf(buf, "%u", uiParam);
773
774 if (SYSPARAMS_Save( SPI_SETSCREENSAVETIMEOUT_REGKEY,
775 SPI_SETSCREENSAVETIMEOUT_VALNAME,
776 buf, fWinIni ))
777 {
778 screensave_timeout = uiParam;
779 spi_loaded[spi_idx] = TRUE;
780 }
781 else
782 ret = FALSE;
783 break;
784 }
785
786 case SPI_GETSCREENSAVEACTIVE: /* 16 */
787 *(BOOL *)pvParam = USER_Driver.pGetScreenSaveActive();
788 break;
789
790 case SPI_SETSCREENSAVEACTIVE: /* 17 */
791 {
792 char buf[5];
793
794 sprintf(buf, "%u", uiParam);
795 USER_Driver.pSetScreenSaveActive( uiParam );
796 /* saved value does not affect Wine */
797 SYSPARAMS_Save( SPI_SETSCREENSAVEACTIVE_REGKEY,
798 SPI_SETSCREENSAVEACTIVE_VALNAME,
799 buf, fWinIni );
800 break;
801 }
802
803 case SPI_GETGRIDGRANULARITY: /* 18 */
804 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
805 if (!spi_loaded[spi_idx])
806 {
807 char buf[10];
808
809 if (SYSPARAMS_Load( SPI_SETGRIDGRANULARITY_REGKEY,
810 SPI_SETGRIDGRANULARITY_VALNAME,
811 buf ))
812 grid_granularity = atoi( buf );
813
814 spi_loaded[spi_idx] = TRUE;
815 }
816 *(INT *)pvParam = grid_granularity;
817 break;
818
819 case SPI_SETGRIDGRANULARITY: /* 19 */
820 {
821 char buf[10];
822
823 spi_idx = SPI_SETGRIDGRANULARITY_IDX;
824 sprintf(buf, "%u", uiParam);
825
826 if (SYSPARAMS_Save( SPI_SETGRIDGRANULARITY_REGKEY,
827 SPI_SETGRIDGRANULARITY_VALNAME,
828 buf, fWinIni ))
829 {
830 grid_granularity = uiParam;
831 spi_loaded[spi_idx] = TRUE;
832 }
833 else
834 ret = FALSE;
835 break;
836 }
837
838 case SPI_SETDESKWALLPAPER: /* 20 */
839 ret = SetDeskWallPaper( (LPSTR)pvParam );
840 break;
841 case SPI_SETDESKPATTERN: /* 21 */
842 /* FIXME: the ability to specify a pattern in pvParam
843 doesn't seem to be documented for Win32 */
844 if ((INT16)uiParam == -1)
845 {
846 char buffer[256];
847 GetProfileStringA( "Desktop", "Pattern",
848 "170 85 170 85 170 85 170 85",
849 buffer, sizeof(buffer) );
850 ret = DESKTOP_SetPattern( (LPSTR)buffer );
851 } else
852 ret = DESKTOP_SetPattern( (LPSTR)pvParam );
853 break;
854
855 case SPI_GETKEYBOARDDELAY: /* 22 */
856 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
857 if (!spi_loaded[spi_idx])
858 {
859 char buf[10];
860
861 if (SYSPARAMS_Load( SPI_SETKEYBOARDDELAY_REGKEY,
862 SPI_SETKEYBOARDDELAY_VALNAME,
863 buf ))
864 {
865 int i = atoi( buf );
866 if ( (i >= 0) && (i <= 3)) keyboard_delay = i;
867 }
868
869 spi_loaded[spi_idx] = TRUE;
870 }
871 *(INT *)pvParam = keyboard_delay;
872 break;
873
874 case SPI_SETKEYBOARDDELAY: /* 23 */
875 {
876 char buf[10];
877
878 spi_idx = SPI_SETKEYBOARDDELAY_IDX;
879 sprintf(buf, "%u", uiParam);
880
881 if (SYSPARAMS_Save( SPI_SETKEYBOARDDELAY_REGKEY,
882 SPI_SETKEYBOARDDELAY_VALNAME,
883 buf, fWinIni ))
884 {
885 if (uiParam <= 3)
886 keyboard_delay = uiParam;
887 spi_loaded[spi_idx] = TRUE;
888 }
889 else
890 ret = FALSE;
891 break;
892 }
893
894 case SPI_ICONVERTICALSPACING: /* 24 */
895 spi_idx = SPI_ICONVERTICALSPACING_IDX;
896 if (pvParam != NULL)
897 {
898 if (!spi_loaded[spi_idx])
899 {
900 char buf[10];
901
902 if (SYSPARAMS_Load( SPI_ICONVERTICALSPACING_REGKEY,
903 SPI_ICONVERTICALSPACING_VALNAME, buf ))
904 {
905 SYSMETRICS_Set( SM_CYICONSPACING, atoi( buf ) );
906 }
907 spi_loaded[spi_idx] = TRUE;
908 }
909
910 *(INT *)pvParam = GetSystemMetrics( SM_CYICONSPACING );
911 }
912 else
913 {
914 char buf[10];
915
916 if (uiParam < 32) uiParam = 32;
917
918 sprintf(buf, "%u", uiParam);
919 if (SYSPARAMS_Save( SPI_ICONVERTICALSPACING_REGKEY,
920 SPI_ICONVERTICALSPACING_VALNAME,
921 buf, fWinIni ))
922 {
923 SYSMETRICS_Set( SM_CYICONSPACING, uiParam );
924 spi_loaded[spi_idx] = TRUE;
925 }
926 else
927 ret = FALSE;
928 }
929
930 break;
931
932 case SPI_GETICONTITLEWRAP: /* 25 */
933 spi_idx = SPI_SETICONTITLEWRAP_IDX;
934 if (!spi_loaded[spi_idx])
935 {
936 char buf[5];
937
938 if (SYSPARAMS_Load( SPI_SETICONTITLEWRAP_REGKEY,
939 SPI_SETICONTITLEWRAP_VALNAME, buf ))
940 icon_title_wrap = atoi(buf);
941 spi_loaded[spi_idx] = TRUE;
942 }
943
944 *(BOOL *)pvParam = icon_title_wrap;
945 break;
946
947 case SPI_SETICONTITLEWRAP: /* 26 */
948 {
949 char buf[5];
950
951 spi_idx = SPI_SETICONTITLEWRAP_IDX;
952 sprintf(buf, "%u", uiParam);
953 if (SYSPARAMS_Save( SPI_SETICONTITLEWRAP_REGKEY,
954 SPI_SETICONTITLEWRAP_VALNAME,
955 buf, fWinIni ))
956 {
957 icon_title_wrap = uiParam;
958 spi_loaded[spi_idx] = TRUE;
959 }
960 else
961 ret = FALSE;
962 break;
963 }
964
965 case SPI_GETMENUDROPALIGNMENT: /* 27 */
966 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
967
968 if (!spi_loaded[spi_idx])
969 {
970 char buf[5];
971
972 if (SYSPARAMS_Load( SPI_SETMENUDROPALIGNMENT_REGKEY,
973 SPI_SETMENUDROPALIGNMENT_VALNAME, buf ))
974 {
975 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, atoi( buf ) );
976 }
977 spi_loaded[spi_idx] = TRUE;
978 }
979
980
981 *(BOOL *)pvParam = GetSystemMetrics( SM_MENUDROPALIGNMENT );
982 break;
983
984 case SPI_SETMENUDROPALIGNMENT: /* 28 */
985 {
986 char buf[5];
987 spi_idx = SPI_SETMENUDROPALIGNMENT_IDX;
988
989 sprintf(buf, "%u", uiParam);
990 if (SYSPARAMS_Save( SPI_SETMENUDROPALIGNMENT_REGKEY,
991 SPI_SETMENUDROPALIGNMENT_VALNAME,
992 buf, fWinIni ))
993 {
994 SYSMETRICS_Set( SM_MENUDROPALIGNMENT, uiParam );
995 spi_loaded[spi_idx] = TRUE;
996 }
997 else
998 ret = FALSE;
999 break;
1000 }
1001
1002 case SPI_SETDOUBLECLKWIDTH: /* 29 */
1003 {
1004 char buf[10];
1005 spi_idx = SPI_SETDOUBLECLKWIDTH_IDX;
1006
1007 sprintf(buf, "%u", uiParam);
1008 if (SYSPARAMS_Save( SPI_SETDOUBLECLKWIDTH_REGKEY,
1009 SPI_SETDOUBLECLKWIDTH_VALNAME,
1010 buf, fWinIni ))
1011 {
1012 SYSMETRICS_Set( SM_CXDOUBLECLK, uiParam );
1013 spi_loaded[spi_idx] = TRUE;
1014 }
1015 else
1016 ret = FALSE;
1017 break;
1018 }
1019
1020 case SPI_SETDOUBLECLKHEIGHT: /* 30 */
1021 {
1022 char buf[10];
1023 spi_idx = SPI_SETDOUBLECLKHEIGHT_IDX;
1024
1025 sprintf(buf, "%u", uiParam);
1026 if (SYSPARAMS_Save( SPI_SETDOUBLECLKHEIGHT_REGKEY,
1027 SPI_SETDOUBLECLKHEIGHT_VALNAME,
1028 buf, fWinIni ))
1029 {
1030 SYSMETRICS_Set( SM_CYDOUBLECLK, uiParam );
1031 spi_loaded[spi_idx] = TRUE;
1032 }
1033 else
1034 ret = FALSE;
1035 break;
1036 }
1037
1038 case SPI_GETICONTITLELOGFONT: /* 31 */
1039 {
1040 LPLOGFONTA lpLogFont = (LPLOGFONTA)pvParam;
1041 LOGFONTA lfDefault;
1042
1043 /*
1044 * The 'default GDI fonts' seems to be returned.
1045 * If a returned font is not a correct font in your environment,
1046 * please try to fix objects/gdiobj.c at first.
1047 */
1048 SYSPARAMS_GetGUIFont( &lfDefault );
1049
1050 GetProfileStringA( "Desktop", "IconTitleFaceName",
1051 lfDefault.lfFaceName,
1052 lpLogFont->lfFaceName, LF_FACESIZE );
1053 lpLogFont->lfHeight = -GetProfileIntA( "Desktop", "IconTitleSize", 13 );
1054 lpLogFont->lfWidth = 0;
1055 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1056 lpLogFont->lfWeight = FW_NORMAL;
1057 lpLogFont->lfItalic = FALSE;
1058 lpLogFont->lfStrikeOut = FALSE;
1059 lpLogFont->lfUnderline = FALSE;
1060 lpLogFont->lfCharSet = lfDefault.lfCharSet; /* at least 'charset' should not be hard-coded */
1061 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1062 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1063 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1064 break;
1065 }
1066
1067 case SPI_SETDOUBLECLICKTIME: /* 32 */
1068 {
1069 char buf[10];
1070
1071 spi_idx = SPI_SETDOUBLECLICKTIME_IDX;
1072 sprintf(buf, "%u", uiParam);
1073
1074 if (SYSPARAMS_Save( SPI_SETDOUBLECLICKTIME_REGKEY,
1075 SPI_SETDOUBLECLICKTIME_VALNAME,
1076 buf, fWinIni ))
1077 {
1078 if (!uiParam)
1079 uiParam = 500;
1080 double_click_time = uiParam;
1081 spi_loaded[spi_idx] = TRUE;
1082 }
1083 else
1084 ret = FALSE;
1085 break;
1086 }
1087
1088 case SPI_SETMOUSEBUTTONSWAP: /* 33 */
1089 {
1090 char buf[5];
1091 spi_idx = SPI_SETMOUSEBUTTONSWAP_IDX;
1092
1093 sprintf(buf, "%u", uiParam);
1094 if (SYSPARAMS_Save( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1095 SPI_SETMOUSEBUTTONSWAP_VALNAME,
1096 buf, fWinIni ))
1097 {
1098 SYSMETRICS_Set( SM_SWAPBUTTON, uiParam );
1099 spi_loaded[spi_idx] = TRUE;
1100 }
1101 else
1102 ret = FALSE;
1103 break;
1104 }
1105
1106 WINE_SPI_FIXME(SPI_SETICONTITLELOGFONT); /* 34 */
1107
1108 case SPI_GETFASTTASKSWITCH: /* 35 */
1109 *(BOOL *)pvParam = 1;
1110 break;
1111
1112 case SPI_SETFASTTASKSWITCH: /* 36 */
1113 /* the action is disabled */
1114 ret = FALSE;
1115 break;
1116
1117 case SPI_SETDRAGFULLWINDOWS: /* 37 WINVER >= 0x0400 */
1118 {
1119 char buf[5];
1120
1121 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1122 sprintf(buf, "%u", uiParam);
1123 if (SYSPARAMS_Save( SPI_SETDRAGFULLWINDOWS_REGKEY,
1124 SPI_SETDRAGFULLWINDOWS_VALNAME,
1125 buf, fWinIni ))
1126 {
1127 drag_full_windows = uiParam;
1128 spi_loaded[spi_idx] = TRUE;
1129 }
1130 else
1131 ret = FALSE;
1132 break;
1133 }
1134
1135 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1136 spi_idx = SPI_SETDRAGFULLWINDOWS_IDX;
1137 if (!spi_loaded[spi_idx])
1138 {
1139 char buf[5];
1140
1141 if (SYSPARAMS_Load( SPI_SETDRAGFULLWINDOWS_REGKEY,
1142 SPI_SETDRAGFULLWINDOWS_VALNAME, buf ))
1143 drag_full_windows = atoi(buf);
1144 spi_loaded[spi_idx] = TRUE;
1145 }
1146
1147 *(BOOL *)pvParam = drag_full_windows;
1148 break;
1149
1150 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1151 {
1152 LPNONCLIENTMETRICSA lpnm = (LPNONCLIENTMETRICSA)pvParam;
1153
1154 if (lpnm->cbSize == sizeof(NONCLIENTMETRICSA))
1155 {
1156 LPLOGFONTA lpLogFont = &(lpnm->lfMenuFont);
1157
1158 /* clear the struct, so we have 'sane' members */
1159 memset(
1160 (char *)pvParam + sizeof(lpnm->cbSize),
1161 0,
1162 lpnm->cbSize - sizeof(lpnm->cbSize)
1163 );
1164
1165 /* initialize geometry entries */
1166 lpnm->iBorderWidth = -1; /* FIXME */
1167 lpnm->iScrollWidth = GetSystemMetrics(SM_CXVSCROLL);
1168 lpnm->iScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1169 /* caption */
1170 lpnm->iCaptionWidth = GetSystemMetrics(SM_CXSIZE);
1171 lpnm->iCaptionHeight = lpnm->iCaptionWidth;
1172 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfCaptionFont), 0 );
1173 lpnm->lfCaptionFont.lfWeight = FW_BOLD;
1174
1175 /* small caption */
1176 lpnm->iSmCaptionWidth = GetSystemMetrics(SM_CXSMSIZE);
1177 lpnm->iSmCaptionHeight = lpnm->iSmCaptionWidth;
1178 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0, (LPVOID)&(lpnm->lfSmCaptionFont), 0 );
1179
1180 /* menus, FIXME: names of wine.conf entries are bogus */
1181
1182 lpnm->iMenuWidth = GetProfileIntA( "Desktop", "MenuWidth", 13 ); /* size of the menu buttons*/
1183 lpnm->iMenuHeight = GetProfileIntA( "Desktop", "MenuHeight",
1184 (TWEAK_WineLook > WIN31_LOOK) ? 13 : 27 );
1185
1186 GetProfileStringA( "Desktop", "MenuFont",
1187 (TWEAK_WineLook > WIN31_LOOK) ? lpnm->lfCaptionFont.lfFaceName : "System",
1188 lpLogFont->lfFaceName, LF_FACESIZE );
1189
1190 lpLogFont->lfHeight = -GetProfileIntA( "Desktop", "MenuFontSize", 13 );
1191 lpLogFont->lfWidth = 0;
1192 lpLogFont->lfEscapement = lpLogFont->lfOrientation = 0;
1193 lpLogFont->lfWeight = (TWEAK_WineLook > WIN31_LOOK) ? FW_NORMAL : FW_BOLD;
1194 lpLogFont->lfItalic = FALSE;
1195 lpLogFont->lfStrikeOut = FALSE;
1196 lpLogFont->lfUnderline = FALSE;
1197 lpLogFont->lfCharSet = lpnm->lfCaptionFont.lfCharSet;
1198 lpLogFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1199 lpLogFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1200 lpLogFont->lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
1201
1202 SystemParametersInfoA( SPI_GETICONTITLELOGFONT, 0,
1203 (LPVOID)&(lpnm->lfStatusFont), 0 );
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 WINE_SPI_FIXME(SPI_GETDEFAULTINPUTLANG); /* 89 WINVER >= 0x400 */
1588 WINE_SPI_FIXME(SPI_SETDEFAULTINPUTLANG); /* 90 WINVER >= 0x400 */
1589
1590 WINE_SPI_FIXME(SPI_SETLANGTOGGLE); /* 91 WINVER >= 0x400 */
1591
1592 case SPI_GETWINDOWSEXTENSION: /* 92 WINVER >= 0x400 */
1593 WARN("pretend no support for Win9x Plus! for now.\n");
1594 ret = FALSE; /* yes, this is the result value */
1595 break;
1596
1597 WINE_SPI_FIXME(SPI_SETMOUSETRAILS); /* 93 WINVER >= 0x400 */
1598 WINE_SPI_FIXME(SPI_GETMOUSETRAILS); /* 94 WINVER >= 0x400 */
1599
1600 case SPI_SETSCREENSAVERRUNNING: /* 97 WINVER >= 0x400 */
1601 {
1602 /* SPI_SCREENSAVERRUNNING is an alias for SPI_SETSCREENSAVERRUNNING */
1603 char buf[5];
1604
1605 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1606 sprintf(buf, "%u", uiParam);
1607
1608 /* save only temporarily */
1609 if (SYSPARAMS_Save( SPI_SETSCREENSAVERRUNNING_REGKEY,
1610 SPI_SETSCREENSAVERRUNNING_VALNAME,
1611 buf, 0 ))
1612 {
1613 screensaver_running = uiParam;
1614 spi_loaded[spi_idx] = TRUE;
1615 }
1616 else
1617 ret = FALSE;
1618 break;
1619 }
1620
1621 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1622 *(UINT *)pvParam = 4;
1623 break;
1624 WINE_SPI_FIXME(SPI_SETMOUSEHOVERWIDTH); /* 99 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1625
1626 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1627 *(UINT *)pvParam = 4;
1628 break;
1629 WINE_SPI_FIXME(SPI_SETMOUSEHOVERHEIGHT); /* 101 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1630
1631 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1632 *(UINT *)pvParam = 400; /* default for menu dropdowns */
1633 break;
1634 WINE_SPI_FIXME(SPI_SETMOUSEHOVERTIME); /* 103 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1635
1636 case SPI_GETWHEELSCROLLLINES: /* 104 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1637 *(UINT *)pvParam = 3; /* default for num scroll lines */
1638 break;
1639
1640 WINE_SPI_FIXME(SPI_SETWHEELSCROLLLINES); /* 105 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1641
1642 case SPI_GETMENUSHOWDELAY: /* 106 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1643 *(UINT *)pvParam = 400; /* Tested against Windows NT 4.0 and Windows 2000 */
1644 break;
1645
1646 WINE_SPI_FIXME(SPI_GETSHOWIMEUI); /* 110 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1647 WINE_SPI_FIXME(SPI_SETSHOWIMEUI); /* 111 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1648
1649 case SPI_GETSCREENSAVERRUNNING: /* 114 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1650 spi_idx = SPI_SETSCREENSAVERRUNNING_IDX;
1651 if (!spi_loaded[spi_idx])
1652 {
1653 char buf[5];
1654
1655 if (SYSPARAMS_Load( SPI_SETSCREENSAVERRUNNING_REGKEY,
1656 SPI_SETSCREENSAVERRUNNING_VALNAME, buf ))
1657 screensaver_running = atoi( buf );
1658 spi_loaded[spi_idx] = TRUE;
1659 }
1660
1661 *(BOOL *)pvParam = screensaver_running;
1662 break;
1663
1664 WINE_SPI_FIXME(SPI_GETDESKWALLPAPER); /* 115 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1665 WINE_SPI_FIXME(SPI_GETACTIVEWINDOWTRACKING);/* 0x1000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1666 WINE_SPI_FIXME(SPI_SETACTIVEWINDOWTRACKING);/* 0x1001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1667 WINE_SPI_FIXME(SPI_GETMENUANIMATION); /* 0x1002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1668 WINE_SPI_FIXME(SPI_SETMENUANIMATION); /* 0x1003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1669 WINE_SPI_FIXME(SPI_GETCOMBOBOXANIMATION); /* 0x1004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1670 WINE_SPI_FIXME(SPI_SETCOMBOBOXANIMATION); /* 0x1005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1671 WINE_SPI_FIXME(SPI_GETLISTBOXSMOOTHSCROLLING);/* 0x1006 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1672 WINE_SPI_FIXME(SPI_SETLISTBOXSMOOTHSCROLLING);/* 0x1007 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1673 WINE_SPI_FIXME(SPI_GETGRADIENTCAPTIONS); /* 0x1008 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1674 WINE_SPI_FIXME(SPI_SETGRADIENTCAPTIONS); /* 0x1009 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1675 WINE_SPI_FIXME(SPI_GETMENUUNDERLINES); /* 0x100A _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1676 WINE_SPI_FIXME(SPI_SETMENUUNDERLINES); /* 0x100B _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1677 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKZORDER); /* 0x100C _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1678 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKZORDER); /* 0x100D _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1679 WINE_SPI_FIXME(SPI_GETHOTTRACKING); /* 0x100E _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1680 WINE_SPI_FIXME(SPI_SETHOTTRACKING); /* 0x100F _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1681 WINE_SPI_FIXME(SPI_GETFOREGROUNDLOCKTIMEOUT);/* 0x2000 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1682 WINE_SPI_FIXME(SPI_SETFOREGROUNDLOCKTIMEOUT);/* 0x2001 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1683 WINE_SPI_FIXME(SPI_GETACTIVEWNDTRKTIMEOUT); /* 0x2002 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1684 WINE_SPI_FIXME(SPI_SETACTIVEWNDTRKTIMEOUT); /* 0x2003 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1685 WINE_SPI_FIXME(SPI_GETFOREGROUNDFLASHCOUNT);/* 0x2004 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1686 WINE_SPI_FIXME(SPI_SETFOREGROUNDFLASHCOUNT);/* 0x2005 _WIN32_WINNT >= 0x500 || _WIN32_WINDOW > 0x400 */
1687
1688 default:
1689 FIXME( "Unknown action: %u\n", uiAction );
1690 SetLastError( ERROR_INVALID_SPI_VALUE );
1691 ret = FALSE;
1692 break;
1693 }
1694
1695 if (ret)
1696 SYSPARAMS_NotifyChange( uiAction, fWinIni );
1697 return ret;
1698
1699 #undef WINE_SPI_FIXME
1700 #undef WINE_SPI_WARN
1701 }
1702
1703
1704 /***********************************************************************
1705 * SystemParametersInfo (USER.483)
1706 */
1707 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
1708 LPVOID lpvParam, UINT16 fuWinIni )
1709 {
1710 BOOL16 ret;
1711
1712 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
1713
1714 switch (uAction)
1715 {
1716 case SPI_GETBEEP: /* 1 */
1717 case SPI_GETSCREENSAVEACTIVE: /* 16 */
1718 case SPI_GETICONTITLEWRAP: /* 25 */
1719 case SPI_GETMENUDROPALIGNMENT: /* 27 */
1720 case SPI_GETFASTTASKSWITCH: /* 35 */
1721 case SPI_GETDRAGFULLWINDOWS: /* 38 WINVER >= 0x0400 */
1722 {
1723 BOOL tmp;
1724 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1725 if (ret && lpvParam)
1726 *(BOOL16 *)lpvParam = tmp;
1727 break;
1728 }
1729
1730 case SPI_GETBORDER: /* 5 */
1731 case SPI_ICONHORIZONTALSPACING: /* 13 */
1732 case SPI_GETSCREENSAVETIMEOUT: /* 14 */
1733 case SPI_GETGRIDGRANULARITY: /* 18 */
1734 case SPI_GETKEYBOARDDELAY: /* 22 */
1735 case SPI_ICONVERTICALSPACING: /* 24 */
1736 {
1737 INT tmp;
1738 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1739 if (ret && lpvParam)
1740 *(INT16 *)lpvParam = tmp;
1741 break;
1742 }
1743
1744 case SPI_GETKEYBOARDSPEED: /* 10 */
1745 {
1746 DWORD tmp;
1747 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1748 if (ret && lpvParam)
1749 *(WORD *)lpvParam = tmp;
1750 break;
1751 }
1752
1753 case SPI_GETICONTITLELOGFONT: /* 31 */
1754 {
1755 LOGFONTA tmp;
1756 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1757 if (ret && lpvParam)
1758 SYSPARAMS_LogFont32ATo16( &tmp, (LPLOGFONT16)lpvParam );
1759 break;
1760 }
1761
1762 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1763 {
1764 NONCLIENTMETRICSA tmp;
1765 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
1766 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
1767 {
1768 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1769 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
1770 if (ret)
1771 SYSPARAMS_NonClientMetrics32ATo16( &tmp, lpnm16 );
1772 }
1773 else /* winfile 95 sets cbSize to 340 */
1774 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1775 break;
1776 }
1777
1778 case SPI_GETWORKAREA: /* 48 WINVER >= 0x400 */
1779 {
1780 RECT tmp;
1781 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1782 if (ret && lpvParam)
1783 CONV_RECT32TO16( &tmp, (RECT16 *)lpvParam );
1784 break;
1785 }
1786
1787 case SPI_GETMOUSEHOVERWIDTH: /* 98 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1788 case SPI_GETMOUSEHOVERHEIGHT: /* 100 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1789 case SPI_GETMOUSEHOVERTIME: /* 102 _WIN32_WINNT >= 0x400 || _WIN32_WINDOW > 0x400 */
1790 {
1791 UINT tmp;
1792 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
1793 if (ret && lpvParam)
1794 *(UINT16 *)lpvParam = tmp;
1795 break;
1796 }
1797
1798 default:
1799 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
1800 }
1801
1802 return ret;
1803 }
1804
1805 /***********************************************************************
1806 * SystemParametersInfoW (USER32.@)
1807 */
1808 BOOL WINAPI SystemParametersInfoW( UINT uiAction, UINT uiParam,
1809 PVOID pvParam, UINT fuWinIni )
1810 {
1811 BOOL ret;
1812
1813 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
1814
1815 switch (uiAction)
1816 {
1817 case SPI_SETDESKWALLPAPER: /* 20 */
1818 case SPI_SETDESKPATTERN: /* 21 */
1819 {
1820 char buffer[256];
1821 if (pvParam)
1822 if (!WideCharToMultiByte( CP_ACP, 0, (LPWSTR)pvParam, -1,
1823 buffer, sizeof(buffer), NULL, NULL ))
1824 buffer[sizeof(buffer)-1] = 0;
1825 ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
1826 break;
1827 }
1828
1829 case SPI_GETICONTITLELOGFONT: /* 31 */
1830 {
1831 LOGFONTA tmp;
1832 ret = SystemParametersInfoA( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
1833 if (ret && pvParam)
1834 SYSPARAMS_LogFont32ATo32W( &tmp, (LPLOGFONTW)pvParam );
1835 break;
1836 }
1837
1838 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
1839 {
1840 NONCLIENTMETRICSA tmp;
1841 LPNONCLIENTMETRICSW lpnmW = (LPNONCLIENTMETRICSW)pvParam;
1842 if (lpnmW && lpnmW->cbSize == sizeof(NONCLIENTMETRICSW))
1843 {
1844 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
1845 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1846 if (ret)
1847 SYSPARAMS_NonClientMetrics32ATo32W( &tmp, lpnmW );
1848 }
1849 else
1850 ret = FALSE;
1851 break;
1852 }
1853
1854 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
1855 {
1856 ICONMETRICSA tmp;
1857 LPICONMETRICSW lpimW = (LPICONMETRICSW)pvParam;
1858 if (lpimW && lpimW->cbSize == sizeof(ICONMETRICSW))
1859 {
1860 tmp.cbSize = sizeof(ICONMETRICSA);
1861 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1862 if (ret)
1863 {
1864 lpimW->iHorzSpacing = tmp.iHorzSpacing;
1865 lpimW->iVertSpacing = tmp.iVertSpacing;
1866 lpimW->iTitleWrap = tmp.iTitleWrap;
1867 SYSPARAMS_LogFont32ATo32W( &tmp.lfFont, &lpimW->lfFont );
1868 }
1869 }
1870 else
1871 ret = FALSE;
1872 break;
1873 }
1874
1875 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
1876 {
1877 HIGHCONTRASTA tmp;
1878 LPHIGHCONTRASTW lphcW = (LPHIGHCONTRASTW)pvParam;
1879 if (lphcW && lphcW->cbSize == sizeof(HIGHCONTRASTW))
1880 {
1881 tmp.cbSize = sizeof(HIGHCONTRASTA);
1882 ret = SystemParametersInfoA( uiAction, uiParam, &tmp, fuWinIni );
1883 if (ret)
1884 {
1885 lphcW->dwFlags = tmp.dwFlags;
1886 lphcW->lpszDefaultScheme = NULL; /* FIXME? */
1887 }
1888 }
1889 else
1890 ret = FALSE;
1891 break;
1892 }
1893
1894 default:
1895 ret = SystemParametersInfoA( uiAction, uiParam, pvParam, fuWinIni );
1896 break;
1897 }
1898 return ret;
1899 }
1900
1901
1902 /**********************************************************************
1903 * SetDoubleClickTime (USER32.@)
1904 */
1905 BOOL WINAPI SetDoubleClickTime( UINT interval )
1906 {
1907 return SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
1908 }
1909
1910
1911 /**********************************************************************
1912 * GetDoubleClickTime (USER32.@)
1913 */
1914 UINT WINAPI GetDoubleClickTime(void)
1915 {
1916 char buf[10];
1917
1918 if (!spi_loaded[SPI_SETDOUBLECLICKTIME_IDX])
1919 {
1920 if (SYSPARAMS_Load( SPI_SETDOUBLECLICKTIME_REGKEY,
1921 SPI_SETDOUBLECLICKTIME_VALNAME,
1922 buf ))
1923 {
1924 double_click_time = atoi( buf );
1925 if (!double_click_time) double_click_time = 500;
1926 }
1927 spi_loaded[SPI_SETDOUBLECLICKTIME_IDX] = TRUE;
1928 }
1929 return double_click_time;
1930 }
Windows API implementation