/* This file is part of VCC (Virtual Color Computer). VCC (Virtual Color Computer) is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. VCC (Virtual Color Computer) is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with VCC (Virtual Color Computer). If not, see . Execution Trace Display - Part of the Debugger package for VCC Author: Mike Rojas */ #include "ExecutionTrace.h" #include "Debugger.h" #include "DebuggerUtils.h" #include "defines.h" #include "resource.h" #include #include #include #include #include #include #include #include #include "config.h" static HINSTANCE g_hinstDLG; namespace VCC::Debugger::UI { const std::string cWindowSizeX("WindowSizeX"); const std::string cWindowSizeY("WindowSizeY"); const std::string cWindowPosX("WindowPosX"); const std::string cWindowPosY("WindowPosY"); const std::string cSection("ExecutionTrace"); HWND ExecutionTraceWindow = nullptr; HWND hWndExecutionTrace; HWND hWndVScrollBar; HWND hWndHScrollBar; HWND hWndTrace; HHOOK hHookKeyboard = nullptr; void CaptureKeyboardEvents(); void ReleaseKeyboard(); int ScrollBarTop = 140; int ScrollBarWidth = 19; enum class TraceStatus { Stopped, Enabled, Collecting, LoadPage, Loaded }; TraceStatus status = TraceStatus::Stopped; long traceOffset = 0; long tracePage = 50; long traceCursor = 0; long horizontalOffset = 0; long horizontalWidth = 965; bool showHScrollBar = true; BackBufferInfo BackBuffer_; int ExportStart=1; int ExportStop=0; char ExportPath[MAX_PATH]={}; //------------------------------------------------------------------------------- const char *ToCCStringCStr(const unsigned char CC) { static const char* flags = "EFHINZVC"; static char buffer[9]; for (int i = 0, mask = 0x80; i < 8; ++i, mask >>= 1) buffer[i] = CC & mask ? flags[i] : '.'; buffer[8] = 0; return buffer; } std::string ToCCString(const unsigned char CC) { return std::string(ToCCStringCStr(CC)); } //------------------------------------------------------------------------------- std::string ToStateChangeString(const CPUTrace& trace, bool showPC = true) { std::ostringstream fmt; if ((trace.startState.A != trace.endState.A) && (trace.startState.B != trace.endState.B)) { fmt << " D=" << ToHexString(trace.endState.A, 2) << ToHexString(trace.endState.B, 2); } else if (trace.startState.A != trace.endState.A) { fmt << " A=" << ToHexString(trace.endState.A, 2); } else if (trace.startState.B != trace.endState.B) { fmt << " B=" << ToHexString(trace.endState.B, 2); } if (trace.endState.IsNative6309) { if ((trace.startState.E != trace.endState.E) && (trace.startState.F != trace.endState.F)) { fmt << " W=" << ToHexString(trace.endState.E, 2) << ToHexString(trace.endState.F, 2); } else if (trace.startState.E != trace.endState.E) { fmt << " E=" << ToHexString(trace.endState.E, 2); } else if (trace.startState.F != trace.endState.F) { fmt << " F=" << ToHexString(trace.endState.F, 2); } } if (trace.startState.X != trace.endState.X) { fmt << " X=" << ToHexString(trace.endState.X, 4); } if (trace.startState.Y != trace.endState.Y) { fmt << " Y=" << ToHexString(trace.endState.Y, 4); } if (trace.startState.U != trace.endState.U) { fmt << " U=" << ToHexString(trace.endState.U, 4); } if (trace.startState.S != trace.endState.S) { fmt << " S=" << ToHexString(trace.endState.S, 4); } if (trace.endState.IsNative6309) { if (trace.startState.V != trace.endState.V) { fmt << " V=" << ToHexString(trace.endState.V, 4); } } if (trace.startState.DP != trace.endState.DP) { fmt << " DP=" << ToHexString(trace.endState.DP, 2); } if (trace.endState.IsNative6309) { if (trace.startState.MD != trace.endState.MD) { fmt << " MD=" << ToHexString(trace.endState.MD, 2); } } if (trace.startState.CC != trace.endState.CC) { fmt << " CC=" << ToHexString(trace.endState.CC, 2); } if (showPC) { if (trace.startState.PC != trace.endState.PC) { fmt << " PC=" << ToHexString(trace.endState.PC, 4); } } // Skip over first space. return (fmt.str().size() > 0) ? fmt.str().substr(1) : fmt.str(); } //------------------------------------------------------------------------------- void DrawBorder(HDC hdc, LPCRECT clientRect) { RECT rect = *clientRect; // Clear our background. HBRUSH brush = (HBRUSH)GetStockObject(WHITE_BRUSH); FillRect(hdc, &rect, brush); HPEN pen = CreatePen(PS_SOLID, 1, RGB(192, 192, 192)); SelectObject(hdc, pen); // Draw the border. MoveToEx(hdc, rect.left, rect.top, nullptr); LineTo(hdc, rect.right - 1, rect.top); LineTo(hdc, rect.right - 1, rect.bottom - 1); LineTo(hdc, rect.left, rect.bottom - 1); LineTo(hdc, rect.left, rect.top); DeleteObject(pen); } void UpdateTraceStatus(TraceStatus s) { const char* statusLabel[] = { "Stopped", "Enabled", "Collecting", "LoadPage", "Loaded" }; char buf[100]; sprintf(buf, "%s", statusLabel[(int)s]); auto samples = EmuState.Debugger.GetTraceSamples(); if (samples > 0) sprintf(buf + strlen(buf), " (%d)", samples); status = s; HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_TRACE_STATUS); SetWindowText(hCtl, buf); } //------------------------------------------------------------------------------- void DrawSamplingInProgress(HDC hdc) { UpdateTraceStatus(TraceStatus::Collecting); RECT rect; GetClientRect(hWndTrace, &rect); HFONT hFont = CreateFont(24, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, FIXED_PITCH, TEXT("Consolas")); SelectObject(hdc, hFont); long samples = EmuState.Debugger.GetTraceSamples(); std::stringstream ss; ss << samples << " Samples Collected"; DrawText(hdc, ss.str().c_str(), ss.str().size(), &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE); DeleteObject(hFont); } //------------------------------------------------------------------------------- void DrawNoSamplesCollected(HDC hdc) { RECT rect; GetClientRect(hWndTrace, &rect); HFONT hFont = CreateFont(24, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, FIXED_PITCH, TEXT("Consolas")); SelectObject(hdc, hFont); const char* s = "Press Enable to start collection"; if (status == TraceStatus::Enabled && EmuState.Debugger.GetTraceSamples() == 0) s = "Trace enabled, waiting collection"; DrawText(hdc, s, strlen(s), &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE); DeleteObject(hFont); } //------------------------------------------------------------------------------- void DrawSamples(HDC hdc, LPCRECT clientRect) { long samples = EmuState.Debugger.GetTraceSamples(); // Nothing collected yet? if (samples == 0) { DrawNoSamplesCollected(hdc); return; } // Indicate what we collected. UpdateTraceStatus(TraceStatus::Stopped); // Adjust Vertical Scrollbar based on samples collected. SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); si.nMax = samples; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); // Draw the collection. RECT rect = *clientRect; HFONT hFont = CreateFont(15, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, FIXED_PITCH, TEXT("Consolas")); SelectObject(hdc, hFont); HPEN pen = CreatePen(PS_SOLID, 1, RGB(192, 192, 192)); SelectObject(hdc, pen); EmuState.Debugger.LockTrace(); auto& currentTrace = EmuState.Debugger.GetTraceResult(); // Load page? if (currentTrace.size() == 0 || status == TraceStatus::LoadPage) { UpdateTraceStatus(TraceStatus::Loaded); } // Draw our header line. SetTextColor(hdc, RGB(138, 27, 255)); std::vector headers = { "Sample", "Clock", "Cycles", "Address", "Memory", "Instruction", "CPU Cycles", "State Changes", "CC", "D", "X", "Y", "U", "S", "DP" }; std::vector columns = { 60, 90, 60, 60, 90, 90, 80, 100, 80, 40, 40, 40, 40, 40, 40 }; std::vector priority = { 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1 }; bool Is6309 = EmuState.CpuType == 1; // Running a 6309 CPU? if (Is6309) { headers.emplace(headers.begin() + 9, "W"); columns.emplace(columns.begin() + 9, 40); priority.emplace(priority.begin() + 9, 1); headers.emplace_back("MD"); columns.emplace_back(40); priority.emplace_back(1); } // size between columns const int columnGutter = 2; const int rowHeight = 15; // size of a column auto columnSize = [&](int col) { return columnGutter + columns[col] * priority[col]; }; long total = 0; for (size_t i = 0; i < columns.size(); ++i) total += columnSize(i); auto border = 4; auto widthScale = (float)horizontalWidth / total; float px = (float)border; int col = 0; for (auto h : headers) { RECT rc; float w = widthScale * columnSize(col); col++; int x = (int)px; SetRect(&rc, rect.left + x + columnGutter/2, rect.top, rect.left + x + (int)w - columnGutter/2, rect.top + 20); // Draw the border. MoveToEx(hdc, rc.left, rc.top, nullptr); LineTo(hdc, rc.right - 1, rc.top); LineTo(hdc, rc.right - 1, rc.bottom - 1); LineTo(hdc, rc.left, rc.bottom - 1); LineTo(hdc, rc.left, rc.top); DrawText(hdc, h, strlen(h), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); px += w; } // Trace Mark Highlight Colors HBRUSH hBrushMark1 = CreateSolidBrush(RGB(20, 200, 20)); HBRUSH hBrushMark2 = CreateSolidBrush(RGB(200, 20, 20)); HBRUSH hBrushCursor = CreateSolidBrush(RGB(230, 230, 230)); Debugger::tracebuffer_type marks; EmuState.Debugger.GetTraceMarkSamples(marks); long traceMark1 = -1; long traceMark2 = -1; // Calculate trace timing. if (marks.size() == 2) { traceMark1 = marks[0].cycleTime; traceMark2 = marks[1].cycleTime; long cycles = abs(traceMark2 - traceMark1); double hz = EmuState.CPUCurrentSpeed * 1000000.0; double elapsed = cycles / hz * 1000000.0; std::stringstream ss; ss << "T1 = " << traceMark1 << ", "; ss << "T2 = " << traceMark2 << ", "; ss << "Elapsed = " << cycles << " cycles, "; ss << elapsed << " us at " << hz / 1000 << "kHz"; HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_TRACE_TIMING); SetWindowText(hCtl, ss.str().c_str()); } else if (marks.size() == 1) { traceMark1 = marks[0].cycleTime; std::stringstream ss; ss << "T1 = " << traceMark1 << " set, right click to set T2"; HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_TRACE_TIMING); SetWindowText(hCtl, ss.str().c_str()); } else { std::string s = "Press 1 or 2 to set time marks on trace."; HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_TRACE_TIMING); SetWindowText(hCtl, s.c_str()); } // Draw our current page of samples SetTextColor(hdc, RGB(0, 0, 0)); int y = rect.top + 20; int lines = std::min((long)currentTrace.size(), tracePage); for (int i = 0; i < lines; i++) { std::string s; RECT rc; px = (float)border; col = 0; long n = i + traceOffset; auto setColumn = [&](int col) { float w = widthScale * columnSize(col); int x = (int)px; SetRect(&rc, rect.left + x + columnGutter/2, y, rect.left + x + (int)w - columnGutter/2, y + rowHeight); px += w; }; if (n >= (long)currentTrace.size()) continue; if (n == traceCursor) { SetRect(&rc, rect.left, y, rect.right, y + rowHeight); FillRect(hdc, &rc, hBrushCursor); } if (currentTrace[n].cycleTime == traceMark1) { SetRect(&rc, rect.left, y, rect.right, y + rowHeight); FillRect(hdc, &rc, hBrushMark1); } if (currentTrace[n].cycleTime == traceMark2) { SetRect(&rc, rect.left, y, rect.right, y + rowHeight); FillRect(hdc, &rc, hBrushMark2); } int w = columns[0]; setColumn(col++); s = ToDecimalString(n + 1, 10, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToDecimalString(currentTrace[n].clock, 0, false); s += "(+"; s += ToDecimalString(currentTrace[n].clock - currentTrace[n].frameStart, 0, false); s += ")"; DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); if (currentTrace[n].event == TraceEvent::Instruction) { setColumn(col++); s = ToDecimalString(currentTrace[n].cycleTime, 10, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString(currentTrace[n].pc, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToByteString(currentTrace[n].bytes); DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = currentTrace[n].instruction + " " + currentTrace[n].operand; DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToDecimalString(currentTrace[n].execCycles, 2, false); s += " / "; s += ToDecimalString(currentTrace[n].decodeCycles, 2, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToStateChangeString(currentTrace[n]); DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToCCString(currentTrace[n].startState.CC); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString((currentTrace[n].startState.A << 8) + currentTrace[n].startState.B, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); if (Is6309) { setColumn(col++); s = ToHexString((currentTrace[n].startState.E << 8) + currentTrace[n].startState.F, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); } setColumn(col++); s = ToHexString(currentTrace[n].startState.X, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString(currentTrace[n].startState.Y, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString(currentTrace[n].startState.U, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString(currentTrace[n].startState.S, 4); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); setColumn(col++); s = ToHexString(currentTrace[n].startState.DP, 2); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); if (Is6309) { setColumn(col++); s = ToHexString(currentTrace[n].startState.MD, 2); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); } y += rowHeight; } else if (currentTrace[n].event == TraceEvent::EmulatorCycle) { px += 10; w = 1200; int x = (int)px; SetRect(&rc, rect.left + x, y, rect.left + x + w, y + rowHeight); std::stringstream ss; ss << "Emulation :: "; switch (currentTrace[n].emulationState) { case 0: ss << " CPU Only "; break; case 1: ss << " Timer IRQ "; break; case 2: ss << " Audio Sample "; break; case 3: ss << " Both, 1st Audio "; break; case 4: ss << " Both, 2nd Timer "; break; case 5: ss << " Both, 1st Timer "; break; case 6: ss << " Both, 2nd Audio "; break; case 7: ss << " Both Timer/Audio "; break; case 10: ss << "Cycle Start ======="; break; case 20: ss << "Cycle End ---------"; break; } ss << " : "; ss << " exec " << currentTrace[n].emulator[0]; ss << " timer " << currentTrace[n].emulator[1]; ss << " sound " << currentTrace[n].emulator[2]; ss << " cycles " << currentTrace[n].emulator[3]; ss << " drift " << currentTrace[n].emulator[4]; ss << " total " << currentTrace[n].emulator[5]; DrawText(hdc, ss.str().c_str(), ss.str().size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); y += rowHeight; } else if (currentTrace[n].event > TraceEvent::ScreenStart && currentTrace[n].event < TraceEvent::ScreenEnd) { setColumn(col++); s = ToDecimalString(currentTrace[n].cycleTime, 10, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); setColumn(col++); setColumn(col++); s = currentTrace[n].instruction; DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); if (currentTrace[n].execCycles || currentTrace[n].decodeCycles) { s = ToDecimalString(currentTrace[n].execCycles, 2, false); s += " / "; s += ToDecimalString(currentTrace[n].decodeCycles, 2, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); } y += rowHeight; } else if (currentTrace[n].event > TraceEvent::IRQStart && currentTrace[n].event < TraceEvent::IRQEnd) { setColumn(col++); s = ToDecimalString(currentTrace[n].cycleTime, 10, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); setColumn(col++); setColumn(col++); s = currentTrace[n].instruction; DrawText(hdc, s.c_str(), s.size(), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); setColumn(col++); if (currentTrace[n].execCycles || currentTrace[n].decodeCycles) { s = ToDecimalString(currentTrace[n].execCycles, 2, false); s += " / "; s += ToDecimalString(currentTrace[n].decodeCycles, 2, false); DrawText(hdc, s.c_str(), s.size(), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); } y += rowHeight; } } DeleteObject(hBrushCursor); DeleteObject(hBrushMark1); DeleteObject(hBrushMark2); DeleteObject(pen); DeleteObject(hFont); EmuState.Debugger.UnlockTrace(); } //------------------------------------------------------------------------------- void DrawExecutionTrace(HDC hdc, LPCRECT clientRect) { // Draw the border. DrawBorder(hdc, clientRect); // Get tracing status. bool tracing = EmuState.Debugger.IsTracing(); // Show tracing is in progress. if (tracing) { DrawSamplingInProgress(hdc); return; } DrawSamples(hdc, clientRect); } //------------------------------------------------------------------------------- void ResizeWindow(int width, int height) { HWND hCtl = GetDlgItem(hWndExecutionTrace, IDCLOSE); SetWindowPos(hCtl, nullptr, 9, height - 33, 0, 0, SWP_NOSIZE); hCtl = GetDlgItem(hWndExecutionTrace, IDC_TRACE_TIMING); SetWindowPos(hCtl, nullptr, 100, height - 28, 0, 0, SWP_NOSIZE); SCROLLINFO si; RECT Rect; GetClientRect(hWndExecutionTrace, &Rect); DeleteDC(BackBuffer_.DeviceContext); horizontalWidth = std::max(900l, (long)Rect.right - ScrollBarWidth - 10); BackBuffer_ = AttachBackBuffer(hWndExecutionTrace, horizontalWidth, 0); // Hide horizontal scrollbar if not needed. showHScrollBar = Rect.right - ScrollBarWidth < horizontalWidth; ShowWindow(hWndHScrollBar, showHScrollBar ? SW_SHOW : SW_HIDE); int bottomOffset = showHScrollBar ? 0 : -ScrollBarWidth; if (showHScrollBar) { SetWindowPos(hWndHScrollBar, nullptr, 0, Rect.bottom - 39 - ScrollBarWidth, Rect.right - ScrollBarWidth, ScrollBarWidth, 0); si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndHScrollBar, SB_CTL, &si); si.nPage = Rect.right - ScrollBarWidth; SetScrollInfo(hWndHScrollBar, SB_CTL, &si, TRUE); } SetWindowPos(hWndVScrollBar, nullptr, Rect.right - ScrollBarWidth, ScrollBarTop, ScrollBarWidth, Rect.bottom - 60 - ScrollBarTop - bottomOffset, 0); SetWindowPos(hWndTrace, nullptr, 0, 140, width - ScrollBarWidth, Rect.bottom - 197 - bottomOffset, 0); tracePage = (Rect.bottom - 218 - bottomOffset) / 15; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); si.nPage = tracePage; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); if (status == TraceStatus::Loaded) { UpdateTraceStatus(TraceStatus::LoadPage); } InvalidateRect(hWndTrace, &BackBuffer_.Rect, FALSE); } //------------------------------------------------------------------------------- LRESULT CALLBACK PanelProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_CREATE: { RECT Rect; GetClientRect(hwnd, &Rect); horizontalWidth = std::max(900l, (long)Rect.right - ScrollBarWidth); BackBuffer_ = AttachBackBuffer(hwnd, horizontalWidth, 0); break; } case WM_MOUSEMOVE: { CaptureKeyboardEvents(); // Make sure we capture when the mouse leaves the control. TRACKMOUSEEVENT mouse = { 0 }; mouse.cbSize = sizeof(mouse); mouse.hwndTrack = hwnd; mouse.dwFlags = TME_LEAVE; TrackMouseEvent(&mouse); break; } case WM_MOUSELEAVE: ReleaseCapture(); break; case WM_LBUTTONDOWN: { int y = GET_Y_LPARAM(lParam); if (y > 20) { int mark = ((y - 20) / 15) + traceOffset; traceCursor = mark; InvalidateRect(hwnd, nullptr, FALSE); } break; } case WM_PAINT: { PAINTSTRUCT ps; HDC hdc = BeginPaint(hwnd, &ps); DrawExecutionTrace(BackBuffer_.DeviceContext, &BackBuffer_.Rect); BitBlt(hdc, 0, 0, BackBuffer_.Width, BackBuffer_.Height, BackBuffer_.DeviceContext, horizontalOffset, 0, SRCCOPY); EndPaint(hwnd, &ps); break; } case WM_DESTROY: ReleaseCapture(); DeleteDC(BackBuffer_.DeviceContext); break; } return DefWindowProcW(hwnd, msg, wParam, lParam); } //------------------------------------------------------------------------------- void SetTraceSamples() { HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_MAX_TRACE_SAMPLES); int index = SendMessage(hCtl, CB_GETCURSEL, (WPARAM)0, (LPARAM)0); TCHAR buf[256] = { 0 }; SendMessage(hCtl, (UINT)CB_GETLBTEXT, (WPARAM)index, (LPARAM)buf); std::string samples = buf; int maxSamples = std::stoi(samples); EmuState.Debugger.SetTraceMaxSamples(maxSamples); ExportStop = maxSamples; auto total = maxSamples; auto visible = tracePage; auto pos = 0; SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE; si.nMin = 0; si.nPage = visible; si.nMax = total > visible ? total - 1 : 0; si.nPos = pos; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); } //------------------------------------------------------------------------------- void SetupControls(HWND hDlg) { RECT Rect; GetClientRect(hDlg, &Rect); WNDCLASSW rwc = {0}; rwc.lpszClassName = L"TraceWindow"; rwc.hbrBackground = GetSysColorBrush(COLOR_BTNFACE); rwc.style = CS_HREDRAW; rwc.lpfnWndProc = PanelProc; rwc.hCursor = LoadCursor(nullptr, IDC_ARROW); RegisterClassW(&rwc); hWndTrace = CreateWindowExW(WS_EX_STATICEDGE, L"TraceWindow", nullptr, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0, 140, Rect.right - ScrollBarWidth, Rect.bottom - 197, hDlg, (HMENU)1, nullptr, nullptr); tracePage = (Rect.bottom - 218) / 15; HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_MAX_TRACE_SAMPLES); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"10000"); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"100000"); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"250000"); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"500000"); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"1000000"); SendMessage(hCtl, (UINT)CB_ADDSTRING, 0, (LPARAM)"2000000"); SendMessage(hCtl, (UINT)CB_SETCURSEL, 0, 0); SetTraceSamples(); hWndVScrollBar = CreateWindowEx( 0, "SCROLLBAR", nullptr, WS_VISIBLE | WS_CHILD | SBS_VERT, Rect.right - ScrollBarWidth, ScrollBarTop, ScrollBarWidth, Rect.bottom - 58 - ScrollBarTop, hDlg, (HMENU)IDT_TRC_VSCROLLBAR, (HINSTANCE)GetWindowLong(hDlg, GWL_HINSTANCE), nullptr); if (!hWndVScrollBar) { MessageBox(nullptr, "Vertical Scroll Bar Failed.", "Error", MB_OK | MB_ICONERROR); return; } SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; si.nMin = 0; si.nMax = 10000; si.nPage = tracePage; si.nPos = 0; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); hWndHScrollBar = CreateWindowEx( 0, "SCROLLBAR", nullptr, WS_VISIBLE | WS_CHILD | SBS_HORZ, 0, Rect.bottom - 39 - ScrollBarWidth, Rect.right - ScrollBarWidth, ScrollBarWidth, hDlg, (HMENU)IDT_TRC_HSCROLLBAR, (HINSTANCE)GetWindowLong(hDlg, GWL_HINSTANCE), nullptr); if (!hWndVScrollBar) { MessageBox(nullptr, "Vertical Scroll Bar Failed.", "Error", MB_OK | MB_ICONERROR); return; } showHScrollBar = true; horizontalWidth = EmuState.CpuType == 0 ? 965 : 1035; si.cbSize = sizeof(si); si.fMask = SIF_ALL; si.nMin = 0; si.nMax = horizontalWidth; si.nPage = Rect.right - ScrollBarWidth; si.nPos = 0; SetScrollInfo(hWndHScrollBar, SB_CTL, &si, TRUE); SetFocus(hWndTrace); } //------------------------------------------------------------------------------- void GetAddressList(int hListCtl, Debugger::triggerbuffer_type& list) { HWND hCtl = GetDlgItem(hWndExecutionTrace, hListCtl); int count = SendMessage(hCtl, LB_GETCOUNT, (WPARAM)0, (LPARAM)0); for (int n = 0; n < count; n++) { TCHAR buf[256] = { 0 }; SendMessage(hCtl, (UINT)LB_GETTEXT, (WPARAM)n, (LPARAM)buf); int addr; std::istringstream is(buf); is >> std::hex >> addr; if (addr > 0xffff) { throw std::out_of_range("Trigger address is too large"); } list.push_back(static_cast(addr)); } } //------------------------------------------------------------------------------- void UpdateTriggers(int hListCtl) { bool startTrigger = hListCtl == IDC_LIST_START_TRACE; Debugger::triggerbuffer_type triggers; GetAddressList(hListCtl, triggers); if (startTrigger) { EmuState.Debugger.SetTraceStartTriggers(triggers); } else { EmuState.Debugger.SetTraceStopTriggers(triggers); } } //------------------------------------------------------------------------------- void EnableTrace() { traceOffset = 0; EmuState.Debugger.ResetTrace(); SetTraceSamples(); UpdateTriggers(IDC_LIST_START_TRACE); UpdateTriggers(IDC_LIST_STOP_TRACE); EmuState.Debugger.SetTraceEnable(); UpdateTraceStatus(TraceStatus::Enabled); } //------------------------------------------------------------------------------- void StopTrace() { EmuState.Debugger.SetTraceDisable(); UpdateTraceStatus(TraceStatus::Stopped); } //------------------------------------------------------------------------------- void ResetTrace() { traceOffset = 0; EmuState.Debugger.ResetTrace(); UpdateTraceStatus(TraceStatus::Stopped); } //------------------------------------------------------------------------------- void AddAddressTrace(int hListCtl) { HWND hCtl = GetDlgItem(hWndExecutionTrace, IDC_EDIT_TRACE_ADDR); TCHAR buf[256]; GetWindowText(hCtl, buf, 256); std::string addr = buf; for (auto& c : addr) c = toupper(c); if ((addr.size() != 4) || (addr.find_first_not_of("0123456789ABCDEF") != std::string::npos)) { MessageBox(hWndExecutionTrace, "Enter a validate 4 byte hex address", "Invalid Address", IDOK); return; } hCtl = GetDlgItem(hWndExecutionTrace, hListCtl); int pos = SendMessage(hCtl, LB_ADDSTRING, 0, (LPARAM)addr.c_str()); SendMessage(hCtl, LB_SETITEMDATA, pos, (LPARAM)0); SendMessage(hCtl, LB_SETCURSEL, pos, 0); UpdateTriggers(hListCtl); } //------------------------------------------------------------------------------- void RemoveAddressTrace(int hListCtl) { HWND hCtl = GetDlgItem(hWndExecutionTrace, hListCtl); int selected = SendMessage(hCtl, LB_GETCURSEL, 0, 0); if (selected != LB_ERR) { SendMessage(hCtl, LB_DELETESTRING, selected, 0); UpdateTriggers(hListCtl); } } //------------------------------------------------------------------------------- void SetTraceConfiguration() { HWND hCtl; int checked; hCtl = GetDlgItem(hWndExecutionTrace, IDC_SHOW_SCN_TRACE); checked = SendMessage(hCtl, BM_GETCHECK, 0, 0); bool captureScreenTraces = checked == BST_CHECKED; hCtl = GetDlgItem(hWndExecutionTrace, IDC_SHOW_EMU_TRACE); checked = SendMessage(hCtl, BM_GETCHECK, 0, 0); bool captureEmulationTraces = checked == BST_CHECKED; EmuState.Debugger.SetTraceOptions(captureScreenTraces, captureEmulationTraces); } //------------------------------------------------------------------------------- LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) { if (nCode < 0) // do not process message return CallNextHookEx(hHookKeyboard, nCode, wParam, lParam); BOOL upFlag = (HIWORD(lParam) & KF_UP) == KF_UP; // Only process Key Down events if (!upFlag) { if (wParam == VK_UP) { traceCursor--; if (traceCursor < 0) { traceCursor = 0; } // Keep trace in range of cursor. if (traceCursor < traceOffset) { traceOffset--; if (traceOffset < 0) { traceOffset = 0; } SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); si.nPos = traceOffset; si.fMask = SIF_POS; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); } InvalidateRect(hWndTrace, nullptr, FALSE); } if (wParam == VK_DOWN) { long samples = EmuState.Debugger.GetTraceSamples(); traceCursor++; if (traceCursor >= samples) { traceCursor = std::max(0l, samples - 1); } if (traceCursor >= traceOffset + tracePage) { traceOffset++; if ((traceOffset + tracePage) >= samples) { traceOffset = samples - tracePage; } SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); si.nPos = traceOffset; si.fMask = SIF_POS; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); } InvalidateRect(hWndTrace, nullptr, FALSE); } if (wParam == '1') { EmuState.Debugger.SetTraceMark(1, traceCursor); InvalidateRect(hWndTrace, nullptr, FALSE); } if (wParam == '2') { EmuState.Debugger.SetTraceMark(2, traceCursor); InvalidateRect(hWndTrace, nullptr, FALSE); } } return CallNextHookEx(hHookKeyboard, nCode, wParam, lParam); } //------------------------------------------------------------------------------- void CaptureKeyboardEvents() { if (hHookKeyboard == nullptr) { hHookKeyboard = SetWindowsHookEx( WH_KEYBOARD, KeyboardProc, nullptr, GetCurrentThreadId()); } } //------------------------------------------------------------------------------- void ReleaseKeyboard() { if (hHookKeyboard != nullptr) { UnhookWindowsHookEx(hHookKeyboard); hHookKeyboard = nullptr; } } //------------------------------------------------------------------------------- // Export trace to open file //------------------------------------------------------------------------------- void WriteTrace(HANDLE hf, unsigned int start, unsigned int nlines) { EmuState.Debugger.LockTrace(); unsigned int offset = start > 1 ? start-1 : 0; auto & _trace = EmuState.Debugger.GetTraceResult(); int count = std::min((unsigned int)_trace.size(), nlines); const size_t lineSize = 65536; char *line = new char[lineSize]; // FIXME: This is needed and should not be commented out. Wrap it conditional // either here or in the debug log functions. //FilePrintf(hf,"offset:%d nlines:%d count%d _tsize:%d\n", // offset, nlines, count, _trace.size()); char* pos = line; const char* end = pos + lineSize; DWORD dummy; auto Flush = [&]() { WriteFile(hf, line, pos - line, &dummy, nullptr); pos = line; }; auto Write = [&](const char* fmt, ...) { va_list args; va_start(args, fmt); auto remaining = end - pos; auto count = vsnprintf(pos, remaining, fmt, args); va_end(args); pos += count; if (end - pos < 100) Flush(); }; Write(" Line Cycles PC Instruction "); if (EmuState.CpuType == 1) Write("CC D W X Y U S DP MD\n"); else Write("CC D X Y U S DP\n"); for (int n = 0; n < count; n++) { Write("%7d ",n + offset + 1); // Line Write("%7d ",_trace[n].cycleTime); // Cycles // Instruction if (_trace[n].event == TraceEvent::Instruction) { Write("%4X ",_trace[n].pc); // Address std::string s = _trace[n].instruction + " " + _trace[n].operand; Write("%-19s ",s.c_str()); // Instruction Write(ToCCStringCStr(_trace[n].startState.CC)); // CC Write(" %02X%02X",_trace[n].startState.A, // D _trace[n].startState.B); if (EmuState.CpuType == 1) Write(" %02X%02X",_trace[n].startState.E, _trace[n].startState.F); Write(" %04X",_trace[n].startState.X); // X Write(" %04X",_trace[n].startState.Y); // Y Write(" %04X",_trace[n].startState.U); // U Write(" %04X",_trace[n].startState.S); // S Write(" %02X",_trace[n].startState.DP); // DP if (EmuState.CpuType == 1) Write(" %02X",_trace[n].startState.MD); // MD Write("\n"); // Emulator event } else if (_trace[n].event == TraceEvent::EmulatorCycle) { Write("[Emu] :: "); switch (_trace[n].emulationState) { case 0: Write("CPUOnly\n"); break; case 1: Write("TimerIRQ\n"); break; case 2: Write("AudioSample\n"); break; case 3: Write("1stAudio\n"); break; case 4: Write("2ndTimer\n"); break; case 5: Write("1stTimer\n"); break; case 6: Write("2ndAudio\n"); break; case 7: Write("TimerAudio\n"); break; case 10: Write("CycleStart\n"); break; case 20: Write("CycleEnd\n"); break; default: Write("\n"); } // Screen or IRQ event } else if ((_trace[n].event > TraceEvent::ScreenStart && _trace[n].event < TraceEvent::ScreenEnd ) || (_trace[n].event > TraceEvent::IRQStart && _trace[n].event < TraceEvent::IRQEnd ) ) { Write(_trace[n].instruction.c_str()); Write("\n"); } } Flush(); delete[] line; EmuState.Debugger.UnlockTrace(); } //------------------------------------------------------------------------------- // Select file using standard dialog //------------------------------------------------------------------------------- BOOL ChooseTraceFile(HWND hOwn,char * filename,int namsiz) { FileDialog dlg; dlg.setFilter("Text File\0*.txt;\0All files\0*.*\0\0"); dlg.setDefExt("txt"); dlg.setTitle("Select Trace File"); dlg.setFlags(OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT); if ( dlg.show(1,hOwn) ) { dlg.getpath(filename,namsiz); return TRUE; } else { return FALSE; } } //------------------------------------------------------------------------------- // Export to file dialog //------------------------------------------------------------------------------- INT_PTR CALLBACK ExportTraceProc(HWND hDlg,UINT uMsg,WPARAM wPrm,LPARAM /*lPrm*/) { switch (uMsg) { case WM_INITDIALOG: SetDlgItemInt(hDlg,IDC_EDIT_START,ExportStart,FALSE); SetDlgItemInt(hDlg,IDC_EDIT_STOP,ExportStop,FALSE); SetDlgItemText(hDlg,IDC_ERROR_TEXT,""); return TRUE; case WM_COMMAND: switch (LOWORD(wPrm)) { case IDOK: { ExportStart = GetDlgItemInt(hDlg,IDC_EDIT_START,nullptr,FALSE); ExportStop = GetDlgItemInt(hDlg,IDC_EDIT_STOP,nullptr,FALSE); int count = ExportStop-ExportStart+1; if ((count < 1) || (count > EmuState.Debugger.GetTraceSamples())) { SetDlgItemText(hDlg,IDC_ERROR_TEXT,"Invalid Line Range"); return FALSE; } ChooseTraceFile(hDlg, ExportPath, MAX_PATH); HANDLE hFile = CreateFile(ExportPath, GENERIC_READ | GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (hFile != INVALID_HANDLE_VALUE) { WriteTrace(hFile,ExportStart,count); CloseHandle(hFile); EndDialog(hDlg, (INT_PTR) nullptr); } else { SetDlgItemText(hDlg,IDC_ERROR_TEXT,"File create failed!"); return FALSE; } return TRUE; } case IDCANCEL: EndDialog(hDlg, (INT_PTR) nullptr); return TRUE; } break; case WM_CLOSE: EndDialog(hDlg, (INT_PTR) nullptr); return TRUE; } return FALSE; } void SaveSettings(HWND hDlg) { constexpr int cHeaderHeight = 20; // header with labels RECT CurWindow; ::GetWindowRect(hDlg, &CurWindow); RECT CurScreen; ::GetClientRect(hDlg, &CurScreen); int clientWidth = (int)CurScreen.right; int clientHeight = (int)CurScreen.bottom; { VCC::Rect rect; // remember positioning: rect.x = CurWindow.left; rect.y = CurWindow.top; // remember size: rect.w = clientWidth; // Used for saving new window size to the ini file. rect.h = clientHeight - cHeaderHeight; auto& s = Setting(); auto write = [&](const std::string& key, int value) { s.write(cSection, key, value); }; write(cWindowSizeX, rect.w); write(cWindowSizeY, rect.h); write(cWindowPosX, rect.x); write(cWindowPosY, rect.y); } } void LoadSettings(HWND hDlg) { if (hDlg != nullptr) { Rect rect; rect.x = CW_USEDEFAULT; rect.y = CW_USEDEFAULT; rect.w = 465; rect.h = 485; if (!GetAsyncKeyState(VK_SHIFT)) { auto& s = Setting(); auto read = [&](const std::string& key, int& value) { value = s.read(cSection, key, value); }; read(cWindowSizeX, rect.w); read(cWindowSizeY, rect.h); read(cWindowPosX, rect.x); read(cWindowPosY, rect.y); } RECT ra = { 0,0,0,0 }; // left,top,right,bottom ::AdjustWindowRect(&ra, WS_OVERLAPPEDWINDOW, TRUE); int windowBorderWidth = ra.right - ra.left; int windowBorderHeight = ra.bottom - ra.top; ::GetWindowRect(hDlg, &ra); int width = rect.w + windowBorderWidth; int height = rect.h + windowBorderHeight + 0; /*GetRenderWindowStatusBarHeight();*/ int flags = SWP_NOOWNERZORDER | SWP_NOZORDER; int x = rect.IsDefaultX() ? ra.left : rect.x; int y = rect.IsDefaultY() ? ra.top : rect.y; SetWindowPos(hDlg, nullptr, x, y, width, height, flags); } } //------------------------------------------------------------------------------- // Trace window processing //------------------------------------------------------------------------------- INT_PTR CALLBACK ExecutionTraceDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_INITDIALOG: { RECT Rect; GetClientRect(hDlg, &Rect); hWndExecutionTrace = hDlg; SetupControls(hDlg); SetTimer(hDlg, IDT_PROC_TIMER, 100, nullptr); LoadSettings(hDlg); break; } case WM_MOUSEWHEEL: { SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); int delta = GET_WHEEL_DELTA_WPARAM(wParam); if (delta < 0) { si.nPos += si.nPage / 2; } else { si.nPos -= si.nPage / 2; } si.nPos = roundUp(si.nPos, si.nPage / 2); si.fMask = SIF_POS; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hWndVScrollBar, SB_CTL, &si); traceOffset = si.nPos; if (status == TraceStatus::Loaded) { status = TraceStatus::LoadPage; } InvalidateRect(hWndTrace, &BackBuffer_.Rect, FALSE); return 0; } case WM_VSCROLL: { SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndVScrollBar, SB_CTL, &si); switch ((int)LOWORD(wParam)) { case SB_PAGEUP: si.nPos -= si.nPage; break; case SB_PAGEDOWN: si.nPos += si.nPage; break; case SB_THUMBPOSITION: si.nPos = si.nTrackPos; break; case SB_THUMBTRACK: si.nPos = si.nTrackPos; break; case SB_TOP: si.nPos = 0; break; case SB_BOTTOM: si.nPos = si.nMax; break; case SB_ENDSCROLL: break; case SB_LINEUP: si.nPos -= si.nPage / 2; break; case SB_LINEDOWN: si.nPos += si.nPage / 2; break; } si.nPos = roundUp(si.nPos, si.nPage / 2); si.fMask = SIF_POS; SetScrollInfo(hWndVScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hWndVScrollBar, SB_CTL, &si); traceOffset = si.nPos; if (status == TraceStatus::Loaded) { status = TraceStatus::LoadPage; } InvalidateRect(hWndTrace, &BackBuffer_.Rect, FALSE); return 0; } case WM_HSCROLL: { SCROLLINFO si; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hWndHScrollBar, SB_CTL, &si); switch ((int)LOWORD(wParam)) { case SB_PAGELEFT: si.nPos -= si.nPage; break; case SB_PAGERIGHT: si.nPos += si.nPage; break; case SB_THUMBPOSITION: si.nPos = si.nTrackPos; break; case SB_THUMBTRACK: si.nPos = si.nTrackPos; break; case SB_LEFT: si.nPos = 0; break; case SB_RIGHT: si.nPos = si.nMax; break; case SB_ENDSCROLL: break; case SB_LINELEFT: si.nPos -= si.nPage / 2; break; case SB_LINERIGHT: si.nPos += si.nPage / 2; break; } si.fMask = SIF_POS; SetScrollInfo(hWndHScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hWndHScrollBar, SB_CTL, &si); horizontalOffset = si.nPos; InvalidateRect(hWndTrace, &BackBuffer_.Rect, FALSE); return 0; } case WM_GETMINMAXINFO: { LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam; lpMMI->ptMinTrackSize.x = 475; lpMMI->ptMinTrackSize.y = 570; break; } case WM_SIZE: { UINT width = LOWORD(lParam); UINT height = HIWORD(lParam); ResizeWindow(width, height); return 0; } case WM_TIMER: switch (wParam) { case IDT_PROC_TIMER: { // only refresh display if something actually changed! static TraceStatus oldStatus = TraceStatus::Stopped; static long oldSamples = 0; auto samples = EmuState.Debugger.GetTraceSamples(); if (oldStatus != status || oldSamples != samples) { oldStatus = status; oldSamples = samples; InvalidateRect(hWndTrace, &BackBuffer_.Rect, FALSE); } return 0; } } break; case WM_CLOSE: DestroyWindow(hDlg); break; case WM_NCDESTROY: SaveSettings(hDlg); KillTimer(hDlg, IDT_PROC_TIMER); ExecutionTraceWindow = nullptr; break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDC_MAX_TRACE_SAMPLES: if (HIWORD(wParam) == CBN_SELCHANGE) { SetTraceSamples(); } break; case IDC_BTN_ENABLE_TRACE: EnableTrace(); break; case IDC_BTN_STOP_TRACE: StopTrace(); break; case IDC_BTN_RESET_TRACE: ResetTrace(); break; case IDC_BTN_EXPORT: ReleaseKeyboard(); DialogBox(g_hinstDLG,(LPCTSTR) IDD_EXPORT,hDlg,(DLGPROC) ExportTraceProc); break; case IDC_BTN_ADD_START_TRACE: AddAddressTrace(IDC_LIST_START_TRACE); break; case IDC_BTN_DEL_START_TRACE: RemoveAddressTrace(IDC_LIST_START_TRACE); break; case IDC_BTN_ADD_STOP_TRACE: AddAddressTrace(IDC_LIST_STOP_TRACE); break; case IDC_BTN_DEL_STOP_TRACE: RemoveAddressTrace(IDC_LIST_STOP_TRACE); break; case IDC_SHOW_EMU_TRACE: case IDC_SHOW_SCN_TRACE: SetTraceConfiguration(); break; case IDCLOSE: break; } break; } return FALSE; } } //------------------------------------------------------------------------------- // Open Trace Window //------------------------------------------------------------------------------- void VCC::Debugger::UI::OpenExecutionTraceWindow(HINSTANCE instance, HWND parent) { g_hinstDLG = instance; if (ExecutionTraceWindow == nullptr) { ExecutionTraceWindow = CreateDialog( instance, MAKEINTRESOURCE(IDD_EXEC_TRACE), parent, ExecutionTraceDlgProc); ShowWindow(ExecutionTraceWindow, SW_SHOWNORMAL); } SetFocus(ExecutionTraceWindow); }