You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
343 lines
8.4 KiB
343 lines
8.4 KiB
//-----------------------------------------------------------------------------
|
|
// File: usefuldi.cpp
|
|
//
|
|
// Desc: Contains various DInput-specific utility classes and functions
|
|
// to help the UI carry its operations more easily.
|
|
//
|
|
// Copyright (C) 1999-2000 Microsoft Corporation. All Rights Reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "common.hpp"
|
|
|
|
// don't want useful.cpp to use precompiled header
|
|
#include "useful.cpp"
|
|
|
|
|
|
BOOL IsObjectOnExcludeList(DWORD dwOfs)
|
|
{
|
|
if (dwOfs == DIK_PREVTRACK ||
|
|
dwOfs == DIK_NEXTTRACK ||
|
|
dwOfs == DIK_MUTE ||
|
|
dwOfs == DIK_CALCULATOR ||
|
|
dwOfs == DIK_PLAYPAUSE ||
|
|
dwOfs == DIK_MEDIASTOP ||
|
|
dwOfs == DIK_VOLUMEDOWN ||
|
|
dwOfs == DIK_VOLUMEUP ||
|
|
dwOfs == DIK_WEBHOME ||
|
|
dwOfs == DIK_SLEEP ||
|
|
dwOfs == DIK_WEBSEARCH ||
|
|
dwOfs == DIK_WEBFAVORITES ||
|
|
dwOfs == DIK_WEBREFRESH ||
|
|
dwOfs == DIK_WEBSTOP ||
|
|
dwOfs == DIK_WEBFORWARD ||
|
|
dwOfs == DIK_WEBBACK ||
|
|
dwOfs == DIK_MYCOMPUTER ||
|
|
dwOfs == DIK_MAIL ||
|
|
dwOfs == DIK_MEDIASELECT ||
|
|
dwOfs == DIK_LWIN ||
|
|
dwOfs == DIK_RWIN ||
|
|
dwOfs == DIK_POWER ||
|
|
dwOfs == DIK_WAKE)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CALLBACK IncrementValPerObject(LPCDIDEVICEOBJECTINSTANCEW lpddoi, LPVOID pvRef)
|
|
{
|
|
if (pvRef != NULL)
|
|
++(*((int *)pvRef));
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
BOOL CALLBACK KeyboardIncrementValPerObject(LPCDIDEVICEOBJECTINSTANCEW lpddoi, LPVOID pvRef)
|
|
{
|
|
if (pvRef != NULL && !IsObjectOnExcludeList(lpddoi->dwOfs))
|
|
++(*((int *)pvRef));
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
BOOL CALLBACK FillDIDeviceObject(LPCDIDEVICEOBJECTINSTANCEW lpddoi, LPVOID pvRef)
|
|
{
|
|
if (pvRef == NULL || lpddoi == NULL)
|
|
return DIENUM_CONTINUE;
|
|
|
|
DIDEVOBJSTRUCT &os = *((DIDEVOBJSTRUCT *)pvRef);
|
|
assert(os.pdoi != NULL);
|
|
assert(os.n < os.nObjects);
|
|
if (os.pdoi != NULL && os.n < os.nObjects)
|
|
os.pdoi[os.n++] = *lpddoi;
|
|
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
// This is a special EnumObjects() callback for keyboard type devices. When we enumerate, dwOfs
|
|
// member of lpddoi is meaningless. We need to take the middle 16 bits of dwType as dwOfs
|
|
// (also same as DIK_xxx).
|
|
BOOL CALLBACK FillDIKeyboardDeviceObject(LPCDIDEVICEOBJECTINSTANCEW lpddoi, LPVOID pvRef)
|
|
{
|
|
if (pvRef == NULL || lpddoi == NULL || IsObjectOnExcludeList(lpddoi->dwOfs))
|
|
return DIENUM_CONTINUE;
|
|
|
|
DIDEVOBJSTRUCT &os = *((DIDEVOBJSTRUCT *)pvRef);
|
|
assert(os.pdoi != NULL);
|
|
assert(os.n < os.nObjects);
|
|
if (os.pdoi != NULL && os.n < os.nObjects)
|
|
{
|
|
os.pdoi[os.n] = *lpddoi;
|
|
os.pdoi[os.n].dwOfs = os.pdoi[os.n].dwType >> 8;
|
|
wcscpy(os.pdoi[os.n].tszName, lpddoi->tszName);
|
|
++os.n;
|
|
}
|
|
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
HRESULT FillDIDeviceObjectStruct(DIDEVOBJSTRUCT &os, LPDIRECTINPUTDEVICE8W pDID)
|
|
{
|
|
if (pDID == NULL)
|
|
return E_FAIL;
|
|
|
|
DIDEVICEINSTANCEW didi;
|
|
didi.dwSize = sizeof(didi);
|
|
pDID->GetDeviceInfo(&didi);
|
|
|
|
HRESULT hr;
|
|
if (LOBYTE(didi.dwDevType) == DI8DEVTYPE_KEYBOARD)
|
|
hr = pDID->EnumObjects(KeyboardIncrementValPerObject, &os.nObjects,
|
|
DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV);
|
|
else
|
|
hr = pDID->EnumObjects(IncrementValPerObject, &os.nObjects,
|
|
DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV);
|
|
if (FAILED(hr))
|
|
{
|
|
os.nObjects = 0;
|
|
return hr;
|
|
}
|
|
|
|
if (os.nObjects == 0)
|
|
return S_OK;
|
|
|
|
if (os.pdoi != NULL)
|
|
free(os.pdoi);
|
|
os.pdoi = (DIDEVICEOBJECTINSTANCEW *)malloc(sizeof(DIDEVICEOBJECTINSTANCEW) * os.nObjects);
|
|
if (os.pdoi == NULL)
|
|
{
|
|
os.nObjects = 0;
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Check if this device is a keyboard. If so, it needs special treatment.
|
|
os.n = 0;
|
|
if ((didi.dwDevType & 0xFF) == DI8DEVTYPE_KEYBOARD)
|
|
{
|
|
hr = pDID->EnumObjects(FillDIKeyboardDeviceObject, &os,
|
|
DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV);
|
|
} else {
|
|
hr = pDID->EnumObjects(FillDIDeviceObject, &os,
|
|
DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
os.nObjects = 0;
|
|
return hr;
|
|
}
|
|
|
|
assert(os.nObjects == os.n);
|
|
os.nObjects = os.n;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
LPTSTR AllocConfigureFlagStr(DWORD dwFlags)
|
|
{
|
|
static const AFS_FLAG flag[] = {
|
|
#define f(F) { F, _T(#F) }
|
|
f(DICD_EDIT), f(DICD_DEFAULT)
|
|
#undef f
|
|
};
|
|
static const int flags = sizeof(flag) / sizeof(AFS_FLAG);
|
|
return AllocFlagStr(dwFlags, flag, flags);
|
|
}
|
|
|
|
LPTSTR AllocActionFlagStr(DWORD dwFlags)
|
|
{
|
|
static const AFS_FLAG flag[] = {
|
|
#define f(F) { F, _T(#F) }
|
|
f(DIA_FORCEFEEDBACK),
|
|
f(DIA_APPMAPPED),
|
|
f(DIA_APPNOMAP),
|
|
f(DIA_NORANGE),
|
|
#undef f
|
|
}; static const int flags = sizeof(flag) / sizeof(AFS_FLAG);
|
|
return AllocFlagStr(dwFlags, flag, flags);
|
|
}
|
|
|
|
LPTSTR AllocActionHowFlagStr(DWORD dwFlags)
|
|
{
|
|
static const AFS_FLAG flag[] = {
|
|
#define f(F) { F, _T(#F) }
|
|
f(DIAH_UNMAPPED),
|
|
f(DIAH_USERCONFIG),
|
|
f(DIAH_APPREQUESTED),
|
|
f(DIAH_HWAPP),
|
|
f(DIAH_HWDEFAULT),
|
|
f(DIAH_DEFAULT),
|
|
f(DIAH_ERROR)
|
|
#undef f
|
|
}; static const int flags = sizeof(flag) / sizeof(AFS_FLAG);
|
|
return AllocFlagStr(dwFlags, flag, flags);
|
|
}
|
|
|
|
void CleanupActionFormatCopy(DIACTIONFORMATW &c)
|
|
{
|
|
if (c.rgoAction != NULL)
|
|
{
|
|
for (DWORD i = 0; i < c.dwNumActions; i++)
|
|
if (c.rgoAction[i].lptszActionName != NULL)
|
|
free((LPTSTR)c.rgoAction[i].lptszActionName);
|
|
free(c.rgoAction);
|
|
}
|
|
c.rgoAction = NULL;
|
|
}
|
|
|
|
HRESULT CopyActionFormat(DIACTIONFORMATW &to, const DIACTIONFORMATW &from)
|
|
{
|
|
DWORD i;
|
|
|
|
// copy all simple members
|
|
to = from;
|
|
|
|
// null copied pointers since we're going to duplicate them (makes sure cleanup works)
|
|
to.rgoAction = NULL;
|
|
|
|
// handle pointers/arrays/strings
|
|
to.rgoAction = new DIACTIONW [to.dwNumActions];
|
|
if (to.rgoAction == NULL)
|
|
goto fail;
|
|
|
|
// first null it all
|
|
memset(to.rgoAction, 0, sizeof(DIACTIONW) * to.dwNumActions);
|
|
|
|
// now copy...
|
|
for (i = 0; i < to.dwNumActions; i++)
|
|
{
|
|
// copy simple members
|
|
to.rgoAction[i] = from.rgoAction[i];
|
|
|
|
// handle pointers/arrays/strings
|
|
to.rgoAction[i].lptszActionName = _wcsdup(from.rgoAction[i].lptszActionName);
|
|
if (to.rgoAction[i].lptszActionName == NULL)
|
|
goto fail;
|
|
}
|
|
|
|
return S_OK;
|
|
fail:
|
|
CleanupActionFormatCopy(to);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
LPDIACTIONFORMATW DupActionFormat(LPCDIACTIONFORMATW lpAcFor)
|
|
{
|
|
if (!lpAcFor)
|
|
return NULL;
|
|
|
|
LPDIACTIONFORMATW pdup = new DIACTIONFORMATW;
|
|
if (!pdup)
|
|
return NULL;
|
|
|
|
if (FAILED(CopyActionFormat(*pdup, *lpAcFor)))
|
|
{
|
|
delete pdup;
|
|
return NULL;
|
|
}
|
|
|
|
return pdup;
|
|
}
|
|
|
|
void FreeActionFormatDup(LPDIACTIONFORMATW &lpAcFor)
|
|
{
|
|
if (!lpAcFor)
|
|
return;
|
|
|
|
CleanupActionFormatCopy(*lpAcFor);
|
|
delete lpAcFor;
|
|
lpAcFor = NULL;
|
|
}
|
|
|
|
void TraceActionFormat(LPTSTR header, const DIACTIONFORMATW &acf)
|
|
{
|
|
#ifdef CFGUI__TRACE_ACTION_FORMATS
|
|
tracescope(a, header);
|
|
trace(_T("\n"));
|
|
|
|
traceDWORD(acf.dwSize);
|
|
traceDWORD(acf.dwActionSize);
|
|
traceDWORD(acf.dwDataSize);
|
|
traceDWORD(acf.dwNumActions);
|
|
{tracescope(b, _T("acf.rgoAction Array\n"));
|
|
for (DWORD i = 0; i < acf.dwNumActions; i++)
|
|
{
|
|
const DIACTIONW &a = acf.rgoAction[i];
|
|
static TCHAR buf[MAX_PATH];
|
|
_stprintf(buf, _T("Action %d\n"), i);
|
|
{tracescope(c, buf);
|
|
traceHEX(a.uAppData);
|
|
traceDWORD(a.dwSemantic);
|
|
LPTSTR str = AllocActionFlagStr(a.dwFlags);
|
|
trace1(_T("a.dwFlags = %s\n"), str);
|
|
free(str);
|
|
traceWSTR(a.lptszActionName);
|
|
traceUINT(a.uResIdString);
|
|
traceDWORD(a.dwObjID);
|
|
traceGUID(a.guidInstance);
|
|
str = AllocActionHowFlagStr(a.dwHow);
|
|
trace1(_T("a.dwHow = %s\n"), str);
|
|
free(str);
|
|
}
|
|
}
|
|
}
|
|
traceGUID(acf.guidActionMap);
|
|
traceDWORD(acf.dwGenre);
|
|
traceDWORD(acf.dwBufferSize);
|
|
traceLONG(acf.lAxisMin);
|
|
traceLONG(acf.lAxisMax);
|
|
traceHEX(acf.hInstString);
|
|
traceHEX(acf.dwCRC);
|
|
traceWSTR(acf.tszActionMap);
|
|
#endif
|
|
}
|
|
|
|
BOOL IsZeroOrInvalidColorSet(const DICOLORSET &cs)
|
|
{
|
|
if (cs.dwSize < sizeof(DICOLORSET))
|
|
return TRUE;
|
|
|
|
const int colors = 8;
|
|
D3DCOLOR color[colors] = {
|
|
cs.cTextFore,
|
|
cs.cTextHighlight,
|
|
cs.cCalloutLine,
|
|
cs.cCalloutHighlight,
|
|
cs.cBorder,
|
|
cs.cControlFill,
|
|
cs.cHighlightFill,
|
|
cs.cAreaFill
|
|
};
|
|
|
|
for (int i = 0; i < colors; i++)
|
|
if (color[i])
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// D3DCOLOR2COLORREF swaps the blue and red components since GDI and D3D store RGB in the opposite order.
|
|
// It also removes the alpha component as the GDI doesn't use that, and including it causes incorrect color.
|
|
COLORREF D3DCOLOR2COLORREF(D3DCOLOR c)
|
|
{
|
|
LPBYTE pC = (LPBYTE)&c;
|
|
|
|
return (COLORREF)((DWORD(*pC) << 16) + (DWORD(*(pC+1)) << 8) + DWORD(*(pC+2)));
|
|
}
|