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