0fede4ceec15ad12f0c68323525ebc6f15c3df62
[reactos.git] / win32ss / user / ntuser / sysparams.c
1 /*
2 * COPYRIGHT: GPL, see COPYING in the top level directory
3 * PROJECT: ReactOS win32 kernel mode subsystem server
4 * PURPOSE: System parameters functions
5 * FILE: win32ss/user/ntuser/sysparams.c
6 * PROGRAMER: Timo Kreuzer (timo.kreuzer@reactos.org)
7 */
8
9 // TODO:
10 // - Check all values that are in Winsta in ROS.
11 // - Does setting invalid fonts work?
12 // - Save appropriate text metrics.
13
14 #include <win32k.h>
15 DBG_DEFAULT_CHANNEL(UserSysparams);
16
17 SPIVALUES gspv;
18 BOOL gbSpiInitialized = FALSE;
19 BOOL g_PaintDesktopVersion = FALSE;
20
21 // HACK! We initialize SPI before we have a proper surface to get this from.
22 #define dpi 96
23 //(pPrimarySurface->GDIInfo.ulLogPixelsY)
24 #define REG2METRIC(reg) (reg > 0 ? reg : ((-(reg) * dpi + 720) / 1440))
25 #define METRIC2REG(met) (-((((met) * 1440)- 0) / dpi))
26
27 #define REQ_INTERACTIVE_WINSTA(err) \
28 do { \
29 if (GetW32ProcessInfo()->prpwinsta != InputWindowStation) \
30 { \
31 if (GetW32ProcessInfo()->prpwinsta == NULL) \
32 { \
33 ERR("NtUserSystemParametersInfo called without active window station, and it requires an interactive one\n"); \
34 } \
35 else \
36 { \
37 ERR("NtUserSystemParametersInfo requires interactive window station (current is '%wZ')\n", \
38 &(OBJECT_HEADER_TO_NAME_INFO(OBJECT_TO_OBJECT_HEADER(GetW32ProcessInfo()->prpwinsta))->Name)); \
39 } \
40 EngSetLastError(err); \
41 return 0; \
42 } \
43 } while (0)
44
45 static const WCHAR* KEY_MOUSE = L"Control Panel\\Mouse";
46 static const WCHAR* VAL_MOUSE1 = L"MouseThreshold1";
47 static const WCHAR* VAL_MOUSE2 = L"MouseThreshold2";
48 static const WCHAR* VAL_MOUSE3 = L"MouseSpeed";
49 static const WCHAR* VAL_MOUSETRAILS = L"MouseTrails";
50 static const WCHAR* VAL_DBLCLKWIDTH = L"DoubleClickWidth";
51 static const WCHAR* VAL_DBLCLKHEIGHT = L"DoubleClickHeight";
52 static const WCHAR* VAL_DBLCLKTIME = L"DoubleClickSpeed";
53 static const WCHAR* VAL_SNAPDEFBTN = L"SnapToDefaultButton";
54 static const WCHAR* VAL_SWAP = L"SwapMouseButtons";
55 static const WCHAR* VAL_HOVERTIME = L"MouseHoverTime";
56 static const WCHAR* VAL_HOVERWIDTH = L"MouseHoverWidth";
57 static const WCHAR* VAL_HOVERHEIGHT = L"MouseHoverHeight";
58 static const WCHAR* VAL_SENSITIVITY = L"MouseSensitivity";
59
60 static const WCHAR* KEY_DESKTOP = L"Control Panel\\Desktop";
61 static const WCHAR* VAL_SCRTO = L"ScreenSaveTimeOut";
62 static const WCHAR* VAL_SCRNSV = L"SCRNSAVE.EXE";
63 static const WCHAR* VAL_SCRACT = L"ScreenSaveActive";
64 static const WCHAR* VAL_GRID = L"GridGranularity";
65 static const WCHAR* VAL_DRAG = L"DragFullWindows";
66 static const WCHAR* VAL_DRAGHEIGHT = L"DragHeight";
67 static const WCHAR* VAL_DRAGWIDTH = L"DragWidth";
68 static const WCHAR* VAL_FNTSMOOTH = L"FontSmoothing";
69 static const WCHAR* VAL_SCRLLLINES = L"WheelScrollLines";
70 static const WCHAR* VAL_CLICKLOCKTIME = L"ClickLockTime";
71 static const WCHAR* VAL_PAINTDESKVER = L"PaintDesktopVersion";
72 static const WCHAR* VAL_CARETRATE = L"CursorBlinkRate";
73 #if (_WIN32_WINNT >= 0x0600)
74 static const WCHAR* VAL_SCRLLCHARS = L"WheelScrollChars";
75 #endif
76 static const WCHAR* VAL_USERPREFMASK = L"UserPreferencesMask";
77
78 static const WCHAR* KEY_MDALIGN = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows";
79 static const WCHAR* VAL_MDALIGN = L"MenuDropAlignment";
80
81 static const WCHAR* KEY_METRIC = L"Control Panel\\Desktop\\WindowMetrics";
82 static const WCHAR* VAL_BORDER = L"BorderWidth";
83 static const WCHAR* VAL_ICONSPC = L"IconSpacing";
84 static const WCHAR* VAL_ICONVSPC = L"IconVerticalspacing";
85 static const WCHAR* VAL_ITWRAP = L"IconTitleWrap";
86
87 static const WCHAR* KEY_SOUND = L"Control Panel\\Sound";
88 static const WCHAR* VAL_BEEP = L"Beep";
89
90 static const WCHAR* KEY_KBD = L"Control Panel\\Keyboard";
91 static const WCHAR* VAL_KBDSPD = L"KeyboardSpeed";
92 static const WCHAR* VAL_KBDDELAY = L"KeyboardDelay";
93
94 static const WCHAR* KEY_SHOWSNDS = L"Control Panel\\Accessibility\\ShowSounds";
95 static const WCHAR* KEY_KDBPREF = L"Control Panel\\Accessibility\\Keyboard Preference";
96 static const WCHAR* KEY_SCRREAD = L"Control Panel\\Accessibility\\Blind Access";
97 static const WCHAR* VAL_ON = L"On";
98
99
100
101 /** Loading the settings ******************************************************/
102
103 static
104 INT
105 SpiLoadDWord(PCWSTR pwszKey, PCWSTR pwszValue, INT iValue)
106 {
107 DWORD Result;
108 if (!RegReadUserSetting(pwszKey, pwszValue, REG_DWORD, &Result, sizeof(Result)))
109 {
110 return iValue;
111 }
112 return Result;
113 }
114
115 static
116 INT
117 SpiLoadInt(PCWSTR pwszKey, PCWSTR pwszValue, INT iValue)
118 {
119 WCHAR awcBuffer[12];
120 ULONG cbSize;
121
122 cbSize = sizeof(awcBuffer);
123 if (!RegReadUserSetting(pwszKey, pwszValue, REG_SZ, awcBuffer, cbSize))
124 {
125 return iValue;
126 }
127 return _wtoi(awcBuffer);
128 }
129
130 static
131 DWORD
132 SpiLoadUserPrefMask(DWORD dValue)
133 {
134 DWORD Result;
135 if (!RegReadUserSetting(KEY_DESKTOP, VAL_USERPREFMASK, REG_BINARY, &Result, sizeof(Result)))
136 {
137 return dValue;
138 }
139 return Result;
140 }
141
142 static
143 DWORD
144 SpiLoadTimeOut(VOID)
145 { // Must have the string!
146 WCHAR szApplicationName[MAX_PATH];
147 RtlZeroMemory(&szApplicationName, sizeof(szApplicationName));
148 if (!RegReadUserSetting(KEY_DESKTOP, VAL_SCRNSV, REG_SZ, &szApplicationName, sizeof(szApplicationName)))
149 {
150 return 0;
151 }
152 if (wcslen(szApplicationName) == 0) return 0;
153 return SpiLoadInt(KEY_DESKTOP, VAL_SCRTO, 0);
154 }
155
156 static
157 INT
158 SpiLoadMouse(PCWSTR pwszValue, INT iValue)
159 {
160 return SpiLoadInt(KEY_MOUSE, pwszValue, iValue);
161 }
162
163 static
164 INT
165 SpiLoadMetric(PCWSTR pwszValue, INT iValue)
166 {
167 INT iRegVal;
168
169 iRegVal = SpiLoadInt(KEY_METRIC, pwszValue, METRIC2REG(iValue));
170 TRACE("Loaded metric setting '%S', iValue=%d(reg:%d), ret=%d(reg:%d)\n",
171 pwszValue, iValue, METRIC2REG(iValue), REG2METRIC(iRegVal), iRegVal);
172 return REG2METRIC(iRegVal);
173 }
174
175 static
176 VOID
177 SpiLoadFont(PLOGFONTW plfOut, LPWSTR pwszValueName, PLOGFONTW plfDefault)
178 {
179 BOOL bResult;
180
181 bResult = RegReadUserSetting(KEY_METRIC,
182 pwszValueName,
183 REG_BINARY,
184 plfOut,
185 sizeof(LOGFONTW));
186 if (!bResult)
187 *plfOut = *plfDefault;
188 }
189
190 static
191 VOID
192 SpiFixupValues(VOID)
193 {
194 /* Fixup values */
195 gspv.ncm.iCaptionWidth = max(gspv.ncm.iCaptionWidth, 8);
196 gspv.ncm.iBorderWidth = max(gspv.ncm.iBorderWidth, 1);
197 gspv.ncm.iScrollWidth = max(gspv.ncm.iScrollWidth, 8);
198 gspv.ncm.iScrollHeight = max(gspv.ncm.iScrollHeight, 8);
199 // gspv.ncm.iMenuHeight = max(gspv.ncm.iMenuHeight, gspv.tmMenuFont.tmHeight);
200 // gspv.ncm.iMenuHeight = max(gspv.ncm.iMenuHeight,
201 // 2 + gspv.tmMenuFont.tmHeight +
202 // gspv.tmMenuFont.tmExternalLeading);
203 if (gspv.iDblClickTime == 0) gspv.iDblClickTime = 500;
204
205 // FIXME: Hack!!!
206 gspv.tmMenuFont.tmHeight = 11;
207 gspv.tmMenuFont.tmExternalLeading = 2;
208
209 gspv.tmCaptionFont.tmHeight = 11;
210 gspv.tmCaptionFont.tmExternalLeading = 2;
211
212 }
213
214 static
215 VOID
216 SpiUpdatePerUserSystemParameters(VOID)
217 {
218 static LOGFONTW lf1 = {-11, 0, 0, 0, FW_NORMAL, FALSE, FALSE,
219 FALSE, ANSI_CHARSET, 0, 0, DEFAULT_QUALITY,
220 VARIABLE_PITCH | FF_SWISS, L"MS Sans Serif"};
221 static LOGFONTW lf2 = {-11, 0, 0, 0, FW_BOLD, FALSE, FALSE,
222 FALSE, ANSI_CHARSET, 0, 0, DEFAULT_QUALITY,
223 VARIABLE_PITCH | FF_SWISS, L"MS Sans Serif"};
224
225 TRACE("Enter SpiUpdatePerUserSystemParameters\n");
226
227 /* Clear the structure */
228 RtlZeroMemory(&gspv, sizeof(gspv));
229
230 /* Load mouse settings */
231 gspv.caiMouse.FirstThreshold = SpiLoadMouse(VAL_MOUSE1, 6);
232 gspv.caiMouse.SecondThreshold = SpiLoadMouse(VAL_MOUSE2, 10);
233 gspv.caiMouse.Acceleration = SpiLoadMouse(VAL_MOUSE3, 1);
234 gspv.iMouseSpeed = SpiLoadMouse(VAL_SENSITIVITY, 10);
235 gspv.bMouseBtnSwap = SpiLoadMouse(VAL_SWAP, 0);
236 gspv.bSnapToDefBtn = SpiLoadMouse(VAL_SNAPDEFBTN, 0);
237 gspv.iMouseTrails = SpiLoadMouse(VAL_MOUSETRAILS, 0);
238 gspv.iDblClickTime = SpiLoadMouse(VAL_DBLCLKTIME, 500);
239 gspv.iDblClickWidth = SpiLoadMouse(VAL_DBLCLKWIDTH, 4);
240 gspv.iDblClickHeight = SpiLoadMouse(VAL_DBLCLKHEIGHT, 4);
241 gspv.iMouseHoverTime = SpiLoadMouse(VAL_HOVERTIME, 400);
242 gspv.iMouseHoverWidth = SpiLoadMouse(VAL_HOVERWIDTH, 4);
243 gspv.iMouseHoverHeight = SpiLoadMouse(VAL_HOVERHEIGHT, 4);
244
245 /* Load NONCLIENTMETRICS */
246 gspv.ncm.cbSize = sizeof(NONCLIENTMETRICSW);
247 gspv.ncm.iBorderWidth = SpiLoadMetric(VAL_BORDER, 1);
248 gspv.ncm.iScrollWidth = SpiLoadMetric(L"ScrollWidth", 16);
249 gspv.ncm.iScrollHeight = SpiLoadMetric(L"ScrollHeight", 16);
250 gspv.ncm.iCaptionWidth = SpiLoadMetric(L"CaptionWidth", 19);
251 gspv.ncm.iCaptionHeight = SpiLoadMetric(L"CaptionHeight", 19);
252 gspv.ncm.iSmCaptionWidth = SpiLoadMetric(L"SmCaptionWidth", 12);
253 gspv.ncm.iSmCaptionHeight = SpiLoadMetric(L"SmCaptionHeight", 14);
254 gspv.ncm.iMenuWidth = SpiLoadMetric(L"MenuWidth", 18);
255 gspv.ncm.iMenuHeight = SpiLoadMetric(L"MenuHeight", 18);
256 #if (WINVER >= 0x0600)
257 gspv.ncm.iPaddedBorderWidth = SpiLoadMetric(L"PaddedBorderWidth", 18);
258 #endif
259 SpiLoadFont(&gspv.ncm.lfCaptionFont, L"CaptionFont", &lf2);
260 SpiLoadFont(&gspv.ncm.lfSmCaptionFont, L"SmCaptionFont", &lf1);
261 SpiLoadFont(&gspv.ncm.lfMenuFont, L"MenuFont", &lf1);
262 SpiLoadFont(&gspv.ncm.lfStatusFont, L"StatusFont", &lf1);
263 SpiLoadFont(&gspv.ncm.lfMessageFont, L"MessageFont", &lf1);
264
265 /* Load MINIMIZEDMETRICS */
266 gspv.mm.cbSize = sizeof(MINIMIZEDMETRICS);
267 gspv.mm.iWidth = SpiLoadMetric(L"MinWidth", 160);
268 gspv.mm.iHorzGap = SpiLoadMetric(L"MinHorzGap", 160);
269 gspv.mm.iVertGap = SpiLoadMetric(L"MinVertGap", 24);
270 gspv.mm.iArrange = SpiLoadInt(KEY_METRIC, L"MinArrange", ARW_HIDE);
271
272 /* Load ICONMETRICS */
273 gspv.im.cbSize = sizeof(ICONMETRICSW);
274 gspv.im.iHorzSpacing = SpiLoadMetric(VAL_ICONSPC, 64);
275 gspv.im.iVertSpacing = SpiLoadMetric(VAL_ICONVSPC, 64);
276 gspv.im.iTitleWrap = SpiLoadMetric(VAL_ITWRAP, 0);
277 SpiLoadFont(&gspv.im.lfFont, L"IconFont", &lf1);
278
279 /* Load desktop settings */
280 gspv.bDragFullWindows = SpiLoadInt(KEY_DESKTOP, VAL_DRAG, 0);
281 gspv.iWheelScrollLines = SpiLoadInt(KEY_DESKTOP, VAL_SCRLLLINES, 3);
282 gspv.dwMouseClickLockTime = SpiLoadDWord(KEY_DESKTOP, VAL_CLICKLOCKTIME, 1200);
283 gpsi->dtCaretBlink = SpiLoadInt(KEY_DESKTOP, VAL_CARETRATE, 530);
284 gspv.dwUserPrefMask = SpiLoadUserPrefMask(UPM_DEFAULT);
285 gspv.bMouseClickLock = (gspv.dwUserPrefMask & UPM_CLICKLOCK) != 0;
286 gspv.bMouseCursorShadow = (gspv.dwUserPrefMask & UPM_CURSORSHADOW) != 0;
287 #if (_WIN32_WINNT >= 0x0600)
288 gspv.uiWheelScrollChars = SpiLoadInt(KEY_DESKTOP, VAL_SCRLLCHARS, 3);
289 #endif
290
291 /* Some hardcoded values for now */
292
293 gspv.tmCaptionFont.tmAveCharWidth = 6;
294 gspv.bBeep = TRUE;
295 gspv.uiFocusBorderWidth = 1;
296 gspv.uiFocusBorderHeight = 1;
297 gspv.bMenuDropAlign = 1;
298 gspv.dwMenuShowDelay = 100;
299 gspv.dwForegroundFlashCount = 3;
300
301 gspv.iScrSaverTimeout = SpiLoadTimeOut();
302 gspv.bScrSaverActive = FALSE;
303 gspv.bScrSaverRunning = FALSE;
304 #if(WINVER >= 0x0600)
305 gspv.bScrSaverSecure = FALSE;
306 #endif
307
308 gspv.accesstimeout.cbSize = sizeof(ACCESSTIMEOUT);
309 gspv.filterkeys.cbSize = sizeof(FILTERKEYS);
310 gspv.togglekeys.cbSize = sizeof(TOGGLEKEYS);
311 gspv.mousekeys.cbSize = sizeof(MOUSEKEYS);
312 gspv.stickykeys.cbSize = sizeof(STICKYKEYS);
313 gspv.serialkeys.cbSize = sizeof(SERIALKEYS);
314 gspv.soundsentry.cbSize = sizeof(SOUNDSENTRYW);
315 gspv.highcontrast.cbSize = sizeof(HIGHCONTRASTW);
316 gspv.animationinfo.cbSize = sizeof(ANIMATIONINFO);
317
318 /* Make sure we don't use broken values */
319 SpiFixupValues();
320
321 /* Update SystemMetrics */
322 InitMetrics();
323
324 if (gbSpiInitialized && gpsi)
325 {
326 if (gspv.bKbdPref) gpsi->dwSRVIFlags |= SRVINFO_KBDPREF;
327 if (SPITESTPREF(UPM_KEYBOARDCUES)) gpsi->PUSIFlags |= PUSIF_KEYBOARDCUES;
328 if (SPITESTPREF(UPM_COMBOBOXANIMATION)) gpsi->PUSIFlags |= PUSIF_COMBOBOXANIMATION;
329 if (SPITESTPREF(UPM_LISTBOXSMOOTHSCROLLING)) gpsi->PUSIFlags |= PUSIF_LISTBOXSMOOTHSCROLLING;
330 }
331 gdwLanguageToggleKey = UserGetLanguageToggle();
332 }
333
334 BOOL
335 InitSysParams(VOID)
336 {
337 SpiUpdatePerUserSystemParameters();
338 gbSpiInitialized = TRUE;
339 return TRUE;
340 }
341
342
343 BOOL
344 APIENTRY
345 NtUserUpdatePerUserSystemParameters(
346 DWORD dwReserved,
347 BOOL bEnable)
348 {
349 BOOL bResult;
350
351 TRACE("Enter NtUserUpdatePerUserSystemParameters\n");
352 UserEnterExclusive();
353
354 SpiUpdatePerUserSystemParameters();
355 if(bEnable)
356 g_PaintDesktopVersion = SpiLoadDWord(KEY_DESKTOP, VAL_PAINTDESKVER, 0);
357 else
358 g_PaintDesktopVersion = FALSE;
359 bResult = TRUE;
360
361 TRACE("Leave NtUserUpdatePerUserSystemParameters, returning %d\n", bResult);
362 UserLeave();
363
364 return bResult;
365 }
366
367
368 /** Storing the settings ******************************************************/
369
370 static
371 VOID
372 SpiStoreDWord(PCWSTR pwszKey, PCWSTR pwszValue, DWORD Value)
373 {
374 RegWriteUserSetting(pwszKey,
375 pwszValue,
376 REG_DWORD,
377 &Value,
378 sizeof(Value));
379 }
380
381 static
382 VOID
383 SpiStoreSz(PCWSTR pwszKey, PCWSTR pwszValue, PCWSTR pwsz)
384 {
385 RegWriteUserSetting(pwszKey,
386 pwszValue,
387 REG_SZ,
388 pwsz,
389 (wcslen(pwsz) + 1) * sizeof(WCHAR));
390 }
391
392 static
393 VOID
394 SpiStoreSzInt(PCWSTR pwszKey, PCWSTR pwszValue, INT iValue)
395 {
396 WCHAR awcBuffer[15];
397
398 _itow(iValue, awcBuffer, 10);
399 RegWriteUserSetting(pwszKey,
400 pwszValue,
401 REG_SZ,
402 awcBuffer,
403 (wcslen(awcBuffer) + 1) * sizeof(WCHAR));
404 }
405
406 static
407 VOID
408 SpiStoreMetric(LPCWSTR pwszValue, INT iValue)
409 {
410 SpiStoreSzInt(KEY_METRIC, pwszValue, METRIC2REG(iValue));
411 }
412
413 static
414 VOID
415 SpiStoreFont(PCWSTR pwszValue, LOGFONTW* plogfont)
416 {
417 RegWriteUserSetting(KEY_METRIC,
418 pwszValue,
419 REG_BINARY,
420 plogfont,
421 sizeof(LOGFONTW));
422 }
423
424
425 /** Get/Set value *************************************************************/
426
427 // FIXME: get rid of the flags and only use this from um. kernel can access data directly.
428 static
429 UINT_PTR
430 SpiMemCopy(PVOID pvDst, PVOID pvSrc, ULONG cbSize, BOOL bProtect)
431 {
432 NTSTATUS Status = STATUS_SUCCESS;
433
434 if (bProtect)
435 {
436 _SEH2_TRY
437 {
438 RtlCopyMemory(pvDst, pvSrc, cbSize);
439 }
440 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
441 {
442 Status = _SEH2_GetExceptionCode();
443 }
444 _SEH2_END;
445 }
446 else
447 {
448 RtlCopyMemory(pvDst, pvSrc, cbSize);
449 }
450
451 if (!NT_SUCCESS(Status))
452 {
453 SetLastNtError(Status);
454 ERR("SpiMemCopy failed, pvDst=%p, pvSrc=%p, bProtect=%d\n", pvDst, pvSrc, bProtect);
455 }
456
457 return NT_SUCCESS(Status);
458 }
459
460 static inline
461 UINT_PTR
462 SpiGet(PVOID pvParam, PVOID pvData, ULONG cbSize, FLONG fl)
463 {
464 REQ_INTERACTIVE_WINSTA(ERROR_ACCESS_DENIED);
465 return SpiMemCopy(pvParam, pvData, cbSize, fl & SPIF_PROTECT);
466 }
467
468 static inline
469 UINT_PTR
470 SpiSet(PVOID pvData, PVOID pvParam, ULONG cbSize, FLONG fl)
471 {
472 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
473 return SpiMemCopy(pvData, pvParam, cbSize, fl & SPIF_PROTECT);
474 }
475
476 static inline
477 UINT_PTR
478 SpiGetEx(PVOID pvParam, PVOID pvData, ULONG cbSize, FLONG fl)
479 {
480 ULONG cbBufSize;
481 /* Get the cbSite member from UM memory */
482 if (!SpiSet(&cbBufSize, pvParam, sizeof(ULONG), fl))
483 return 0;
484 /* Verify the correct size */
485 if (cbBufSize != cbSize)
486 return 0;
487 return SpiGet(pvParam, pvData, cbSize, fl);
488 }
489
490 static inline
491 UINT_PTR
492 SpiGetInt(PVOID pvParam, PVOID piValue, FLONG fl)
493 {
494 return SpiGet(pvParam, piValue, sizeof(INT), fl);
495 }
496
497 static inline
498 UINT_PTR
499 SpiSetYesNo(BOOL *pbData, BOOL bValue, PCWSTR pwszKey, PCWSTR pwszValue, FLONG fl)
500 {
501 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
502 *pbData = bValue ? TRUE : FALSE;
503 if (fl & SPIF_UPDATEINIFILE)
504 {
505 SpiStoreSz(pwszKey, pwszValue, bValue ? L"Yes" : L"No");
506 }
507 return (UINT_PTR)pwszKey;
508 }
509
510 static inline
511 UINT_PTR
512 SpiSetBool(BOOL *pbData, INT iValue, PCWSTR pwszKey, PCWSTR pwszValue, FLONG fl)
513 {
514 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
515 *pbData = iValue ? TRUE : FALSE;
516 if (fl & SPIF_UPDATEINIFILE)
517 {
518 SpiStoreSzInt(pwszKey, pwszValue, iValue);
519 }
520 return (UINT_PTR)pwszKey;
521 }
522
523 static inline
524 UINT_PTR
525 SpiSetDWord(PVOID pvData, INT iValue, PCWSTR pwszKey, PCWSTR pwszValue, FLONG fl)
526 {
527 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
528 *(INT*)pvData = iValue;
529 if (fl & SPIF_UPDATEINIFILE)
530 {
531 SpiStoreDWord(pwszKey, pwszValue, iValue);
532 }
533 return (UINT_PTR)pwszKey;
534 }
535
536 static inline
537 UINT_PTR
538 SpiSetInt(PVOID pvData, INT iValue, PCWSTR pwszKey, PCWSTR pwszValue, FLONG fl)
539 {
540 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
541 *(INT*)pvData = iValue;
542 if (fl & SPIF_UPDATEINIFILE)
543 {
544 SpiStoreSzInt(pwszKey, pwszValue, iValue);
545 }
546 return (UINT_PTR)pwszKey;
547 }
548
549 static inline
550 UINT_PTR
551 SpiSetMetric(PVOID pvData, INT iValue, PCWSTR pwszValue, FLONG fl)
552 {
553 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
554 *(INT*)pvData = iValue;
555 if (fl & SPIF_UPDATEINIFILE)
556 {
557 SpiStoreMetric(pwszValue, iValue);
558 }
559 return (UINT_PTR)KEY_METRIC;
560 }
561
562 static inline
563 UINT_PTR
564 SpiSetUserPref(DWORD dwMask, PVOID pvValue, FLONG fl)
565 {
566 DWORD dwRegMask;
567 BOOL bValue = PtrToUlong(pvValue);
568
569 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
570
571 /* Set or clear bit according to bValue */
572 gspv.dwUserPrefMask = bValue ? gspv.dwUserPrefMask | dwMask :
573 gspv.dwUserPrefMask & ~dwMask;
574
575 if (fl & SPIF_UPDATEINIFILE)
576 {
577 /* Read current value */
578 if (!RegReadUserSetting(KEY_DESKTOP,
579 VAL_USERPREFMASK,
580 REG_BINARY,
581 &dwRegMask,
582 sizeof(DWORD)))
583 {
584 WARN("Failed to read UserPreferencesMask setting\n");
585 dwRegMask = 0;
586 }
587
588 /* Set or clear bit according to bValue */
589 dwRegMask = bValue ? (dwRegMask | dwMask) : (dwRegMask & ~dwMask);
590
591 /* write back value */
592 RegWriteUserSetting(KEY_DESKTOP,
593 VAL_USERPREFMASK,
594 REG_BINARY,
595 &dwRegMask,
596 sizeof(DWORD));
597 }
598
599 return (UINT_PTR)KEY_DESKTOP;
600 }
601
602 static inline
603 UINT_PTR
604 SpiGetUserPref(DWORD dwMask, PVOID pvParam, FLONG fl)
605 {
606 INT iValue = gspv.dwUserPrefMask & dwMask ? 1 : 0;
607 return SpiGetInt(pvParam, &iValue, fl);
608 }
609
610 static
611 UINT_PTR
612 SpiSetWallpaper(PVOID pvParam, FLONG fl)
613 {
614 UNICODE_STRING ustr;
615 WCHAR awc[MAX_PATH];
616 BOOL bResult;
617 HBITMAP hbmp, hOldBitmap;
618 SURFACE *psurfBmp;
619 ULONG ulTile, ulStyle;
620
621 REQ_INTERACTIVE_WINSTA(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
622
623 if (!pvParam)
624 {
625 /* FIXME: Reset Wallpaper to registry value */
626 return (UINT_PTR)KEY_DESKTOP;
627 }
628
629 /* Capture UNICODE_STRING */
630 bResult = SpiMemCopy(&ustr, pvParam, sizeof(ustr), fl & SPIF_PROTECT);
631 if (!bResult)
632 {
633 return 0;
634 }
635 if (ustr.Length > MAX_PATH * sizeof(WCHAR))
636 {
637 return 0;
638 }
639
640 /* Copy the string buffer name */
641 bResult = SpiMemCopy(gspv.awcWallpaper, ustr.Buffer, ustr.Length, fl & SPIF_PROTECT);
642 if (!bResult)
643 {
644 return 0;
645 }
646
647 /* Update the UNICODE_STRING */
648 gspv.ustrWallpaper.Buffer = gspv.awcWallpaper;
649 gspv.ustrWallpaper.MaximumLength = MAX_PATH * sizeof(WCHAR);
650 gspv.ustrWallpaper.Length = ustr.Length;
651 gspv.awcWallpaper[ustr.Length / sizeof(WCHAR)] = 0;
652
653 TRACE("SpiSetWallpaper, name=%S\n", gspv.awcWallpaper);
654
655 /* Update registry */
656 if (fl & SPIF_UPDATEINIFILE)
657 {
658 SpiStoreSz(KEY_DESKTOP, L"Wallpaper", gspv.awcWallpaper);
659 }
660
661 /* Got a filename? */
662 if (gspv.awcWallpaper[0] != 0)
663 {
664 /* Convert file name to nt file name */
665 ustr.Buffer = awc;
666 ustr.MaximumLength = MAX_PATH * sizeof(WCHAR);
667 ustr.Length = 0;
668 if (!W32kDosPathNameToNtPathName(gspv.awcWallpaper, &ustr))
669 {
670 ERR("RtlDosPathNameToNtPathName_U failed\n");
671 return 0;
672 }
673
674 /* Load the Bitmap */
675 hbmp = UserLoadImage(ustr.Buffer);
676 if (!hbmp)
677 {
678 ERR("UserLoadImage failed\n");
679 return 0;
680 }
681
682 /* Try to get the size of the wallpaper */
683 if (!(psurfBmp = SURFACE_ShareLockSurface(hbmp)))
684 {
685 GreDeleteObject(hbmp);
686 return 0;
687 }
688
689 gspv.cxWallpaper = psurfBmp->SurfObj.sizlBitmap.cx;
690 gspv.cyWallpaper = psurfBmp->SurfObj.sizlBitmap.cy;
691 gspv.WallpaperMode = wmCenter;
692
693 SURFACE_ShareUnlockSurface(psurfBmp);
694
695 /* Change the bitmap's ownership */
696 GreSetObjectOwner(hbmp, GDI_OBJ_HMGR_PUBLIC);
697
698 /* Yes, Windows really loads the current setting from the registry. */
699 ulTile = SpiLoadInt(KEY_DESKTOP, L"TileWallpaper", 0);
700 ulStyle = SpiLoadInt(KEY_DESKTOP, L"WallpaperStyle", 0);
701 TRACE("SpiSetWallpaper: ulTile=%lu, ulStyle=%lu\n", ulTile, ulStyle);
702
703 /* Check the values we found in the registry */
704 if (ulTile && !ulStyle)
705 {
706 gspv.WallpaperMode = wmTile;
707 }
708 else if (!ulTile && ulStyle)
709 {
710 if (ulStyle == 2)
711 {
712 gspv.WallpaperMode = wmStretch;
713 }
714 else if (ulStyle == 6)
715 {
716 gspv.WallpaperMode = wmFit;
717 }
718 else if (ulStyle == 10)
719 {
720 gspv.WallpaperMode = wmFill;
721 }
722 }
723 }
724 else
725 {
726 /* Remove wallpaper */
727 gspv.cxWallpaper = 0;
728 gspv.cyWallpaper = 0;
729 hbmp = 0;
730 }
731
732 /* Take care of the old wallpaper, if any */
733 hOldBitmap = gspv.hbmWallpaper;
734 if(hOldBitmap != NULL)
735 {
736 /* Delete the old wallpaper */
737 GreSetObjectOwner(hOldBitmap, GDI_OBJ_HMGR_POWNED);
738 GreDeleteObject(hOldBitmap);
739 }
740
741 /* Set the new wallpaper */
742 gspv.hbmWallpaper = hbmp;
743
744 NtUserRedrawWindow(UserGetShellWindow(), NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
745
746
747 return (UINT_PTR)KEY_DESKTOP;
748 }
749
750 static BOOL
751 SpiNotifyNCMetricsChanged(VOID)
752 {
753 PWND pwndDesktop, pwndCurrent;
754 HWND *ahwnd;
755 USER_REFERENCE_ENTRY Ref;
756 int i;
757
758 pwndDesktop = UserGetDesktopWindow();
759 ASSERT(pwndDesktop);
760
761 ahwnd = IntWinListChildren(pwndDesktop);
762 if(!ahwnd)
763 return FALSE;
764
765 for (i = 0; ahwnd[i]; i++)
766 {
767 pwndCurrent = UserGetWindowObject(ahwnd[i]);
768 if(!pwndCurrent)
769 continue;
770
771 UserRefObjectCo(pwndCurrent, &Ref);
772 co_WinPosSetWindowPos(pwndCurrent, 0, pwndCurrent->rcWindow.left,pwndCurrent->rcWindow.top,
773 pwndCurrent->rcWindow.right-pwndCurrent->rcWindow.left
774 ,pwndCurrent->rcWindow.bottom - pwndCurrent->rcWindow.top,
775 SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|
776 SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW);
777 UserDerefObjectCo(pwndCurrent);
778 }
779
780 ExFreePoolWithTag(ahwnd, USERTAG_WINDOWLIST);
781
782 return TRUE;
783 }
784
785 static
786 UINT_PTR
787 SpiGetSet(UINT uiAction, UINT uiParam, PVOID pvParam, FLONG fl)
788 {
789 switch (uiAction)
790 {
791 case SPI_GETBEEP:
792 return SpiGetInt(pvParam, &gspv.bBeep, fl);
793
794 case SPI_SETBEEP:
795 return SpiSetYesNo(&gspv.bBeep, uiParam, KEY_SOUND, VAL_BEEP, fl);
796
797 case SPI_GETMOUSE:
798 return SpiGet(pvParam, &gspv.caiMouse, 3 * sizeof(INT), fl);
799
800 case SPI_SETMOUSE:
801 if (!SpiSet(&gspv.caiMouse, pvParam, 3 * sizeof(INT), fl))
802 return 0;
803 if (fl & SPIF_UPDATEINIFILE)
804 {
805 SpiStoreSzInt(KEY_MOUSE, VAL_MOUSE1, gspv.caiMouse.FirstThreshold);
806 SpiStoreSzInt(KEY_MOUSE, VAL_MOUSE2, gspv.caiMouse.SecondThreshold);
807 SpiStoreSzInt(KEY_MOUSE, VAL_MOUSE3, gspv.caiMouse.Acceleration);
808 }
809 return (UINT_PTR)KEY_MOUSE;
810
811 case SPI_GETBORDER:
812 return SpiGetInt(pvParam, &gspv.ncm.iBorderWidth, fl);
813
814 case SPI_SETBORDER:
815 uiParam = max(uiParam, 1);
816 return SpiSetInt(&gspv.ncm.iBorderWidth, uiParam, KEY_METRIC, VAL_BORDER, fl);
817
818 case SPI_GETKEYBOARDSPEED:
819 return SpiGetInt(pvParam, &gspv.dwKbdSpeed, fl);
820
821 case SPI_SETKEYBOARDSPEED:
822 return SpiSetInt(&gspv.dwKbdSpeed, uiParam, KEY_KBD, VAL_KBDSPD, fl);
823
824 case SPI_LANGDRIVER:
825 ERR("SPI_LANGDRIVER is unimplemented\n");
826 break;
827
828 case SPI_GETSCREENSAVETIMEOUT:
829 return SpiGetInt(pvParam, &gspv.iScrSaverTimeout, fl);
830
831 case SPI_SETSCREENSAVETIMEOUT:
832 return SpiSetInt(&gspv.iScrSaverTimeout, uiParam, KEY_DESKTOP, VAL_SCRTO, fl);
833
834 case SPI_GETSCREENSAVEACTIVE:
835 return SpiGetInt(pvParam, &gspv.bScrSaverActive, fl);
836
837 case SPI_SETSCREENSAVEACTIVE:
838 return SpiSetInt(&gspv.bScrSaverActive, uiParam, KEY_DESKTOP, VAL_SCRACT, fl);
839
840 case SPI_GETGRIDGRANULARITY:
841 return SpiGetInt(pvParam, &gspv.uiGridGranularity, fl);
842
843 case SPI_SETGRIDGRANULARITY:
844 return SpiSetInt(&gspv.uiGridGranularity, uiParam, KEY_DESKTOP, VAL_GRID, fl);
845
846 case SPI_GETDESKWALLPAPER:
847 uiParam = min(uiParam, gspv.ustrWallpaper.Length + 1UL);
848 return SpiGet(pvParam, gspv.awcWallpaper, uiParam, fl);
849
850 case SPI_SETDESKWALLPAPER:
851 return SpiSetWallpaper(pvParam, fl);
852
853 case SPI_SETDESKPATTERN:
854 ERR("SPI_SETDESKPATTERN is unimplemented\n");
855 break;
856
857 case SPI_GETKEYBOARDDELAY:
858 return SpiGetInt(pvParam, &gspv.iKbdDelay, fl);
859
860 case SPI_SETKEYBOARDDELAY:
861 return SpiSetInt(&gspv.iKbdDelay, uiParam, KEY_KBD, VAL_KBDDELAY, fl);
862
863 case SPI_ICONHORIZONTALSPACING:
864 if (pvParam)
865 {
866 return SpiGetInt(pvParam, &gspv.im.iHorzSpacing, fl);
867 }
868 uiParam = max(uiParam, 32);
869 return SpiSetMetric(&gspv.im.iHorzSpacing, uiParam, VAL_ICONSPC, fl);
870
871 case SPI_ICONVERTICALSPACING:
872 if (pvParam)
873 {
874 return SpiGetInt(pvParam, &gspv.im.iVertSpacing, fl);
875 }
876 uiParam = max(uiParam, 32);
877 return SpiSetMetric(&gspv.im.iVertSpacing, uiParam, VAL_ICONVSPC, fl);
878
879 case SPI_GETICONTITLEWRAP:
880 return SpiGetInt(pvParam, &gspv.im.iTitleWrap, fl);
881
882 case SPI_SETICONTITLEWRAP:
883 return SpiSetInt(&gspv.im.iTitleWrap, uiParam, KEY_METRIC, VAL_ITWRAP, fl);
884
885 case SPI_GETMENUDROPALIGNMENT:
886 return SpiGetInt(pvParam, &gspv.bMenuDropAlign, fl);
887
888 case SPI_SETMENUDROPALIGNMENT:
889 return SpiSetBool(&gspv.bMenuDropAlign, uiParam, KEY_MDALIGN, VAL_MDALIGN, fl);
890
891 case SPI_SETDOUBLECLKWIDTH:
892 return SpiSetInt(&gspv.iDblClickWidth, uiParam, KEY_MOUSE, VAL_DBLCLKWIDTH, fl);
893
894 case SPI_SETDOUBLECLKHEIGHT:
895 return SpiSetInt(&gspv.iDblClickHeight, uiParam, KEY_MOUSE, VAL_DBLCLKHEIGHT, fl);
896
897 case SPI_GETICONTITLELOGFONT:
898 return SpiGet(pvParam, &gspv.im.lfFont, sizeof(LOGFONTW), fl);
899
900 case SPI_SETICONTITLELOGFONT:
901 if (!SpiSet(&gspv.im.lfFont, pvParam, sizeof(LOGFONTW), fl))
902 return 0;
903 if (fl & SPIF_UPDATEINIFILE)
904 {
905 SpiStoreFont(L"IconFont", &gspv.im.lfFont);
906 }
907 return (UINT_PTR)KEY_METRIC;
908
909 case SPI_SETDOUBLECLICKTIME:
910 return SpiSetInt(&gspv.iDblClickTime, uiParam, KEY_MOUSE, VAL_DBLCLKTIME, fl);
911
912 case SPI_SETMOUSEBUTTONSWAP:
913 return SpiSetInt(&gspv.bMouseBtnSwap, uiParam, KEY_MOUSE, VAL_SWAP, fl);
914
915 case SPI_GETFASTTASKSWITCH:
916 return SpiGetInt(pvParam, &gspv.bFastTaskSwitch, fl);
917
918 case SPI_SETFASTTASKSWITCH:
919 /* According to Winetest this one is unimplemented */
920 return 1;
921
922 case SPI_GETDRAGFULLWINDOWS:
923 return SpiGetInt(pvParam, &gspv.bDragFullWindows, fl);
924
925 case SPI_SETDRAGFULLWINDOWS:
926 return SpiSetInt(&gspv.bDragFullWindows, uiParam, KEY_DESKTOP, VAL_DRAG, fl);
927
928 case SPI_GETNONCLIENTMETRICS:
929 {
930 return SpiGet(pvParam, &gspv.ncm, sizeof(NONCLIENTMETRICSW), fl);
931 }
932
933 case SPI_SETNONCLIENTMETRICS:
934 {
935 LPNONCLIENTMETRICSW metrics = (LPNONCLIENTMETRICSW)pvParam;
936
937 /* Fixup user's structure size */
938 metrics->cbSize = sizeof(NONCLIENTMETRICSW);
939
940 if (!SpiSet(&gspv.ncm, metrics, sizeof(NONCLIENTMETRICSW), fl))
941 return 0;
942
943 if (fl & SPIF_UPDATEINIFILE)
944 {
945 SpiStoreMetric(VAL_BORDER, gspv.ncm.iBorderWidth);
946 SpiStoreMetric(L"ScrollWidth", gspv.ncm.iScrollWidth);
947 SpiStoreMetric(L"ScrollHeight", gspv.ncm.iScrollHeight);
948 SpiStoreMetric(L"CaptionWidth", gspv.ncm.iCaptionWidth);
949 SpiStoreMetric(L"CaptionHeight", gspv.ncm.iCaptionHeight);
950 SpiStoreMetric(L"SmCaptionWidth", gspv.ncm.iSmCaptionWidth);
951 SpiStoreMetric(L"SmCaptionHeight", gspv.ncm.iSmCaptionHeight);
952 SpiStoreMetric(L"MenuWidth", gspv.ncm.iMenuWidth);
953 SpiStoreMetric(L"MenuHeight", gspv.ncm.iMenuHeight);
954 #if (WINVER >= 0x0600)
955 SpiStoreMetric(L"PaddedBorderWidth", gspv.ncm.iPaddedBorderWidth);
956 #endif
957 SpiStoreFont(L"CaptionFont", &gspv.ncm.lfCaptionFont);
958 SpiStoreFont(L"SmCaptionFont", &gspv.ncm.lfSmCaptionFont);
959 SpiStoreFont(L"MenuFont", &gspv.ncm.lfMenuFont);
960 SpiStoreFont(L"StatusFont", &gspv.ncm.lfStatusFont);
961 SpiStoreFont(L"MessageFont", &gspv.ncm.lfMessageFont);
962 }
963
964 if(!SpiNotifyNCMetricsChanged())
965 return 0;
966
967 return (UINT_PTR)KEY_METRIC;
968 }
969
970 case SPI_GETMINIMIZEDMETRICS:
971 {
972 return SpiGet(pvParam, &gspv.mm, sizeof(MINIMIZEDMETRICS), fl);
973 }
974
975 case SPI_SETMINIMIZEDMETRICS:
976 {
977 LPMINIMIZEDMETRICS metrics = (LPMINIMIZEDMETRICS)pvParam;
978
979 /* Fixup user's structure size */
980 metrics->cbSize = sizeof(MINIMIZEDMETRICS);
981
982 if (!SpiSet(&gspv.mm, metrics, sizeof(MINIMIZEDMETRICS), fl))
983 return 0;
984
985 gspv.mm.iWidth = max(0, gspv.mm.iWidth);
986 gspv.mm.iHorzGap = max(0, gspv.mm.iHorzGap);
987 gspv.mm.iVertGap = max(0, gspv.mm.iVertGap);
988 gspv.mm.iArrange = gspv.mm.iArrange & 0xf;
989
990 if (fl & SPIF_UPDATEINIFILE)
991 {
992 SpiStoreMetric(L"MinWidth", gspv.mm.iWidth);
993 SpiStoreMetric(L"MinHorzGap", gspv.mm.iHorzGap);
994 SpiStoreMetric(L"MinVertGap", gspv.mm.iVertGap);
995 SpiStoreMetric(L"MinArrange", gspv.mm.iArrange);
996 }
997
998 return (UINT_PTR)KEY_METRIC;
999 }
1000
1001 case SPI_GETICONMETRICS:
1002 {
1003 return SpiGet(pvParam, &gspv.im, sizeof(ICONMETRICSW), fl);
1004 }
1005
1006 case SPI_SETICONMETRICS:
1007 {
1008 LPICONMETRICSW metrics = (LPICONMETRICSW)pvParam;
1009
1010 /* Fixup user's structure size */
1011 metrics->cbSize = sizeof(ICONMETRICSW);
1012
1013 if (!SpiSet(&gspv.im, metrics, sizeof(ICONMETRICSW), fl))
1014 return 0;
1015
1016 if (fl & SPIF_UPDATEINIFILE)
1017 {
1018 SpiStoreMetric(VAL_ICONSPC, gspv.im.iHorzSpacing);
1019 SpiStoreMetric(VAL_ICONVSPC, gspv.im.iVertSpacing);
1020 SpiStoreMetric(VAL_ITWRAP, gspv.im.iTitleWrap);
1021 SpiStoreFont(L"IconFont", &gspv.im.lfFont);
1022 }
1023 return (UINT_PTR)KEY_METRIC;
1024 }
1025
1026 case SPI_GETWORKAREA:
1027 {
1028 PMONITOR pmonitor = UserGetPrimaryMonitor();
1029
1030 if(!pmonitor)
1031 return 0;
1032
1033 return SpiGet(pvParam, &pmonitor->rcWork, sizeof(RECTL), fl);
1034 }
1035
1036 case SPI_SETWORKAREA:
1037 {
1038 /* FIXME: We should set the work area of the monitor
1039 that contains the specified rectangle */
1040 PMONITOR pmonitor = UserGetPrimaryMonitor();
1041 RECT rcWorkArea;
1042
1043 if(!pmonitor)
1044 return 0;
1045
1046 if (!SpiSet(&rcWorkArea, pvParam, sizeof(RECTL), fl))
1047 return 0;
1048
1049 /* Verify the new values */
1050 if (rcWorkArea.left < 0 ||
1051 rcWorkArea.top < 0 ||
1052 rcWorkArea.right > gpsi->aiSysMet[SM_CXSCREEN] ||
1053 rcWorkArea.bottom > gpsi->aiSysMet[SM_CYSCREEN] ||
1054 rcWorkArea.right <= rcWorkArea.left ||
1055 rcWorkArea.bottom <= rcWorkArea.top)
1056 return 0;
1057
1058 pmonitor->rcWork = rcWorkArea;
1059 if (fl & SPIF_UPDATEINIFILE)
1060 {
1061 // FIXME: What to do?
1062 }
1063 return (UINT_PTR)KEY_DESKTOP;
1064 }
1065
1066 case SPI_SETPENWINDOWS:
1067 ERR("SPI_SETPENWINDOWS is unimplemented\n");
1068 break;
1069
1070 case SPI_GETFILTERKEYS:
1071 {
1072 LPFILTERKEYS FilterKeys = (LPFILTERKEYS)pvParam;
1073
1074 if (uiParam != 0 && uiParam != sizeof(FILTERKEYS))
1075 return 0;
1076
1077 if (!FilterKeys || FilterKeys->cbSize != sizeof(FILTERKEYS))
1078 return 0;
1079
1080 return SpiGet(pvParam, &gspv.filterkeys, sizeof(FILTERKEYS), fl);
1081 }
1082
1083 case SPI_SETFILTERKEYS:
1084 {
1085 LPFILTERKEYS FilterKeys = (LPFILTERKEYS)pvParam;
1086
1087 if (uiParam != 0 && uiParam != sizeof(FILTERKEYS))
1088 return 0;
1089
1090 if (!FilterKeys || FilterKeys->cbSize != sizeof(FILTERKEYS))
1091 return 0;
1092
1093 if (!SpiSet(&gspv.filterkeys, pvParam, sizeof(FILTERKEYS), fl))
1094 return 0;
1095
1096 if (fl & SPIF_UPDATEINIFILE)
1097 {
1098 // FIXME: What to do?
1099 }
1100 return (UINT_PTR)KEY_DESKTOP;
1101 }
1102
1103 case SPI_GETTOGGLEKEYS:
1104 {
1105 LPTOGGLEKEYS ToggleKeys = (LPTOGGLEKEYS)pvParam;
1106
1107 if (uiParam != 0 && uiParam != sizeof(TOGGLEKEYS))
1108 return 0;
1109
1110 if (!ToggleKeys || ToggleKeys->cbSize != sizeof(TOGGLEKEYS))
1111 return 0;
1112
1113 return SpiGet(pvParam, &gspv.togglekeys, sizeof(TOGGLEKEYS), fl);
1114 }
1115
1116 case SPI_SETTOGGLEKEYS:
1117 {
1118 LPTOGGLEKEYS ToggleKeys = (LPTOGGLEKEYS)pvParam;
1119
1120 if (uiParam != 0 && uiParam != sizeof(TOGGLEKEYS))
1121 return 0;
1122
1123 if (!ToggleKeys || ToggleKeys->cbSize != sizeof(TOGGLEKEYS))
1124 return 0;
1125
1126 if (!SpiSet(&gspv.togglekeys, pvParam, sizeof(TOGGLEKEYS), fl))
1127 return 0;
1128
1129 if (fl & SPIF_UPDATEINIFILE)
1130 {
1131 // FIXME: What to do?
1132 }
1133 return (UINT_PTR)KEY_DESKTOP;
1134 }
1135
1136 case SPI_GETMOUSEKEYS:
1137 {
1138 LPMOUSEKEYS MouseKeys = (LPMOUSEKEYS)pvParam;
1139
1140 if (uiParam != 0 && uiParam != sizeof(MOUSEKEYS))
1141 return 0;
1142
1143 if (!MouseKeys || MouseKeys->cbSize != sizeof(MOUSEKEYS))
1144 return 0;
1145
1146 return SpiGet(pvParam, &gspv.mousekeys, sizeof(MOUSEKEYS), fl);
1147 }
1148
1149 case SPI_SETMOUSEKEYS:
1150 {
1151 LPMOUSEKEYS MouseKeys = (LPMOUSEKEYS)pvParam;
1152
1153 if (uiParam != 0 && uiParam != sizeof(MOUSEKEYS))
1154 return 0;
1155
1156 if (!MouseKeys || MouseKeys->cbSize != sizeof(MOUSEKEYS))
1157 return 0;
1158
1159 if (!SpiSet(&gspv.mousekeys, pvParam, sizeof(MOUSEKEYS), fl))
1160 return 0;
1161
1162 if (fl & SPIF_UPDATEINIFILE)
1163 {
1164 // FIXME: What to do?
1165 }
1166 return (UINT_PTR)KEY_DESKTOP;
1167 }
1168
1169 case SPI_GETSHOWSOUNDS:
1170 return SpiGetInt(pvParam, &gspv.bShowSounds, fl);
1171
1172 case SPI_SETSHOWSOUNDS:
1173 return SpiSetBool(&gspv.bShowSounds, uiParam, KEY_SHOWSNDS, VAL_ON, fl);
1174
1175 case SPI_GETSTICKYKEYS:
1176 {
1177 LPSTICKYKEYS StickyKeys = (LPSTICKYKEYS)pvParam;
1178
1179 if (uiParam != 0 && uiParam != sizeof(STICKYKEYS))
1180 return 0;
1181
1182 if (!StickyKeys || StickyKeys->cbSize != sizeof(STICKYKEYS))
1183 return 0;
1184
1185 return SpiGetEx(pvParam, &gspv.stickykeys, sizeof(STICKYKEYS), fl);
1186 }
1187
1188 case SPI_SETSTICKYKEYS:
1189 {
1190 LPSTICKYKEYS StickyKeys = (LPSTICKYKEYS)pvParam;
1191
1192 if (uiParam != 0 && uiParam != sizeof(STICKYKEYS))
1193 return 0;
1194
1195 if (!StickyKeys || StickyKeys->cbSize != sizeof(STICKYKEYS))
1196 return 0;
1197
1198 if (!SpiSet(&gspv.stickykeys, pvParam, sizeof(STICKYKEYS), fl))
1199 return 0;
1200
1201 if (fl & SPIF_UPDATEINIFILE)
1202 {
1203 // FIXME: What to do?
1204 }
1205 return (UINT_PTR)KEY_DESKTOP;
1206 }
1207
1208 case SPI_GETACCESSTIMEOUT:
1209 {
1210 LPACCESSTIMEOUT AccessTimeout = (LPACCESSTIMEOUT)pvParam;
1211
1212 if (uiParam != 0 && uiParam != sizeof(ACCESSTIMEOUT))
1213 return 0;
1214
1215 if (!AccessTimeout || AccessTimeout->cbSize != sizeof(ACCESSTIMEOUT))
1216 return 0;
1217
1218 return SpiGetEx(pvParam, &gspv.accesstimeout, sizeof(ACCESSTIMEOUT), fl);
1219 }
1220
1221 case SPI_SETACCESSTIMEOUT:
1222 {
1223 LPACCESSTIMEOUT AccessTimeout = (LPACCESSTIMEOUT)pvParam;
1224
1225 if (uiParam != 0 && uiParam != sizeof(ACCESSTIMEOUT))
1226 {
1227 return 0;
1228 }
1229
1230 if (!AccessTimeout || AccessTimeout->cbSize != sizeof(ACCESSTIMEOUT))
1231 {
1232 return 0;
1233 }
1234
1235 if (!SpiSet(&gspv.accesstimeout, pvParam, sizeof(ACCESSTIMEOUT), fl))
1236 return 0;
1237
1238 if (fl & SPIF_UPDATEINIFILE)
1239 {
1240 // FIXME: What to do?
1241 }
1242 return (UINT_PTR)KEY_DESKTOP;
1243 }
1244
1245 case SPI_GETSERIALKEYS:
1246 {
1247 LPSERIALKEYS SerialKeys = (LPSERIALKEYS)pvParam;
1248
1249 if (uiParam != 0 && uiParam != sizeof(SERIALKEYS))
1250 return 0;
1251
1252 if (!SerialKeys || SerialKeys->cbSize != sizeof(SERIALKEYS))
1253 return 0;
1254
1255 return SpiGet(pvParam, &gspv.serialkeys, sizeof(SERIALKEYS), fl);
1256 }
1257
1258 case SPI_SETSERIALKEYS:
1259 {
1260 LPSERIALKEYS SerialKeys = (LPSERIALKEYS)pvParam;
1261
1262 if (uiParam != 0 && uiParam != sizeof(SERIALKEYS))
1263 return 0;
1264
1265 if (!SerialKeys || SerialKeys->cbSize != sizeof(SERIALKEYS))
1266 return 0;
1267
1268 if (!SpiSet(&gspv.serialkeys, pvParam, sizeof(SERIALKEYS), fl))
1269 return 0;
1270
1271 if (fl & SPIF_UPDATEINIFILE)
1272 {
1273 // FIXME: What to do?
1274 }
1275 return (UINT_PTR)KEY_DESKTOP;
1276 }
1277
1278 case SPI_GETSOUNDSENTRY:
1279 {
1280 LPSOUNDSENTRYW SoundsEntry = (LPSOUNDSENTRYW)pvParam;
1281
1282 if (uiParam != 0 && uiParam != sizeof(SOUNDSENTRYW))
1283 return 0;
1284
1285 if (!SoundsEntry || SoundsEntry->cbSize != sizeof(SOUNDSENTRYW))
1286 return 0;
1287
1288 return SpiGet(pvParam, &gspv.soundsentry, sizeof(SOUNDSENTRYW), fl);
1289 }
1290
1291 case SPI_SETSOUNDSENTRY:
1292 {
1293 LPSOUNDSENTRYW SoundsEntry = (LPSOUNDSENTRYW)pvParam;
1294
1295 if (uiParam != 0 && uiParam != sizeof(SOUNDSENTRYW))
1296 return 0;
1297
1298 if (!SoundsEntry || SoundsEntry->cbSize != sizeof(SOUNDSENTRYW))
1299 return 0;
1300
1301 if (!SpiSet(&gspv.soundsentry, pvParam, sizeof(SOUNDSENTRYW), fl))
1302 return 0;
1303
1304 if (fl & SPIF_UPDATEINIFILE)
1305 {
1306 // FIXME: What to do?
1307 }
1308 return (UINT_PTR)KEY_DESKTOP;
1309 }
1310
1311 case SPI_GETHIGHCONTRAST:
1312 {
1313 LPHIGHCONTRASTW highcontrast = (LPHIGHCONTRASTW)pvParam;
1314
1315 if (uiParam != 0 && uiParam != sizeof(HIGHCONTRASTW))
1316 return 0;
1317
1318 if (!highcontrast || highcontrast->cbSize != sizeof(HIGHCONTRASTW))
1319 return 0;
1320
1321 return SpiGet(pvParam, &gspv.highcontrast, sizeof(HIGHCONTRASTW), fl);
1322 }
1323
1324 case SPI_SETHIGHCONTRAST:
1325 {
1326 LPHIGHCONTRASTW highcontrast = (LPHIGHCONTRASTW)pvParam;
1327
1328 if (uiParam != 0 && uiParam != sizeof(HIGHCONTRASTW))
1329 return 0;
1330
1331 if (!highcontrast || highcontrast->cbSize != sizeof(HIGHCONTRASTW))
1332 return 0;
1333
1334 if (!SpiSet(&gspv.highcontrast, pvParam, sizeof(HIGHCONTRASTW), fl))
1335 return 0;
1336
1337 if (fl & SPIF_UPDATEINIFILE)
1338 {
1339 // FIXME: What to do?
1340 }
1341 return (UINT_PTR)KEY_DESKTOP;
1342 }
1343
1344 case SPI_GETKEYBOARDPREF:
1345 return SpiGetInt(pvParam, &gspv.bKbdPref, fl);
1346
1347 case SPI_SETKEYBOARDPREF:
1348 return SpiSetBool(&gspv.bKbdPref, uiParam, KEY_KDBPREF, VAL_ON, fl);
1349
1350 case SPI_GETSCREENREADER:
1351 return SpiGetInt(pvParam, &gspv.bScreenReader, fl);
1352
1353 case SPI_SETSCREENREADER:
1354 return SpiSetBool(&gspv.bScreenReader, uiParam, KEY_SCRREAD, VAL_ON, fl);
1355
1356 case SPI_GETANIMATION:
1357 return SpiGet(pvParam, &gspv.animationinfo, sizeof(ANIMATIONINFO), fl);
1358
1359 case SPI_SETANIMATION:
1360 if (!SpiSet(&gspv.animationinfo, pvParam, sizeof(ANIMATIONINFO), fl))
1361 return 0;
1362 if (fl & SPIF_UPDATEINIFILE)
1363 {
1364 // FIXME: What to do?
1365 }
1366 return (UINT_PTR)KEY_DESKTOP;
1367
1368 case SPI_GETFONTSMOOTHING:
1369 return SpiGetInt(pvParam, &gspv.bFontSmoothing, fl);
1370
1371 case SPI_SETFONTSMOOTHING:
1372 gspv.bFontSmoothing = uiParam ? TRUE : FALSE;
1373 if (fl & SPIF_UPDATEINIFILE)
1374 {
1375 SpiStoreSzInt(KEY_DESKTOP, VAL_FNTSMOOTH, uiParam ? 2 : 0);
1376 }
1377 return (UINT_PTR)KEY_DESKTOP;
1378
1379 case SPI_SETDRAGWIDTH:
1380 return SpiSetInt(&gspv.iDragWidth, uiParam, KEY_DESKTOP, VAL_DRAGWIDTH, fl);
1381
1382 case SPI_SETDRAGHEIGHT:
1383 return SpiSetInt(&gspv.iDragHeight, uiParam, KEY_DESKTOP, VAL_DRAGHEIGHT, fl);
1384
1385 case SPI_SETHANDHELD:
1386 return SpiSetBool(&gspv.bHandHeld, uiParam, KEY_DESKTOP, L"HandHeld", fl);
1387
1388 case SPI_GETLOWPOWERTIMEOUT:
1389 return SpiGetInt(pvParam, &gspv.iLowPwrTimeout, fl);
1390
1391 case SPI_GETPOWEROFFTIMEOUT:
1392 return SpiGetInt(pvParam, &gspv.iPwrOffTimeout, fl);
1393
1394 case SPI_SETLOWPOWERTIMEOUT:
1395 return SpiSetInt(&gspv.iLowPwrTimeout, uiParam, KEY_DESKTOP, L"LowPowerTimeOut", fl);
1396
1397 case SPI_SETPOWEROFFTIMEOUT:
1398 return SpiSetInt(&gspv.iPwrOffTimeout, uiParam, KEY_DESKTOP, L"PowerOffTimeOut", fl);
1399
1400 case SPI_GETLOWPOWERACTIVE:
1401 return SpiGetInt(pvParam, &gspv.iPwrOffTimeout, fl);
1402
1403 case SPI_GETPOWEROFFACTIVE:
1404 return SpiGetInt(pvParam, &gspv.bPwrOffActive, fl);
1405
1406 case SPI_SETLOWPOWERACTIVE:
1407 return SpiSetBool(&gspv.bLowPwrActive, uiParam, KEY_DESKTOP, L"LowPowerActive", fl);
1408
1409 case SPI_SETPOWEROFFACTIVE:
1410 return SpiSetBool(&gspv.bPwrOffActive, uiParam, KEY_DESKTOP, L"PowerOffActive", fl);
1411
1412 case SPI_SETCURSORS:
1413 ERR("SPI_SETCURSORS is unimplemented\n");
1414 break;
1415
1416 case SPI_SETICONS:
1417 ERR("SPI_SETICONS is unimplemented\n");
1418 break;
1419
1420 case SPI_GETDEFAULTINPUTLANG:
1421 if (!gspklBaseLayout)
1422 return FALSE;
1423
1424 return SpiGet(pvParam, &gspklBaseLayout->hkl, sizeof(HKL), fl);
1425
1426 case SPI_SETDEFAULTINPUTLANG:
1427 {
1428 HKL hkl;
1429
1430 /* Note: SPIF_UPDATEINIFILE is not supported */
1431 if ((fl & SPIF_UPDATEINIFILE) || !SpiSet(&hkl, pvParam, sizeof(hkl), fl))
1432 return FALSE;
1433
1434 return UserSetDefaultInputLang(hkl);
1435 }
1436
1437 case SPI_SETLANGTOGGLE:
1438 gdwLanguageToggleKey = UserGetLanguageToggle();
1439 return gdwLanguageToggleKey;
1440 break;
1441
1442 case SPI_GETWINDOWSEXTENSION:
1443 ERR("SPI_GETWINDOWSEXTENSION is unimplemented\n");
1444 break;
1445
1446 case SPI_GETMOUSETRAILS:
1447 return SpiGetInt(pvParam, &gspv.iMouseTrails, fl);
1448
1449 case SPI_SETMOUSETRAILS:
1450 return SpiSetInt(&gspv.iMouseTrails, uiParam, KEY_MOUSE, VAL_MOUSETRAILS, fl);
1451
1452 case SPI_GETSNAPTODEFBUTTON:
1453 return SpiGetInt(pvParam, &gspv.bSnapToDefBtn, fl);
1454
1455 case SPI_SETSNAPTODEFBUTTON:
1456 return SpiSetBool(&gspv.bSnapToDefBtn, uiParam, KEY_MOUSE, VAL_SNAPDEFBTN, fl);
1457
1458 case SPI_GETMOUSEHOVERWIDTH:
1459 return SpiGetInt(pvParam, &gspv.iMouseHoverWidth, fl);
1460
1461 case SPI_SETMOUSEHOVERWIDTH:
1462 return SpiSetInt(&gspv.iMouseHoverWidth, uiParam, KEY_MOUSE, VAL_HOVERWIDTH, fl);
1463
1464 case SPI_GETMOUSEHOVERHEIGHT:
1465 return SpiGetInt(pvParam, &gspv.iMouseHoverHeight, fl);
1466
1467 case SPI_SETMOUSEHOVERHEIGHT:
1468 return SpiSetInt(&gspv.iMouseHoverHeight, uiParam, KEY_MOUSE, VAL_HOVERHEIGHT, fl);
1469
1470 case SPI_GETMOUSEHOVERTIME:
1471 return SpiGetInt(pvParam, &gspv.iMouseHoverTime, fl);
1472
1473 case SPI_SETMOUSEHOVERTIME:
1474 /* See http://msdn2.microsoft.com/en-us/library/ms724947.aspx
1475 * copy text from it, if some agument why xp and 2003 behovir diffent
1476 * only if they do not have SP install
1477 * " Windows Server 2003 and Windows XP: The operating system does not
1478 * enforce the use of USER_TIMER_MAXIMUM and USER_TIMER_MINIMUM until
1479 * Windows Server 2003 SP1 and Windows XP SP2 "
1480 */
1481 return SpiSetInt(&gspv.iMouseHoverTime, uiParam, KEY_MOUSE, VAL_HOVERTIME, fl);
1482
1483 case SPI_GETWHEELSCROLLLINES:
1484 return SpiGetInt(pvParam, &gspv.iWheelScrollLines, fl);
1485
1486 case SPI_SETWHEELSCROLLLINES:
1487 return SpiSetInt(&gspv.iWheelScrollLines, uiParam, KEY_DESKTOP, VAL_SCRLLLINES, fl);
1488
1489 case SPI_GETMENUSHOWDELAY:
1490 return SpiGetInt(pvParam, &gspv.dwMenuShowDelay, fl);
1491
1492 case SPI_SETMENUSHOWDELAY:
1493 return SpiSetInt(&gspv.dwMenuShowDelay, uiParam, KEY_DESKTOP, L"MenuShowDelay", fl);
1494
1495 #if (_WIN32_WINNT >= 0x0600)
1496 case SPI_GETWHEELSCROLLCHARS:
1497 return SpiGetInt(pvParam, &gspv.uiWheelScrollChars, fl);
1498
1499 case SPI_SETWHEELSCROLLCHARS:
1500 return SpiSetInt(&gspv.uiWheelScrollChars, uiParam, KEY_DESKTOP, VAL_SCRLLCHARS, fl);
1501 #endif
1502 case SPI_GETSHOWIMEUI:
1503 return SpiGetInt(pvParam, &gspv.bShowImeUi, fl);
1504
1505 case SPI_SETSHOWIMEUI:
1506 return SpiSetBool(&gspv.bShowImeUi, uiParam, KEY_DESKTOP, L"", fl);
1507
1508 case SPI_GETMOUSESPEED:
1509 return SpiGetInt(pvParam, &gspv.iMouseSpeed, fl);
1510
1511 case SPI_SETMOUSESPEED:
1512 {
1513 /* Allowed range is [1:20] */
1514 if ((INT_PTR)pvParam < 1 || (INT_PTR)pvParam > 20)
1515 return 0;
1516 else
1517 return SpiSetInt(&gspv.iMouseSpeed, (INT_PTR)pvParam, KEY_MOUSE, VAL_SENSITIVITY, fl);
1518 }
1519
1520 case SPI_GETSCREENSAVERRUNNING:
1521 return SpiGetInt(pvParam, &gspv.bScrSaverRunning, fl);
1522
1523 case SPI_SETSCREENSAVERRUNNING:
1524 // FIXME: also return value?
1525 return SpiSetBool(&gspv.bScrSaverRunning, uiParam, KEY_MOUSE, L"", fl);
1526
1527 #if(WINVER >= 0x0600)
1528 case SPI_GETAUDIODESCRIPTION:
1529 return SpiGet(pvParam, &gspv.audiodescription, sizeof(AUDIODESCRIPTION), fl);
1530
1531 case SPI_SETAUDIODESCRIPTION:
1532 ERR("SPI_SETAUDIODESCRIPTION is unimplemented\n");
1533 break;
1534
1535 case SPI_GETSCREENSAVESECURE:
1536 return SpiGetInt(pvParam, &gspv.bScrSaverSecure, fl);
1537
1538 case SPI_SETSCREENSAVESECURE:
1539 return SpiSetBool(&gspv.bScrSaverSecure, uiParam, KEY_DESKTOP, L"ScreenSaverIsSecure", fl);
1540 #endif
1541
1542 case SPI_GETACTIVEWINDOWTRACKING:
1543 return SpiGetUserPref(UPM_ACTIVEWINDOWTRACKING, pvParam, fl);
1544
1545 case SPI_SETACTIVEWINDOWTRACKING:
1546 return SpiSetUserPref(UPM_ACTIVEWINDOWTRACKING, pvParam, fl);
1547
1548 case SPI_GETMENUANIMATION:
1549 return SpiGetUserPref(UPM_MENUANIMATION, pvParam, fl);
1550
1551 case SPI_SETMENUANIMATION:
1552 return SpiSetUserPref(UPM_MENUANIMATION, pvParam, fl);
1553
1554 case SPI_GETCOMBOBOXANIMATION:
1555 return SpiGetUserPref(UPM_COMBOBOXANIMATION, pvParam, fl);
1556
1557 case SPI_SETCOMBOBOXANIMATION:
1558 return SpiSetUserPref(UPM_COMBOBOXANIMATION, pvParam, fl);
1559
1560 case SPI_GETLISTBOXSMOOTHSCROLLING:
1561 return SpiGetUserPref(UPM_LISTBOXSMOOTHSCROLLING, pvParam, fl);
1562
1563 case SPI_SETLISTBOXSMOOTHSCROLLING:
1564 return SpiSetUserPref(UPM_LISTBOXSMOOTHSCROLLING, pvParam, fl);
1565
1566 case SPI_GETGRADIENTCAPTIONS:
1567 return SpiGetUserPref(UPM_GRADIENTCAPTIONS, pvParam, fl);
1568
1569 case SPI_SETGRADIENTCAPTIONS:
1570 return SpiSetUserPref(UPM_GRADIENTCAPTIONS, pvParam, fl);
1571
1572 case SPI_GETKEYBOARDCUES:
1573 return SpiGetUserPref(UPM_KEYBOARDCUES, pvParam, fl);
1574
1575 case SPI_SETKEYBOARDCUES:
1576 return SpiSetUserPref(UPM_KEYBOARDCUES, pvParam, fl);
1577
1578 case SPI_GETACTIVEWNDTRKZORDER:
1579 return SpiGetUserPref(UPM_ACTIVEWNDTRKZORDER, pvParam, fl);
1580
1581 case SPI_SETACTIVEWNDTRKZORDER:
1582 return SpiSetUserPref(UPM_ACTIVEWNDTRKZORDER, pvParam, fl);
1583
1584 case SPI_GETHOTTRACKING:
1585 return SpiGetUserPref(UPM_HOTTRACKING, pvParam, fl);
1586
1587 case SPI_SETHOTTRACKING:
1588 return SpiSetUserPref(UPM_HOTTRACKING, pvParam, fl);
1589
1590 case SPI_GETMENUFADE:
1591 return SpiGetUserPref(UPM_MENUFADE, pvParam, fl);
1592
1593 case SPI_SETMENUFADE:
1594 return SpiSetUserPref(UPM_MENUFADE, pvParam, fl);
1595
1596 case SPI_GETSELECTIONFADE:
1597 return SpiGetUserPref(UPM_SELECTIONFADE, pvParam, fl);
1598
1599 case SPI_SETSELECTIONFADE:
1600 return SpiSetUserPref(UPM_SELECTIONFADE, pvParam, fl);
1601
1602 case SPI_GETTOOLTIPANIMATION:
1603 return SpiGetUserPref(UPM_TOOLTIPANIMATION, pvParam, fl);
1604
1605 case SPI_SETTOOLTIPANIMATION:
1606 return SpiSetUserPref(UPM_TOOLTIPANIMATION, pvParam, fl);
1607
1608 case SPI_GETTOOLTIPFADE:
1609 return SpiGetUserPref(UPM_TOOLTIPFADE, pvParam, fl);
1610
1611 case SPI_SETTOOLTIPFADE:
1612 return SpiSetUserPref(UPM_TOOLTIPFADE, pvParam, fl);
1613
1614 case SPI_GETCURSORSHADOW:
1615 return SpiGetUserPref(UPM_CURSORSHADOW, pvParam, fl);
1616
1617 case SPI_SETCURSORSHADOW:
1618 gspv.bMouseCursorShadow = PtrToUlong(pvParam);
1619 return SpiSetUserPref(UPM_CURSORSHADOW, pvParam, fl);
1620
1621 case SPI_GETUIEFFECTS:
1622 return SpiGetUserPref(UPM_UIEFFECTS, pvParam, fl);
1623
1624 case SPI_SETUIEFFECTS:
1625 return SpiSetUserPref(UPM_UIEFFECTS, pvParam, fl);
1626
1627 case SPI_GETMOUSESONAR:
1628 return SpiGetInt(pvParam, &gspv.bMouseSonar, fl);
1629
1630 case SPI_SETMOUSESONAR:
1631 return SpiSetBool(&gspv.bMouseSonar, uiParam, KEY_MOUSE, L"", fl);
1632
1633 case SPI_GETMOUSECLICKLOCK:
1634 return SpiGetUserPref(UPM_CLICKLOCK, pvParam, fl);
1635
1636 case SPI_SETMOUSECLICKLOCK:
1637 gspv.bMouseClickLock = PtrToUlong(pvParam);
1638 return SpiSetUserPref(UPM_CLICKLOCK, pvParam, fl);
1639
1640 case SPI_GETMOUSEVANISH:
1641 return SpiGetInt(pvParam, &gspv.bMouseVanish, fl);
1642
1643 case SPI_SETMOUSEVANISH:
1644 return SpiSetBool(&gspv.bMouseVanish, uiParam, KEY_MOUSE, L"", fl);
1645
1646 case SPI_GETFLATMENU:
1647 return SpiGetUserPref(UPM_FLATMENU, pvParam, fl);
1648
1649 case SPI_SETFLATMENU:
1650 return SpiSetUserPref(UPM_FLATMENU, pvParam, fl);
1651
1652 case SPI_GETDROPSHADOW:
1653 return SpiGetUserPref(UPM_DROPSHADOW, pvParam, fl);
1654
1655 case SPI_SETDROPSHADOW:
1656 return SpiSetUserPref(UPM_DROPSHADOW, pvParam, fl);
1657
1658 case SPI_GETBLOCKSENDINPUTRESETS:
1659 return SpiGetInt(pvParam, &gspv.bBlockSendInputResets, fl);
1660
1661 case SPI_SETBLOCKSENDINPUTRESETS:
1662 return SpiSetBool(&gspv.bBlockSendInputResets, uiParam, KEY_MOUSE, L"", fl);
1663
1664 #if(_WIN32_WINNT >= 0x0600)
1665 case SPI_GETDISABLEOVERLAPPEDCONTENT:
1666 return SpiGetInt(pvParam, &gspv.bDisableOverlappedContent, fl);
1667
1668 case SPI_SETDISABLEOVERLAPPEDCONTENT:
1669 return SpiSetBool(&gspv.bDisableOverlappedContent, uiParam, KEY_MOUSE, L"", fl);
1670
1671 case SPI_GETCLIENTAREAANIMATION:
1672 return SpiGetInt(pvParam, &gspv.bClientAreaAnimation, fl);
1673
1674 case SPI_SETCLIENTAREAANIMATION:
1675 return SpiSetBool(&gspv.bClientAreaAnimation, uiParam, KEY_MOUSE, L"", fl);
1676
1677 case SPI_GETCLEARTYPE:
1678 return SpiGetInt(pvParam, &gspv.bClearType, fl);
1679
1680 case SPI_SETCLEARTYPE:
1681 return SpiSetBool(&gspv.bClearType, uiParam, KEY_MOUSE, L"", fl);
1682
1683 case SPI_GETSPEECHRECOGNITION:
1684 return SpiGetInt(pvParam, &gspv.bSpeechRecognition, fl);
1685
1686 case SPI_SETSPEECHRECOGNITION:
1687 return SpiSetBool(&gspv.bSpeechRecognition, uiParam, KEY_MOUSE, L"", fl);
1688 #endif
1689
1690 case SPI_GETFOREGROUNDLOCKTIMEOUT:
1691 return SpiGetInt(pvParam, &gspv.dwForegroundLockTimeout, fl);
1692
1693 case SPI_SETFOREGROUNDLOCKTIMEOUT:
1694 return SpiSetInt(&gspv.dwForegroundLockTimeout, uiParam, KEY_MOUSE, L"", fl);
1695
1696 case SPI_GETACTIVEWNDTRKTIMEOUT:
1697 return SpiGetInt(pvParam, &gspv.dwActiveTrackingTimeout, fl);
1698
1699 case SPI_SETACTIVEWNDTRKTIMEOUT:
1700 return SpiSetInt(&gspv.dwActiveTrackingTimeout, uiParam, KEY_MOUSE, L"", fl);
1701
1702 case SPI_GETFOREGROUNDFLASHCOUNT:
1703 return SpiGetInt(pvParam, &gspv.dwForegroundFlashCount, fl);
1704
1705 case SPI_SETFOREGROUNDFLASHCOUNT:
1706 return SpiSetInt(&gspv.dwForegroundFlashCount, uiParam, KEY_MOUSE, L"", fl);
1707
1708 case SPI_GETCARETWIDTH:
1709 return SpiGetInt(pvParam, &gspv.dwCaretWidth, fl);
1710
1711 case SPI_SETCARETWIDTH:
1712 return SpiSetInt(&gspv.dwCaretWidth, uiParam, KEY_MOUSE, L"", fl);
1713
1714 case SPI_GETMOUSECLICKLOCKTIME:
1715 return SpiGetInt(pvParam, &gspv.dwMouseClickLockTime, fl);
1716
1717 case SPI_SETMOUSECLICKLOCKTIME:
1718 return SpiSetDWord(&gspv.dwMouseClickLockTime, uiParam, KEY_DESKTOP, VAL_CLICKLOCKTIME, fl);
1719
1720 case SPI_GETFONTSMOOTHINGTYPE:
1721 return SpiGetInt(pvParam, &gspv.uiFontSmoothingType, fl);
1722
1723 case SPI_SETFONTSMOOTHINGTYPE:
1724 return SpiSetInt(&gspv.uiFontSmoothingType, uiParam, KEY_MOUSE, L"", fl);
1725
1726 case SPI_GETFONTSMOOTHINGCONTRAST:
1727 return SpiGetInt(pvParam, &gspv.uiFontSmoothingContrast, fl);
1728
1729 case SPI_SETFONTSMOOTHINGCONTRAST:
1730 return SpiSetInt(&gspv.uiFontSmoothingContrast, uiParam, KEY_MOUSE, L"", fl);
1731
1732 case SPI_GETFOCUSBORDERWIDTH:
1733 return SpiGetInt(pvParam, &gspv.uiFocusBorderWidth, fl);
1734
1735 case SPI_SETFOCUSBORDERWIDTH:
1736 return SpiSetInt(&gspv.uiFocusBorderWidth, uiParam, KEY_MOUSE, L"", fl);
1737
1738 case SPI_GETFOCUSBORDERHEIGHT:
1739 return SpiGetInt(pvParam, &gspv.uiFocusBorderHeight, fl);
1740
1741 case SPI_SETFOCUSBORDERHEIGHT:
1742 return SpiSetInt(&gspv.uiFocusBorderHeight, uiParam, KEY_MOUSE, L"", fl);
1743
1744 case SPI_GETFONTSMOOTHINGORIENTATION:
1745 return SpiGetInt(pvParam, &gspv.uiFontSmoothingOrientation, fl);
1746
1747 case SPI_SETFONTSMOOTHINGORIENTATION:
1748 return SpiSetInt(&gspv.uiFontSmoothingOrientation, uiParam, KEY_MOUSE, L"", fl);
1749
1750 /* The following are undocumented, but valid SPI values */
1751 case 0x1010:
1752 case 0x1011:
1753 case 0x1028:
1754 case 0x1029:
1755 case 0x102A:
1756 case 0x102B:
1757 case 0x102C:
1758 case 0x102D:
1759 case 0x102E:
1760 case 0x102F:
1761 case 0x1030:
1762 case 0x1031:
1763 case 0x1032:
1764 case 0x1033:
1765 case 0x1034:
1766 case 0x1035:
1767 case 0x1036:
1768 case 0x1037:
1769 case 0x1038:
1770 case 0x1039:
1771 case 0x103A:
1772 case 0x103B:
1773 case 0x103C:
1774 case 0x103D:
1775 ERR("Undocumented SPI value %x is unimplemented\n", uiAction);
1776 break;
1777
1778 default:
1779 ERR("Invalid SPI value: %u\n", uiAction);
1780 EngSetLastError(ERROR_INVALID_PARAMETER);
1781 return 0;
1782 }
1783
1784 return 0;
1785 }
1786
1787 static BOOL
1788 SpiGetSetProbeBuffer(UINT uiAction, UINT uiParam, PVOID pvParam)
1789 {
1790 BOOL bToUser = TRUE;
1791 ULONG cbSize = 0;
1792
1793 switch (uiAction)
1794 {
1795 case SPI_GETBEEP:
1796 case SPI_GETBORDER:
1797 case SPI_GETKEYBOARDSPEED:
1798 case SPI_GETSCREENSAVETIMEOUT:
1799 case SPI_GETSCREENSAVEACTIVE:
1800 case SPI_GETGRIDGRANULARITY:
1801 case SPI_GETKEYBOARDDELAY:
1802 case SPI_GETICONTITLEWRAP:
1803 case SPI_GETMENUDROPALIGNMENT:
1804 case SPI_GETFASTTASKSWITCH:
1805 case SPI_GETDRAGFULLWINDOWS:
1806 case SPI_GETSHOWSOUNDS:
1807 case SPI_GETKEYBOARDPREF:
1808 case SPI_GETSCREENREADER:
1809 case SPI_GETFONTSMOOTHING:
1810 case SPI_GETLOWPOWERTIMEOUT:
1811 case SPI_GETPOWEROFFTIMEOUT:
1812 case SPI_GETLOWPOWERACTIVE:
1813 case SPI_GETPOWEROFFACTIVE:
1814 case SPI_GETMOUSETRAILS:
1815 case SPI_GETSNAPTODEFBUTTON:
1816 case SPI_GETMOUSEHOVERWIDTH:
1817 case SPI_GETMOUSEHOVERHEIGHT:
1818 case SPI_GETMOUSEHOVERTIME:
1819 case SPI_GETWHEELSCROLLLINES:
1820 case SPI_GETMENUSHOWDELAY:
1821 #if (_WIN32_WINNT >= 0x0600)
1822 case SPI_GETWHEELSCROLLCHARS:
1823 #endif
1824 case SPI_GETSHOWIMEUI:
1825 case SPI_GETMOUSESPEED:
1826 case SPI_GETSCREENSAVERRUNNING:
1827 #if(WINVER >= 0x0600)
1828 case SPI_GETSCREENSAVESECURE:
1829 #endif
1830 case SPI_GETACTIVEWINDOWTRACKING:
1831 case SPI_GETMENUANIMATION:
1832 case SPI_GETCOMBOBOXANIMATION:
1833 case SPI_GETLISTBOXSMOOTHSCROLLING:
1834 case SPI_GETGRADIENTCAPTIONS:
1835 case SPI_GETKEYBOARDCUES:
1836 case SPI_GETACTIVEWNDTRKZORDER:
1837 case SPI_GETHOTTRACKING:
1838 case SPI_GETMENUFADE:
1839 case SPI_GETSELECTIONFADE:
1840 case SPI_GETTOOLTIPANIMATION:
1841 case SPI_GETTOOLTIPFADE:
1842 case SPI_GETCURSORSHADOW:
1843 case SPI_GETUIEFFECTS:
1844 case SPI_GETMOUSESONAR:
1845 case SPI_GETMOUSECLICKLOCK:
1846 case SPI_GETMOUSEVANISH:
1847 case SPI_GETFLATMENU:
1848 case SPI_GETDROPSHADOW:
1849 case SPI_GETBLOCKSENDINPUTRESETS:
1850 #if(_WIN32_WINNT >= 0x0600)
1851 case SPI_GETDISABLEOVERLAPPEDCONTENT:
1852 case SPI_GETCLIENTAREAANIMATION:
1853 case SPI_GETCLEARTYPE:
1854 case SPI_GETSPEECHRECOGNITION:
1855 #endif
1856 case SPI_GETFOREGROUNDLOCKTIMEOUT:
1857 case SPI_GETACTIVEWNDTRKTIMEOUT:
1858 case SPI_GETFOREGROUNDFLASHCOUNT:
1859 case SPI_GETCARETWIDTH:
1860 case SPI_GETMOUSECLICKLOCKTIME:
1861 case SPI_GETFONTSMOOTHINGTYPE:
1862 case SPI_GETFONTSMOOTHINGCONTRAST:
1863 case SPI_GETFOCUSBORDERWIDTH:
1864 case SPI_GETFOCUSBORDERHEIGHT:
1865 case SPI_GETFONTSMOOTHINGORIENTATION:
1866 cbSize = sizeof(INT);
1867 break;
1868
1869 case SPI_ICONHORIZONTALSPACING:
1870 case SPI_ICONVERTICALSPACING:
1871 if (pvParam) cbSize = sizeof(INT);
1872 break;
1873
1874 case SPI_GETMOUSE:
1875 cbSize = 3 * sizeof(INT);
1876 break;
1877
1878 case SPI_GETDESKWALLPAPER:
1879 cbSize = min(uiParam, gspv.ustrWallpaper.Length + 1UL);
1880 break;
1881
1882 case SPI_GETICONTITLELOGFONT:
1883 cbSize = sizeof(LOGFONTW);
1884 break;
1885
1886 case SPI_GETNONCLIENTMETRICS:
1887 cbSize = sizeof(NONCLIENTMETRICSW);
1888 break;
1889
1890 case SPI_GETMINIMIZEDMETRICS:
1891 cbSize = sizeof(MINIMIZEDMETRICS);
1892 break;
1893
1894 case SPI_GETICONMETRICS:
1895 cbSize = sizeof(ICONMETRICSW);
1896 break;
1897
1898 case SPI_GETWORKAREA:
1899 cbSize = sizeof(RECTL);
1900 break;
1901
1902 case SPI_GETFILTERKEYS:
1903 cbSize = sizeof(FILTERKEYS);
1904 break;
1905
1906 case SPI_GETTOGGLEKEYS:
1907 cbSize = sizeof(TOGGLEKEYS);
1908 break;
1909
1910 case SPI_GETMOUSEKEYS:
1911 cbSize = sizeof(MOUSEKEYS);
1912 break;
1913
1914 case SPI_GETSTICKYKEYS:
1915 cbSize = sizeof(STICKYKEYS);
1916 break;
1917
1918 case SPI_GETACCESSTIMEOUT:
1919 cbSize = sizeof(ACCESSTIMEOUT);
1920 break;
1921
1922 case SPI_GETSERIALKEYS:
1923 cbSize = sizeof(SERIALKEYS);
1924 break;
1925
1926 case SPI_GETSOUNDSENTRY:
1927 cbSize = sizeof(SOUNDSENTRYW);
1928 break;
1929
1930 case SPI_GETHIGHCONTRAST:
1931 cbSize = sizeof(HIGHCONTRASTW);
1932 break;
1933
1934 case SPI_GETANIMATION:
1935 cbSize = sizeof(ANIMATIONINFO);
1936 break;
1937
1938 case SPI_GETDEFAULTINPUTLANG:
1939 cbSize = sizeof(HKL);
1940 break;
1941
1942 #if(WINVER >= 0x0600)
1943 case SPI_GETAUDIODESCRIPTION:
1944 cbSize = sizeof(AUDIODESCRIPTION);
1945 break;
1946 #endif
1947
1948 case SPI_SETMOUSE:
1949 cbSize = 3 * sizeof(INT);
1950 bToUser = FALSE;
1951 break;
1952
1953 case SPI_SETICONTITLELOGFONT:
1954 cbSize = sizeof(LOGFONTW);
1955 bToUser = FALSE;
1956 break;
1957
1958 case SPI_SETNONCLIENTMETRICS:
1959 cbSize = sizeof(NONCLIENTMETRICSW);
1960 bToUser = FALSE;
1961 break;
1962
1963 case SPI_SETMINIMIZEDMETRICS:
1964 cbSize = sizeof(MINIMIZEDMETRICS);
1965 bToUser = FALSE;
1966 break;
1967
1968 case SPI_SETICONMETRICS:
1969 cbSize = sizeof(ICONMETRICSW);
1970 bToUser = FALSE;
1971 break;
1972
1973 case SPI_SETWORKAREA:
1974 cbSize = sizeof(RECTL);
1975 bToUser = FALSE;
1976 break;
1977
1978 case SPI_SETFILTERKEYS:
1979 cbSize = sizeof(FILTERKEYS);
1980 bToUser = FALSE;
1981 break;
1982
1983 case SPI_SETTOGGLEKEYS:
1984 cbSize = sizeof(TOGGLEKEYS);
1985 bToUser = FALSE;
1986 break;
1987
1988 case SPI_SETMOUSEKEYS:
1989 cbSize = sizeof(MOUSEKEYS);
1990 bToUser = FALSE;
1991 break;
1992
1993 case SPI_SETSTICKYKEYS:
1994 cbSize = sizeof(STICKYKEYS);
1995 bToUser = FALSE;
1996 break;
1997
1998 case SPI_SETACCESSTIMEOUT:
1999 cbSize = sizeof(ACCESSTIMEOUT);
2000 bToUser = FALSE;
2001 break;
2002
2003 case SPI_SETSERIALKEYS:
2004 cbSize = sizeof(SERIALKEYS);
2005 bToUser = FALSE;
2006 break;
2007
2008 case SPI_SETSOUNDSENTRY:
2009 cbSize = sizeof(SOUNDSENTRYW);
2010 bToUser = FALSE;
2011 break;
2012
2013 case SPI_SETHIGHCONTRAST:
2014 cbSize = sizeof(HIGHCONTRASTW);
2015 bToUser = FALSE;
2016 break;
2017
2018 case SPI_SETANIMATION:
2019 cbSize = sizeof(ANIMATIONINFO);
2020 bToUser = FALSE;
2021 break;
2022
2023 case SPI_SETDEFAULTINPUTLANG:
2024 cbSize = sizeof(HKL);
2025 bToUser = FALSE;
2026 break;
2027
2028 case SPI_SETMOUSESPEED:
2029 cbSize = sizeof(INT);
2030 bToUser = FALSE;
2031 break;
2032 }
2033
2034 if (cbSize)
2035 {
2036 _SEH2_TRY
2037 {
2038 if (bToUser)
2039 {
2040 ProbeForWrite(pvParam, cbSize, sizeof(UCHAR));
2041 }
2042 else
2043 {
2044 ProbeForRead(pvParam, cbSize, sizeof(UCHAR));
2045 }
2046 }
2047 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2048 {
2049 _SEH2_YIELD(return FALSE);
2050 }
2051 _SEH2_END;
2052 }
2053
2054 return TRUE;
2055 }
2056
2057 BOOL
2058 FASTCALL
2059 UserSystemParametersInfo(
2060 UINT uiAction,
2061 UINT uiParam,
2062 PVOID pvParam,
2063 UINT fWinIni)
2064 {
2065 ULONG_PTR ulResult;
2066 PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
2067
2068 ASSERT(ppi);
2069
2070 if (!gbSpiInitialized)
2071 {
2072 KeRosDumpStackFrames(NULL, 20);
2073 //ASSERT(FALSE);
2074 return FALSE;
2075 }
2076
2077 /* Get a pointer to the current Windowstation */
2078 if (!ppi->prpwinsta)
2079 {
2080 ERR("UserSystemParametersInfo called without active window station.\n");
2081 //ASSERT(FALSE);
2082 //return FALSE;
2083 }
2084
2085 if ((fWinIni & SPIF_PROTECT) && !SpiGetSetProbeBuffer(uiAction, uiParam, pvParam))
2086 {
2087 EngSetLastError(ERROR_NOACCESS);
2088 return FALSE;
2089 }
2090
2091 /* Do the actual operation */
2092 ulResult = SpiGetSet(uiAction, uiParam, pvParam, fWinIni);
2093
2094 /* Did we change something? */
2095 if (ulResult > 1)
2096 {
2097 SpiFixupValues();
2098
2099 /* Update system metrics */
2100 InitMetrics();
2101
2102 /* Send notification to toplevel windows, if requested */
2103 if (fWinIni & (SPIF_SENDCHANGE | SPIF_SENDWININICHANGE))
2104 {
2105 /* Send WM_SETTINGCHANGE to all toplevel windows */
2106 co_IntSendMessageTimeout(HWND_BROADCAST,
2107 WM_SETTINGCHANGE,
2108 (WPARAM)uiAction,
2109 (LPARAM)ulResult,
2110 SMTO_NORMAL,
2111 100,
2112 &ulResult);
2113 }
2114 ulResult = 1;
2115 }
2116
2117 return ulResult;
2118 }
2119
2120 BOOL
2121 APIENTRY
2122 NtUserSystemParametersInfo(
2123 UINT uiAction,
2124 UINT uiParam,
2125 PVOID pvParam,
2126 UINT fWinIni)
2127 {
2128 BOOL bResult;
2129
2130 TRACE("Enter NtUserSystemParametersInfo(%u)\n", uiAction);
2131 UserEnterExclusive();
2132
2133 // FIXME: Get rid of the flags and only use this from um. kernel can access data directly.
2134 /* Set UM memory protection flag */
2135 fWinIni |= SPIF_PROTECT;
2136
2137 /* Call internal function */
2138 bResult = UserSystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
2139
2140 TRACE("Leave NtUserSystemParametersInfo, returning %d\n", bResult);
2141 UserLeave();
2142
2143 return bResult;
2144 }
2145
2146 /* EOF */