mirror of
https://github.com/arehnman/yttrium-virtio-gpu.git
synced 2026-10-31 02:05:04 +00:00
408 lines
11 KiB
C++
408 lines
11 KiB
C++
#include "StdAfx.h"
|
|
#include "RegParam.h"
|
|
|
|
#define REG_PATH_DELIMITER TEXT("\\")
|
|
|
|
#define REG_DEV_PARAMS_KNAME TEXT("Ndi\\Params")
|
|
|
|
#define REG_PARAM_DESC_VNAME TEXT("ParamDesc")
|
|
#define REG_PARAM_DEFAULT_VNAME TEXT("Default")
|
|
#define REG_PARAM_TYPE_VNAME TEXT("Type")
|
|
#define REG_PARAM_OPT_VNAME TEXT("Optional")
|
|
|
|
#define REG_PARAM_ENUM_VALUES_KNAME TEXT("Enum")
|
|
|
|
#define REG_PARAM_NUM_TYPE_MIN_VNAME TEXT("Min")
|
|
#define REG_PARAM_NUM_TYPE_MAX_VNAME TEXT("Max")
|
|
#define REG_PARAM_NUM_TYPE_STEP_VNAME TEXT("Step")
|
|
|
|
#define REG_PARAM_EDIT_TYPE_LIM_VNAME TEXT("LimitText")
|
|
#define REG_PARAM_EDIT_TYPE_UCASE_VNAME TEXT("UpperCase")
|
|
|
|
#define REG_PARAM_INFO_DELIMITER TEXT("-----------------------------------------------------")
|
|
#define REG_PARAM_INFO_IDENT TEXT(" ")
|
|
|
|
static const LPCTSTR RegParamTypes[] =
|
|
{
|
|
TEXT("enum"),
|
|
TEXT("int"),
|
|
TEXT("long"),
|
|
TEXT("edit")
|
|
};
|
|
|
|
static BOOL ReadStringDWord(neTKVMRegAccess &DevParamsRegKey,
|
|
LPCTSTR lpzValueName,
|
|
LPDWORD lpdwValue,
|
|
LPCTSTR lpzSubKey)
|
|
{
|
|
BOOL bRes = FALSE;
|
|
TCHAR tcaBuf[DEFAULT_REG_ENTRY_DATA_LEN];
|
|
|
|
bRes = (DevParamsRegKey.ReadString(lpzValueName, tcaBuf, TBUF_SIZEOF(tcaBuf), lpzSubKey) != 0);
|
|
if (bRes == TRUE)
|
|
{
|
|
LPTSTR lpPos = NULL;
|
|
DWORD dwVal = _tcstoul(tcaBuf, &lpPos, 0);
|
|
|
|
if (*lpPos != 0)
|
|
{
|
|
throw neTKVMRegParamBadRegistryException();
|
|
}
|
|
|
|
*lpdwValue = dwVal;
|
|
}
|
|
|
|
return bRes;
|
|
}
|
|
|
|
|
|
static DWORD ReadStringDWord(neTKVMRegAccess &DevParamsRegKey,
|
|
LPCTSTR lpzValueName,
|
|
DWORD dwDefault,
|
|
LPCTSTR lpzSubKey)
|
|
{
|
|
DWORD dwRes = 0;
|
|
return ReadStringDWord(DevParamsRegKey, lpzValueName, &dwRes, lpzSubKey)?dwRes:dwDefault;
|
|
}
|
|
|
|
neTKVMRegParamType neTKVMRegParam::GetType(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
{
|
|
neTKVMRegParamType eRes = NETKVM_RTT_UNKNOWN;
|
|
TCHAR tcaBuf[DEFAULT_REG_ENTRY_DATA_LEN];
|
|
tstring ParamRegSubKey(REG_DEV_PARAMS_KNAME);
|
|
|
|
if (pszName == NULL)
|
|
{
|
|
throw neTKVMRegParamBadNameException();
|
|
}
|
|
|
|
ParamRegSubKey += REG_PATH_DELIMITER;
|
|
ParamRegSubKey += pszName;
|
|
|
|
if (DevParamsRegKey.ReadString(REG_PARAM_TYPE_VNAME, tcaBuf, TBUF_SIZEOF(tcaBuf), ParamRegSubKey.c_str()) != 0)
|
|
{
|
|
for (int i = 0; i < ARRAY_SIZE(RegParamTypes); i++)
|
|
{
|
|
if (_tcsicmp(tcaBuf, RegParamTypes[i]) == 0)
|
|
{
|
|
eRes = (neTKVMRegParamType)i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return eRes;
|
|
}
|
|
|
|
neTKVMRegParam *neTKVMRegParam::GetParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
{
|
|
neTKVMRegParam *Param = NULL;
|
|
neTKVMRegParamType eParamType = neTKVMRegParam::GetType(DevParamsRegKey, pszName);
|
|
switch (eParamType)
|
|
{
|
|
case NETKVM_RTT_ENUM:
|
|
Param = new neTKVMRegEnumParam(DevParamsRegKey, pszName);
|
|
break;
|
|
case NETKVM_RTT_INT:
|
|
Param = new neTKVMRegIntParam(DevParamsRegKey, pszName);
|
|
break;
|
|
case NETKVM_RTT_LONG:
|
|
Param = new neTKVMRegLongParam(DevParamsRegKey, pszName);
|
|
break;
|
|
case NETKVM_RTT_EDIT:
|
|
Param = new neTKVMRegEditParam(DevParamsRegKey, pszName);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (Param)
|
|
{
|
|
Param->Load();
|
|
|
|
if (Param->ValidateValue(Param->GetValue().c_str()) == false)
|
|
{
|
|
delete Param;
|
|
throw neTKVMRegParamBadRegistryException();
|
|
}
|
|
}
|
|
|
|
return Param;
|
|
}
|
|
|
|
neTKVMRegParam *neTKVMRegParam::GetParam(neTKVMRegAccess &DevParamsRegKey, DWORD dwIndex)
|
|
{
|
|
neTKVMRegParam *Param = NULL;
|
|
TCHAR tcaBuf[DEFAULT_REG_ENTRY_DATA_LEN];
|
|
|
|
if (DevParamsRegKey.ReadKeyName(tcaBuf,
|
|
TBUF_SIZEOF(tcaBuf),
|
|
dwIndex,
|
|
REG_DEV_PARAMS_KNAME) == TRUE)
|
|
{
|
|
Param = neTKVMRegParam::GetParam(DevParamsRegKey, tcaBuf);
|
|
}
|
|
|
|
return Param;
|
|
}
|
|
|
|
neTKVMRegParam::neTKVMRegParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: m_bOptional(false), m_DevParamsRegKey(DevParamsRegKey), m_ParamRegSubKey(REG_DEV_PARAMS_KNAME)
|
|
{
|
|
if (pszName)
|
|
{
|
|
m_Name = pszName;
|
|
}
|
|
|
|
if (m_Name.empty())
|
|
{
|
|
throw neTKVMRegParamBadNameException();
|
|
}
|
|
|
|
m_ParamRegSubKey += REG_PATH_DELIMITER;
|
|
m_ParamRegSubKey += pszName;
|
|
}
|
|
|
|
|
|
neTKVMRegParam::~neTKVMRegParam(void)
|
|
{
|
|
|
|
}
|
|
|
|
void neTKVMRegParam::Load(void)
|
|
{
|
|
TCHAR tcaBuf[DEFAULT_REG_ENTRY_DATA_LEN];
|
|
DWORD dwRes;
|
|
|
|
if (GetType(m_DevParamsRegKey, m_Name.c_str()) != GetType())
|
|
{
|
|
throw neTKVMRegParamBadTypeException();
|
|
}
|
|
|
|
m_bOptional = ReadStringDWord(m_DevParamsRegKey, REG_PARAM_OPT_VNAME, (DWORD)false, m_ParamRegSubKey.c_str())?true:false;
|
|
|
|
// Read Value
|
|
dwRes = m_DevParamsRegKey.ReadString(m_Name.c_str(), tcaBuf, TBUF_SIZEOF(tcaBuf));
|
|
if (dwRes == 0)
|
|
{ // There's no value => Read Default
|
|
dwRes = m_DevParamsRegKey.ReadString(REG_PARAM_DEFAULT_VNAME, tcaBuf, TBUF_SIZEOF(tcaBuf), m_ParamRegSubKey.c_str());
|
|
}
|
|
|
|
if (dwRes != 0)
|
|
{
|
|
SetValue(tcaBuf);
|
|
}
|
|
else if (m_bOptional == false)
|
|
{
|
|
throw neTKVMRegParamBadRegistryException();
|
|
}
|
|
|
|
if (m_DevParamsRegKey.ReadString(REG_PARAM_DESC_VNAME, tcaBuf, TBUF_SIZEOF(tcaBuf), m_ParamRegSubKey.c_str()) != 0)
|
|
{
|
|
SetDescription(tcaBuf);
|
|
}
|
|
}
|
|
|
|
bool neTKVMRegParam::Save(void)
|
|
{
|
|
return (m_DevParamsRegKey.WriteString(m_Name.c_str(), m_Value.c_str()) == TRUE)?true:false;
|
|
}
|
|
|
|
void neTKVMRegParam::FillExInfo(neTKVMRegParamExInfoList &ExInfoList)
|
|
{
|
|
ExInfoList.clear();
|
|
}
|
|
|
|
neTKVMRegEnumParam::neTKVMRegEnumParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: neTKVMRegParam(DevParamsRegKey, pszName)
|
|
{
|
|
|
|
}
|
|
|
|
bool neTKVMRegEnumParam::ValidateValue(LPCTSTR pszValue)
|
|
{
|
|
bool bRes = false;
|
|
neTKVMTStrList::iterator i;
|
|
|
|
for (i = m_Values.begin(); bRes == false && i != m_Values.end(); i++)
|
|
{
|
|
bRes = _tcsicmp((*i).c_str(), pszValue) == 0;
|
|
}
|
|
|
|
return bRes;
|
|
}
|
|
|
|
void neTKVMRegEnumParam::Load(void)
|
|
{
|
|
DWORD dwI = 0;
|
|
TCHAR tcaBuf[DEFAULT_REG_ENTRY_DATA_LEN];
|
|
tstring EnumValuesSubKey = m_ParamRegSubKey + REG_PATH_DELIMITER + REG_PARAM_ENUM_VALUES_KNAME;
|
|
|
|
neTKVMRegParam::Load();
|
|
|
|
while (m_DevParamsRegKey.ReadValueName(tcaBuf, TBUF_SIZEOF(tcaBuf), dwI++, EnumValuesSubKey.c_str()))
|
|
{
|
|
tstring EnumVName(tcaBuf);
|
|
m_Values.push_back(EnumVName);
|
|
if (m_DevParamsRegKey.ReadString(EnumVName.c_str(), tcaBuf, TBUF_SIZEOF(tcaBuf), EnumValuesSubKey.c_str()) == 0)
|
|
{
|
|
throw neTKVMRegParamBadRegistryException();
|
|
}
|
|
|
|
m_ValueDescs.push_back(tcaBuf);
|
|
}
|
|
}
|
|
void neTKVMRegEnumParam::FillExInfo(neTKVMRegParamExInfoList &ExInfoList)
|
|
{
|
|
neTKVMTStrList::iterator i;
|
|
neTKVMTStrList::iterator j;
|
|
|
|
neTKVMRegParam::FillExInfo(ExInfoList);
|
|
|
|
for (i = m_Values.begin(), j = m_ValueDescs.begin();
|
|
i!= m_Values.end() && j != m_ValueDescs.end();
|
|
i++, j++)
|
|
{
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_ENUM_VALUE, *i));
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_ENUM_VALUE_DESC, *j));
|
|
}
|
|
}
|
|
|
|
template <class INT_T>
|
|
neTKVMRegNumParam<INT_T>::neTKVMRegNumParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: m_nMin(0), m_nMax((INT_T)-1), m_nStep(0), neTKVMRegParam(DevParamsRegKey, pszName)
|
|
{
|
|
|
|
}
|
|
|
|
template <class INT_T>
|
|
neTKVMRegNumParam<INT_T>::~neTKVMRegNumParam()
|
|
{
|
|
|
|
}
|
|
|
|
template <class INT_T>
|
|
bool neTKVMRegNumParam<INT_T>::ValidateValue(LPCTSTR pszValue)
|
|
{
|
|
bool bRes = false;
|
|
|
|
if (pszValue)
|
|
{
|
|
LPTSTR psTmp = NULL;
|
|
INT_T nValue = _tcstol(pszValue, &psTmp, 0);
|
|
|
|
if (*psTmp == 0 && nValue >= m_nMin && nValue <= m_nMax)
|
|
{
|
|
bRes = (((nValue - m_nMin) % m_nStep) == 0);
|
|
}
|
|
}
|
|
|
|
return bRes;
|
|
}
|
|
|
|
template <class INT_T>
|
|
void neTKVMRegNumParam<INT_T>::Load(void)
|
|
{
|
|
neTKVMRegParam::Load();
|
|
|
|
m_nMin = (INT_T)ReadStringDWord(m_DevParamsRegKey, REG_PARAM_NUM_TYPE_MIN_VNAME, (DWORD)0, m_ParamRegSubKey.c_str());
|
|
m_nMax = (INT_T)ReadStringDWord(m_DevParamsRegKey, REG_PARAM_NUM_TYPE_MAX_VNAME, (DWORD)-1, m_ParamRegSubKey.c_str());
|
|
m_nStep = (INT_T)ReadStringDWord(m_DevParamsRegKey, REG_PARAM_NUM_TYPE_STEP_VNAME, (DWORD)1, m_ParamRegSubKey.c_str());
|
|
}
|
|
|
|
template <class INT_T>
|
|
void neTKVMRegNumParam<INT_T>::FillExInfo(neTKVMRegParamExInfoList &ExInfoList)
|
|
{
|
|
tstringstream tss;
|
|
|
|
neTKVMRegParam::FillExInfo(ExInfoList);
|
|
|
|
tss << m_nMin;
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_NUM_MIN, tss.str()));
|
|
|
|
tss.str(tstring());
|
|
tss << m_nMax;
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_NUM_MAX, tss.str()));
|
|
|
|
tss.str(tstring());
|
|
tss << m_nStep;
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_NUM_STEP, tss.str()));
|
|
}
|
|
|
|
neTKVMRegIntParam::neTKVMRegIntParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: neTKVMRegNumParam<unsigned int>(DevParamsRegKey, pszName)
|
|
{
|
|
|
|
}
|
|
|
|
neTKVMRegLongParam::neTKVMRegLongParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: neTKVMRegNumParam<unsigned long>(DevParamsRegKey, pszName)
|
|
{
|
|
|
|
}
|
|
|
|
neTKVMRegEditParam::neTKVMRegEditParam(neTKVMRegAccess &DevParamsRegKey, LPCTSTR pszName)
|
|
: m_nLimitText(0), m_bUpperCase(false), neTKVMRegParam(DevParamsRegKey, pszName)
|
|
{
|
|
|
|
}
|
|
|
|
bool neTKVMRegEditParam::ValidateValue(LPCTSTR pszValue)
|
|
{
|
|
bool bRes = false;
|
|
|
|
if (pszValue == NULL)
|
|
{
|
|
goto End;
|
|
}
|
|
|
|
if (m_nLimitText && _tcslen(pszValue) > m_nLimitText)
|
|
{
|
|
goto End;
|
|
}
|
|
|
|
if (m_bUpperCase)
|
|
{
|
|
while (*pszValue)
|
|
{
|
|
if (!_istupper(*pszValue))
|
|
{
|
|
goto End;
|
|
}
|
|
pszValue++;
|
|
}
|
|
}
|
|
|
|
bRes = true;
|
|
|
|
End:
|
|
return bRes;
|
|
}
|
|
|
|
void neTKVMRegEditParam::Load(void)
|
|
{
|
|
neTKVMRegParam::Load();
|
|
|
|
m_nLimitText = ReadStringDWord(m_DevParamsRegKey, REG_PARAM_EDIT_TYPE_LIM_VNAME, m_nLimitText, m_ParamRegSubKey.c_str());
|
|
m_bUpperCase = ReadStringDWord(m_DevParamsRegKey, REG_PARAM_EDIT_TYPE_UCASE_VNAME, (DWORD)false, m_ParamRegSubKey.c_str())?true:false;
|
|
}
|
|
|
|
void neTKVMRegEditParam::FillExInfo(neTKVMRegParamExInfoList &ExInfoList)
|
|
{
|
|
tstringstream tss;
|
|
|
|
neTKVMRegParam::FillExInfo(ExInfoList);
|
|
|
|
tss << m_bUpperCase;
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_EDIT_UPPER_CASE, tss.str()));
|
|
|
|
if (m_nLimitText)
|
|
{
|
|
tss.str(tstring());
|
|
tss << m_nLimitText;
|
|
ExInfoList.push_back(neTKVMRegParamExInfo(NETKVM_RPIID_EDIT_TEXT_LIMIT, tss.str()));
|
|
}
|
|
}
|
|
|
|
|