2571 lines
74 KiB
C++
2571 lines
74 KiB
C++
/****************************************************************************
|
|
* *
|
|
* Project64 - A Nintendo 64 emulator. *
|
|
* http://www.pj64-emu.com/ *
|
|
* Copyright (C) 2012 Project64. All rights reserved. *
|
|
* *
|
|
* License: *
|
|
* GNU/GPLv2 http://www.gnu.org/licenses/gpl-2.0.html *
|
|
* *
|
|
****************************************************************************/
|
|
#include "stdafx.h"
|
|
#include "DebuggerUI.h"
|
|
#include "MemoryScanner.h"
|
|
|
|
CDebugMemorySearch* CDebugMemorySearch::_this = NULL;
|
|
HHOOK CDebugMemorySearch::hWinMessageHook = NULL;
|
|
|
|
const CSetValueDlg::ComboItem CDebugMemorySearch::ModalChangeTypeItems[] = {
|
|
{ "uint8", ValueType_uint8 },
|
|
{ "int8", ValueType_int8 },
|
|
{ "uint16", ValueType_uint16 },
|
|
{ "int16", ValueType_int16 },
|
|
{ "uint32", ValueType_uint32 },
|
|
{ "int32", ValueType_int32 },
|
|
{ "uint64", ValueType_uint64 },
|
|
{ "int64", ValueType_int64 },
|
|
{ "float", ValueType_float },
|
|
{ "double", ValueType_double },
|
|
{ "string", ValueType_string },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
CDebugMemorySearch::CDebugMemorySearch(CDebuggerUI * debugger) :
|
|
CDebugDialog<CDebugMemorySearch>(debugger)
|
|
{
|
|
}
|
|
|
|
CDebugMemorySearch::~CDebugMemorySearch()
|
|
{
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
DlgSavePos_Init(DebuggerUI_MemorySearchPos);
|
|
DlgResize_Init(false, true);
|
|
|
|
m_HexCheckbox.Attach(GetDlgItem(IDC_CHK_HEX));
|
|
m_UnsignedCheckbox.Attach(GetDlgItem(IDC_CHK_UNSIGNED));
|
|
m_IgnoreCaseCheckbox.Attach(GetDlgItem(IDC_CHK_IGNORECASE));
|
|
m_UnkEncodingCheckbox.Attach(GetDlgItem(IDC_CHK_UNKENCODING));
|
|
m_SearchValue.Attach(GetDlgItem(IDC_SEARCH_VALUE));
|
|
m_SearchTypeOptions.Attach(GetDlgItem(IDC_CMB_SCANTYPE));
|
|
m_ValueTypeOptions.Attach(GetDlgItem(IDC_CMB_VALUETYPE));
|
|
m_AddrStart.Attach(GetDlgItem(IDC_ADDR_START));
|
|
m_AddrEnd.Attach(GetDlgItem(IDC_ADDR_END));
|
|
m_PhysicalCheckbox.Attach(GetDlgItem(IDC_CHK_PHYSICAL));
|
|
m_ResultsListCtrl.Attach(GetDlgItem(IDC_LST_RESULTS));
|
|
m_ResultsScrollbar.Attach(GetDlgItem(IDC_SCRL_RESULTS));
|
|
m_WatchListCtrl.Attach(GetDlgItem(IDC_LST_WATCHLIST));
|
|
m_WatchListScrollbar.Attach(GetDlgItem(IDC_SCRL_WATCHLIST));
|
|
|
|
m_SearchValue.SetDisplayFormat(DisplayDefault);
|
|
m_AddrEnd.SetDisplayType(CEditNumber32::DisplayHex);
|
|
m_AddrStart.SetDisplayType(CEditNumber32::DisplayHex);
|
|
|
|
UpdateOptions(); // setup search type combobox
|
|
|
|
CComboBox & vtcb = m_ValueTypeOptions;
|
|
vtcb.SetItemData(vtcb.AddString("int8"), ValueType_int8);
|
|
vtcb.SetItemData(vtcb.AddString("int16"), ValueType_int16);
|
|
vtcb.SetItemData(vtcb.AddString("int32"), ValueType_int32);
|
|
vtcb.SetItemData(vtcb.AddString("int64"), ValueType_int64);
|
|
vtcb.SetItemData(vtcb.AddString("float"), ValueType_float);
|
|
vtcb.SetItemData(vtcb.AddString("double"), ValueType_double);
|
|
vtcb.SetItemData(vtcb.AddString("string"), ValueType_string);
|
|
vtcb.SetCurSel(0);
|
|
|
|
m_ResultsListCtrl.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
|
|
m_ResultsListCtrl.ModifyStyle(LVS_OWNERDRAWFIXED, 0, 0);
|
|
m_ResultsListCtrl.AddColumn("Address", ResultsListCtrl_Col_Address);
|
|
m_ResultsListCtrl.AddColumn("Value", ResultsListCtrl_Col_Value);
|
|
m_ResultsListCtrl.AddColumn("Previous", ResultsListCtrl_Col_Previous);
|
|
m_ResultsListCtrl.SetColumnWidth(ResultsListCtrl_Col_Address, 80);
|
|
m_ResultsListCtrl.SetColumnWidth(ResultsListCtrl_Col_Value, 80);
|
|
m_ResultsListCtrl.SetColumnWidth(ResultsListCtrl_Col_Previous, 80);
|
|
|
|
m_WatchListCtrl.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
|
|
m_WatchListCtrl.ModifyStyle(LVS_OWNERDRAWFIXED, 0, 0);
|
|
m_WatchListCtrl.AddColumn("Lock", WatchListCtrl_Col_Lock);
|
|
m_WatchListCtrl.AddColumn("BP", WatchListCtrl_Col_BP);
|
|
m_WatchListCtrl.AddColumn("Address", WatchListCtrl_Col_Address);
|
|
m_WatchListCtrl.AddColumn("Description", WatchListCtrl_Col_Description);
|
|
m_WatchListCtrl.AddColumn("Type", WatchListCtrl_Col_Type);
|
|
m_WatchListCtrl.AddColumn("Value", WatchListCtrl_Col_Value);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_Lock, 35);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_BP, 35);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_Address, 80);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_Description, 160);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_Type, 50);
|
|
m_WatchListCtrl.SetColumnWidth(WatchListCtrl_Col_Value, 90);
|
|
|
|
m_bJalSelected = false;
|
|
m_bJalHexWasChecked = false;
|
|
m_bJalUnsignedWasChecked = false;
|
|
|
|
m_bDraggingSeparator = false;
|
|
::GetWindowRect(GetDlgItem(IDC_SEPARATOR), &m_InitialSeparatorRect);
|
|
ScreenToClient(&m_InitialSeparatorRect);
|
|
|
|
uint32_t ramSize = (g_MMU != NULL) ? g_MMU->RdramSize() : 0x00400000;
|
|
|
|
m_AddrStart.SetValue(0x80000000, true, true);
|
|
m_AddrEnd.SetValue(0x80000000 + ramSize - 1, true, true);
|
|
|
|
FixListHeader(m_WatchListCtrl);
|
|
FixListHeader(m_ResultsListCtrl);
|
|
|
|
UpdateResultsList(true);
|
|
UpdateWatchList();
|
|
|
|
LoadWindowPos();
|
|
WindowCreated();
|
|
|
|
m_hCursorSizeNS = LoadCursor(NULL, IDC_SIZENS);
|
|
|
|
SetTimer(TIMER_ID_AUTO_REFRESH, 100, NULL);
|
|
|
|
_this = this;
|
|
m_ThreadId = ::GetCurrentThreadId();
|
|
hWinMessageHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)HookProc, NULL, m_ThreadId);
|
|
|
|
GameReset();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnDestroy(void)
|
|
{
|
|
UnhookWindowsHookEx(hWinMessageHook);
|
|
KillTimer(TIMER_ID_AUTO_REFRESH);
|
|
|
|
m_UnsignedCheckbox.Detach();
|
|
m_IgnoreCaseCheckbox.Detach();
|
|
m_UnkEncodingCheckbox.Detach();
|
|
m_HexCheckbox.Detach();
|
|
m_SearchValue.Detach();
|
|
m_SearchTypeOptions.Detach();
|
|
m_ValueTypeOptions.Detach();
|
|
m_AddrStart.Detach();
|
|
m_AddrEnd.Detach();
|
|
m_PhysicalCheckbox.Detach();
|
|
m_ResultsListCtrl.Detach();
|
|
m_ResultsScrollbar.Detach();
|
|
m_WatchListCtrl.Detach();
|
|
m_WatchListScrollbar.Detach();
|
|
return 0;
|
|
}
|
|
|
|
void CDebugMemorySearch::GameReset(void)
|
|
{
|
|
if (m_hWnd == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SendMessage(WM_GAMERESET);
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnGameReset(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
ReloadWatchList();
|
|
return FALSE;
|
|
}
|
|
|
|
void CDebugMemorySearch::ReloadWatchList(void)
|
|
{
|
|
stdstr strGame = g_Settings->LoadStringVal(Game_GameName);
|
|
|
|
FlushWatchList();
|
|
|
|
if (m_StrGame != strGame)
|
|
{
|
|
m_StrGame = strGame;
|
|
LoadWatchList();
|
|
}
|
|
}
|
|
|
|
void CDebugMemorySearch::OnTimer(UINT_PTR nIDEvent)
|
|
{
|
|
if (nIDEvent == TIMER_ID_AUTO_REFRESH)
|
|
{
|
|
RefreshResultsListValues();
|
|
RefreshWatchListValues();
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK CDebugMemorySearch::HookProc(int nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
MSG *pMsg = (MSG*)lParam;
|
|
|
|
switch (pMsg->message)
|
|
{
|
|
case WM_MOUSEWHEEL:
|
|
_this->OnInterceptMouseWheel(pMsg->wParam, pMsg->lParam);
|
|
break;
|
|
case WM_MOUSEMOVE:
|
|
_this->OnInterceptMouseMove(pMsg->wParam, pMsg->lParam);
|
|
break;
|
|
}
|
|
|
|
if (nCode < 0)
|
|
{
|
|
return CallNextHookEx(hWinMessageHook, nCode, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CDebugMemorySearch::OnExitSizeMove(void)
|
|
{
|
|
UpdateWatchList(true);
|
|
SaveWindowPos(true);
|
|
}
|
|
|
|
void CDebugMemorySearch::OnSizing(UINT /*fwSide*/, LPRECT /*pRect*/)
|
|
{
|
|
FixListHeader(m_WatchListCtrl);
|
|
FixListHeader(m_ResultsListCtrl);
|
|
SetMsgHandled(FALSE);
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnCancel(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
EndDialog(0);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnHexCheckbox(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
bool bChecked = (m_HexCheckbox.GetCheck() == BST_CHECKED);
|
|
m_SearchValue.SetDisplayFormat(bChecked ? DisplayHex : DisplayDefault);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnSearchButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
|
|
Search();
|
|
// emulator won't resume sometimes unless there's a sleep() here
|
|
Sleep(50); // todo fix?
|
|
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResetButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
ResetResults();
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnScanTypeChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
SearchType searchType = (SearchType)m_SearchTypeOptions.GetItemData(m_SearchTypeOptions.GetCurSel());
|
|
|
|
bool bDidFirstScan = m_MemoryScanner.DidFirstScan();
|
|
|
|
if (searchType == SearchType_JalTo)
|
|
{
|
|
m_bJalSelected = true;
|
|
m_SearchValue.EnableWindow(TRUE);
|
|
|
|
SetComboBoxSelByData(m_ValueTypeOptions, ValueType_int32);
|
|
m_ValueTypeOptions.EnableWindow(FALSE);
|
|
|
|
// remember checkbox states
|
|
m_bJalHexWasChecked = (m_HexCheckbox.GetCheck() == BST_CHECKED);
|
|
m_bJalUnsignedWasChecked = (m_UnsignedCheckbox.GetCheck() == BST_CHECKED);
|
|
|
|
m_SearchValue.SetDisplayFormat(DisplayHex);
|
|
|
|
m_HexCheckbox.SetCheck(BST_CHECKED);
|
|
m_HexCheckbox.EnableWindow(FALSE);
|
|
m_UnsignedCheckbox.SetCheck(BST_CHECKED);
|
|
m_UnsignedCheckbox.EnableWindow(FALSE);
|
|
}
|
|
else if(m_bJalSelected)
|
|
{
|
|
m_bJalSelected = false;
|
|
m_SearchValue.SetDisplayFormat(m_bJalHexWasChecked ? DisplayHex : DisplayDefault);
|
|
m_HexCheckbox.SetCheck(m_bJalHexWasChecked ? BST_CHECKED : BST_UNCHECKED);
|
|
m_HexCheckbox.EnableWindow(TRUE);
|
|
m_UnsignedCheckbox.SetCheck(m_bJalUnsignedWasChecked ? BST_CHECKED : BST_UNCHECKED);
|
|
m_UnsignedCheckbox.EnableWindow(TRUE);
|
|
}
|
|
|
|
switch (searchType)
|
|
{
|
|
case SearchType_JalTo:
|
|
break;
|
|
case SearchType_UnknownValue:
|
|
case SearchType_IncreasedValue:
|
|
case SearchType_DecreasedValue:
|
|
case SearchType_ChangedValue:
|
|
case SearchType_UnchangedValue:
|
|
m_ValueTypeOptions.EnableWindow(!bDidFirstScan);
|
|
m_SearchValue.EnableWindow(FALSE);
|
|
break;
|
|
default:
|
|
m_ValueTypeOptions.EnableWindow(!bDidFirstScan);
|
|
m_SearchValue.EnableWindow(TRUE);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnValueTypeChanged(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
ValueType valueType = (ValueType)m_ValueTypeOptions.GetItemData(m_ValueTypeOptions.GetCurSel());
|
|
|
|
if (valueType == ValueType_string || valueType == ValueType_istring || valueType == ValueType_unkstring)
|
|
{
|
|
m_SearchValue.EnableWindow(TRUE);
|
|
SetComboBoxSelByData(m_SearchTypeOptions, SearchType_ExactValue);
|
|
m_SearchTypeOptions.EnableWindow(FALSE);
|
|
|
|
m_UnkEncodingCheckbox.ShowWindow(SW_SHOW);
|
|
m_IgnoreCaseCheckbox.ShowWindow(SW_SHOW);
|
|
m_UnsignedCheckbox.ShowWindow(SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
bool bShowUnsigned = (valueType != ValueType_float && valueType != ValueType_double);
|
|
m_UnsignedCheckbox.ShowWindow(bShowUnsigned ? SW_SHOW : SW_HIDE);
|
|
|
|
m_UnkEncodingCheckbox.ShowWindow(SW_HIDE);
|
|
m_IgnoreCaseCheckbox.ShowWindow(SW_HIDE);
|
|
|
|
m_SearchTypeOptions.EnableWindow(TRUE);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnRdramButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
bool bPhysicalChecked = (m_PhysicalCheckbox.GetCheck() == BST_CHECKED);
|
|
uint32_t addrStart = bPhysicalChecked ? 0 : 0x80000000;
|
|
uint32_t ramSize = (g_MMU != NULL) ? g_MMU->RdramSize() : 0x00400000;
|
|
m_AddrStart.SetValue(addrStart, true, true);
|
|
m_AddrEnd.SetValue(addrStart + ramSize - 1, true, true);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnRomButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
bool bPhysicalChecked = (m_PhysicalCheckbox.GetCheck() == BST_CHECKED);
|
|
uint32_t addrStart = bPhysicalChecked ? 0x10000000 : 0xB0000000;
|
|
m_AddrStart.SetValue(addrStart, true, true);
|
|
m_AddrEnd.SetValue(addrStart + g_Rom->GetRomSize() - 1, true, true);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnSpmemButton(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
bool bPhysicalChecked = (m_PhysicalCheckbox.GetCheck() == BST_CHECKED);
|
|
uint32_t addrStart = bPhysicalChecked ? 0x04000000 : 0xA4000000;
|
|
m_AddrStart.SetValue(addrStart, true, true);
|
|
m_AddrEnd.SetValue(addrStart + 0x1FFF, true, true);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsCustomDraw(LPNMHDR lpnmh)
|
|
{
|
|
NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(lpnmh);
|
|
DWORD drawStage = pLVCD->nmcd.dwDrawStage;
|
|
|
|
switch (drawStage)
|
|
{
|
|
case CDDS_PREPAINT: return (CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT);
|
|
case CDDS_ITEMPREPAINT: return CDRF_NOTIFYSUBITEMDRAW;
|
|
case (CDDS_ITEMPREPAINT | CDDS_SUBITEM): break;
|
|
default: return CDRF_DODEFAULT;
|
|
}
|
|
|
|
uint32_t nItem = (uint32_t)pLVCD->nmcd.dwItemSpec;
|
|
uint32_t nSubItem = pLVCD->iSubItem;
|
|
size_t index = m_ResultsListCtrl.GetItemData(nItem);
|
|
CScanResult *presult = m_MemoryScanner.GetResult(index);
|
|
|
|
switch (nSubItem)
|
|
{
|
|
case ResultsListCtrl_Col_Address:
|
|
if (presult->m_AddressType == AddressType_Physical)
|
|
{
|
|
// green if address is physical
|
|
pLVCD->clrText = RGB(0x44, 0x88, 0x44);
|
|
}
|
|
break;
|
|
case ResultsListCtrl_Col_Value:
|
|
{
|
|
pLVCD->clrText = RGB(0, 0, 0);
|
|
char szCurrentValue[1024], szOldValue[1024];
|
|
presult->GetMemoryValueString(szCurrentValue, 1024);
|
|
presult->GetValueString(szOldValue, 1024);
|
|
|
|
if (presult->IsStringType())
|
|
{
|
|
pLVCD->clrText = RGB(0, 0, 0);
|
|
if (presult->m_DisplayFormat == DisplayHex)
|
|
{
|
|
// blue if hex string
|
|
pLVCD->clrText = RGB(0, 0, 255);
|
|
}
|
|
}
|
|
else if (strcmp(szCurrentValue, szOldValue) != 0)
|
|
{
|
|
// red if value has changed
|
|
pLVCD->clrText = RGB(255, 0, 0);
|
|
}
|
|
}
|
|
break;
|
|
case ResultsListCtrl_Col_Previous:
|
|
pLVCD->clrText = RGB(0, 0, 0);
|
|
break;
|
|
}
|
|
|
|
return CDRF_DODEFAULT;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsDblClick(LPNMHDR)
|
|
{
|
|
LONG iItem = m_ResultsListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Copy result to watch list
|
|
int index = m_ResultsListCtrl.GetItemData(iItem);
|
|
AddResultToWatchList(index);
|
|
|
|
UpdateWatchList(true);
|
|
return true;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsRClick(LPNMHDR /*lpnmh*/)
|
|
{
|
|
LONG iItem = m_ResultsListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//Load the menu
|
|
HMENU hMenu = LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(IDR_MEM_SEARCH));
|
|
HMENU hPopupMenu = GetSubMenu(hMenu, 0);
|
|
|
|
//Get the current Mouse location
|
|
POINT Mouse;
|
|
GetCursorPos(&Mouse);
|
|
|
|
//Show the menu
|
|
TrackPopupMenu(hPopupMenu, 0, Mouse.x, Mouse.y, 0, m_hWnd, NULL);
|
|
DestroyMenu(hMenu);
|
|
return true;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsPopupViewMemory(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* presult = GetFirstSelectedScanResult();
|
|
|
|
if (presult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
bool bUseVaddr = (presult->m_AddressType == AddressType_Virtual);
|
|
m_Debugger->Debug_ShowMemoryLocation(presult->m_Address, bUseVaddr);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsPopupAddToWatchList(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
LONG iItem = -1;
|
|
|
|
while ((iItem = m_ResultsListCtrl.GetNextItem(iItem, LVNI_SELECTED)) != -1)
|
|
{
|
|
int index = m_ResultsListCtrl.GetItemData(iItem);
|
|
AddResultToWatchList(index);
|
|
}
|
|
|
|
UpdateWatchList(true);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsPopupAddAllToWatchList(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
size_t numResults = m_MemoryScanner.GetNumResults();
|
|
|
|
for (size_t i = 0; i < numResults; i++)
|
|
{
|
|
AddResultToWatchList(i);
|
|
}
|
|
|
|
UpdateWatchList(true);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsPopupSetValue(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedScanResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char szInitialValue[1024];
|
|
pFirstResult->GetMemoryValueString(szInitialValue, 1024);
|
|
|
|
if (m_SetValueDlg.DoModal("Change value", "New value:", szInitialValue))
|
|
{
|
|
int nItems = m_ResultsListCtrl.GetItemCount();
|
|
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_ResultsListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_ResultsListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = m_MemoryScanner.GetResult(index);
|
|
char* enteredString = m_SetValueDlg.GetEnteredString();
|
|
presult->SetMemoryValueFromString(enteredString);
|
|
m_ResultsListCtrl.SetItemText(iItem, ResultsListCtrl_Col_Value, enteredString);
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultsPopupRemove(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
int nItems = m_ResultsListCtrl.GetItemCount();
|
|
|
|
for (int iItem = nItems - 1; iItem >= 0; iItem--)
|
|
{
|
|
bool bSelected = (m_ResultsListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
size_t index = m_ResultsListCtrl.GetItemData(iItem);
|
|
m_MemoryScanner.RemoveResult(index);
|
|
}
|
|
}
|
|
|
|
UpdateResultsList(true);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListItemChanged(LPNMHDR /*lpnmh*/)
|
|
{
|
|
//LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lpnmh;
|
|
//
|
|
//bool bSelected = (pnmv->uNewState & LVNI_SELECTED) != 0;
|
|
//
|
|
//if (bSelected)
|
|
//{
|
|
// //for (size_t i = 0; i < m_WatchList.size(); i++)
|
|
// //{
|
|
// // m_WatchList[i].SetSelected(false);
|
|
// //}
|
|
//
|
|
// int iItem = pnmv->iItem;
|
|
// int index = m_WatchListCtrl.GetItemData(iItem);
|
|
// CScanResult *presult = &m_WatchList[index];
|
|
// //presult->SetSelected(bSelected);
|
|
//}
|
|
|
|
return true;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListCustomDraw(LPNMHDR lpnmh)
|
|
{
|
|
NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(lpnmh);
|
|
DWORD drawStage = pLVCD->nmcd.dwDrawStage;
|
|
|
|
switch (drawStage)
|
|
{
|
|
case CDDS_PREPAINT: return (CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT);
|
|
case CDDS_ITEMPREPAINT: return CDRF_NOTIFYSUBITEMDRAW;
|
|
case (CDDS_ITEMPREPAINT | CDDS_SUBITEM): break;
|
|
default: return CDRF_DODEFAULT;
|
|
}
|
|
|
|
uint32_t nItem = (uint32_t)pLVCD->nmcd.dwItemSpec;
|
|
uint32_t nSubItem = pLVCD->iSubItem;
|
|
size_t index = m_WatchListCtrl.GetItemData(nItem);
|
|
CScanResult *presult = &m_WatchList[index];
|
|
|
|
switch (nSubItem)
|
|
{
|
|
case WatchListCtrl_Col_Address:
|
|
if (presult->m_AddressType == AddressType_Physical)
|
|
{
|
|
// green if address is physical
|
|
pLVCD->clrText = RGB(0x44, 0x88, 0x44);
|
|
}
|
|
break;
|
|
case WatchListCtrl_Col_Value:
|
|
if (presult->IsStringType())
|
|
{
|
|
pLVCD->clrText = RGB(0, 0, 0);
|
|
if (presult->m_DisplayFormat == DisplayHex)
|
|
{
|
|
// blue if hex string
|
|
pLVCD->clrText = RGB(0, 0, 255);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
pLVCD->clrText = RGB(0, 0, 0);
|
|
break;
|
|
}
|
|
|
|
return CDRF_DODEFAULT;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListDblClick(LPNMHDR /*lpnmh*/)
|
|
{
|
|
LONG iItem = m_WatchListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult *presult = &m_WatchList[index];
|
|
|
|
int nSelectedCol = -1;
|
|
|
|
// hit test for column
|
|
|
|
POINT mousePt;
|
|
RECT listRect;
|
|
GetCursorPos(&mousePt);
|
|
m_WatchListCtrl.GetWindowRect(&listRect);
|
|
|
|
int mouseX = mousePt.x - listRect.left;
|
|
|
|
for (int nCol = 0, colX = 0; nCol < WatchListCtrl_Num_Columns; nCol++)
|
|
{
|
|
int colWidth = m_WatchListCtrl.GetColumnWidth(nCol);
|
|
if (mouseX >= colX && mouseX <= colX + colWidth)
|
|
{
|
|
nSelectedCol = nCol;
|
|
break;
|
|
}
|
|
colX += colWidth;
|
|
}
|
|
|
|
switch (nSelectedCol)
|
|
{
|
|
case WatchListCtrl_Col_Lock:
|
|
m_Debugger->Breakpoints()->ToggleMemLock(presult->m_Address);
|
|
break;
|
|
case WatchListCtrl_Col_Address:
|
|
{
|
|
if (m_SetValueDlg.DoModal("Change address", "New address:", stdstr_f("0x%08X", presult->m_Address).c_str()))
|
|
{
|
|
char* szEnteredString = m_SetValueDlg.GetEnteredString();
|
|
uint32_t newAddr = strtoul(szEnteredString, NULL, 0);
|
|
if (presult->SetAddressSafe(newAddr))
|
|
{
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Address, stdstr_f("0x%08X", newAddr).c_str());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case WatchListCtrl_Col_Value:
|
|
{
|
|
char szInitialValue[1024];
|
|
presult->GetMemoryValueString(szInitialValue, 1024);
|
|
if (m_SetValueDlg.DoModal("Change value", "New value:", szInitialValue))
|
|
{
|
|
presult->SetMemoryValueFromString(m_SetValueDlg.GetEnteredString());
|
|
}
|
|
}
|
|
break;
|
|
case WatchListCtrl_Col_Description:
|
|
{
|
|
if (m_SetValueDlg.DoModal("Set description", "New description:", presult->GetDescription()))
|
|
{
|
|
char* szEnteredString = m_SetValueDlg.GetEnteredString();
|
|
presult->SetDescription(szEnteredString);
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Description, szEnteredString);
|
|
}
|
|
}
|
|
break;
|
|
case WatchListCtrl_Col_Type:
|
|
{
|
|
if (m_SetValueDlg.DoModal("Change type", "New type:", presult->GetType(), ModalChangeTypeItems))
|
|
{
|
|
ValueType t = (ValueType) m_SetValueDlg.GetEnteredData();
|
|
presult->SetType(t);
|
|
|
|
if (t == ValueType_string)
|
|
{
|
|
if (m_SetValueDlg.DoModal("String length", "New string length:", stdstr_f("%d", presult->GetStrLength()).c_str()))
|
|
{
|
|
const char* enteredString = m_SetValueDlg.GetEnteredString();
|
|
int length = atoi(enteredString);
|
|
presult->SetStrLengthSafe(length);
|
|
}
|
|
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Type, stdstr_f("char[%d]", presult->GetStrLength()).c_str());
|
|
}
|
|
else
|
|
{
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Type, presult->GetTypeName());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListRClick(LPNMHDR /*lpnmh*/)
|
|
{
|
|
LONG iItem = m_WatchListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult *presult = &m_WatchList[index];
|
|
|
|
//Load the menu
|
|
HMENU hMenu = LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(IDR_MEM_WATCHLIST));
|
|
HMENU hPopupMenu = GetSubMenu(hMenu, 0);
|
|
|
|
//Get the current Mouse location
|
|
POINT Mouse;
|
|
GetCursorPos(&Mouse);
|
|
|
|
CBreakpoints* breakpoints = m_Debugger->Breakpoints();
|
|
|
|
bool bHaveLock = breakpoints->MemLockExists(presult->m_Address, 1);
|
|
bool bHaveReadBP = (breakpoints->ReadBPExists8(presult->m_Address) != CBreakpoints::BPSTATE::BP_NOT_SET);
|
|
bool bHaveWriteBP = (breakpoints->WriteBPExists8(presult->m_Address) != CBreakpoints::BPSTATE::BP_NOT_SET);
|
|
bool bHex = (presult->m_DisplayFormat == DisplayHex);
|
|
|
|
CheckMenuItem(hPopupMenu, ID_WATCHLIST_LOCKVALUE, bHaveLock ? MF_CHECKED : MF_UNCHECKED);
|
|
CheckMenuItem(hPopupMenu, ID_WATCHLIST_READBP, bHaveReadBP ? MF_CHECKED : MF_UNCHECKED);
|
|
CheckMenuItem(hPopupMenu, ID_WATCHLIST_WRITEBP, bHaveWriteBP ? MF_CHECKED : MF_UNCHECKED);
|
|
CheckMenuItem(hPopupMenu, ID_WATCHLIST_HEXADECIMAL, bHex ? MF_CHECKED : MF_UNCHECKED);
|
|
|
|
//Show the menu
|
|
TrackPopupMenu(hPopupMenu, 0, Mouse.x, Mouse.y, 0, m_hWnd, NULL);
|
|
DestroyMenu(hMenu);
|
|
return true;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupViewMemory(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* presult = GetFirstSelectedWatchListResult();
|
|
|
|
if (presult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
bool bUseVaddr = (presult->m_AddressType == AddressType_Virtual);
|
|
m_Debugger->Debug_ShowMemoryLocation(presult->m_Address, bUseVaddr);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupLock(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = nItems - 1; iItem >= 0; iItem--)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
m_Debugger->Breakpoints()->ToggleMemLock(presult->m_Address);
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupReadBP(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* presult = GetFirstSelectedWatchListResult();
|
|
|
|
if (presult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
m_Debugger->Breakpoints()->RBPToggle(presult->m_Address);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupWriteBP(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* presult = GetFirstSelectedWatchListResult();
|
|
|
|
if (presult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
m_Debugger->Breakpoints()->WBPToggle(presult->m_Address);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupAddSymbol(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* presult = GetFirstSelectedWatchListResult();
|
|
|
|
if (presult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// todo fix magic numbers
|
|
int nSymType = 1;
|
|
|
|
switch (presult->GetType())
|
|
{
|
|
case ValueType_uint8: nSymType = 2; break;
|
|
case ValueType_uint16: nSymType = 3; break;
|
|
case ValueType_uint32: nSymType = 4; break;
|
|
case ValueType_uint64: nSymType = 5; break;
|
|
case ValueType_int8: nSymType = 6; break;
|
|
case ValueType_int16: nSymType = 7; break;
|
|
case ValueType_int32: nSymType = 8; break;
|
|
case ValueType_int64: nSymType = 9; break;
|
|
case ValueType_float: nSymType = 10; break;
|
|
case ValueType_double: nSymType = 11; break;
|
|
}
|
|
|
|
m_AddSymbolDlg.DoModal(m_Debugger, presult->GetVirtualAddress(), nSymType);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupHexadecimal(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
|
|
if (presult->m_DisplayFormat == DisplayDefault)
|
|
{
|
|
presult->m_DisplayFormat = DisplayHex;
|
|
}
|
|
else
|
|
{
|
|
presult->m_DisplayFormat = DisplayDefault;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupChangeValue(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedWatchListResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char szPlaceholder[1024];
|
|
pFirstResult->GetMemoryValueString(szPlaceholder, 1024);
|
|
|
|
if (m_SetValueDlg.DoModal("Change value", "New value:", szPlaceholder))
|
|
{
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = nItems - 1; iItem >= 0; iItem--)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
char* enteredString = m_SetValueDlg.GetEnteredString();
|
|
// todo prompt for size change if string is too long
|
|
presult->SetMemoryValueFromString(enteredString);
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Value, enteredString);
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupChangeDescription(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedWatchListResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_SetValueDlg.DoModal("Change description", "New description:", pFirstResult->GetDescription()))
|
|
{
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
char* description = m_SetValueDlg.GetEnteredString();
|
|
presult->SetDescription(description);
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Description, description);
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupChangeType(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedWatchListResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_SetValueDlg.DoModal("Change type", "New type:", pFirstResult->GetType(), ModalChangeTypeItems))
|
|
{
|
|
ValueType t = (ValueType)m_SetValueDlg.GetEnteredData();
|
|
int length = 0;
|
|
|
|
if (t == ValueType_string)
|
|
{
|
|
if (m_SetValueDlg.DoModal("String length", "New string length:",
|
|
stdstr_f("%d", pFirstResult->GetStrLength()).c_str()))
|
|
{
|
|
const char* enteredString = m_SetValueDlg.GetEnteredString();
|
|
length = atoi(enteredString);
|
|
|
|
if (length <= 0)
|
|
{
|
|
length = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
|
|
if (presult->IsStringType())
|
|
{
|
|
presult->SetStrLengthSafe(length);
|
|
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Type,
|
|
stdstr_f("char[%d]", presult->GetStrLength()).c_str());
|
|
}
|
|
else
|
|
{
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Type, presult->GetTypeName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupChangeAddress(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedWatchListResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_SetValueDlg.DoModal("Change address", "New address:", stdstr_f("0x%08X", pFirstResult->m_Address).c_str()))
|
|
{
|
|
char* enteredString = m_SetValueDlg.GetEnteredString();
|
|
uint32_t newAddr = strtoul(enteredString, NULL, 0);
|
|
stdstr newAddrStr = stdstr_f("0x%08X", newAddr);
|
|
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
presult->SetAddressSafe(newAddr);
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Address, newAddrStr.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupChangeAddressBy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
CScanResult* pFirstResult = GetFirstSelectedWatchListResult();
|
|
|
|
if (pFirstResult == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_SetValueDlg.DoModal("Adjust address", "Address offset (+/-):", "0"))
|
|
{
|
|
char* szEnteredString = m_SetValueDlg.GetEnteredString();
|
|
int offset = atoi(szEnteredString);
|
|
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = 0; iItem < nItems; iItem++)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
uint32_t newAddr = presult->m_Address + offset;
|
|
if (presult->SetAddressSafe(newAddr))
|
|
{
|
|
stdstr newAddrStr = stdstr_f("0x%08X", presult->m_Address);
|
|
m_WatchListCtrl.SetItemText(iItem, WatchListCtrl_Col_Address, newAddrStr.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupRemove(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
RemoveSelectedWatchListItems();
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupRemoveAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
ClearWatchList();
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupCopyGamesharkCode(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
int numWatchListItems = m_WatchListCtrl.GetItemCount();
|
|
|
|
stdstr strGSCode = "";
|
|
|
|
for (int i = 0; i < numWatchListItems; i++)
|
|
{
|
|
if (m_WatchListCtrl.GetItemState(i, LVNI_SELECTED) == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
size_t index = m_WatchListCtrl.GetItemData(i);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
|
|
uint32_t vaddr = presult->GetVirtualAddress();
|
|
|
|
if (presult->IsStringType())
|
|
{
|
|
int length = presult->GetStrLength();
|
|
|
|
char str[1024];
|
|
presult->GetMemoryValueString(str, 1024, true);
|
|
|
|
bool haveOddLength = (length & 1) != 0;
|
|
int evenLength = length & ~1;
|
|
|
|
if (length >= 2)
|
|
{
|
|
for (int j = 0; j < evenLength; j += 2)
|
|
{
|
|
strGSCode += stdstr_f("%08X %02X%02X\n", (vaddr + j) | GS_TWOBYTE, (uint8_t)str[j], (uint8_t)str[j + 1]);
|
|
}
|
|
}
|
|
|
|
if (haveOddLength)
|
|
{
|
|
strGSCode += stdstr_f("%08X 00%02X\n", (vaddr + length - 1), (uint8_t)str[length - 1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMixed value;
|
|
presult->GetMemoryValue(&value);
|
|
|
|
switch (presult->GetType())
|
|
{
|
|
case ValueType_uint8:
|
|
case ValueType_int8:
|
|
strGSCode += stdstr_f("%08X 00%02X\n", vaddr, value.m_Value._uint8);
|
|
break;
|
|
case ValueType_uint16:
|
|
case ValueType_int16:
|
|
strGSCode += stdstr_f("%08X %04X\n", vaddr | GS_TWOBYTE, value.m_Value._uint16);
|
|
break;
|
|
case ValueType_uint32:
|
|
case ValueType_int32:
|
|
case ValueType_float:
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 0) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint32 >> 16));
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 2) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint32));
|
|
break;
|
|
case ValueType_uint64:
|
|
case ValueType_int64:
|
|
case ValueType_double:
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 0) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint64 >> 48));
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 2) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint64 >> 32));
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 4) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint64 >> 16));
|
|
strGSCode += stdstr_f("%08X %04X\n", (vaddr + 6) | GS_TWOBYTE, (uint16_t)(value.m_Value._uint64));
|
|
break;
|
|
default:
|
|
g_Notify->BreakPoint(__FILE__, __LINE__);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strGSCode.length() == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, strGSCode.length());
|
|
strncpy((char*)GlobalLock(hMem), strGSCode.c_str(), strGSCode.length() - 1);
|
|
GlobalUnlock(hMem);
|
|
OpenClipboard();
|
|
EmptyClipboard();
|
|
SetClipboardData(CF_TEXT, hMem);
|
|
CloseClipboard();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnWatchListPopupCopyAddressAndDescription(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
int numWatchListItems = m_WatchListCtrl.GetItemCount();
|
|
|
|
stdstr str = "";
|
|
|
|
for (int i = 0; i < numWatchListItems; i++)
|
|
{
|
|
if (m_WatchListCtrl.GetItemState(i, LVNI_SELECTED) == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
size_t index = m_WatchListCtrl.GetItemData(i);
|
|
CScanResult* presult = &m_WatchList[index];
|
|
|
|
str += stdstr_f("%08X %s\n", presult->m_Address, presult->GetDescription());
|
|
}
|
|
|
|
if (str.length() == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, str.length());
|
|
|
|
strncpy((char*)GlobalLock(hMem), str.c_str(), str.length() - 1);
|
|
GlobalUnlock(hMem);
|
|
OpenClipboard();
|
|
EmptyClipboard();
|
|
SetClipboardData(CF_TEXT, hMem);
|
|
CloseClipboard();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnSetFont(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
// set row height for the results list and watch list
|
|
CClientDC dc(m_hWnd);
|
|
dc.SelectFont((HFONT)wParam);
|
|
TEXTMETRIC tm;
|
|
dc.GetTextMetrics(&tm);
|
|
m_ListCtrlRowHeight = tm.tmHeight + tm.tmExternalLeading;
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnMeasureItem(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
|
|
{
|
|
if (wParam == IDC_LST_RESULTS || wParam == IDC_LST_WATCHLIST)
|
|
{
|
|
MEASUREITEMSTRUCT* lpMeasureItem = (MEASUREITEMSTRUCT*)lParam;
|
|
lpMeasureItem->itemHeight = m_ListCtrlRowHeight;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnScroll(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
|
|
{
|
|
WORD type = LOWORD(wParam);
|
|
HWND hScrollbar = (HWND)lParam;
|
|
WORD scrlId = (WORD)::GetDlgCtrlID(hScrollbar);
|
|
|
|
SCROLLINFO scrollInfo;
|
|
scrollInfo.cbSize = sizeof(SCROLLINFO);
|
|
scrollInfo.fMask = SIF_ALL;
|
|
|
|
::GetScrollInfo(hScrollbar, SB_CTL, &scrollInfo);
|
|
|
|
int newPos;
|
|
|
|
switch (type)
|
|
{
|
|
case SB_LINEUP:
|
|
newPos = scrollInfo.nPos - 1;
|
|
break;
|
|
case SB_LINEDOWN:
|
|
newPos = scrollInfo.nPos + 1;
|
|
break;
|
|
case SB_THUMBTRACK:
|
|
newPos = scrollInfo.nTrackPos;
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
::SetScrollPos(hScrollbar, SB_CTL, newPos, TRUE);
|
|
|
|
if (scrlId == IDC_SCRL_RESULTS)
|
|
{
|
|
UpdateResultsList();
|
|
}
|
|
else if (scrlId == IDC_SCRL_WATCHLIST)
|
|
{
|
|
UpdateWatchList();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnMouseDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
if (MouseHovering(IDC_SEPARATOR, 0, 1))
|
|
{
|
|
::GetWindowRect(GetDlgItem(IDC_SEPARATOR), &m_LastSeparatorRect);
|
|
ScreenToClient(&m_LastSeparatorRect);
|
|
m_bDraggingSeparator = true;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnMouseUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
if (m_bDraggingSeparator)
|
|
{
|
|
UpdateResultsList(true, false);
|
|
}
|
|
|
|
m_bDraggingSeparator = false;
|
|
return 0;
|
|
}
|
|
|
|
void CDebugMemorySearch::OnInterceptMouseMove(WPARAM /*wParam*/, LPARAM /*lParam*/)
|
|
{
|
|
if (MouseHovering(IDC_SEPARATOR, 0, 1) || m_bDraggingSeparator)
|
|
{
|
|
SetCursor(m_hCursorSizeNS);
|
|
}
|
|
|
|
CPoint cursorPos;
|
|
GetCursorPos(&cursorPos);
|
|
ScreenToClient(&cursorPos);
|
|
|
|
if (m_bDraggingSeparator && cursorPos.y >= m_InitialSeparatorRect.top)
|
|
{
|
|
CRect sepRect, windowRect;
|
|
int yChange = cursorPos.y - m_LastSeparatorRect.top;
|
|
|
|
// move separator
|
|
HWND hSeparator = GetDlgItem(IDC_SEPARATOR);
|
|
::GetWindowRect(hSeparator, &sepRect);
|
|
ScreenToClient(&sepRect);
|
|
::SetWindowPos(hSeparator, NULL, sepRect.left, cursorPos.y, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER);
|
|
::InvalidateRect(hSeparator, NULL, true);
|
|
|
|
// move and resize controls
|
|
SeparatorMoveCtrl(IDC_LST_WATCHLIST, yChange, false);
|
|
SeparatorMoveCtrl(IDC_SCRL_WATCHLIST, yChange, false);
|
|
SeparatorMoveCtrl(IDC_NUM_RESULTS, yChange, true);
|
|
SeparatorMoveCtrl(IDC_LST_RESULTS, yChange, true);
|
|
SeparatorMoveCtrl(IDC_SCRL_RESULTS, yChange, true);
|
|
|
|
// adjust window height
|
|
GetWindowRect(&windowRect);
|
|
windowRect.bottom += yChange;
|
|
SetWindowPos(HWND_TOP, &windowRect, SWP_NOMOVE);
|
|
|
|
// save separator pos
|
|
::GetWindowRect(hSeparator, &m_LastSeparatorRect);
|
|
ScreenToClient(&m_LastSeparatorRect);
|
|
}
|
|
}
|
|
|
|
void CDebugMemorySearch::OnInterceptMouseWheel(WPARAM wParam, LPARAM /*lParam*/)
|
|
{
|
|
int nScroll = -((short)HIWORD(wParam) / WHEEL_DELTA);
|
|
|
|
if (MouseHovering(IDC_LST_RESULTS) || MouseHovering(IDC_SCRL_RESULTS))
|
|
{
|
|
// scroll results list
|
|
int scrollPos = m_ResultsScrollbar.GetScrollPos();
|
|
m_ResultsScrollbar.SetScrollPos(scrollPos + nScroll);
|
|
UpdateResultsList();
|
|
}
|
|
else if (MouseHovering(IDC_LST_WATCHLIST) || MouseHovering(IDC_SCRL_WATCHLIST))
|
|
{
|
|
// scroll watch list
|
|
int scrollPos = m_WatchListScrollbar.GetScrollPos();
|
|
m_WatchListScrollbar.SetScrollPos(scrollPos + nScroll);
|
|
UpdateWatchList();
|
|
}
|
|
}
|
|
|
|
// util
|
|
|
|
void CDebugMemorySearch::ClearWatchList(void)
|
|
{
|
|
for (size_t i = 0; i < m_WatchList.size(); i++)
|
|
{
|
|
m_WatchList[i].DeleteDescription();
|
|
}
|
|
|
|
m_WatchList.clear();
|
|
UpdateWatchList(true);
|
|
}
|
|
|
|
void CDebugMemorySearch::RemoveWatchListItem(int index)
|
|
{
|
|
m_WatchList[index].DeleteDescription();
|
|
m_WatchList.erase(m_WatchList.begin() + index);
|
|
}
|
|
|
|
void CDebugMemorySearch::RemoveSelectedWatchListItems(void)
|
|
{
|
|
int nItems = m_WatchListCtrl.GetItemCount();
|
|
for (int iItem = nItems - 1; iItem >= 0; iItem--)
|
|
{
|
|
bool bSelected = (m_WatchListCtrl.GetItemState(iItem, LVNI_SELECTED) != 0);
|
|
|
|
if (bSelected)
|
|
{
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
RemoveWatchListItem(index);
|
|
}
|
|
}
|
|
|
|
UpdateWatchList();
|
|
}
|
|
|
|
void CDebugMemorySearch::AddResultToWatchList(int resultIndex)
|
|
{
|
|
CScanResult result = *m_MemoryScanner.GetResult(resultIndex);
|
|
m_WatchList.push_back(result);
|
|
}
|
|
|
|
CScanResult* CDebugMemorySearch::GetFirstSelectedScanResult(void)
|
|
{
|
|
LONG iItem = m_ResultsListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
|
|
if (iItem == -1)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int index = m_ResultsListCtrl.GetItemData(iItem);
|
|
CScanResult *presult = m_MemoryScanner.GetResult(index);
|
|
return presult;
|
|
}
|
|
|
|
CScanResult* CDebugMemorySearch::GetFirstSelectedWatchListResult(void)
|
|
{
|
|
LONG iItem = m_WatchListCtrl.GetNextItem(-1, LVNI_SELECTED);
|
|
|
|
if (iItem == -1)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int index = m_WatchListCtrl.GetItemData(iItem);
|
|
CScanResult *presult = &m_WatchList[index];
|
|
return presult;
|
|
}
|
|
|
|
void CDebugMemorySearch::SetComboBoxSelByData(CComboBox& cb, DWORD_PTR data)
|
|
{
|
|
int numOptions = cb.GetCount();
|
|
|
|
for (int i = 0; i < numOptions; i++)
|
|
{
|
|
if (cb.GetItemData(i) == data)
|
|
{
|
|
cb.SetCurSel(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CDebugMemorySearch::MouseHovering(WORD ctrlId, int hMargin, int vMargin)
|
|
{
|
|
CRect ctrlRect;
|
|
POINT pointerPos;
|
|
|
|
::GetCursorPos(&pointerPos);
|
|
|
|
HWND hWnd = WindowFromPoint(pointerPos);
|
|
|
|
if (hWnd != m_hWnd && ::GetDlgCtrlID(hWnd) != ctrlId)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
::GetWindowRect(GetDlgItem(ctrlId), &ctrlRect);
|
|
|
|
return (
|
|
pointerPos.x >= ctrlRect.left - hMargin &&
|
|
pointerPos.x <= ctrlRect.right + hMargin &&
|
|
pointerPos.y >= ctrlRect.top - vMargin &&
|
|
pointerPos.y <= ctrlRect.bottom + vMargin);
|
|
}
|
|
|
|
void CDebugMemorySearch::SeparatorMoveCtrl(WORD ctrlId, int yChange, bool bResize)
|
|
{
|
|
CRect rect;
|
|
HWND hControl = GetDlgItem(ctrlId);
|
|
::GetWindowRect(hControl, &rect);
|
|
ScreenToClient(&rect);
|
|
|
|
if (bResize) // resize control
|
|
{
|
|
::SetWindowPos(hControl, NULL, 0, 0, rect.Width(), rect.Height() + yChange,
|
|
SWP_NOMOVE | SWP_NOZORDER);
|
|
}
|
|
else // move control
|
|
{
|
|
::SetWindowPos(hControl, NULL, rect.left, rect.top + yChange, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER);
|
|
}
|
|
|
|
::InvalidateRect(hControl, NULL, true);
|
|
}
|
|
|
|
int CDebugMemorySearch::GetNumVisibleRows(CListViewCtrl& list)
|
|
{
|
|
CHeaderCtrl header = list.GetHeader();
|
|
CRect listRect, headRect;
|
|
list.GetWindowRect(&listRect);
|
|
header.GetWindowRect(&headRect);
|
|
int innerHeight = listRect.Height() - headRect.Height();
|
|
return (innerHeight / m_ListCtrlRowHeight);
|
|
}
|
|
|
|
void CDebugMemorySearch::ResetResults(void)
|
|
{
|
|
::SetWindowTextA(GetDlgItem(IDC_NUM_RESULTS), "Results");
|
|
m_MemoryScanner.Reset();
|
|
UpdateResultsList(true);
|
|
UpdateOptions();
|
|
}
|
|
|
|
void CDebugMemorySearch::Search(void)
|
|
{
|
|
ValueType valueType = (ValueType) m_ValueTypeOptions.GetItemData(m_ValueTypeOptions.GetCurSel());
|
|
SearchType searchType = (SearchType) m_SearchTypeOptions.GetItemData(m_SearchTypeOptions.GetCurSel());
|
|
DWORD startAddress = m_AddrStart.GetValue();
|
|
DWORD endAddress = m_AddrEnd.GetValue();
|
|
|
|
bool bHexChecked = (m_HexCheckbox.GetCheck() == BST_CHECKED);
|
|
bool bPhysicalChecked = (m_PhysicalCheckbox.GetCheck() == BST_CHECKED);
|
|
|
|
MixedValue value;
|
|
int stringValueLength;
|
|
bool bUseSearchValue;
|
|
|
|
if (valueType == ValueType_string)
|
|
{
|
|
if (m_UnkEncodingCheckbox.GetCheck() == BST_CHECKED)
|
|
{
|
|
valueType = ValueType_unkstring;
|
|
}
|
|
else if (m_IgnoreCaseCheckbox.GetCheck() == BST_CHECKED)
|
|
{
|
|
valueType = ValueType_istring;
|
|
}
|
|
}
|
|
else if (m_UnsignedCheckbox.GetCheck() == BST_CHECKED)
|
|
{
|
|
switch (valueType)
|
|
{
|
|
case ValueType_int8: valueType = ValueType_uint8; break;
|
|
case ValueType_int16: valueType = ValueType_uint16; break;
|
|
case ValueType_int32: valueType = ValueType_uint32; break;
|
|
case ValueType_int64: valueType = ValueType_uint64; break;
|
|
}
|
|
}
|
|
|
|
switch (searchType)
|
|
{
|
|
case SearchType_UnknownValue:
|
|
case SearchType_ChangedValue:
|
|
case SearchType_UnchangedValue:
|
|
case SearchType_IncreasedValue:
|
|
case SearchType_DecreasedValue:
|
|
bUseSearchValue = false;
|
|
break;
|
|
default:
|
|
bUseSearchValue = true;
|
|
m_SearchValue.SetType(valueType);
|
|
break;
|
|
}
|
|
|
|
m_MemoryScanner.SetSearchType(searchType);
|
|
m_MemoryScanner.SetValueType(valueType);
|
|
|
|
if (bUseSearchValue)
|
|
{
|
|
switch (valueType)
|
|
{
|
|
case ValueType_uint8:
|
|
if (!m_SearchValue.GetValue(value._uint8))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<uint8_t>(value._uint8);
|
|
break;
|
|
case ValueType_int8:
|
|
if (!m_SearchValue.GetValue(value._sint8))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<int8_t>(value._sint8);
|
|
break;
|
|
case ValueType_uint16:
|
|
if (!m_SearchValue.GetValue(value._uint16))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<uint16_t>(value._uint16);
|
|
break;
|
|
case ValueType_int16:
|
|
if (!m_SearchValue.GetValue(value._sint16))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<int16_t>(value._sint16);
|
|
break;
|
|
case ValueType_uint32:
|
|
if (!m_SearchValue.GetValue(value._uint32))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<uint32_t>(value._uint32);
|
|
break;
|
|
case ValueType_int32:
|
|
if (!m_SearchValue.GetValue(value._sint32))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<int32_t>(value._sint32);
|
|
break;
|
|
case ValueType_uint64:
|
|
if (!m_SearchValue.GetValue(value._uint64))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<uint64_t>(value._uint64);
|
|
break;
|
|
case ValueType_int64:
|
|
if (!m_SearchValue.GetValue(value._sint64))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<int64_t>(value._sint64);
|
|
break;
|
|
case ValueType_float:
|
|
if (!m_SearchValue.GetValue(value._float))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<float>(value._float);
|
|
break;
|
|
case ValueType_double:
|
|
if (!m_SearchValue.GetValue(value._double))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
m_MemoryScanner.SetValue<double>(value._double);
|
|
break;
|
|
case ValueType_string:
|
|
if (bHexChecked)
|
|
{
|
|
if (!m_SearchValue.GetValueHexString(value._string, stringValueLength))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!m_SearchValue.GetValueString(value._string, stringValueLength))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
}
|
|
|
|
m_MemoryScanner.SetValue<const char*>(value._string);
|
|
m_MemoryScanner.SetStringValueLength(stringValueLength);
|
|
break;
|
|
case ValueType_unkstring:
|
|
case ValueType_istring:
|
|
if (!m_SearchValue.GetValueString(value._string, stringValueLength))
|
|
{
|
|
goto value_parse_error;
|
|
}
|
|
|
|
m_MemoryScanner.SetValue<const char*>(value._string);
|
|
m_MemoryScanner.SetStringValueLength(stringValueLength);
|
|
break;
|
|
default:
|
|
MessageBox("Unimplemented value type", "Unimplemented", MB_OK);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!m_MemoryScanner.DidFirstScan())
|
|
{
|
|
m_MemoryScanner.SetAddressType(bPhysicalChecked ? AddressType_Physical : AddressType_Virtual);
|
|
bool bAddressRangeValid = m_MemoryScanner.SetAddressRange(startAddress, endAddress);
|
|
|
|
if (!bAddressRangeValid)
|
|
{
|
|
MessageBox("Invalid address range", "Invalid address range");
|
|
return;
|
|
}
|
|
|
|
m_MemoryScanner.FirstScan(m_SearchValue.GetDisplayFormat());
|
|
UpdateOptions();
|
|
}
|
|
else
|
|
{
|
|
m_MemoryScanner.NextScan();
|
|
|
|
if (m_MemoryScanner.GetNumResults() == 0)
|
|
{
|
|
UpdateOptions();
|
|
}
|
|
}
|
|
|
|
UpdateResultsList(true);
|
|
return;
|
|
|
|
value_parse_error:
|
|
MessageBox("Invalid value", "Invalid value", MB_OK);
|
|
return;
|
|
}
|
|
|
|
void CDebugMemorySearch::UpdateOptions(void)
|
|
{
|
|
bool bDidFirstScan = m_MemoryScanner.DidFirstScan();
|
|
bool bHaveResults = (m_MemoryScanner.GetNumResults() > 0);
|
|
|
|
m_ValueTypeOptions.EnableWindow(!bDidFirstScan);
|
|
::EnableWindow(GetDlgItem(IDC_BTN_RESET), bDidFirstScan);
|
|
::EnableWindow(GetDlgItem(IDC_BTN_RDRAM), !bDidFirstScan);
|
|
::EnableWindow(GetDlgItem(IDC_BTN_ROM), !bDidFirstScan);
|
|
::EnableWindow(GetDlgItem(IDC_BTN_SPMEM), !bDidFirstScan);
|
|
m_PhysicalCheckbox.EnableWindow(!bDidFirstScan);
|
|
m_AddrStart.EnableWindow(!bDidFirstScan);
|
|
m_AddrEnd.EnableWindow(!bDidFirstScan);
|
|
|
|
m_UnsignedCheckbox.EnableWindow(!bDidFirstScan);
|
|
m_IgnoreCaseCheckbox.EnableWindow(!bDidFirstScan);
|
|
m_UnkEncodingCheckbox.EnableWindow(!bDidFirstScan);
|
|
|
|
SearchType searchType = (SearchType)m_SearchTypeOptions.GetItemData(m_SearchTypeOptions.GetCurSel());
|
|
ValueType valueType = (ValueType)m_ValueTypeOptions.GetItemData(m_ValueTypeOptions.GetCurSel());
|
|
|
|
if (!bDidFirstScan)
|
|
{
|
|
m_SearchTypeOptions.EnableWindow(TRUE);
|
|
|
|
CComboBox & cb = m_SearchTypeOptions;
|
|
cb.ResetContent();
|
|
cb.SetItemData(cb.AddString("Exact value"), SearchType_ExactValue);
|
|
cb.SetItemData(cb.AddString("Unknown initial value"), SearchType_UnknownValue);
|
|
cb.SetItemData(cb.AddString("Greater than..."), SearchType_GreaterThanValue);
|
|
cb.SetItemData(cb.AddString("Less than..."), SearchType_LessThanValue);
|
|
cb.SetItemData(cb.AddString("JAL to..."), SearchType_JalTo);
|
|
cb.SetCurSel(0);
|
|
|
|
if (valueType == ValueType_string)
|
|
{
|
|
m_SearchTypeOptions.EnableWindow(false);
|
|
}
|
|
|
|
m_SearchValue.EnableWindow(TRUE);
|
|
|
|
::EnableWindow(GetDlgItem(IDC_BTN_SEARCH), true);
|
|
}
|
|
else
|
|
{
|
|
CComboBox & cb = m_SearchTypeOptions;
|
|
cb.ResetContent();
|
|
cb.SetItemData(cb.AddString("Exact value"), SearchType_ExactValue);
|
|
cb.SetItemData(cb.AddString("Changed value"), SearchType_ChangedValue);
|
|
cb.SetItemData(cb.AddString("Unchanged value"), SearchType_UnchangedValue);
|
|
cb.SetItemData(cb.AddString("Greater than..."), SearchType_GreaterThanValue);
|
|
cb.SetItemData(cb.AddString("Less than..."), SearchType_LessThanValue);
|
|
cb.SetItemData(cb.AddString("Increased value"), SearchType_IncreasedValue);
|
|
cb.SetItemData(cb.AddString("Decreased value"), SearchType_DecreasedValue);
|
|
cb.SetCurSel(0);
|
|
|
|
if (m_bJalSelected)
|
|
{
|
|
m_HexCheckbox.SetCheck(m_bJalHexWasChecked ? BST_CHECKED : BST_UNCHECKED);
|
|
m_UnsignedCheckbox.SetCheck(m_bJalUnsignedWasChecked ? BST_CHECKED : BST_UNCHECKED);
|
|
m_bJalSelected = false;
|
|
m_bJalHexWasChecked = false;
|
|
m_bJalUnsignedWasChecked = false;
|
|
}
|
|
|
|
m_HexCheckbox.EnableWindow(TRUE);
|
|
m_UnsignedCheckbox.EnableWindow(TRUE);
|
|
|
|
m_SearchValue.EnableWindow(TRUE);
|
|
|
|
if (searchType == SearchType_JalTo ||
|
|
valueType == ValueType_string ||
|
|
valueType == ValueType_istring ||
|
|
valueType == ValueType_unkstring)
|
|
{
|
|
// complex search types, disable next search
|
|
::EnableWindow(GetDlgItem(IDC_BTN_SEARCH), false);
|
|
m_SearchTypeOptions.EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
m_UnsignedCheckbox.ShowWindow(SW_SHOW);
|
|
::EnableWindow(GetDlgItem(IDC_BTN_SEARCH), bHaveResults);
|
|
m_SearchTypeOptions.EnableWindow(bHaveResults);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDebugMemorySearch::UpdateResultsList(bool bUpdateScrollbar, bool bResetScrollPos)
|
|
{
|
|
size_t numResults = m_MemoryScanner.GetNumResults();
|
|
size_t numVisibleRows = GetNumVisibleRows(m_ResultsListCtrl);
|
|
|
|
if (bUpdateScrollbar)
|
|
{
|
|
bool bCanDisplayAll = (numVisibleRows >= numResults);
|
|
int scrollRangeMax = bCanDisplayAll ? 0 : numResults - numVisibleRows;
|
|
|
|
m_ResultsScrollbar.EnableWindow(!bCanDisplayAll);
|
|
m_ResultsScrollbar.SetScrollRange(0, scrollRangeMax, false);
|
|
|
|
if (bResetScrollPos)
|
|
{
|
|
m_ResultsScrollbar.SetScrollPos(0, true);
|
|
}
|
|
}
|
|
|
|
size_t start = m_ResultsScrollbar.GetScrollPos();
|
|
size_t end = start + numVisibleRows;
|
|
|
|
if (end > numResults)
|
|
{
|
|
end = numResults;
|
|
}
|
|
|
|
m_ResultsListCtrl.SetRedraw(FALSE);
|
|
m_ResultsListCtrl.DeleteAllItems();
|
|
|
|
int nItem = 0;
|
|
|
|
for (size_t index = start; index < end; index++)
|
|
{
|
|
char szAddress[32];
|
|
char szCurrentValue[1024];
|
|
char szValue[1024];
|
|
|
|
CScanResult *presult = m_MemoryScanner.GetResult(index);
|
|
|
|
presult->GetAddressString(szAddress);
|
|
presult->GetMemoryValueString(szCurrentValue, 1024);
|
|
presult->GetValueString(szValue, 1024);
|
|
|
|
m_ResultsListCtrl.AddItem(nItem, ResultsListCtrl_Col_Address, szAddress);
|
|
m_ResultsListCtrl.SetItemText(nItem, ResultsListCtrl_Col_Value, szCurrentValue);
|
|
m_ResultsListCtrl.SetItemText(nItem, ResultsListCtrl_Col_Previous, szValue);
|
|
m_ResultsListCtrl.SetItemData(nItem, index);
|
|
|
|
nItem++;
|
|
}
|
|
|
|
m_ResultsListCtrl.SetRedraw(TRUE);
|
|
|
|
char szNumResults[32];
|
|
sprintf(szNumResults, "Results (%d)", numResults);
|
|
::SetWindowTextA(GetDlgItem(IDC_NUM_RESULTS), szNumResults);
|
|
}
|
|
|
|
void CDebugMemorySearch::UpdateWatchList(bool bUpdateScrollbar)
|
|
{
|
|
size_t numEntries = m_WatchList.size();
|
|
size_t numVisibleRows = GetNumVisibleRows(m_WatchListCtrl);
|
|
|
|
if (bUpdateScrollbar)
|
|
{
|
|
bool bCanDisplayAll = (numVisibleRows >= numEntries);
|
|
int scrollRangeMax = bCanDisplayAll ? 0 : numEntries - numVisibleRows;
|
|
|
|
m_WatchListScrollbar.SetScrollRange(0, scrollRangeMax, false);
|
|
m_WatchListScrollbar.SetScrollPos(0, true);
|
|
m_WatchListScrollbar.EnableWindow(!bCanDisplayAll);
|
|
}
|
|
|
|
size_t start = m_WatchListScrollbar.GetScrollPos();
|
|
size_t end = start + numVisibleRows;
|
|
|
|
if (end > numEntries)
|
|
{
|
|
end = numEntries;
|
|
}
|
|
|
|
m_WatchListCtrl.SetRedraw(FALSE);
|
|
m_WatchListCtrl.DeleteAllItems();
|
|
|
|
int nItem = 0;
|
|
|
|
for (size_t index = start; index < end; index++)
|
|
{
|
|
CScanResult *presult = &m_WatchList[index];
|
|
char szAddress[16];
|
|
char szValue[1024];
|
|
char szValueType[32];
|
|
const char* pSzValueType;
|
|
const char* pSzDescription;
|
|
|
|
presult->GetAddressString(szAddress);
|
|
presult->GetMemoryValueString(szValue, 1024);
|
|
pSzValueType = presult->GetTypeName();
|
|
pSzDescription = presult->GetDescription();
|
|
|
|
switch(presult->GetType())
|
|
{
|
|
case ValueType_string:
|
|
case ValueType_istring:
|
|
case ValueType_unkstring:
|
|
sprintf(szValueType, "%s[%d]", pSzValueType, presult->GetStrLength());
|
|
pSzValueType = szValueType;
|
|
break;
|
|
}
|
|
|
|
m_WatchListCtrl.AddItem(nItem, WatchListCtrl_Col_Lock, "");
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_BP, "");
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Address, szAddress);
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Description, pSzDescription);
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Type, pSzValueType);
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Value, szValue);
|
|
m_WatchListCtrl.SetItemData(nItem, index);
|
|
|
|
//if (presult->IsSelected())
|
|
//{
|
|
// m_WatchListCtrl.SetItemState(nItem, LVIS_SELECTED, LVIS_SELECTED);
|
|
//}
|
|
|
|
nItem++;
|
|
}
|
|
|
|
m_WatchListCtrl.SetRedraw(TRUE);
|
|
}
|
|
|
|
void CDebugMemorySearch::RefreshResultsListValues(void)
|
|
{
|
|
if (!g_MMU || m_bDraggingSeparator)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int numShownResults = m_ResultsListCtrl.GetItemCount();
|
|
|
|
if (numShownResults > 0)
|
|
{
|
|
m_ResultsListCtrl.SetRedraw(FALSE);
|
|
|
|
for (int nItem = 0; nItem < numShownResults; nItem++)
|
|
{
|
|
size_t index = m_ResultsListCtrl.GetItemData(nItem);
|
|
CScanResult *presult = m_MemoryScanner.GetResult(index);
|
|
|
|
if (presult == NULL)
|
|
{
|
|
g_Notify->BreakPoint(__FILE__, __LINE__);
|
|
break;
|
|
}
|
|
|
|
char szCurrentValue[1024];
|
|
presult->GetMemoryValueString(szCurrentValue, 1024);
|
|
|
|
m_ResultsListCtrl.SetItemText(nItem, ResultsListCtrl_Col_Value, szCurrentValue);
|
|
}
|
|
|
|
m_ResultsListCtrl.SetRedraw(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDebugMemorySearch::RefreshWatchListValues(void)
|
|
{
|
|
if (!g_MMU || m_bDraggingSeparator)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int numShownWatchListEntries = m_WatchListCtrl.GetItemCount();
|
|
|
|
if (numShownWatchListEntries > 0)
|
|
{
|
|
m_WatchListCtrl.SetRedraw(FALSE);
|
|
|
|
for (int nItem = 0; nItem < numShownWatchListEntries; nItem++)
|
|
{
|
|
size_t index = m_WatchListCtrl.GetItemData(nItem);
|
|
CScanResult *presult = &m_WatchList[index];
|
|
|
|
CBreakpoints *breakpoints = m_Debugger->Breakpoints();
|
|
|
|
bool bHaveLock = breakpoints->MemLockExists(presult->m_Address, 1);
|
|
bool bHaveReadBP = (breakpoints->ReadBPExists8(presult->m_Address) != CBreakpoints::BPSTATE::BP_NOT_SET);
|
|
bool bHaveWriteBP = (breakpoints->WriteBPExists8(presult->m_Address) != CBreakpoints::BPSTATE::BP_NOT_SET);
|
|
bool bHaveExecBP = (breakpoints->ExecutionBPExists(presult->m_Address) != CBreakpoints::BPSTATE::BP_NOT_SET);
|
|
|
|
char szBPStates[4];
|
|
sprintf(szBPStates, "%s%s%s",
|
|
bHaveReadBP ? "R" : "",
|
|
bHaveWriteBP ? "W" : "",
|
|
bHaveExecBP ? "E" : "");
|
|
|
|
char szCurrentValue[1024];
|
|
presult->GetMemoryValueString(szCurrentValue, 1024);
|
|
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Lock, (bHaveLock ? "X" : ""));
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_BP, szBPStates);
|
|
m_WatchListCtrl.SetItemText(nItem, WatchListCtrl_Col_Value, szCurrentValue);
|
|
}
|
|
|
|
m_WatchListCtrl.SetRedraw(TRUE);
|
|
}
|
|
}
|
|
|
|
void CDebugMemorySearch::FlushWatchList(void)
|
|
{
|
|
if (m_WatchList.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CPath wlPath = GetWatchListPath();
|
|
m_WatchListFile.Open(wlPath, CFileBase::modeCreate | CFile::modeWrite);
|
|
|
|
if (!m_WatchListFile.IsOpen())
|
|
{
|
|
return;
|
|
}
|
|
|
|
size_t numWatchListEntries = m_WatchList.size();
|
|
|
|
for (size_t i = 0; i < numWatchListEntries; i++)
|
|
{
|
|
CScanResult* presult = &m_WatchList[i];
|
|
|
|
char szValueType[32];
|
|
const char* pSzValueType;
|
|
|
|
pSzValueType = presult->GetTypeName();
|
|
|
|
switch (presult->GetType())
|
|
{
|
|
case ValueType_string:
|
|
case ValueType_istring:
|
|
case ValueType_unkstring:
|
|
sprintf(szValueType, "%s[%d]", pSzValueType, presult->GetStrLength());
|
|
pSzValueType = szValueType;
|
|
break;
|
|
}
|
|
|
|
char cAddrType = (presult->m_AddressType == AddressType_Physical) ? 'p' : 'v';
|
|
const char* szDisplayFormat = (presult->m_DisplayFormat == DisplayDefault) ? "def" : "hex";
|
|
|
|
stdstr line = stdstr_f("%c,%08X,%s,%s,%s\n",
|
|
cAddrType, presult->m_Address, pSzValueType, szDisplayFormat, presult->GetDescription());
|
|
|
|
m_WatchListFile.Write(line.c_str(), line.length());
|
|
}
|
|
|
|
m_WatchListFile.Close();
|
|
|
|
return;
|
|
}
|
|
|
|
void CDebugMemorySearch::LoadWatchList(void)
|
|
{
|
|
if (m_hWnd)
|
|
{
|
|
ClearWatchList();
|
|
}
|
|
|
|
CPath wlPath = GetWatchListPath();
|
|
m_WatchListFile.Open(wlPath, CFileBase::modeRead);
|
|
|
|
if (!m_WatchListFile.IsOpen())
|
|
{
|
|
return;
|
|
}
|
|
|
|
uint32_t length = m_WatchListFile.GetLength();
|
|
char* szWlFile = new char[length + 1];
|
|
|
|
m_WatchListFile.SeekToBegin();
|
|
m_WatchListFile.Read(szWlFile, length);
|
|
szWlFile[length] = '\0';
|
|
|
|
m_WatchListFile.Close();
|
|
|
|
char* p = szWlFile;
|
|
|
|
while (*p)
|
|
{
|
|
CScanResult result(AddressType_Virtual, DisplayDefault);
|
|
|
|
char* szAddrType, *szAddress, *szValueType, *szDisplayFormat, *szDescription;
|
|
|
|
szAddrType = p; p = strchr(p, ','); *p++ = '\0';
|
|
szAddress = p; p = strchr(p, ','); *p++ = '\0';
|
|
szValueType = p; p = strchr(p, ','); *p++ = '\0';
|
|
szDisplayFormat = p; p = strchr(p, ','); *p++ = '\0';
|
|
szDescription = p; p = strchr(p, '\n'); *p++ = '\0';
|
|
|
|
switch (szAddrType[0])
|
|
{
|
|
case 'v': result.m_AddressType = AddressType_Virtual; break;
|
|
case 'p': result.m_AddressType = AddressType_Physical; break;
|
|
default: goto parse_error;
|
|
}
|
|
|
|
uint32_t address = strtoul(szAddress, NULL, 16);
|
|
result.m_Address = address;
|
|
|
|
ValueType type;
|
|
int charArrayLength = 0;
|
|
type = CMixed::GetTypeFromString(szValueType, &charArrayLength);
|
|
|
|
if (type == ValueType_invalid)
|
|
{
|
|
goto parse_error;
|
|
}
|
|
|
|
result.SetType(type);
|
|
|
|
if (result.IsStringType())
|
|
{
|
|
// g_MMU is null here, can't use SetStrLengthSafe
|
|
// todo fix
|
|
result.SetStrLength(charArrayLength);
|
|
}
|
|
|
|
if (strcmp(szDisplayFormat, "hex") == 0)
|
|
{
|
|
result.m_DisplayFormat = DisplayHex;
|
|
}
|
|
else if (strcmp(szDisplayFormat, "def") == 0)
|
|
{
|
|
result.m_DisplayFormat = DisplayDefault;
|
|
}
|
|
else
|
|
{
|
|
goto parse_error;
|
|
}
|
|
|
|
if (strlen(szDescription) > 0)
|
|
{
|
|
result.SetDescription(szDescription);
|
|
}
|
|
|
|
m_WatchList.push_back(result);
|
|
}
|
|
|
|
UpdateWatchList();
|
|
|
|
parse_error:
|
|
delete[] szWlFile;
|
|
|
|
}
|
|
|
|
void CDebugMemorySearch::FixListHeader(CListViewCtrl& listCtrl)
|
|
{
|
|
CRect listRect, headRect;
|
|
CHeaderCtrl listHead = listCtrl.GetHeader();
|
|
|
|
listCtrl.GetWindowRect(&listRect);
|
|
listHead.GetWindowRect(&headRect);
|
|
|
|
listHead.ResizeClient(listRect.Width(), headRect.Height());
|
|
}
|
|
|
|
CPath CDebugMemorySearch::GetWatchListPath(void)
|
|
{
|
|
stdstr strSaveDir = g_Settings->LoadStringVal(Directory_NativeSave);
|
|
|
|
stdstr wlFileName = stdstr_f("%s.wlst", m_StrGame.c_str());
|
|
|
|
CPath wlFilePath(strSaveDir.c_str(), wlFileName.c_str());
|
|
|
|
if (g_Settings->LoadBool(Setting_UniqueSaveDir))
|
|
{
|
|
stdstr strUniqueSaveDir = g_Settings->LoadStringVal(Game_UniqueSaveDir);
|
|
wlFilePath.AppendDirectory(strUniqueSaveDir.c_str());
|
|
}
|
|
|
|
wlFilePath.NormalizePath(CPath(CPath::MODULE_DIRECTORY));
|
|
|
|
if (!wlFilePath.DirectoryExists())
|
|
{
|
|
wlFilePath.DirectoryCreate();
|
|
}
|
|
|
|
return wlFilePath;
|
|
}
|
|
|
|
////////////////////////
|
|
|
|
INT_PTR CSetValueDlg::DoModal(const char* caption, const char* label, const char* initialText)
|
|
{
|
|
m_Mode = Mode_TextBox;
|
|
m_Caption = caption;
|
|
m_Label = label;
|
|
m_InitialText = initialText;
|
|
return CDialogImpl<CSetValueDlg>::DoModal();
|
|
}
|
|
|
|
INT_PTR CSetValueDlg::DoModal(const char* caption, const char* label, DWORD_PTR initialData, const ComboItem items[])
|
|
{
|
|
m_Mode = Mode_ComboBox;
|
|
m_Caption = caption;
|
|
m_Label = label;
|
|
m_InitialData = initialData;
|
|
m_ComboItems = items;
|
|
return CDialogImpl<CSetValueDlg>::DoModal();
|
|
}
|
|
|
|
char* CSetValueDlg::GetEnteredString(void)
|
|
{
|
|
return m_EnteredString;
|
|
}
|
|
|
|
DWORD_PTR CSetValueDlg::GetEnteredData(void)
|
|
{
|
|
if (m_Mode != Mode_ComboBox)
|
|
{
|
|
g_Notify->BreakPoint(__FILE__, __LINE__);
|
|
}
|
|
|
|
return m_EnteredData;
|
|
}
|
|
|
|
LRESULT CSetValueDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
SetWindowText(m_Caption);
|
|
CenterWindow();
|
|
m_Value.Attach(GetDlgItem(IDC_EDIT_VALUE));
|
|
m_CmbValue.Attach(GetDlgItem(IDC_CMB_VALUE));
|
|
m_Prompt.Attach(GetDlgItem(IDC_LBL_PROMPT));
|
|
|
|
m_Prompt.SetWindowText(m_Label);
|
|
|
|
if (m_Mode == Mode_TextBox)
|
|
{
|
|
m_CmbValue.ShowWindow(SW_HIDE);
|
|
m_Value.SetWindowTextA(m_InitialText);
|
|
m_Value.SetFocus();
|
|
m_Value.SetSelAll();
|
|
}
|
|
else if (m_Mode == Mode_ComboBox)
|
|
{
|
|
m_Value.ShowWindow(SW_HIDE);
|
|
|
|
for (int i = 0; m_ComboItems[i].str != NULL; i++)
|
|
{
|
|
int idx = m_CmbValue.AddString(m_ComboItems[i].str);
|
|
m_CmbValue.SetItemData(idx, m_ComboItems[i].data);
|
|
if (m_ComboItems[i].data == m_InitialData)
|
|
{
|
|
m_CmbValue.SetCurSel(idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CSetValueDlg::OnDestroy(void)
|
|
{
|
|
m_Value.Detach();
|
|
m_CmbValue.Detach();
|
|
m_Prompt.Detach();
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CSetValueDlg::OnOK(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
if (m_EnteredString != NULL)
|
|
{
|
|
delete[] m_EnteredString;
|
|
m_EnteredString = NULL;
|
|
}
|
|
|
|
if (m_Mode == Mode_TextBox)
|
|
{
|
|
int length = m_Value.GetWindowTextLength();
|
|
m_EnteredString = new char[length + 1];
|
|
m_Value.GetWindowText(m_EnteredString, length + 1);
|
|
}
|
|
else if (m_Mode == Mode_ComboBox)
|
|
{
|
|
int length = m_CmbValue.GetWindowTextLength();
|
|
m_EnteredString = new char[length + 1];
|
|
m_CmbValue.GetWindowText(m_EnteredString, length + 1);
|
|
|
|
m_EnteredData = m_CmbValue.GetItemData(m_CmbValue.GetCurSel());
|
|
}
|
|
|
|
EndDialog(TRUE);
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CSetValueDlg::OnCancel(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hwnd*/, BOOL& /*bHandled*/)
|
|
{
|
|
EndDialog(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
CSetValueDlg::CSetValueDlg(void) :
|
|
m_EnteredString(NULL)
|
|
{
|
|
}
|
|
|
|
CSetValueDlg::~CSetValueDlg(void)
|
|
{
|
|
if (m_EnteredString != NULL)
|
|
{
|
|
delete[] m_EnteredString;
|
|
}
|
|
}
|
|
|
|
////////////////////////
|
|
|
|
CEditMixed::CEditMixed(void) :
|
|
m_String(NULL)
|
|
{
|
|
}
|
|
|
|
CEditMixed::~CEditMixed(void)
|
|
{
|
|
if (m_String != NULL)
|
|
{
|
|
free(m_String);
|
|
}
|
|
}
|
|
|
|
DisplayFormat CEditMixed::GetDisplayFormat(void)
|
|
{
|
|
return m_DisplayFormat;
|
|
}
|
|
|
|
void CEditMixed::SetDisplayFormat(DisplayFormat fmt)
|
|
{
|
|
m_DisplayFormat = fmt;
|
|
}
|
|
|
|
void CEditMixed::ReloadString(void)
|
|
{
|
|
if (m_String != NULL)
|
|
{
|
|
free(m_String);
|
|
}
|
|
|
|
m_StringLength = GetWindowTextLength();
|
|
m_String = (char*) malloc(m_StringLength + 1);
|
|
GetWindowText(m_String, m_StringLength + 1);
|
|
}
|
|
|
|
BOOL CEditMixed::Attach(HWND hWndNew)
|
|
{
|
|
return SubclassWindow(hWndNew);
|
|
}
|
|
|
|
bool CEditMixed::GetValue(uint8_t& value)
|
|
{
|
|
uint64_t valueU64;
|
|
bool bValid = GetValue(valueU64);
|
|
|
|
if (!bValid || valueU64 > UINT8_MAX)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (uint8_t)(valueU64 & 0xFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(int8_t& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint8_t&)value);
|
|
}
|
|
|
|
int64_t valueS64;
|
|
bool bValid = GetValue(valueS64);
|
|
|
|
if (!bValid || valueS64 > INT8_MAX || valueS64 < INT8_MIN)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (int8_t)(valueS64 & 0xFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(uint16_t& value)
|
|
{
|
|
uint64_t valueU64;
|
|
bool bValid = GetValue(valueU64);
|
|
|
|
if (!bValid || valueU64 > UINT16_MAX)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (uint16_t)(valueU64 & 0xFFFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(int16_t& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint16_t&)value);
|
|
}
|
|
|
|
int64_t valueS64;
|
|
bool bValid = GetValue(valueS64);
|
|
|
|
if (!bValid || valueS64 > INT16_MAX || valueS64 < INT16_MIN)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (int16_t)(valueS64 & 0xFFFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(uint32_t& value)
|
|
{
|
|
uint64_t valueU64;
|
|
bool bValid = GetValue(valueU64);
|
|
|
|
if (!bValid || valueU64 > UINT32_MAX)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (uint32_t)(valueU64 & 0xFFFFFFFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(int32_t& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint32_t&)value);
|
|
}
|
|
|
|
int64_t valueS64;
|
|
bool bValid = GetValue(valueS64);
|
|
|
|
if (!bValid || (valueS64 > INT32_MAX) || (valueS64 < INT32_MIN))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (int32_t)(valueS64 & 0xFFFFFFFF);
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(uint64_t& value)
|
|
{
|
|
ReloadString();
|
|
|
|
char *end;
|
|
uint64_t res = strtoull(m_String, &end, m_DisplayFormat == DisplayHex ? 16 : 10);
|
|
|
|
if (*end != '\0')
|
|
{
|
|
return false; // parse failure
|
|
}
|
|
|
|
value = res;
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(int64_t& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint64_t&)value);
|
|
}
|
|
|
|
ReloadString();
|
|
|
|
char *end;
|
|
uint64_t res = strtoll(m_String, &end, m_DisplayFormat == DisplayHex ? 16 : 10);
|
|
|
|
if (*end != '\0')
|
|
{
|
|
return false; // parse failure
|
|
}
|
|
|
|
value = res;
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(float& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint32_t&)value);
|
|
}
|
|
|
|
ReloadString();
|
|
|
|
float valueF32;
|
|
char *end;
|
|
|
|
valueF32 = strtof(m_String, &end);
|
|
|
|
if (*end != '\0')
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = valueF32;
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValue(double& value)
|
|
{
|
|
if (m_DisplayFormat == DisplayHex)
|
|
{
|
|
return GetValue((uint64_t&)value);
|
|
}
|
|
|
|
ReloadString();
|
|
|
|
double valueF64;
|
|
char *end;
|
|
|
|
valueF64 = strtod(m_String, &end);
|
|
|
|
if (*end != '\0')
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = valueF64;
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValueString(const char*& value, int& length)
|
|
{
|
|
ReloadString();
|
|
|
|
if (m_StringLength == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
value = (const char*)m_String;
|
|
length = m_StringLength;
|
|
return true;
|
|
}
|
|
|
|
bool CEditMixed::GetValueHexString(const char*& value, int& length)
|
|
{
|
|
ReloadString();
|
|
|
|
if (m_StringLength == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int numBytes = CMemoryScanner::ParseHexString(NULL, m_String);
|
|
|
|
if (numBytes == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char *hexString = (char*) malloc(numBytes);
|
|
CMemoryScanner::ParseHexString(hexString, m_String);
|
|
|
|
free(m_String);
|
|
|
|
m_String = hexString;
|
|
m_StringLength = numBytes;
|
|
|
|
value = (const char*)m_String;
|
|
length = m_StringLength;
|
|
return true;
|
|
}
|