//
// Save
// ====
//
// Save the information for this object to the AuditDataFile
//
bool CLocaleScanner::SaveData (CAuditDataFile* pAuditDataFile)
{
CLogFile log;
log.Write("CLocaleScanner::SaveData Start" ,true);
CString strValue;
// Add the Category for memory
CAuditDataFileCategory category(HARDWARE_CLASS);
// Each audited item gets added an a CAuditDataFileItem to the category
CAuditDataFileItem l1(V_LOCALE_CODEPAGE ,m_iCodePage);
CAuditDataFileItem l2(V_LOCALE_CALENDARTYPE ,m_strCalendarType);
CAuditDataFileItem l3(V_LOCALE_COUNTRY ,m_strCountry);
CAuditDataFileItem l4(V_LOCALE_COUNTRYCODE ,m_iCountryCode);
CAuditDataFileItem l5(V_LOCALE_CURRENCY ,m_strCurrency);
CAuditDataFileItem l6(V_LOCALE_DATEFORMAT ,m_strDateFormat);
CAuditDataFileItem l7(V_LOCALE_LANGUAGE ,m_strLanguage);
CAuditDataFileItem l8(V_LOCALE_LOCALLANGUAGE ,m_strLocaleLocalLanguage);
CAuditDataFileItem l9(V_LOCALE_OEM_CODEPAGE ,m_iOEMCodePage);
CAuditDataFileItem l10(V_LOCALE_TIMEFORMAT ,m_strTimeFormat);
CAuditDataFileItem l11(V_LOCALE_TIMEFORMATSPECIFIER ,m_strTimeFormatSpecifier);
CAuditDataFileItem l12(V_LOCALE_TIMEZONE ,m_strLocaleTimeZone);
// Add the items to the category
category.AddItem(l1);
category.AddItem(l2);
category.AddItem(l3);
category.AddItem(l4);
category.AddItem(l5);
category.AddItem(l6);
category.AddItem(l7);
category.AddItem(l8);
category.AddItem(l9);
category.AddItem(l10);
category.AddItem(l11);
category.AddItem(l12);
// ...and add the category to the AuditDataFile
pAuditDataFile->AddAuditDataFileItem(category);
// we always need to get the default browser details so do here
CAuditDataFileCategory browserCategory("Internet|Browsers|Default Browser", FALSE, TRUE);
CAuditDataFileItem b1("Path", GetRegValue("HKEY_CLASSES_ROOT\\http\\shell\\open\\command", ""));
browserCategory.AddItem(b1);
pAuditDataFile->AddInternetItem(browserCategory);
log.Write("CLocaleScanner::SaveData End" ,true);
return true;
}
static void GetDriveDebugInfo9x()
{
/*
* HKEY_LOCAL_MACHINE\Enum\ESDI
* *\ (disk id)
* *\ (eg. MF&CHILD0000&PCI&VEN_8086&DEV_7111&SUBSYS_197615AD&REV_01&BUS_00&DEV_07&FUNC_0100)
* DMACurrentlyUsed 0 or 1
* DeviceDesc "GENERIC IDE DISK TYPE01"
*/
vector<CString> Drives;
if( !GetRegSubKeys( "HKEY_LOCAL_MACHINE\\Enum\\ESDI", Drives ) )
return;
for( unsigned drive = 0; drive < Drives.size(); ++drive )
{
vector<CString> IDs;
if( !GetRegSubKeys( Drives[drive], IDs ) )
continue;
for( unsigned id = 0; id < IDs.size(); ++id )
{
CString DeviceDesc;
GetRegValue( IDs[id], "DeviceDesc", DeviceDesc );
TrimRight( DeviceDesc );
int DMACurrentlyUsed = -1;
GetRegValue( IDs[id], "DMACurrentlyUsed", DMACurrentlyUsed );
LOG->Info( "Drive: \"%s\" DMA: %s",
DeviceDesc.c_str(), DMACurrentlyUsed? "yes":"NO" );
}
}
}
bool
CKNSettings::GetSettingsFromRegistry()
{
// If opening the key for reading succeeds, get the registry values for
// Server, Path, User, and Pass, and store them in their appropriate
// variables.
if(OpenKey(true))
{
if(GetRegValue("Server", m_strServer) &&
GetRegValueNum("Port", (DWORD&) m_iPort) &&
GetRegValue("Path", m_strPath) &&
GetRegValue("User", m_strUser) &&
GetRegValue("Pass", m_strPass))
{
// If getting all of the above values succeeds, close the key
CloseKey();
return true;
}
}
return false;
}
bool Vm1::cmd_add_reg_reg(DWORD reg1,DWORD reg2)
{
//printf("add reg,reg");
//прибавляем один регистр к другому
SetRegValue(reg1,GetRegValue(reg1)+GetRegValue(reg2));
return true;
}
bool Vm1::cmd_cmp_reg_reg(DWORD regs,DWORD regs2)
{
//printf("cmp reg,reg");
//сравнение двух регистров
DWORD reg1=GetRegValue(regs);
DWORD reg2=GetRegValue(regs2);
if(reg1==reg2){ reg.zero_flag=true; reg.carry_flag=false; }
if(reg1>reg2) { reg.zero_flag=false; reg.carry_flag=false; }
if(reg1<reg2) { reg.zero_flag=false; reg.carry_flag=true; }
return true;
}
bool Vm1::cmd_xor_byte_ptr_reg(DWORD reg1,DWORD reg2)
{
//printf("xor byte ptr [reg],reg2
DWORD real_addr=GetRegValue(reg1);
if(!IsValid_VirtAddrAll(real_addr,4)) return false;
real_addr=convert_addr(real_addr,true);
byte real_src=*(byte*)real_addr;
real_src^=(byte)GetRegValue(reg2);
*(byte*)real_addr=real_src;
return true;
}
static void GetDriveDebugInfoNT()
{
/*
* HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\Scsi\
* Scsi Port *\
* DMAEnabled 0 or 1
* Driver "Ultra", "atapi", etc
* Scsi Bus *\
* Target Id *\
* Logical Unit Id *\
* Identifier "WDC WD1200JB-75CRA0"
* Type "DiskPeripheral"
*/
vector<CString> Ports;
if( !GetRegSubKeys( "HKEY_LOCAL_MACHINE\\HARDWARE\\DEVICEMAP\\Scsi", Ports ) )
return;
for( unsigned i = 0; i < Ports.size(); ++i )
{
int DMAEnabled = -1;
GetRegValue( Ports[i], "DMAEnabled", DMAEnabled );
CString Driver;
GetRegValue( Ports[i], "Driver", Driver );
vector<CString> Busses;
if( !GetRegSubKeys( Ports[i], Busses, "Scsi Bus .*" ) )
continue;
for( unsigned bus = 0; bus < Busses.size(); ++bus )
{
vector<CString> TargetIDs;
if( !GetRegSubKeys( Busses[bus], TargetIDs, "Target Id .*" ) )
continue;
for( unsigned tid = 0; tid < TargetIDs.size(); ++tid )
{
vector<CString> LUIDs;
if( !GetRegSubKeys( TargetIDs[tid], LUIDs, "Logical Unit Id .*" ) )
continue;
for( unsigned luid = 0; luid < LUIDs.size(); ++luid )
{
CString Identifier;
GetRegValue( LUIDs[luid], "Identifier", Identifier );
TrimRight( Identifier );
LOG->Info( "Drive: \"%s\" Driver: %s DMA: %s",
Identifier.c_str(), Driver.c_str(), DMAEnabled == 1? "yes":DMAEnabled == -1? "N/A":"NO" );
}
}
}
}
}
bool Vm1::cmd_mov_reg_reg(DWORD regs,DWORD regs2)
{
//printf("mov reg,reg");
//записываем одно значение в другое
SetRegValue(regs,GetRegValue(regs2));
return true;
}
bool RegistryAccess::GetRegValue( const RString &sKey, const RString &sName, bool &bVal )
{
int iVal;
bool b = GetRegValue( sKey, sName, iVal );
bVal = !!iVal;
return b;
}
/* Find the list of services associated with a group name and start those
* services */
static BOOL LoadGroup(PWCHAR group_name)
{
HKEY group_hkey = NULL;
LPWSTR services = NULL;
LONG ret;
WINE_TRACE("Loading service group for %s\n", wine_dbgstr_w(group_name));
/* Lookup group_name value of svchost registry entry */
ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, svchost_path, 0,
KEY_READ, &group_hkey);
if (ret != ERROR_SUCCESS)
{
WINE_ERR("cannot open key %s, err=%d\n",
wine_dbgstr_w(svchost_path), ret);
return FALSE;
}
services = GetRegValue(group_hkey, group_name);
RegCloseKey(group_hkey);
if (!services)
{
WINE_ERR("cannot find registry value %s in %s\n",
wine_dbgstr_w(group_name), wine_dbgstr_w(svchost_path));
return FALSE;
}
/* Start services */
if (!(ret = StartGroupServices(services)))
WINE_TRACE("Failed to start service group\n");
HeapFree(GetProcessHeap(), 0, services);
return ret;
}
static
SIZE_T
GetBIOSValue(
BOOL UseSMBios,
PCHAR DmiString,
LPWSTR RegValue,
PVOID pBuf,
DWORD cchBuf,
BOOL bTrim)
{
SIZE_T Length = 0;
BOOL Result;
if (UseSMBios)
{
Length = GetSMBiosStringW(DmiString, pBuf, cchBuf, bTrim);
}
if (Length == 0)
{
Result = GetRegValue(HKEY_LOCAL_MACHINE, L"Hardware\\Description\\System\\BIOS", RegValue, REG_SZ, pBuf, cchBuf * sizeof(WCHAR));
if (Result)
{
Length = wcslen(pBuf);
}
}
return Length;
}
bool
CtrlrConfig::GetCSS(uint8_t &value)
{
bool retVal;
retVal = GetRegValue(value, CC_CSS, CC_SH_CSS);
LOG_NRM("Reading CC.CSS = 0x%02X", value);
return retVal;
}
bool
CtrlrConfig::GetEN(uint8_t &value)
{
bool retVal;
retVal = GetRegValue(value, CC_EN, CC_SH_EN);
LOG_NRM("Reading CC.EN = 0x%02X", value);
return retVal;
}
long GetInt (LPCTSTR szSection, LPCTSTR szKey,long nDefault, short prodId)
{
string szKeyName = GetRegBase (prodId) + string(_T("\\")) + szSection;
string retVal;
if(!GetRegValue (g_AppKeyHive, szKeyName.c_str(),szKey, retVal,prodId))
return nDefault;
return _ttol(retVal.c_str());
}
bool
CtrlrConfig::GetIOSQES(uint8_t &value)
{
bool retVal;
retVal = GetRegValue(value, CC_IOSQES, CC_SH_IOSQES);
LOG_NRM("Reading CC.IOSQES = 0x%02X; (2^%d) = %d", value, value,
(1 << value));
return retVal;
}
bool Vm1::cmd_mod_reg_imm(DWORD reg1,DWORD imm)
{
//printf("mod reg,reg");
//остаток от деления
DWORD regs1=GetRegValue(reg1);
regs1 = regs1 % imm;
SetRegValue(reg1,regs1);
return true;
}
static
BOOL
GetDirectXVersion(WCHAR * szBuffer)
{
WCHAR szVer[20];
if (!GetRegValue(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\DirectX", L"Version", REG_SZ, szVer, sizeof(szVer)))
return FALSE;
if(!wcscmp(szVer, L"4.02.0095"))
wcscpy(szBuffer, L"1.0");
else if (!wcscmp(szVer, L"4.03.00.1096"))
wcscpy(szBuffer, L"2.0");
else if (!wcscmp(szVer, L"4.04.0068"))
wcscpy(szBuffer, L"3.0");
else if (!wcscmp(szVer, L"4.04.0069"))
wcscpy(szBuffer, L"3.0");
else if (!wcscmp(szVer, L"4.05.00.0155"))
wcscpy(szBuffer, L"5.0");
else if (!wcscmp(szVer, L"4.05.01.1721"))
wcscpy(szBuffer, L"5.0");
else if (!wcscmp(szVer, L"4.05.01.1998"))
wcscpy(szBuffer, L"5.0");
else if (!wcscmp(szVer, L"4.06.02.0436"))
wcscpy(szBuffer, L"6.0");
else if (!wcscmp(szVer, L"4.07.00.0700"))
wcscpy(szBuffer, L"7.0");
else if (!wcscmp(szVer, L"4.07.00.0716"))
wcscpy(szBuffer, L"7.0a");
else if (!wcscmp(szVer, L"4.08.00.0400"))
wcscpy(szBuffer, L"8.0");
else if (!wcscmp(szVer, L"4.08.01.0881"))
wcscpy(szBuffer, L"8.1");
else if (!wcscmp(szVer, L"4.08.01.0810"))
wcscpy(szBuffer, L"8.1");
else if (!wcscmp(szVer, L"4.09.0000.0900"))
wcscpy(szBuffer, L"9.0");
else if (!wcscmp(szVer, L"4.09.00.0900"))
wcscpy(szBuffer, L"9.0");
else if (!wcscmp(szVer, L"4.09.0000.0901"))
wcscpy(szBuffer, L"9.0a");
else if (!wcscmp(szVer, L"4.09.00.0901"))
wcscpy(szBuffer, L"9.0a");
else if (!wcscmp(szVer, L"4.09.0000.0902"))
wcscpy(szBuffer, L"9.0b");
else if (!wcscmp(szVer, L"4.09.00.0902"))
wcscpy(szBuffer, L"9.0b");
else if (!wcscmp(szVer, L"4.09.00.0904"))
wcscpy(szBuffer, L"9.0c");
else if (!wcscmp(szVer, L"4.09.0000.0904"))
wcscpy(szBuffer, L"9.0c");
else
return FALSE;
return TRUE;
}
bool Vm1::cmd_mov_reg_ptr_reg(DWORD reg1,DWORD reg2)
{
//printf("mov reg,byte ptr [reg]");
DWORD real_addr=GetRegValue(reg2);
if(!IsValid_VirtAddrAll(real_addr,4)) return false;
real_addr=convert_addr(real_addr,true);
byte real_src=*(byte*)real_addr;
SetRegValue(reg1,real_src);
return true;
}
bool Vm1::cmd_shl_reg_reg(DWORD reg1,DWORD reg2)
{
//printf("shl reg,reg");
//побитовое смещение
DWORD regs1=GetRegValue(reg1);
DWORD regs2=reg2;
regs1 = regs1 << regs2;
SetRegValue(reg1,regs1);
return true;
}
DWORD Utility::GetRegValue(HKEY hKeyHandle, LPCTSTR lpSubkey, LPCTSTR lpRegName, int &nRegvalue)
{
CString strRegValue;
DWORD dwRet;
dwRet = GetRegValue(hKeyHandle, lpSubkey, lpRegName, strRegValue);
if( dwRet != ERROR_SUCCESS )
{
return dwRet;
}
nRegvalue = _ttoi(strRegValue);
return dwRet;
}
/******************************************************************************
Handles InitDialog
******************************************************************************/
BOOL PBDlg::OnInitDialog()
{
//Initializes the Dialog
CDialog::OnInitDialog();
//Loads the Icon
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
//Sets the Icons
SetIcon(m_hIcon, TRUE);
SetIcon(m_hIcon, FALSE);
//Sets up dialog with registry entries
CString temp;
temp = GetRegValue(L"OLDVERSION", L"0");
PBDlg::SetDlgItemText(IDC_OLD_VERSION, temp);
temp = GetRegValue(L"CURRENTVERSION", L"1");
PBDlg::SetDlgItemText(IDC_CURRENT_VERSION, temp);
temp = GetRegValue(L"INSTALLERVERSION", L"0");
PBDlg::SetDlgItemText(IDC_INSTALLER_VERSION, temp);
temp = GetRegValue(L"OLDDIRECTORY", L"");
PBDlg::SetDlgItemText(IDC_OLD_DIRECTORY, temp);
temp = GetRegValue(L"CURRENTDIRECTORY", L"");
PBDlg::SetDlgItemText(IDC_CURRENT_DIRECTORY, temp);
temp = GetRegValue(L"UPDATERDIRECTORY", L"");
PBDlg::SetDlgItemText(IDC_UPDATER_DIRECTORY, temp);
temp = GetRegValue(L"OUTPUTDIRECTORY", L"");
PBDlg::SetDlgItemText(IDC_OUTPUT_FOLDER, temp);
temp = GetRegValue(L"INSTALLERDIRECTORY", L"");
PBDlg::SetDlgItemText(IDC_INSTALLER_DIRECTORY, temp);
//Sets checked states of appropriate check boxes
PBDlg::CheckDlgButton(IDC_DEFAULT_PATH, TRUE);
PBDlg::OnClickedDefaultPath();
PBDlg::CheckDlgButton(IDC_DEFAULT_VERSION, TRUE);
PBDlg::OnClickedDefaultVersion();
PBDlg::CheckDlgButton(IDC_IGNORE_ATTRIBUTES, TRUE);
PBDlg::CheckDlgButton(IDC_IGNORE_FILE_TIME, TRUE);
PBDlg::CheckDlgButton(IDC_IGNORE_VERSION, TRUE);
PBDlg::CheckDlgButton(IDC_IGNORE_READ_ONLY, TRUE);
//Returns Success
return TRUE;
}
char *GetRegValueString( const char *key_name, const char *value_name )
{
DWORD type;
DWORD data_length;
char *data = GetRegValue( key_name, value_name, type, data_length );
if( data )
{
if( type == REG_SZ )
{
return data;
}
free(data);
}
return NULL;
}
BOOL CSerialPDD::Init()
{
InitialPower(TRUE);
if (m_PowerCallbackThread == NULL) {
m_PowerCallbackThread = new CSerialPDDPowerUpCallback(this);
if ( m_PowerCallbackThread && !m_PowerCallbackThread->Init()){
delete m_PowerCallbackThread;
m_PowerCallbackThread = NULL;
}
}
m_PowerHelperHandle = DDKPwr_Initialize(SetPowerStateStatic, (DWORD)this , TRUE, 1000 );
if (!GetRegValue( SERIAL_RX_BUFFER_SIZE, (LPBYTE)&m_ulRxBufferSize,sizeof(m_ulRxBufferSize))) {
m_ulRxBufferSize = 0 ;
}
return (IsKeyOpened() && m_PowerCallbackThread!=NULL && m_PowerHelperHandle!=INVALID_HANDLE_VALUE );
}
string GetString (LPCTSTR szSection, LPCTSTR szKey,LPCTSTR szDefault, short prodId)
{
string szKeyName;
if (szSection != NULL)
{
szKeyName = GetRegBase (prodId) + string(_T("\\")) + szSection;
}
else
{
szKeyName = GetRegBase(prodId);
}
string retVal;
if(!GetRegValue (g_AppKeyHive, szKeyName.c_str(), szKey, retVal,prodId))
return szDefault;
return retVal;
}
bool GetRegValueInteger( const char *key_name, const char *value_name, DWORD &value )
{
DWORD type;
DWORD data_length;
char *data = GetRegValue( key_name, value_name, type, data_length );
if( data )
{
if( type == REG_DWORD && data_length == sizeof( DWORD ) )
{
memcpy( &value, data, data_length );
return true;
}
free(data);
}
return false;
}
///////////////////////////////////////////////////////////
//обработчики опкодов
///////////////////////////////////////////////////////////
bool Vm1::cmd_push(DWORD regs)
{
//printf("push",regs);
//засунем в стек данные
//проверим выход за пределы стека
//возврат false - крушение стека!
if(IsValid_VirtAddr(reg.esp,4,&mem.stack)) return false;
DWORD real_addr=convert_addr(reg.esp,true);
if(real_addr)
{
*(DWORD*)real_addr=GetRegValue(regs);
reg.esp+=sizeof(DWORD);
return true;
}
return false;
}
CSerialPDD::CSerialPDD(LPTSTR lpActivePath, PVOID pMdd, PHWOBJ pHwObj )
: CRegistryEdit(lpActivePath)
, m_pMdd(pMdd)
, m_pHwObj(pHwObj)
{
m_hParent = CreateBusAccessHandle(lpActivePath);
m_PowerHelperHandle = INVALID_HANDLE_VALUE;
m_hPowerLock = NULL;
// Initial Open Count.
m_lOpenCount = 0;
m_ulCommErrors = 0;
m_PowerCallbackThread = NULL;
m_ulRxBufferSize = 0;
memset(&m_PowerCapabilities,0,sizeof(m_PowerCapabilities));
if (!GetRegValue(PC_REG_SERIALPRIORITY_VAL_NAME,(LPBYTE)&m_dwPriority256,sizeof(DWORD))) {
m_dwPriority256 = DEFAULT_CE_THREAD_PRIORITY+55;
}
}
BOOL ShowSelectHomeDlg(LPSTR path)
{
int i;
OPENFILENAME ofn;
ofn.lpstrFile = GetEnvValue("GNUPGHOME");
if ( ofn.lpstrFile && existsPath(ofn.lpstrFile) ) {
strcpy(path, ofn.lpstrFile);
return TRUE;
}
ofn.lpstrFile = GetRegValue(HKEY_CURRENT_USER,"Software\\GNU\\GnuPG","HomeDir");
if ( ofn.lpstrFile && existsPath(ofn.lpstrFile) ) {
strcpy(path, ofn.lpstrFile);
return TRUE;
}
ofn.lpstrFile = GetEnvValue("APPDATA");
if ( ofn.lpstrFile ) {
strcat(ofn.lpstrFile,"\\gnupg");
if ( existsPath(ofn.lpstrFile) ) {
strcpy(path, ofn.lpstrFile);
return TRUE;
}
}
ofn.lStructSize = sizeof(ofn);
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_NONETWORKBUTTON;
ofn.lpstrFile = path;
ofn.lpstrFilter = "Public key rings (pubring.gpg)\0pubring.gpg\0All files (*.*)\0*.*\0";
ofn.lpstrTitle = "Open Public Keyring";
if (!GetOpenFileName(&ofn)) return FALSE;
for(i=strlen(path);i && path[i]!='\\';i--);
path[i] = 0;
return TRUE;
}
BOOL CPdd6410Uart::Init()
{
BOOL bRet = TRUE;
if ( CSerialPDD::Init() && IsKeyOpened() && m_XmitFlushDone!=NULL)
{
// IST Setup .
DDKISRINFO ddi;
if (GetIsrInfo(&ddi)!=ERROR_SUCCESS)
{
bRet = FALSE;
goto CleanUp;
}
m_dwSysIntr = ddi.dwSysintr;
if (m_dwSysIntr != MAXDWORD && m_dwSysIntr!=0 )
{
m_hISTEvent= CreateEvent(0,FALSE,FALSE,NULL);
}
if (m_hISTEvent!=NULL)
{
InterruptInitialize(m_dwSysIntr,m_hISTEvent,0,0);
}
else
{
bRet = FALSE;
goto CleanUp;
}
// Get Device Index.
if (!GetRegValue(PC_REG_DEVINDEX_VAL_NAME, (PBYTE)&m_dwDevIndex, PC_REG_DEVINDEX_VAL_LEN))
{
m_dwDevIndex = 0;
}
if (!GetRegValue(PC_REG_SERIALWATERMARK_VAL_NAME,(PBYTE)&m_dwWaterMark,PC_REG_SERIALWATERMARKER_VAL_LEN))
{
m_dwWaterMark = DEFAULT_VALUE_WATER_MARK;
}
if (!GetRegValue(PC_REG_6410UART_IST_TIMEOUTS_VAL_NAME,(PBYTE)&m_dwISTTimeout, PC_REG_6410UART_IST_TIMEOUTS_VAL_LEN))
{
m_dwISTTimeout = INFINITE;
}
if (!GetRegValue(PC_REG_6410UART_MEM_LENGTH_VAL_NAME, (PBYTE)&m_dwMemLen, PC_REG_6410UART_MEM_LENGTH_VAL_LEN))
{
m_dwMemLen = DEFAULT_VALUE_MEM_LENGH;
}
if (!MapHardware() || !CreateHardwareAccess())
{
bRet = FALSE;
goto CleanUp;
}
#ifdef USE_DMA
if (!GetRegValue(PC_REG_TX_DMA_EN_NAME,(PBYTE)&m_dwTXDMAEnable, sizeof(DWORD)))
{
m_dwTXDMAEnable = FALSE;
}
if(m_dwTXDMAEnable)
{
RETAILMSG(1, (L"[UART] DMA init CH:%d \r\n", m_dwDevIndex));
InitializeDMA(m_dwDevIndex);
}
#endif
bRet = TRUE;
goto CleanUp;
}
bRet = FALSE;
CleanUp:
return bRet;
}
static
BOOL
InitializeDialog(HWND hwndDlg, PDISPLAY_DEVICEW pDispDevice)
{
WCHAR szText[100];
WCHAR szFormat[30];
HKEY hKey;
HWND hDlgCtrls[5];
DWORD dwMemory;
DEVMODEW DevMode;
IDirect3D9 * ppObj = NULL;
D3DADAPTER_IDENTIFIER9 Identifier;
HRESULT hResult;
szText[0] = L'\0';
/* fix wine */
//ppObj = Direct3DCreate9(D3D_SDK_VERSION);
if (ppObj)
{
hResult = IDirect3D9_GetAdapterIdentifier(ppObj, D3DADAPTER_DEFAULT , 2/*D3DENUM_WHQL_LEVEL*/, &Identifier);
if (hResult == D3D_OK)
{
if (Identifier.WHQLLevel)
{
/* adapter is WHQL certified */
LoadStringW(hInst, IDS_OPTION_YES, szText, sizeof(szText)/sizeof(WCHAR));
}
else
{
LoadStringW(hInst, IDS_OPTION_NO, szText, sizeof(szText)/sizeof(WCHAR));
}
}
IDirect3D9_Release(ppObj);
}
else
{
LoadStringW(hInst, IDS_DEVICE_STATUS_UNKNOWN, szText, sizeof(szText)/sizeof(WCHAR));
}
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_LOGO, WM_SETTEXT, 0, (LPARAM)szText);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, &pDispDevice->DeviceKey[18], 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return FALSE;
if (GetRegValue(hKey, NULL, L"HardwareInformation.ChipType", REG_BINARY, szText, sizeof(szText)))
{
/* set chip type */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_CHIP, WM_SETTEXT, 0, (LPARAM)szText);
}
if (GetRegValue(hKey, NULL, L"HardwareInformation.DacType", REG_BINARY, szText, sizeof(szText)))
{
/* set DAC type */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_DAC, WM_SETTEXT, 0, (LPARAM)szText);
}
if (GetRegValue(hKey, NULL, L"HardwareInformation.MemorySize", REG_BINARY, (LPWSTR)&dwMemory, sizeof(dwMemory)))
{
/* set chip memory size */
if (dwMemory > (1048576))
{
/* buggy ATI driver requires that */
dwMemory /= 1048576;
}
szFormat[0] = L'\0';
if (LoadStringW(hInst, IDS_FORMAT_ADAPTER_MEM, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
szFormat[(sizeof(szFormat)/sizeof(WCHAR))-1] = L'\0';
wsprintfW(szText, szFormat, dwMemory);
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MEM, WM_SETTEXT, 0, (LPARAM)szText);
}
/* retrieve current display mode */
DevMode.dmSize = sizeof(DEVMODEW);
if (EnumDisplaySettingsW(pDispDevice->DeviceName, ENUM_CURRENT_SETTINGS, &DevMode))
{
szFormat[0] = L'\0';
if (LoadStringW(hInst, IDS_FORMAT_ADAPTER_MODE, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
szFormat[(sizeof(szFormat)/sizeof(WCHAR))-1] = L'\0';
wsprintfW(szText, szFormat, DevMode.dmPelsWidth, DevMode.dmPelsHeight, DevMode.dmBitsPerPel, DevMode.dmDisplayFrequency);
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MODE, WM_SETTEXT, 0, (LPARAM)szText);
}
/* query attached monitor */
wcscpy(szText, pDispDevice->DeviceName);
ZeroMemory(pDispDevice, sizeof(DISPLAY_DEVICEW));
pDispDevice->cb = sizeof(DISPLAY_DEVICEW);
if (EnumDisplayDevicesW(szText, 0, pDispDevice, 0))
{
/* set monitor name */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MONITOR, WM_SETTEXT, 0, (LPARAM)pDispDevice->DeviceString);
}
hDlgCtrls[0] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_ID);
hDlgCtrls[1] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_VENDOR);
hDlgCtrls[2] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_DRIVER);
hDlgCtrls[3] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_VERSION);
hDlgCtrls[4] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_DATE);
SetDeviceDetails(hDlgCtrls, &GUID_DEVCLASS_DISPLAY, NULL);
return TRUE;
}