dll/win32/syssetup/proppage.c

   1 /*
   2  * PROJECT:     ReactOS system libraries
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/win32/syssetup/proppage.c
   5  * PURPOSE:     Property page providers
   6  * PROGRAMMERS: Copyright 2018 Eric Kohl <eric.kohl@reactos.org>
   7  */
   8
   9 #include "precomp.h"
  10
  11 #define NDEBUG
  12 #include <debug.h>
  13
  14 typedef struct _MOUSE_INFO
  15 {
  16     HKEY hDeviceKey;
  17     DWORD dwSampleRateIndex;
  18     DWORD dwWheelDetection;
  19     DWORD dwInputBufferLength;
  20     DWORD dwInitPolled;
  21 } MOUSE_INFO, *PMOUSE_INFO;
  22
  23 DWORD MouseSampleRates[] = {20, 40, 60, 80, 100, 200};
  24
  25 #define DEFAULT_SAMPLERATEINDEX   4
  26 #define DEFAULT_WHEELDETECTION    2
  27 #define DEFAULT_INPUTBUFFERSIZE 100
  28 #define DEFAULT_MINBUFFERSIZE   100
  29 #define DEFAULT_MAXBUFFERSIZE   300
  30
  31 /*
  32  * @implemented
  33  */
  34 BOOL
  35 WINAPI
  36 CdromPropPageProvider(
  37     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
  38     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
  39     _In_ LPARAM lParam)
  40 {
  41     DPRINT("CdromPropPageProvider(%p %p %lx)\n",
  42            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
  43     return FALSE;
  44 }
  45
  46
  47 /*
  48  * @implemented
  49  */
  50 BOOL
  51 WINAPI
  52 DiskPropPageProvider(
  53     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
  54     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
  55     _In_ LPARAM lParam)
  56 {
  57     DPRINT("DiskPropPageProvider(%p %p %lx)\n",
  58            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
  59     return FALSE;
  60 }
  61
  62
  63 /*
  64  * @implemented
  65  */
  66 BOOL
  67 WINAPI
  68 EisaUpHalPropPageProvider(
  69     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
  70     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
  71     _In_ LPARAM lParam)
  72 {
  73     DPRINT("EisaUpHalPropPageProvider(%p %p %lx)\n",
  74            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
  75     return FALSE;
  76 }
  77
  78
  79 /*
  80  * @unimplemented
  81  */
  82 BOOL
  83 WINAPI
  84 LegacyDriverPropPageProvider(
  85     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
  86     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
  87     _In_ LPARAM lParam)
  88 {
  89     DPRINT1("LegacyDriverPropPageProvider(%p %p %lx)\n",
  90            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
  91     UNIMPLEMENTED;
  92     return FALSE;
  93 }
  94
  95
  96 static
  97 DWORD
  98 MouseGetSampleRateIndex(
  99     DWORD dwSampleRate)
 100 {
 101     DWORD i;
 102
 103     for (i = 0; i < ARRAYSIZE(MouseSampleRates); i++)
 104     {
 105         if (MouseSampleRates[i] == dwSampleRate)
 106             return i;
 107     }
 108
 109     return DEFAULT_SAMPLERATEINDEX;
 110 }
 111
 112
 113 static
 114 BOOL
 115 MouseOnDialogInit(
 116     HWND hwndDlg,
 117     LPARAM lParam)
 118 {
 119     PMOUSE_INFO pMouseInfo;
 120     WCHAR szBuffer[64];
 121     UINT i;
 122     DWORD dwType, dwSize;
 123     DWORD dwSampleRate;
 124     LONG lError;
 125
 126     /* Get the pointer to the mouse info struct */
 127     pMouseInfo = (PMOUSE_INFO)((LPPROPSHEETPAGE)lParam)->lParam;
 128     if (pMouseInfo == NULL)
 129         return FALSE;
 130
 131     /* Keep the pointer to the mouse info struct */
 132     SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pMouseInfo);
 133
 134     /* Add the sample rates */
 135     for (i = 0; i < ARRAYSIZE(MouseSampleRates); i++)
 136     {
 137         wsprintf(szBuffer, L"%lu", MouseSampleRates[i]);
 138         SendDlgItemMessageW(hwndDlg,
 139                             IDC_PS2MOUSESAMPLERATE,
 140                             CB_ADDSTRING,
 141                             0,
 142                             (LPARAM)szBuffer);
 143     }
 144
 145     /* Read the SampleRate parameter */
 146     dwSize = sizeof(DWORD);
 147     lError = RegQueryValueExW(pMouseInfo->hDeviceKey,
 148                               L"SampleRate",
 149                               NULL,
 150                               &dwType,
 151                               (LPBYTE)&dwSampleRate,
 152                               &dwSize);
 153     if (lError == ERROR_SUCCESS && dwType == REG_DWORD && dwSize == sizeof(DWORD))
 154     {
 155         pMouseInfo->dwSampleRateIndex = MouseGetSampleRateIndex(dwSampleRate);
 156     }
 157     else
 158     {
 159         /* Set the default sample rate (100 samples per second) */
 160         pMouseInfo->dwSampleRateIndex = DEFAULT_SAMPLERATEINDEX;
 161     }
 162
 163     /* Set the sample rate */
 164     SendDlgItemMessageW(hwndDlg,
 165                         IDC_PS2MOUSESAMPLERATE,
 166                         CB_SETCURSEL,
 167                         pMouseInfo->dwSampleRateIndex,
 168                         0);
 169
 170     /* Add the detection options */
 171     for (i = IDS_DETECTIONDISABLED; i <= IDS_ASSUMEPRESENT; i++)
 172     {
 173         LoadStringW(hDllInstance, i, szBuffer, ARRAYSIZE(szBuffer));
 174         SendDlgItemMessageW(hwndDlg,
 175                             IDC_PS2MOUSEWHEEL,
 176                             CB_ADDSTRING,
 177                             0,
 178                             (LPARAM)szBuffer);
 179     }
 180
 181     /* Read the EnableWheelDetection parameter */
 182     dwSize = sizeof(DWORD);
 183     lError = RegQueryValueExW(pMouseInfo->hDeviceKey,
 184                               L"EnableWheelDetection",
 185                               NULL,
 186                               &dwType,
 187                               (LPBYTE)&pMouseInfo->dwWheelDetection,
 188                               &dwSize);
 189     if (lError != ERROR_SUCCESS || dwType != REG_DWORD || dwSize != sizeof(DWORD))
 190     {
 191         /* Set the default wheel detection parameter */
 192         pMouseInfo->dwWheelDetection = DEFAULT_WHEELDETECTION;
 193     }
 194
 195     /* Set the wheel detection parameter */
 196     SendDlgItemMessageW(hwndDlg,
 197                         IDC_PS2MOUSEWHEEL,
 198                         CB_SETCURSEL,
 199                         pMouseInfo->dwWheelDetection,
 200                         0);
 201
 202     /* Set the input buffer length range: 100-300 */
 203     SendDlgItemMessageW(hwndDlg,
 204                         IDC_PS2MOUSEINPUTUPDN,
 205                         UDM_SETRANGE32,
 206                         DEFAULT_MINBUFFERSIZE,
 207                         DEFAULT_MAXBUFFERSIZE);
 208
 209     /* Read the MouseDataQueueSize parameter */
 210     dwSize = sizeof(DWORD);
 211     lError = RegQueryValueExW(pMouseInfo->hDeviceKey,
 212                               L"MouseDataQueueSize",
 213                               NULL,
 214                               &dwType,
 215                               (LPBYTE)&pMouseInfo->dwInputBufferLength,
 216                               &dwSize);
 217     if (lError != ERROR_SUCCESS || dwType != REG_DWORD || dwSize != sizeof(DWORD))
 218     {
 219         /* Set the default input buffer length (100 packets) */
 220         pMouseInfo->dwInputBufferLength = DEFAULT_INPUTBUFFERSIZE;
 221     }
 222
 223     /* Set the input buffer length */
 224     SendDlgItemMessageW(hwndDlg,
 225                         IDC_PS2MOUSEINPUTUPDN,
 226                         UDM_SETPOS32,
 227                         0,
 228                         pMouseInfo->dwInputBufferLength);
 229
 230     /* Read the MouseInitializePolled parameter */
 231     dwSize = sizeof(DWORD);
 232     lError = RegQueryValueExW(pMouseInfo->hDeviceKey,
 233                               L"MouseInitializePolled",
 234                               NULL,
 235                               &dwType,
 236                               (LPBYTE)&pMouseInfo->dwInitPolled,
 237                               &dwSize);
 238     if (lError != ERROR_SUCCESS || dwType != REG_DWORD || dwSize != sizeof(DWORD))
 239     {
 240         /* Set the default init polled value (FALSE) */
 241         pMouseInfo->dwInitPolled = 0;
 242     }
 243
 244     /* Set the fast initialization option */
 245     SendDlgItemMessage(hwndDlg,
 246                        IDC_PS2MOUSEFASTINIT,
 247                        BM_SETCHECK,
 248                        (pMouseInfo->dwInitPolled == 0) ? BST_CHECKED : 0,
 249                        0);
 250
 251     return TRUE;
 252 }
 253
 254
 255 static
 256 VOID
 257 MouseOnCommand(
 258     HWND hwndDlg,
 259     WPARAM wParam,
 260     LPARAM lParam)
 261 {
 262     switch (LOWORD(wParam))
 263     {
 264         case IDC_PS2MOUSESAMPLERATE:
 265         case IDC_PS2MOUSEWHEEL:
 266         case IDC_PS2MOUSEINPUTLEN:
 267         case IDC_PS2MOUSEFASTINIT:
 268             if (HIWORD(wParam) == CBN_SELCHANGE ||
 269                 HIWORD(wParam) == CBN_EDITCHANGE)
 270             {
 271                 /* Enable the Apply button */
 272                 PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 273             }
 274             break;
 275
 276         case IDC_PS2MOUSEDEFAULTS:
 277             if (HIWORD(wParam) == BN_CLICKED)
 278             {
 279                 /* Sample rate: 100 */
 280                 SendDlgItemMessageW(hwndDlg,
 281                                     IDC_PS2MOUSESAMPLERATE,
 282                                     CB_SETCURSEL,
 283                                     DEFAULT_SAMPLERATEINDEX,
 284                                     0);
 285
 286                 /* Wheel detection: Assume wheel present */
 287                 SendDlgItemMessageW(hwndDlg,
 288                                     IDC_PS2MOUSEWHEEL,
 289                                     CB_SETCURSEL,
 290                                     DEFAULT_WHEELDETECTION,
 291                                     0);
 292
 293                 /* Input buffer length: 100 packets */
 294                 SendDlgItemMessageW(hwndDlg,
 295                                     IDC_PS2MOUSEINPUTUPDN,
 296                                     UDM_SETPOS32,
 297                                     0,
 298                                     DEFAULT_INPUTBUFFERSIZE);
 299
 300                 /* Fast Initialization: Checked */
 301                 SendDlgItemMessage(hwndDlg,
 302                                    IDC_PS2MOUSEFASTINIT,
 303                                    BM_SETCHECK,
 304                                    (WPARAM)BST_CHECKED,
 305                                    (LPARAM)0);
 306
 307                 /* Enable the Apply button */
 308                 PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
 309             }
 310             break;
 311
 312         default:
 313             break;
 314     }
 315 }
 316
 317
 318 static
 319 VOID
 320 MouseOnApply(
 321     HWND hwndDlg)
 322 {
 323     PMOUSE_INFO pMouseInfo;
 324     DWORD dwSampleRateIndex = 0;
 325     DWORD dwSampleRate, dwWheelDetection;
 326     DWORD dwInputBufferLength;
 327     DWORD dwInitPolled;
 328     UINT uValue;
 329     BOOL bFailed;
 330     INT nIndex;
 331
 332     pMouseInfo = (PMOUSE_INFO)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
 333
 334     /* Get the sample rate setting and store it if it was changed */
 335     nIndex = SendDlgItemMessageW(hwndDlg, IDC_PS2MOUSESAMPLERATE,
 336                                  CB_GETCURSEL, 0, 0);
 337     if (nIndex == CB_ERR)
 338         dwSampleRateIndex = DEFAULT_SAMPLERATEINDEX;
 339     else
 340         dwSampleRateIndex = (DWORD)nIndex;
 341
 342     if (dwSampleRateIndex != pMouseInfo->dwSampleRateIndex)
 343     {
 344         dwSampleRate = MouseSampleRates[dwSampleRateIndex];
 345         RegSetValueExW(pMouseInfo->hDeviceKey,
 346                        L"SampleRate",
 347                        0,
 348                        REG_DWORD,
 349                        (LPBYTE)&dwSampleRate,
 350                        sizeof(dwSampleRate));
 351     }
 352
 353     /* Get the wheel detection setting and store it if it was changed */
 354     nIndex = SendDlgItemMessageW(hwndDlg, IDC_PS2MOUSEWHEEL,
 355                                  CB_GETCURSEL, 0, 0);
 356     if (nIndex == CB_ERR)
 357         dwWheelDetection = DEFAULT_WHEELDETECTION;
 358     else
 359         dwWheelDetection = (DWORD)nIndex;
 360
 361     if (dwWheelDetection != pMouseInfo->dwWheelDetection)
 362     {
 363         RegSetValueExW(pMouseInfo->hDeviceKey,
 364                        L"EnableWheelDetection",
 365                        0,
 366                        REG_DWORD,
 367                        (LPBYTE)&dwWheelDetection,
 368                        sizeof(dwWheelDetection));
 369     }
 370
 371     /* Get the input buffer length setting and store it if it was changed */
 372     uValue = SendDlgItemMessageW(hwndDlg,
 373                                  IDC_PS2MOUSEINPUTUPDN,
 374                                  UDM_GETPOS32,
 375                                  0,
 376                                  (LPARAM)&bFailed);
 377     if (bFailed)
 378         dwInputBufferLength = DEFAULT_INPUTBUFFERSIZE;
 379     else
 380         dwInputBufferLength = (DWORD)uValue;
 381
 382     if (dwInputBufferLength != pMouseInfo->dwInputBufferLength)
 383     {
 384         RegSetValueExW(pMouseInfo->hDeviceKey,
 385                        L"MouseDataQueueSize",
 386                        0,
 387                        REG_DWORD,
 388                        (LPBYTE)&dwInputBufferLength,
 389                        sizeof(dwInputBufferLength));
 390     }
 391
 392     /* Get the fast initialization setting and store it if it was changed */
 393     uValue = SendDlgItemMessage(hwndDlg,
 394                                 IDC_PS2MOUSEFASTINIT,
 395                                 BM_GETCHECK,
 396                                 0,
 397                                 0);
 398     dwInitPolled = (uValue == BST_CHECKED) ? 0 : 1;
 399
 400     if (dwInitPolled != pMouseInfo->dwInitPolled)
 401     {
 402         RegSetValueExW(pMouseInfo->hDeviceKey,
 403                        L"MouseInitializePolled",
 404                        0,
 405                        REG_DWORD,
 406                        (LPBYTE)&dwInitPolled,
 407                        sizeof(dwInitPolled));
 408     }
 409 }
 410
 411
 412 static
 413 BOOL
 414 MouseOnNotify(
 415     HWND hwndDlg,
 416     WPARAM wParam,
 417     LPARAM lParam)
 418 {
 419     switch (((LPNMHDR)lParam)->code)
 420     {
 421         case UDN_DELTAPOS:
 422             if (((LPNMHDR)lParam)->idFrom == IDC_PS2MOUSEINPUTUPDN)
 423             {
 424                 ((LPNMUPDOWN)lParam)->iDelta *= 10;
 425                 return FALSE;
 426             }
 427             break;
 428
 429         case PSN_APPLY:
 430             MouseOnApply(hwndDlg);
 431             return TRUE;
 432     }
 433
 434     return FALSE;
 435 }
 436
 437
 438 static
 439 INT_PTR
 440 MouseOnCtrlColorStatic(
 441     HWND hwndDlg,
 442     WPARAM wParam,
 443     LPARAM lParam)
 444 {
 445     if ((HWND)lParam != GetDlgItem(hwndDlg, IDC_PS2MOUSEINPUTLEN))
 446         return 0;
 447
 448     SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
 449     SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
 450     return (INT_PTR)GetSysColorBrush(COLOR_WINDOW);
 451 }
 452
 453
 454 static
 455 INT_PTR
 456 CALLBACK
 457 MouseDlgProc(
 458     HWND hwndDlg,
 459     UINT uMsg,
 460     WPARAM wParam,
 461     LPARAM lParam)
 462 {
 463     DPRINT("MouseDlgProc\n");
 464
 465     switch (uMsg)
 466     {
 467         case WM_INITDIALOG:
 468             return MouseOnDialogInit(hwndDlg, lParam);
 469
 470         case WM_COMMAND:
 471             MouseOnCommand(hwndDlg, wParam, lParam);
 472             break;
 473
 474         case WM_NOTIFY:
 475             return MouseOnNotify(hwndDlg, wParam, lParam);
 476
 477         case WM_CTLCOLORSTATIC:
 478             return MouseOnCtrlColorStatic(hwndDlg, wParam, lParam);
 479     }
 480
 481     return FALSE;
 482 }
 483
 484
 485 static
 486 UINT
 487 CALLBACK
 488 MouseCallback(
 489     HWND hWnd,
 490     UINT uMsg,
 491     LPPROPSHEETPAGE ppsp)
 492 {
 493     PMOUSE_INFO pMouseInfo;
 494
 495     pMouseInfo = (PMOUSE_INFO)ppsp->lParam;
 496
 497     if (uMsg == PSPCB_RELEASE)
 498     {
 499         if (pMouseInfo->hDeviceKey != NULL)
 500             RegCloseKey(pMouseInfo->hDeviceKey);
 501         HeapFree(GetProcessHeap(), 0, pMouseInfo);
 502     }
 503
 504     return 1;
 505 }
 506
 507
 508 /*
 509  * @implemented
 510  */
 511 BOOL
 512 WINAPI
 513 PS2MousePropPageProvider(
 514     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
 515     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
 516     _In_ LPARAM lParam)
 517 {
 518     PROPSHEETPAGEW PropSheetPage;
 519     HPROPSHEETPAGE hPropSheetPage;
 520     PMOUSE_INFO pMouseInfo;
 521
 522     DPRINT("PS2MousePropPageProvider(%p %p %lx)\n",
 523            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
 524
 525     if (lpPropSheetPageRequest->PageRequested != SPPSR_ENUM_ADV_DEVICE_PROPERTIES)
 526         return FALSE;
 527
 528     pMouseInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MOUSE_INFO));
 529     if (pMouseInfo == NULL)
 530         return FALSE;
 531
 532     pMouseInfo->hDeviceKey = SetupDiOpenDevRegKey(lpPropSheetPageRequest->DeviceInfoSet,
 533                                                   lpPropSheetPageRequest->DeviceInfoData,
 534                                                   DICS_FLAG_GLOBAL,
 535                                                   0,
 536                                                   DIREG_DEV,
 537                                                   KEY_ALL_ACCESS);
 538     if (pMouseInfo->hDeviceKey == INVALID_HANDLE_VALUE)
 539     {
 540         DPRINT1("SetupDiOpenDevRegKey() failed (Error %lu)\n", GetLastError());
 541         HeapFree(GetProcessHeap(), 0, pMouseInfo);
 542         return FALSE;
 543     }
 544
 545     PropSheetPage.dwSize = sizeof(PROPSHEETPAGEW);
 546     PropSheetPage.dwFlags = 0;
 547     PropSheetPage.hInstance = hDllInstance;
 548     PropSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_PS2MOUSEPROPERTIES);
 549     PropSheetPage.pfnDlgProc = MouseDlgProc;
 550     PropSheetPage.lParam = (LPARAM)pMouseInfo;
 551     PropSheetPage.pfnCallback = MouseCallback;
 552
 553     hPropSheetPage = CreatePropertySheetPageW(&PropSheetPage);
 554     if (hPropSheetPage == NULL)
 555     {
 556         DPRINT1("CreatePropertySheetPageW() failed!\n");
 557         HeapFree(GetProcessHeap(), 0, pMouseInfo);
 558         return FALSE;
 559     }
 560
 561     if (!(*lpfnAddPropSheetPageProc)(hPropSheetPage, lParam))
 562     {
 563         DPRINT1("lpfnAddPropSheetPageProc() failed!\n");
 564         DestroyPropertySheetPage(hPropSheetPage);
 565         HeapFree(GetProcessHeap(), 0, pMouseInfo);
 566         return FALSE;
 567     }
 568
 569     return TRUE;
 570 }
 571
 572
 573 /*
 574  * @implemented
 575  */
 576 BOOL
 577 WINAPI
 578 TapePropPageProvider(
 579     _In_ PSP_PROPSHEETPAGE_REQUEST lpPropSheetPageRequest,
 580     _In_ LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
 581     _In_ LPARAM lParam)
 582 {
 583     DPRINT("TapePropPageProvider(%p %p %lx)\n",
 584            lpPropSheetPageRequest, lpfnAddPropSheetPageProc, lParam);
 585     return FALSE;
 586 }
 587
 588 /* EOF */