void CAccelerometer::clearWatch(int callbackID, uint32 watchID)
{
IwTrace(WM_MODULE_ACCEL,("clearWatch (callbackID: %d, watchID %u)", callbackID, watchID));
if (!RemoveWatch(watchID))
{
SetError("Internal Error: clearWatch failed.");
}
}
static void
ToggleWatch(DBusWatch *aWatch, void *aData)
{
if (dbus_watch_get_enabled(aWatch)) {
AddWatch(aWatch, aData);
} else {
RemoveWatch(aWatch, aData);
}
}
void UserTable::OnEventDirectory(const InotifyEvent& rEvt, InotifyWatch* pWatch, IncronTabEntry* pEntry)
{
if (rEvt.IsType(IN_ISDIR)) {
std::string sDirectoryPath = pWatch->GetPath() + "/" + IncronTabEntry::GetSafePath(rEvt.GetName());
if (rEvt.IsType(IN_DELETE) || rEvt.IsType(IN_MOVED_FROM)) {
RemoveWatch(sDirectoryPath);
}
}
}
void RemoveWatch(const AddressWatcher &watch, int ignoreIndex) {
for (int i = 0; i < WatchCount; i++) {
if (i == ignoreIndex)
continue;
if (IsSameWatch(rswatches[i],watch)) {
RemoveWatch(i);
break;
}
}
}
bool ReplaceWatch(const AddressWatcher& Watch, char* Comment, int index)
{
if(index < WatchCount)
RemoveWatch(index);
if(InsertWatch(Watch,Comment))
{
int moveCount = (WatchCount-1)-index;
if(moveCount > 0)
{
AddressWatcher Temp = rswatches[WatchCount-1];
memmove(&(rswatches[index + 1]),&(rswatches[index]),sizeof(AddressWatcher)*moveCount);
rswatches[index] = Temp;
}
return true;
}
return false;
}
LRESULT CALLBACK RamWatchProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT r;
RECT r2;
int dx1, dy1, dx2, dy2;
static int watchIndex=0;
Update_RAM_Watch();
switch(uMsg)
{
case WM_MOVE: {
RECT wrect;
GetWindowRect(hDlg,&wrect);
ramw_x = wrect.left;
ramw_y = wrect.top;
break;
};
case WM_INITDIALOG: {
GetWindowRect(MainWindow->getHWnd(), &r); //Ramwatch window
dx1 = (r.right - r.left) / 2;
dy1 = (r.bottom - r.top) / 2;
GetWindowRect(hDlg, &r2); // Gens window
dx2 = (r2.right - r2.left) / 2;
dy2 = (r2.bottom - r2.top) / 2;
// push it away from the main window if we can
const int width = (r.right-r.left);
const int height = (r.bottom - r.top);
const int width2 = (r2.right-r2.left);
if(r.left+width2 + width < GetSystemMetrics(SM_CXSCREEN))
{
r.right += width;
r.left += width;
}
else if((int)r.left - (int)width2 > 0)
{
r.right -= width2;
r.left -= width2;
}
//-----------------------------------------------------------------------------------
//If user has Save Window Pos selected, override default positioning
if (RWSaveWindowPos)
{
//If ramwindow is for some reason completely off screen, use default instead
if (ramw_x > (-width*2) || ramw_x < (width*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.left = ramw_x; //This also ignores cases of windows -32000 error codes
//If ramwindow is for some reason completely off screen, use default instead
if (ramw_y > (0-height*2) ||ramw_y < (height*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.top = ramw_y; //This also ignores cases of windows -32000 error codes
}
//-------------------------------------------------------------------------------------
SetWindowPos(hDlg, NULL, r.left, r.top, NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
ramwatchmenu=GetMenu(hDlg);
rwrecentmenu=CreateMenu();
UpdateRW_RMenu(rwrecentmenu, RAMMENU_FILE_RECENT, RW_MENU_FIRST_RECENT_FILE);
const char* names[3] = {"Address","Value","Notes"};
int widths[3] = {62,64,64+51+53};
init_list_box(GetDlgItem(hDlg,IDC_WATCHLIST),names,3,widths);
/* if (!ResultCount) //TODO what do these do
reset_address_info();
else
signal_new_frame();*/
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
// if (!noMisalign) SendDlgItemMessage(hDlg, IDC_MISALIGN, BM_SETCHECK, BST_CHECKED, 0);
// if (littleEndian) SendDlgItemMessage(hDlg, IDC_ENDIAN, BM_SETCHECK, BST_CHECKED, 0);
RamWatchAccels = LoadAccelerators(hAppInst, MAKEINTRESOURCE(IDR_ACCELERATOR1));
// due to some bug in windows, the arrow button width from the resource gets ignored, so we have to set it here
SetWindowPos(GetDlgItem(hDlg,ID_WATCHES_UPDOWN), 0,0,0, 30,60, SWP_NOMOVE);
Update_RAM_Watch();
DragAcceptFiles(hDlg, TRUE);
return true;
break;
}
case WM_INITMENU:
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
case WM_MENUSELECT:
case WM_ENTERSIZEMOVE:
break;
case WM_NOTIFY:
{
switch(wParam)
{
case ID_WATCHES_UPDOWN:
{
switch(((LPNMUPDOWN)lParam)->hdr.code)
{
case UDN_DELTAPOS:
int delta = ((LPNMUPDOWN)lParam)->iDelta;
SendMessage(hDlg, WM_COMMAND, delta<0 ? IDC_C_WATCH_UP : IDC_C_WATCH_DOWN,0);
break;
}
}
default:
{
LPNMHDR lP = (LPNMHDR) lParam;
switch (lP->code)
{
case LVN_GETDISPINFO:
{
LV_DISPINFO *Item = (LV_DISPINFO *)lParam;
Item->item.mask = LVIF_TEXT;
Item->item.state = 0;
Item->item.iImage = 0;
const unsigned int iNum = Item->item.iItem;
static char num[11];
switch (Item->item.iSubItem)
{
case 0:
sprintf(num,"%08X",rswatches[iNum].Address);
Item->item.pszText = num;
return true;
case 1: {
int i = rswatches[iNum].CurValue;
int t = rswatches[iNum].Type;
int size = rswatches[iNum].Size;
const char* formatString = ((t=='s') ? "%d" : (t=='u') ? "%u" : (size=='d' ? "%08X" : size=='w' ? "%04X" : "%02X"));
switch (size)
{
case 'b':
default: sprintf(num, formatString, t=='s' ? (char)(i&0xff) : (unsigned char)(i&0xff)); break;
case 'w': sprintf(num, formatString, t=='s' ? (short)(i&0xffff) : (unsigned short)(i&0xffff)); break;
case 'd': sprintf(num, formatString, t=='s' ? (long)(i&0xffffffff) : (unsigned long)(i&0xffffffff)); break;
}
Item->item.pszText = num;
} return true;
case 2:
Item->item.pszText = rswatches[iNum].comment ? rswatches[iNum].comment : "";
return true;
default:
return false;
}
}
case LVN_ODFINDITEM:
{
// disable search by keyboard typing,
// because it interferes with some of the accelerators
// and it isn't very useful here anyway
SetWindowLong(hDlg, DWL_MSGRESULT, ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST)));
return 1;
}
}
}
}
break;
}
case WM_COMMAND:
switch(LOWORD(wParam))
{
case RAMMENU_FILE_SAVE:
QuickSaveWatches();
break;
case RAMMENU_FILE_SAVEAS:
return Save_Watches();
case RAMMENU_FILE_OPEN:
return Load_Watches(true);
case RAMMENU_FILE_APPEND:
return Load_Watches(false);
case RAMMENU_FILE_NEW:
ResetWatches();
return true;
case IDC_C_WATCH_REMOVE:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
RemoveWatch(watchIndex);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_EDIT:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) watchIndex);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH:
rswatches[WatchCount].Address = rswatches[WatchCount].WrongEndian = 0;
rswatches[WatchCount].Size = 'b';
rswatches[WatchCount].Type = 's';
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_DUPLICATE:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
rswatches[WatchCount].Address = rswatches[watchIndex].Address;
rswatches[WatchCount].WrongEndian = rswatches[watchIndex].WrongEndian;
rswatches[WatchCount].Size = rswatches[watchIndex].Size;
rswatches[WatchCount].Type = rswatches[watchIndex].Type;
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_UP:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if (watchIndex == 0 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex - 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex - 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case IDC_C_WATCH_DOWN:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if (watchIndex >= WatchCount - 1 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex + 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex + 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case RAMMENU_FILE_AUTOLOAD:
{
AutoRWLoad ^= 1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
break;
}
case RAMMENU_FILE_SAVEWINDOW:
{
RWSaveWindowPos ^=1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
}
case IDC_C_ADDCHEAT:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST)) | (1 << 24);
// DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITCHEAT), hDlg, (DLGPROC) EditCheatProc,(LPARAM) searchIndex); //TODO: made a IDD_EDITCHEAT dialog, and EditCheatProc (are they in GENS?) and integrate into cheats system
break;
}
case IDCANCEL:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
default:
if (LOWORD(wParam) >= RW_MENU_FIRST_RECENT_FILE && LOWORD(wParam) < RW_MENU_FIRST_RECENT_FILE+MAX_RECENT_WATCHES)
OpenRWRecentFile(LOWORD(wParam) - RW_MENU_FIRST_RECENT_FILE);
}
break;
case WM_KEYDOWN: // handle accelerator keys
{
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
MSG msg;
msg.hwnd = hDlg;
msg.message = uMsg;
msg.wParam = wParam;
msg.lParam = lParam;
if(RamWatchAccels && TranslateAccelerator(hDlg, RamWatchAccels, &msg))
return true;
} break;
case WM_CLOSE:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
case WM_DROPFILES:
{
HDROP hDrop = (HDROP)wParam;
DragQueryFile(hDrop, 0, Str_Tmp, 1024);
DragFinish(hDrop);
return Load_Watches(true, Str_Tmp);
} break;
}
return false;
}
LRESULT CALLBACK EditWatchProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) //Gets info for a RAM Watch, and then inserts it into the Watch List
{
RECT r;
RECT r2;
int dx1, dy1, dx2, dy2;
static int index;
static char s,t = s = 0;
switch(uMsg)
{
case WM_INITDIALOG:
GetWindowRect(MainWindow->getHWnd(), &r);
dx1 = (r.right - r.left) / 2;
dy1 = (r.bottom - r.top) / 2;
GetWindowRect(hDlg, &r2);
dx2 = (r2.right - r2.left) / 2;
dy2 = (r2.bottom - r2.top) / 2;
SetWindowPos(hDlg, NULL, r.left, r.top, NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
index = (int)lParam;
sprintf(Str_Tmp,"%08X",rswatches[index].Address);
SetDlgItemText(hDlg,IDC_EDIT_COMPAREADDRESS,Str_Tmp);
if (rswatches[index].comment != NULL)
SetDlgItemText(hDlg,IDC_PROMPT_EDIT,rswatches[index].comment);
s = rswatches[index].Size;
t = rswatches[index].Type;
switch (s)
{
case 'b':
SendDlgItemMessage(hDlg, IDC_1_BYTE, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'w':
SendDlgItemMessage(hDlg, IDC_2_BYTES, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'd':
SendDlgItemMessage(hDlg, IDC_4_BYTES, BM_SETCHECK, BST_CHECKED, 0);
break;
default:
s = 0;
break;
}
switch (t)
{
case 's':
SendDlgItemMessage(hDlg, IDC_SIGNED, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'u':
SendDlgItemMessage(hDlg, IDC_UNSIGNED, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'h':
SendDlgItemMessage(hDlg, IDC_HEX, BM_SETCHECK, BST_CHECKED, 0);
break;
default:
t = 0;
break;
}
return true;
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_SIGNED:
t='s';
return true;
case IDC_UNSIGNED:
t='u';
return true;
case IDC_HEX:
t='h';
return true;
case IDC_1_BYTE:
s = 'b';
return true;
case IDC_2_BYTES:
s = 'w';
return true;
case IDC_4_BYTES:
s = 'd';
return true;
case IDOK:
{
if (s && t)
{
AddressWatcher Temp;
Temp.Size = s;
Temp.Type = t;
Temp.WrongEndian = false; //replace this when I get little endian working properly
GetDlgItemText(hDlg,IDC_EDIT_COMPAREADDRESS,Str_Tmp,1024);
char *addrstr = Str_Tmp;
if (strlen(Str_Tmp) > 8) addrstr = &(Str_Tmp[strlen(Str_Tmp) - 9]);
for(int i = 0; addrstr[i]; i++) {if(toupper(addrstr[i]) == 'O') addrstr[i] = '0';}
sscanf(addrstr,"%08X",&(Temp.Address));
if((Temp.Address & ~0xFFFFFF) == ~0xFFFFFF)
Temp.Address &= 0xFFFFFF;
if(IsHardwareRAMAddressValid(Temp.Address))
{
GetDlgItemText(hDlg,IDC_PROMPT_EDIT,Str_Tmp,80);
if (index < WatchCount) RemoveWatch(index);
InsertWatch(Temp,Str_Tmp);
if(RamWatchHWnd)
{
ListView_SetItemCount(GetDlgItem(RamWatchHWnd,IDC_WATCHLIST),WatchCount);
}
EndDialog(hDlg, true);
}
else
{
MessageBox(hDlg,"Invalid Address","ERROR",MB_OK);
}
}
else
{
strcpy(Str_Tmp,"Error:");
if (!s)
strcat(Str_Tmp," Size must be specified.");
if (!t)
strcat(Str_Tmp," Type must be specified.");
MessageBox(hDlg,Str_Tmp,"ERROR",MB_OK);
}
RWfileChanged=true;
return true;
break;
}
case IDCANCEL:
EndDialog(hDlg, false);
return false;
break;
}
break;
case WM_CLOSE:
EndDialog(hDlg, false);
return false;
break;
}
return false;
}
//ab Add Breakpoint
//rb Remove Breakpoint
//sp Suspend
void SQDbgServer::ParseMsg(const char *msg)
{
switch(*((unsigned short *)msg)){
case MSG_ID('a','b'): {
BreakPoint bp;
if(ParseBreakpoint(msg+3,bp)){
AddBreakpoint(bp);
scprintf(_SC("added bp %d %s\n"),bp._line,bp._src.c_str());
}
else
scprintf(_SC("error parsing add breakpoint"));
}
break;
case MSG_ID('r','b'): {
BreakPoint bp;
if(ParseBreakpoint(msg+3,bp)){
RemoveBreakpoint(bp);
scprintf(_SC("removed bp %d %s\n"),bp._line,bp._src.c_str());
}else
scprintf(_SC("error parsing remove breakpoint"));
}
break;
case MSG_ID('g','o'):
if(_state!=eDBG_Running){
_state=eDBG_Running;
BeginDocument();
BeginElement(_SC("resumed"));
EndElement(_SC("resumed"));
EndDocument();
// Send(_SC("<resumed/>\r\n"));
scprintf(_SC("go (execution resumed)\n"));
}
break;
case MSG_ID('s','p'):
if(_state!=eDBG_Suspended){
_state=eDBG_Suspended;
scprintf(_SC("suspend\n"));
}
break;
case MSG_ID('s','o'):
if(_state==eDBG_Suspended){
_state=eDBG_StepOver;
}
break;
case MSG_ID('s','i'):
if(_state==eDBG_Suspended){
_state=eDBG_StepInto;
scprintf(_SC("step into\n"));
}
break;
case MSG_ID('s','r'):
if(_state==eDBG_Suspended){
_state=eDBG_StepReturn;
scprintf(_SC("step return\n"));
}
break;
case MSG_ID('d','i'):
if(_state!=eDBG_Disabled){
_state=eDBG_Disabled;
scprintf(_SC("disabled\n"));
}
break;
case MSG_ID('a','w'): {
Watch w;
if(ParseWatch(msg+3,w))
{
AddWatch(w);
scprintf(_SC("added watch %d %s\n"),w._id,w._exp.c_str());
}
else
scprintf(_SC("error parsing add watch"));
}
break;
case MSG_ID('r','w'): {
int id;
if(ParseRemoveWatch(msg+3,id))
{
RemoveWatch(id);
scprintf(_SC("added watch %d\n"),id);
}
else
scprintf(_SC("error parsing remove watch"));
}
break;
case MSG_ID('t','r'):
scprintf(_SC("terminate from user\n"));
break;
case MSG_ID('r','d'):
scprintf(_SC("ready\n"));
_ready=true;
break;
default:
scprintf(_SC("unknown packet"));
}
}
LRESULT CALLBACK EditWatchProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) //Gets info for a RAM Watch, and then inserts it into the Watch List
{
RECT r;
RECT r2;
int dx1, dy1, dx2, dy2;
static int index;
static char s,t = s = 0;
switch(uMsg)
{
case WM_INITDIALOG:
//Clear_Sound_Buffer();
GetWindowRect(hWnd, &r);
dx1 = (r.right - r.left) / 2;
dy1 = (r.bottom - r.top) / 2;
GetWindowRect(hDlg, &r2);
dx2 = (r2.right - r2.left) / 2;
dy2 = (r2.bottom - r2.top) / 2;
//SetWindowPos(hDlg, NULL, max(0, r.left + (dx1 - dx2)), max(0, r.top + (dy1 - dy2)), NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
SetWindowPos(hDlg, NULL, r.left, r.top, NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
index = (int)lParam;
sprintf(Str_Tmp_RW,"%08X",rswatches[index].Address);
SetDlgItemText(hDlg,IDC_EDIT_COMPAREADDRESS,Str_Tmp_RW);
if(rswatches[index].comment != NULL)
SetDlgItemText(hDlg,IDC_PROMPT_EDIT,rswatches[index].comment);
s = rswatches[index].Size;
t = rswatches[index].Type;
switch(s)
{
case 'b':
SendDlgItemMessage(hDlg, IDC_1_BYTE, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'w':
SendDlgItemMessage(hDlg, IDC_2_BYTES, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'd':
SendDlgItemMessage(hDlg, IDC_4_BYTES, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'l':
SendDlgItemMessage(hDlg, IDC_8_BYTES, BM_SETCHECK, BST_CHECKED, 0);
break;
default:
s = 0;
break;
}
switch(t)
{
case 's':
SendDlgItemMessage(hDlg, IDC_SIGNED, BM_SETCHECK, BST_CHECKED, 0);
EnableWindow(GetDlgItem(hDlg,IDC_1_BYTE),true);
EnableWindow(GetDlgItem(hDlg,IDC_2_BYTES),true);
break;
case 'u':
SendDlgItemMessage(hDlg, IDC_UNSIGNED, BM_SETCHECK, BST_CHECKED, 0);
EnableWindow(GetDlgItem(hDlg,IDC_1_BYTE),true);
EnableWindow(GetDlgItem(hDlg,IDC_2_BYTES),true);
break;
case 'h':
SendDlgItemMessage(hDlg, IDC_HEX, BM_SETCHECK, BST_CHECKED, 0);
EnableWindow(GetDlgItem(hDlg,IDC_1_BYTE),true);
EnableWindow(GetDlgItem(hDlg,IDC_2_BYTES),true);
break;
case 'f':
SendDlgItemMessage(hDlg, IDC_FLOAT, BM_SETCHECK, BST_CHECKED, 0);
if(s == 'b' || s == 'w')
{
SendDlgItemMessage(hDlg, IDC_4_BYTES, BM_SETCHECK, BST_CHECKED, 0);
SendDlgItemMessage(hDlg, IDC_8_BYTES, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(hDlg, IDC_2_BYTES, BM_SETCHECK, BST_UNCHECKED, 0);
SendDlgItemMessage(hDlg, IDC_1_BYTE, BM_SETCHECK, BST_UNCHECKED, 0);
s = 'd';
}
EnableWindow(GetDlgItem(hDlg,IDC_1_BYTE),false);
EnableWindow(GetDlgItem(hDlg,IDC_2_BYTES),false);
break;
default:
t = 0;
break;
}
return true;
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_SIGNED:
t='s';
return true;
case IDC_UNSIGNED:
t='u';
return true;
case IDC_HEX:
t='h';
return true;
case IDC_FLOAT:
t='f';
return true;
case IDC_1_BYTE:
s = 'b';
return true;
case IDC_2_BYTES:
s = 'w';
return true;
case IDC_4_BYTES:
s = 'd';
return true;
case IDC_8_BYTES:
s = 'l';
return true;
case IDOK:
{
if(s && t)
{
AddressWatcher Temp = {};
Temp.Size = s;
Temp.Type = t;
Temp.WrongEndian = false; //replace this when I get little endian working properly
GetDlgItemText(hDlg,IDC_EDIT_COMPAREADDRESS,Str_Tmp_RW,1024);
char *addrstr = Str_Tmp_RW;
if(strlen(Str_Tmp_RW) > 8) addrstr = &(Str_Tmp_RW[strlen(Str_Tmp_RW) - 9]);
for(int i = 0; addrstr[i]; i++) {if(toupper(addrstr[i]) == 'O') addrstr[i] = '0';}
sscanf(addrstr,"%08X",&(Temp.Address));
//if((Temp.Address & ~0xFFFFFF) == ~0xFFFFFF)
// Temp.Address &= 0xFFFFFF;
bool canceled = false;
if(!VerifyWatchNotAlreadyAdded(Temp, index))
{
int result = MessageBox(hDlg,"Watch already exists. Replace it?","REPLACE",MB_YESNO);
if(result == IDYES)
RemoveWatch(Temp, index);
if(result == IDNO)
canceled = true;
}
if(!canceled)
{
if(IsHardwareAddressValid(Temp.Address) || !Config::started || (index < WatchCount && Temp.Address == rswatches[index].Address))
{
GetDlgItemText(hDlg,IDC_PROMPT_EDIT,Str_Tmp_RW,80);
ReplaceWatch(Temp,Str_Tmp_RW,index);
if(RamWatchHWnd)
{
ListView_SetItemCount(GetDlgItem(RamWatchHWnd,IDC_WATCHLIST),WatchCount);
}
EndDialog(hDlg, true);
}
else
{
MessageBox(hDlg,"Invalid Address","ERROR",MB_OK);
}
}
}
else
{
strcpy(Str_Tmp_RW,"Error:");
if(!s)
strcat(Str_Tmp_RW," Size must be specified.");
if(!t)
strcat(Str_Tmp_RW," Type must be specified.");
MessageBox(hDlg,Str_Tmp_RW,"ERROR",MB_OK);
}
RWfileChanged=true;
return true;
break;
}
case ID_CANCEL:
case IDCANCEL:
EndDialog(hDlg, false);
return false;
break;
}
break;
case WM_CLOSE:
EndDialog(hDlg, false);
return false;
break;
}
return false;
}