879 lines
21 KiB
C
879 lines
21 KiB
C
#include "setupp.h"
|
|
#pragma hdrstop
|
|
|
|
#include <windowsx.h>
|
|
|
|
//
|
|
// PAGE_INFO and related Prototypes
|
|
//
|
|
typedef struct _PAGE_INFO {
|
|
HDEVINFO deviceInfoSet;
|
|
PSP_DEVINFO_DATA deviceInfoData;
|
|
|
|
HKEY hKeyDev;
|
|
|
|
DWORD enableWheelDetect;
|
|
DWORD sampleRate;
|
|
DWORD bufferLength;
|
|
DWORD mouseInitPolled;
|
|
} PAGE_INFO, * PPAGE_INFO;
|
|
|
|
PPAGE_INFO
|
|
PS2Mouse_CreatePageInfo(
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData
|
|
);
|
|
|
|
void
|
|
PS2Mouse_DestroyPageInfo(
|
|
PPAGE_INFO PageInfo
|
|
);
|
|
|
|
//
|
|
// Function Prototypes
|
|
//
|
|
HPROPSHEETPAGE
|
|
PS2Mouse_CreatePropertyPage(
|
|
PROPSHEETPAGE * PropSheetPage,
|
|
PPAGE_INFO PageInfo
|
|
);
|
|
|
|
UINT CALLBACK
|
|
PS2Mouse_PropPageCallback(
|
|
HWND Hwnd,
|
|
UINT Message,
|
|
LPPROPSHEETPAGE PropSheetPage
|
|
);
|
|
|
|
INT_PTR
|
|
APIENTRY
|
|
PS2Mouse_DlgProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMessage,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
);
|
|
|
|
void
|
|
PS2Mouse_InitializeControls(
|
|
HWND ParentHwnd,
|
|
PPAGE_INFO PageInfo
|
|
);
|
|
|
|
void
|
|
PS2Mouse_OnCommand(
|
|
HWND ParentHwnd,
|
|
int ControlId,
|
|
HWND ControlHwnd,
|
|
UINT NotifyCode
|
|
);
|
|
|
|
BOOL
|
|
PS2Mouse_OnContextMenu(
|
|
HWND HwndControl,
|
|
WORD Xpos,
|
|
WORD Ypos
|
|
);
|
|
|
|
INT_PTR
|
|
PS2Mouse_OnCtlColorStatic(
|
|
HDC DC,
|
|
HWND Hwnd
|
|
);
|
|
|
|
void
|
|
PS2Mouse_OnHelp(
|
|
HWND ParentHwnd,
|
|
LPHELPINFO HelpInfo
|
|
);
|
|
|
|
BOOL
|
|
PS2Mouse_OnInitDialog(
|
|
HWND ParentHwnd,
|
|
HWND FocusHwnd,
|
|
LPARAM Lparam
|
|
);
|
|
|
|
BOOL
|
|
PS2Mouse_OnNotify(
|
|
HWND ParentHwnd,
|
|
LPNMHDR NmHdr
|
|
);
|
|
|
|
//
|
|
// Message macros for up down controls
|
|
//
|
|
#define UpDown_SetRange(hwndUD, nLower, nUpper) \
|
|
(VOID) SendMessage((hwndUD), UDM_SETRANGE, (WPARAM) 0, \
|
|
(LPARAM) MAKELONG((short) (nUpper), (short) (nLower)) )
|
|
|
|
#define UpDown_GetPos(hwndUD) \
|
|
(DWORD) SendMessage((hwndUD), UDM_GETPOS, (WPARAM) 0, (LPARAM) 0)
|
|
|
|
#define UpDown_SetPos(hwndUD, nPos) \
|
|
(short) SendMessage((hwndUD), UDM_SETPOS, (WPARAM) 0, \
|
|
(LPARAM) MAKELONG((short) (nPos), 0) )
|
|
|
|
#define UpDown_SetAccel(hwndUD, nCount, pAccels) \
|
|
(BOOL) SendMessage((hwndUD), UDM_SETACCEL, (WPARAM) nCount, \
|
|
(LPARAM) pAccels)
|
|
|
|
//
|
|
// Constants and strings
|
|
//
|
|
#define MOUSE_INIT_POLLED_DEFAULT 0
|
|
|
|
#define MAX_DETECTION_TYPES 3
|
|
#define WHEEL_DETECT_DEFAULT 2 // Default is now 2 for Beta3 /* 1 */
|
|
|
|
#define DATA_QUEUE_MIN 100
|
|
#define DATA_QUEUE_MAX 300
|
|
#define DATA_QUEUE_DEFAULT 100
|
|
|
|
#define SAMPLE_RATE_DEFAULT 100
|
|
|
|
const DWORD PS2Mouse_SampleRates[] =
|
|
{
|
|
20,
|
|
40,
|
|
60,
|
|
80,
|
|
100,
|
|
200
|
|
};
|
|
|
|
#define MAX_SAMPLE_RATES (sizeof(PS2Mouse_SampleRates)/sizeof(PS2Mouse_SampleRates[0]))
|
|
|
|
#define IDH_DEVMGR_MOUSE_ADVANCED_RATE 2002100
|
|
#define IDH_DEVMGR_MOUSE_ADVANCED_DETECT 2002110
|
|
#define IDH_DEVMGR_MOUSE_ADVANCED_BUFFER 2002120
|
|
#define IDH_DEVMGR_MOUSE_ADVANCED_INIT 2002130
|
|
#define IDH_DEVMGR_MOUSE_ADVANCED_DEFAULT 2002140
|
|
|
|
const DWORD PS2Mouse_HelpIDs[] = {
|
|
IDC_SAMPLE_RATE, IDH_DEVMGR_MOUSE_ADVANCED_RATE,
|
|
IDC_WHEEL_DETECTION, IDH_DEVMGR_MOUSE_ADVANCED_DETECT,
|
|
IDC_BUFFER, IDH_DEVMGR_MOUSE_ADVANCED_BUFFER,
|
|
IDC_BUFFER_SPIN, IDH_DEVMGR_MOUSE_ADVANCED_BUFFER,
|
|
IDC_FAST_INIT, IDH_DEVMGR_MOUSE_ADVANCED_INIT,
|
|
IDC_DEFAULT, IDH_DEVMGR_MOUSE_ADVANCED_DEFAULT,
|
|
0, 0
|
|
};
|
|
|
|
TCHAR szDevMgrHelp[] = L"devmgr.hlp";
|
|
|
|
TCHAR szMouseDataQueueSize[] = L"MouseDataQueueSize";
|
|
TCHAR szSampleRate[] = L"SampleRate";
|
|
TCHAR szEnableWheelDetection[] = L"EnableWheelDetection";
|
|
TCHAR szMouseInitializePolled[] = L"MouseInitializePolled";
|
|
TCHAR szDisablePolledUI[] = L"DisableInitializePolledUI";
|
|
|
|
PPAGE_INFO
|
|
PS2Mouse_CreatePageInfo(
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData)
|
|
{
|
|
PPAGE_INFO tmp = (PPAGE_INFO) MyMalloc(sizeof(PAGE_INFO));
|
|
|
|
if (!tmp) {
|
|
return NULL;
|
|
}
|
|
|
|
tmp->deviceInfoSet = DeviceInfoSet;
|
|
tmp->deviceInfoData = DeviceInfoData;
|
|
|
|
tmp->hKeyDev =
|
|
SetupDiOpenDevRegKey(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DEV,
|
|
KEY_ALL_ACCESS);
|
|
|
|
return tmp;
|
|
}
|
|
|
|
void
|
|
PS2Mouse_DestroyPageInfo(
|
|
PPAGE_INFO PageInfo
|
|
)
|
|
{
|
|
if (PageInfo->hKeyDev != (HKEY) INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(PageInfo->hKeyDev);
|
|
}
|
|
|
|
MyFree(PageInfo);
|
|
}
|
|
|
|
HPROPSHEETPAGE
|
|
PS2Mouse_CreatePropertyPage(
|
|
PROPSHEETPAGE * PropSheetPage,
|
|
PPAGE_INFO PageInfo
|
|
)
|
|
{
|
|
//
|
|
// Add the Port Settings property page
|
|
//
|
|
PropSheetPage->dwSize = sizeof(PROPSHEETPAGE);
|
|
PropSheetPage->dwFlags = PSP_USECALLBACK; // | PSP_HASHELP;
|
|
PropSheetPage->hInstance = MyModuleHandle;
|
|
PropSheetPage->pszTemplate = MAKEINTRESOURCE(IDD_PROP_PAGE_PS2_MOUSE);
|
|
|
|
//
|
|
// following points to the dlg window proc
|
|
//
|
|
PropSheetPage->pfnDlgProc = PS2Mouse_DlgProc;
|
|
PropSheetPage->lParam = (LPARAM) PageInfo;
|
|
|
|
//
|
|
// Following points to the control callback of the dlg window proc.
|
|
// The callback gets called before creation/after destruction of the page
|
|
//
|
|
PropSheetPage->pfnCallback = PS2Mouse_PropPageCallback;
|
|
|
|
//
|
|
// Allocate the actual page
|
|
//
|
|
return CreatePropertySheetPage(PropSheetPage);
|
|
}
|
|
|
|
BOOL APIENTRY
|
|
PS2MousePropPageProvider(
|
|
LPVOID Info,
|
|
LPFNADDPROPSHEETPAGE AddFunction,
|
|
LPARAM Lparam)
|
|
{
|
|
PSP_PROPSHEETPAGE_REQUEST ppr;
|
|
PROPSHEETPAGE psp;
|
|
HPROPSHEETPAGE hpsp;
|
|
PPAGE_INFO ppi = NULL;
|
|
ULONG devStatus, devProblem;
|
|
CONFIGRET cr;
|
|
|
|
ppr = (PSP_PROPSHEETPAGE_REQUEST) Info;
|
|
|
|
if (ppr->PageRequested == SPPSR_ENUM_ADV_DEVICE_PROPERTIES) {
|
|
ppi = PS2Mouse_CreatePageInfo(ppr->DeviceInfoSet, ppr->DeviceInfoData);
|
|
|
|
if (!ppi) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// If this fails, it is most likely that the user does not have
|
|
// write access to the devices key/subkeys in the registry.
|
|
// If you only want to read the settings, then change KEY_ALL_ACCESS
|
|
// to KEY_READ in CreatePageInfo.
|
|
//
|
|
// Administrators usually have access to these reg keys....
|
|
//
|
|
if (ppi->hKeyDev == (HKEY) INVALID_HANDLE_VALUE) {
|
|
PS2Mouse_DestroyPageInfo(ppi);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Retrieve the status of this device instance.
|
|
//
|
|
cr = CM_Get_DevNode_Status(&devStatus,
|
|
&devProblem,
|
|
ppr->DeviceInfoData->DevInst,
|
|
0);
|
|
if ((cr == CR_SUCCESS) &&
|
|
(devStatus & DN_HAS_PROBLEM) &&
|
|
(devProblem & CM_PROB_DISABLED_SERVICE)) {
|
|
//
|
|
// If the controlling service has been disabled, do not show any
|
|
// additional property pages.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
hpsp = PS2Mouse_CreatePropertyPage(&psp, ppi);
|
|
|
|
if (!hpsp) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (!AddFunction(hpsp, Lparam)) {
|
|
DestroyPropertySheetPage(hpsp);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
UINT CALLBACK
|
|
PS2Mouse_PropPageCallback(
|
|
HWND Hwnd,
|
|
UINT Message,
|
|
LPPROPSHEETPAGE PropSheetPage
|
|
)
|
|
{
|
|
PPAGE_INFO ppi;
|
|
|
|
switch (Message) {
|
|
case PSPCB_CREATE:
|
|
return TRUE; // return TRUE to continue with creation of page
|
|
|
|
case PSPCB_RELEASE:
|
|
ppi = (PPAGE_INFO) PropSheetPage->lParam;
|
|
PS2Mouse_DestroyPageInfo(ppi);
|
|
|
|
return 0; // return value ignored
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
APIENTRY
|
|
PS2Mouse_DlgProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMessage,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
switch(uMessage) {
|
|
case WM_COMMAND:
|
|
PS2Mouse_OnCommand(hDlg, (int) LOWORD(wParam), (HWND)lParam, (UINT)HIWORD(wParam));
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
return PS2Mouse_OnContextMenu((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
|
|
case WM_HELP:
|
|
PS2Mouse_OnHelp(hDlg, (LPHELPINFO) lParam);
|
|
break;
|
|
|
|
case WM_CTLCOLORSTATIC:
|
|
return PS2Mouse_OnCtlColorStatic((HDC) wParam, (HWND) lParam);
|
|
|
|
case WM_INITDIALOG:
|
|
return PS2Mouse_OnInitDialog(hDlg, (HWND)wParam, lParam);
|
|
|
|
case WM_NOTIFY:
|
|
return PS2Mouse_OnNotify(hDlg, (NMHDR *)lParam);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD
|
|
PS2Mouse_GetSampleRateIndex(
|
|
DWORD SampleRate
|
|
)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < MAX_SAMPLE_RATES; i++) {
|
|
if (PS2Mouse_SampleRates[i] == SampleRate) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
PS2Mouse_OnDefault(
|
|
HWND ParentHwnd,
|
|
PPAGE_INFO PageInfo
|
|
)
|
|
{
|
|
UpDown_SetPos(GetDlgItem(ParentHwnd, IDC_BUFFER_SPIN), DATA_QUEUE_DEFAULT);
|
|
ComboBox_SetCurSel(GetDlgItem(ParentHwnd, IDC_SAMPLE_RATE),
|
|
PS2Mouse_GetSampleRateIndex(SAMPLE_RATE_DEFAULT));
|
|
ComboBox_SetCurSel(GetDlgItem(ParentHwnd, IDC_WHEEL_DETECTION), WHEEL_DETECT_DEFAULT);
|
|
Button_SetCheck(GetDlgItem(ParentHwnd, IDC_FAST_INIT), !MOUSE_INIT_POLLED_DEFAULT);
|
|
|
|
PropSheet_Changed(GetParent(ParentHwnd), ParentHwnd);
|
|
}
|
|
|
|
void
|
|
PS2Mouse_OnCommand(
|
|
HWND ParentHwnd,
|
|
int ControlId,
|
|
HWND ControlHwnd,
|
|
UINT NotifyCode
|
|
)
|
|
{
|
|
PPAGE_INFO pageInfo = (PPAGE_INFO) GetWindowLongPtr(ParentHwnd, DWLP_USER);
|
|
|
|
if (NotifyCode == CBN_SELCHANGE) {
|
|
PropSheet_Changed(GetParent(ParentHwnd), ParentHwnd);
|
|
}
|
|
else {
|
|
switch (ControlId) {
|
|
case IDC_DEFAULT:
|
|
PS2Mouse_OnDefault(ParentHwnd, pageInfo);
|
|
break;
|
|
|
|
case IDC_FAST_INIT:
|
|
PropSheet_Changed(GetParent(ParentHwnd), ParentHwnd);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
PS2Mouse_OnContextMenu(
|
|
HWND HwndControl,
|
|
WORD Xpos,
|
|
WORD Ypos
|
|
)
|
|
{
|
|
WinHelp(HwndControl,
|
|
szDevMgrHelp,
|
|
HELP_CONTEXTMENU,
|
|
(ULONG_PTR) PS2Mouse_HelpIDs);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
INT_PTR
|
|
PS2Mouse_OnCtlColorStatic(
|
|
HDC DC,
|
|
HWND HStatic
|
|
)
|
|
{
|
|
UINT id = GetDlgCtrlID(HStatic);
|
|
|
|
//
|
|
// WM_CTLCOLORSTATIC is sent for the edit controls because they are read
|
|
// only
|
|
//
|
|
if (id == IDC_BUFFER) {
|
|
SetBkColor(DC, GetSysColor(COLOR_WINDOW));
|
|
return (INT_PTR) GetSysColorBrush(COLOR_WINDOW);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
PS2Mouse_OnHelp(
|
|
HWND ParentHwnd,
|
|
LPHELPINFO HelpInfo
|
|
)
|
|
{
|
|
if (HelpInfo->iContextType == HELPINFO_WINDOW) {
|
|
WinHelp((HWND) HelpInfo->hItemHandle,
|
|
szDevMgrHelp,
|
|
HELP_WM_HELP,
|
|
(ULONG_PTR) PS2Mouse_HelpIDs);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
PS2Mouse_OnInitDialog(
|
|
HWND ParentHwnd,
|
|
HWND FocusHwnd,
|
|
LPARAM Lparam
|
|
)
|
|
{
|
|
PPAGE_INFO pageInfo = (PPAGE_INFO) GetWindowLongPtr(ParentHwnd, DWLP_USER);
|
|
|
|
pageInfo = (PPAGE_INFO) ((LPPROPSHEETPAGE)Lparam)->lParam;
|
|
SetWindowLongPtr(ParentHwnd, DWLP_USER, (ULONG_PTR) pageInfo);
|
|
|
|
PS2Mouse_InitializeControls(ParentHwnd, pageInfo);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
PS2Mouse_OnApply(
|
|
HWND ParentHwnd,
|
|
PPAGE_INFO PageInfo
|
|
)
|
|
{
|
|
DWORD uiEnableWheelDetect, uiSampleRate, uiBufferLength, uiMouseInitPolled;
|
|
int iSel;
|
|
BOOL reboot = FALSE;
|
|
|
|
uiEnableWheelDetect =
|
|
ComboBox_GetCurSel(GetDlgItem(ParentHwnd, IDC_WHEEL_DETECTION));
|
|
uiBufferLength = UpDown_GetPos(GetDlgItem(ParentHwnd, IDC_BUFFER_SPIN));
|
|
uiMouseInitPolled = !Button_GetCheck(GetDlgItem(ParentHwnd, IDC_FAST_INIT));
|
|
|
|
//
|
|
// Must index the array as opposed to getting a real value
|
|
//
|
|
iSel = ComboBox_GetCurSel(GetDlgItem(ParentHwnd, IDC_SAMPLE_RATE));
|
|
if (iSel == CB_ERR) {
|
|
uiSampleRate = PageInfo->sampleRate;
|
|
}
|
|
else {
|
|
uiSampleRate = PS2Mouse_SampleRates[iSel];
|
|
}
|
|
|
|
//
|
|
// See if anything has changed
|
|
//
|
|
if (uiEnableWheelDetect != PageInfo->enableWheelDetect) {
|
|
RegSetValueEx(PageInfo->hKeyDev,
|
|
szEnableWheelDetection,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &uiEnableWheelDetect,
|
|
sizeof(DWORD));
|
|
reboot = TRUE;
|
|
}
|
|
|
|
if (uiSampleRate != PageInfo->sampleRate) {
|
|
RegSetValueEx(PageInfo->hKeyDev,
|
|
szSampleRate,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &uiSampleRate,
|
|
sizeof(DWORD));
|
|
reboot = TRUE;
|
|
}
|
|
|
|
if (uiBufferLength != PageInfo->bufferLength) {
|
|
RegSetValueEx(PageInfo->hKeyDev,
|
|
szMouseDataQueueSize,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &uiBufferLength,
|
|
sizeof(DWORD));
|
|
reboot = TRUE;
|
|
}
|
|
|
|
if (uiMouseInitPolled) {
|
|
//
|
|
// make sure if it is nonzero that it is 1
|
|
//
|
|
uiMouseInitPolled = 1;
|
|
}
|
|
|
|
if (uiMouseInitPolled != PageInfo->mouseInitPolled) {
|
|
RegSetValueEx(PageInfo->hKeyDev,
|
|
szMouseInitializePolled,
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &uiMouseInitPolled,
|
|
sizeof(DWORD));
|
|
reboot = TRUE;
|
|
}
|
|
|
|
if (reboot) {
|
|
SP_DEVINSTALL_PARAMS dip;
|
|
|
|
ZeroMemory(&dip, sizeof(dip));
|
|
dip.cbSize = sizeof(dip);
|
|
|
|
SetupDiGetDeviceInstallParams(PageInfo->deviceInfoSet,
|
|
PageInfo->deviceInfoData,
|
|
&dip);
|
|
|
|
dip.Flags |= DI_NEEDREBOOT;
|
|
|
|
SetupDiSetDeviceInstallParams(PageInfo->deviceInfoSet,
|
|
PageInfo->deviceInfoData,
|
|
&dip);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
PS2Mouse_OnNotify(
|
|
HWND ParentHwnd,
|
|
LPNMHDR NmHdr
|
|
)
|
|
{
|
|
PPAGE_INFO pageInfo = (PPAGE_INFO) GetWindowLongPtr(ParentHwnd, DWLP_USER);
|
|
|
|
switch (NmHdr->code) {
|
|
|
|
//
|
|
// The user is about to change an up down control
|
|
//
|
|
case UDN_DELTAPOS:
|
|
PropSheet_Changed(GetParent(ParentHwnd), ParentHwnd);
|
|
return FALSE;
|
|
|
|
//
|
|
// Sent when the user clicks on Apply OR OK !!
|
|
//
|
|
case PSN_APPLY:
|
|
//
|
|
// Write out the com port options to the registry
|
|
//
|
|
PS2Mouse_OnApply(ParentHwnd, pageInfo);
|
|
SetWindowLongPtr(ParentHwnd, DWLP_MSGRESULT, PSNRET_NOERROR);
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
PS2Mouse_SetupSpinner(
|
|
HKEY Hkey,
|
|
HWND SpinnerHwnd,
|
|
TCHAR ValueName[],
|
|
short MinVal,
|
|
short MaxVal,
|
|
short DefaultVal,
|
|
short IncrementVal
|
|
)
|
|
{
|
|
DWORD dwValue, dwSize;
|
|
UDACCEL accel;
|
|
|
|
UpDown_SetRange(SpinnerHwnd, MinVal, MaxVal);
|
|
dwSize = sizeof(DWORD);
|
|
if (RegQueryValueEx(Hkey,
|
|
ValueName,
|
|
0,
|
|
NULL,
|
|
(PBYTE) &dwValue,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
dwValue = DefaultVal;
|
|
}
|
|
if (((short) dwValue) < MinVal || ((short) dwValue) > MaxVal) {
|
|
dwValue = DefaultVal;
|
|
}
|
|
|
|
if (dwValue % IncrementVal) {
|
|
//
|
|
// Set the value to a good one and return the one we took out of the
|
|
// registry. When the user applies the changes the value in the control
|
|
// will be different and we will write the value out
|
|
//
|
|
UpDown_SetPos(SpinnerHwnd, dwValue - (dwValue % IncrementVal));
|
|
}
|
|
else {
|
|
UpDown_SetPos(SpinnerHwnd, dwValue);
|
|
}
|
|
|
|
accel.nSec = 0;
|
|
accel.nInc = IncrementVal;
|
|
UpDown_SetAccel(SpinnerHwnd, 1, &accel);
|
|
|
|
return dwValue;
|
|
}
|
|
|
|
DWORD
|
|
PS2Mouse_SetupSampleRate(
|
|
HWND ComboBoxHwnd,
|
|
HKEY Hkey
|
|
)
|
|
{
|
|
int i;
|
|
DWORD dwValue, dwSize;
|
|
BOOL badValue = FALSE;
|
|
TCHAR szValue[32];
|
|
|
|
//
|
|
// First setup the cb, then find the correct selection
|
|
//
|
|
for (i = 0; i < MAX_SAMPLE_RATES; i++) {
|
|
wsprintf(szValue, TEXT("%d"), PS2Mouse_SampleRates[i]);
|
|
ComboBox_AddString(ComboBoxHwnd, szValue);
|
|
}
|
|
|
|
//
|
|
// Get the value out of the registry. If it not what we expect or it is not
|
|
// there, then make sure when the user clicks OK, the values are written out
|
|
//
|
|
dwSize = sizeof(DWORD);
|
|
if (RegQueryValueEx(Hkey,
|
|
szSampleRate,
|
|
0,
|
|
NULL,
|
|
(PBYTE) &dwValue,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
dwValue = SAMPLE_RATE_DEFAULT;
|
|
badValue = TRUE;
|
|
}
|
|
|
|
//
|
|
// Assume the value is wrong
|
|
//
|
|
badValue = TRUE;
|
|
for (i = 0; i < MAX_SAMPLE_RATES; i++) {
|
|
if (PS2Mouse_SampleRates[i] == dwValue) {
|
|
badValue = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (badValue) {
|
|
dwValue = SAMPLE_RATE_DEFAULT;
|
|
}
|
|
|
|
ComboBox_SetCurSel(ComboBoxHwnd, PS2Mouse_GetSampleRateIndex(dwValue));
|
|
|
|
if (badValue) {
|
|
return 0xffffffff;
|
|
}
|
|
else {
|
|
return dwValue;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
PS2Mouse_SetupWheelDetection(
|
|
HWND ComboBoxHwnd,
|
|
HKEY Hkey
|
|
)
|
|
{
|
|
int i;
|
|
DWORD dwValue, dwSize;
|
|
BOOL badValue = FALSE;
|
|
TCHAR szDescription[80];
|
|
UINT stringIDs[MAX_DETECTION_TYPES] = {
|
|
IDS_PS2_DETECTION_DISABLED,
|
|
IDS_PS2_DETECTION_LOOK,
|
|
IDS_PS2_DETECTION_ASSUME_PRESENT
|
|
};
|
|
|
|
//
|
|
// First setup the cb, then find the correct selection
|
|
//
|
|
for (i = 0; i < MAX_DETECTION_TYPES; i++) {
|
|
LoadString(MyModuleHandle,
|
|
stringIDs[i],
|
|
szDescription,
|
|
sizeof(szDescription) / sizeof(TCHAR));
|
|
ComboBox_AddString(ComboBoxHwnd, szDescription);
|
|
}
|
|
|
|
//
|
|
// Get the value out of the registry. If it not what we expect or it is not
|
|
// there, then make sure when the user clicks OK, the values are written out
|
|
//
|
|
dwSize = sizeof(DWORD);
|
|
if (RegQueryValueEx(Hkey,
|
|
szEnableWheelDetection,
|
|
0,
|
|
NULL,
|
|
(PBYTE) &dwValue,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
dwValue = WHEEL_DETECT_DEFAULT;
|
|
badValue = TRUE;
|
|
}
|
|
|
|
if (dwValue > 2) {
|
|
dwValue = WHEEL_DETECT_DEFAULT;
|
|
badValue = TRUE;
|
|
}
|
|
|
|
ComboBox_SetCurSel(ComboBoxHwnd, dwValue);
|
|
|
|
if (badValue) {
|
|
return 0xffffffff;
|
|
}
|
|
else {
|
|
return dwValue;
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
PSMouse_SetupFastInit(
|
|
HWND CheckBoxHwnd,
|
|
HKEY Hkey
|
|
)
|
|
{
|
|
DWORD dwSize, dwValue, dwDisable = FALSE;
|
|
BOOL badValue = FALSE;
|
|
|
|
//
|
|
// Get the value out of the registry. If it not what we expect or it is not
|
|
// there, then make sure when the user clicks OK, the values are written out
|
|
//
|
|
dwSize = sizeof(DWORD);
|
|
if (RegQueryValueEx(Hkey,
|
|
szMouseInitializePolled,
|
|
0,
|
|
NULL,
|
|
(PBYTE) &dwValue,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
dwValue = MOUSE_INIT_POLLED_DEFAULT;
|
|
badValue = TRUE;
|
|
}
|
|
|
|
//
|
|
// Make sure the value is 1 or 0. If it is nonzero and not 1, it is assumed
|
|
// to be 1
|
|
//
|
|
if (dwValue != 0 && dwValue != 1) {
|
|
dwValue = 1;
|
|
badValue = TRUE;
|
|
}
|
|
|
|
//
|
|
// This is a bit confusing. The UI has fast initialization, but underneath
|
|
// it is represented as initialize polled which is fast when it is false,
|
|
// but we must show true to the user
|
|
//
|
|
Button_SetCheck(CheckBoxHwnd, !dwValue);
|
|
|
|
dwSize = sizeof(DWORD);
|
|
if (RegQueryValueEx(Hkey,
|
|
szDisablePolledUI,
|
|
0,
|
|
NULL,
|
|
(PBYTE) &dwDisable,
|
|
&dwSize) == ERROR_SUCCESS &&
|
|
dwDisable != FALSE) {
|
|
EnableWindow(CheckBoxHwnd, FALSE);
|
|
}
|
|
|
|
if (badValue) {
|
|
return -1;
|
|
}
|
|
else {
|
|
return dwValue;
|
|
}
|
|
}
|
|
|
|
void
|
|
PS2Mouse_InitializeControls(
|
|
HWND ParentHwnd,
|
|
PPAGE_INFO PageInfo
|
|
)
|
|
{
|
|
HKEY hKey;
|
|
HWND hwnd;
|
|
DWORD dwValue, dwSize;
|
|
int i;
|
|
|
|
if (PageInfo->hKeyDev == (HKEY) INVALID_HANDLE_VALUE) {
|
|
//
|
|
// Disable all of the controls
|
|
//
|
|
return;
|
|
}
|
|
|
|
PageInfo->bufferLength =
|
|
PS2Mouse_SetupSpinner(PageInfo->hKeyDev,
|
|
GetDlgItem(ParentHwnd, IDC_BUFFER_SPIN),
|
|
szMouseDataQueueSize,
|
|
DATA_QUEUE_MIN,
|
|
DATA_QUEUE_MAX,
|
|
DATA_QUEUE_DEFAULT,
|
|
10);
|
|
|
|
PageInfo->sampleRate =
|
|
PS2Mouse_SetupSampleRate(GetDlgItem(ParentHwnd, IDC_SAMPLE_RATE),
|
|
PageInfo->hKeyDev);
|
|
|
|
PageInfo->enableWheelDetect =
|
|
PS2Mouse_SetupWheelDetection(GetDlgItem(ParentHwnd, IDC_WHEEL_DETECTION),
|
|
PageInfo->hKeyDev);
|
|
|
|
PageInfo->mouseInitPolled =
|
|
PSMouse_SetupFastInit(GetDlgItem(ParentHwnd, IDC_FAST_INIT),
|
|
PageInfo->hKeyDev);
|
|
}
|