//------------------------------------------------------------------ // Display VCC memory for debugging // // This file is part of VCC (Virtual Color Computer). // Copyright 2015 by Joseph Forgione // // 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 // . // // Memory Map Display - Part of the Debugger package for VCC // Authors: Mike Rojas, Chet Simpson // New Enhanced Version 2026/08/01: Craig Allsop, EJJaquay //------------------------------------------------------------------ #include "MemoryMap.h" #include "Debugger.h" #include "DebuggerUtils.h" #include "defines.h" #include "../../src/core/tcc1014mmu.h" #include "resource.h" #include "pakinterface.h" #include "../../src/core/tcc1014graphics.h" #include "config.h" #include #include #include #include namespace VCC::Debugger::UI { namespace { MemoryWindow* gMemoryWindows[2] = { 0, 0 }; // windows will allow the track bar to be positioned // pixel by pixel, but it will snap to the // nearest whole value. as the horizontal scrolling // will use small numbers, this causes a visible jumping // of the track bar which is distracting, so instead // allow higher resolution for the track bar and scale // the result. constexpr int cHorzScrollFactor = 10; constexpr int cTopBarStaticWidth = 510; // the tool bar constexpr int cTopBarHeight = 34; constexpr int cHeaderHeight = 20; // header with labels constexpr int cVertScrollBarWidth = 20; constexpr int cHorzScrollBarHeight = 20; // bottom scroll bar constexpr int cAddressWidth = 60; // address column width constexpr int cAsciiCharWidth = 7; // Help text const char *cDbgHelp = "The default memory type displayed is 'CPU'.\n" "Dropdown will select 'REAL', 'ROM', or 'PAK'.\n\n" "In addition to the scroll bar the mouse wheel,\n" "Home, End, PgUp, PgDn, Up, and Down keys\n" "will scroll the display.\n\n" "Select hex to be edited by clicking on a\n" "cell. The cell will turn red and it's address\n" "will be displayed next to the box. Enter byte\n" "values in hexadecimal. ESC to end edit.\n\n" "Select display mode: Ascii, SG4, PMODE, HSCREEN.\n\n" "Click hex title to collapse/expand hex.\n" "Click view title to switch between normal/gime width\n" "and the full width.\n\n" "Other Keys:\n" " [ ] Dec/inc data row width by 1.\n" " { } Dec/inc data row width by 8.\n" ""; } const std::string MemoryWindow::cMemoryWindow("MemoryWindow"); const std::string MemoryWindow::cMemoryWindow2("MemoryWindow2"); const std::string MemoryWindow::cWindowSizeX("WindowSizeX"); const std::string MemoryWindow::cWindowSizeY("WindowSizeY"); const std::string MemoryWindow::cWindowPosX("WindowPosX"); const std::string MemoryWindow::cWindowPosY("WindowPosY"); const std::string MemoryWindow::cAddress("Address"); const std::string MemoryWindow::cAddressMode("AddressMode"); const std::string MemoryWindow::cViewMode("ViewMode"); const std::string MemoryWindow::cHex("Hex"); const std::string MemoryWindow::cWide("Wide"); const std::string MemoryWindow::cDataWidth("DataWidth"); const std::string MemoryWindow::cDataPosX("DataPosX"); struct MemoryWindow::Measurements { const MemoryWindow* mem; int showHex; bool showAscii; int top; int bottom; int left; int right; int height; int width; int hexDigitsWidth; // width of hex digits int hexMinColums; // hex shown columns int hexColumns; // hex columns visible int hexWidth; // hex window width (pixels) int viewWidth; // view window width (pixels) int viewOffset; // view window buffer offset int viewColumns; // view window columns (bytes) int viewMaxColumns; // maximum number of view columns (gime) int viewMaxWidth; // view window maximum width (pixels) int viewWinWidth; // view window minimum width (pixels) float viewCellWidth; int lineHeight; int currLineTop; int viewPosX; // view window horizontal scroll int viewStep; // scrolling increment const int fontHeight = 12; const int maxDataWidth[MemoryWindow::VM_MAX] = { 256,//VM_ASCII, 32,//VM_SG4, 16,//VM_PMODE0_S0, 16,//VM_PMODE0_S1, 32,//VM_PMODE1_S0, 32,//VM_PMODE1_S1, 16,//VM_PMODE2_S0, 16,//VM_PMODE2_S1, 32,//VM_PMODE3_S0, 32,//VM_PMODE3_S1, 32,//VM_PMODE4_RGB_S0, 32,//VM_PMODE4_RGB_S1, 32,//VM_PMODE4_NTSC, 40,//VM_TEXT40, 80,//VM_TEXT80, 80,//VM_HSCREEN1, 160,//VM_HSCREEN2, 80,//VM_HSCREEN3, 80,//VM_HSCREEN4 }; const int pixelViewWidth[MemoryWindow::VM_MAX] = { 8,//VM_ASCII, 8,//VM_SG4, 16,//VM_PMODE0_S0, 16,//VM_PMODE0_S1, 8,//VM_PMODE1_S0, 8,//VM_PMODE1_S1, 16,//VM_PMODE2_S0, 16,//VM_PMODE2_S1, 8,//VM_PMODE3_S0, 8,//VM_PMODE3_S1, 8,//VM_PMODE4_RGB_S0, 8,//VM_PMODE4_RGB_S1, 8,//VM_PMODE4_NTSC, 4,//VM_TEXT40, 2,//VM_TEXT80, 4,//VM_HSCREEN1, 2,//VM_HSCREEN2, 4,//VM_HSCREEN3, 2,//VM_HSCREEN4 }; // // construct display measurements from back buffer client rectangle // Measurements(const MemoryWindow *mem, LPCRECT clientRect) : mem(mem) { showHex = mem->showHex; showAscii = mem->viewMode == MemoryWindow::VM_ASCII; // rect top = clientRect->top; bottom = clientRect->bottom - cHeaderHeight; left = clientRect->left; right = clientRect->right; height = bottom - top; width = right - left; // hex column info hexDigitsWidth = 18; hexColumns = mem->dataWidth > 32 ? 32 : mem->dataWidth; hexMinColums = hexColumns < 16 ? 16 : hexColumns; hexWidth = HexColumnPos(hexMinColums); if (!showHex) { hexWidth = HexColumnPos(0) + 10; hexColumns = 0; } // include a gutter after width of 16 int gutter = (hexColumns > 16 && hexColumns & 7) ? 10 : 0; // view column info viewMaxColumns = (mem->dataWidth > maxDataWidth[mem->viewMode] ? maxDataWidth[mem->viewMode] : mem->dataWidth); viewColumns = mem->showWideView ? mem->dataWidth : viewMaxColumns; viewWidth = width - hexWidth - gutter; // view width is remaining width viewWinWidth = viewColumns * 2 * pixelViewWidth[mem->viewMode]; viewMaxWidth = (viewWidth - 2) & (~0xF); // round view width viewOffset = 0; int charWidth = 16; viewStep = 1; if (mem->viewMode == MemoryWindow::VM_TEXT40 || mem->viewMode == MemoryWindow::VM_TEXT80) { charWidth = 4; viewStep = 2; } if (viewMaxWidth > viewColumns * charWidth * pixelViewWidth[mem->viewMode]) viewMaxWidth = viewColumns * charWidth * pixelViewWidth[mem->viewMode]; // line rows lineHeight = (height / 32) - 1; currLineTop = top + cHeaderHeight; if (mem->viewMode == MemoryWindow::VM_SG4) { if (viewMaxWidth > viewColumns * 16) viewMaxWidth = viewColumns * 16; } viewCellWidth = ((float)viewMaxWidth / viewWinWidth) * pixelViewWidth[mem->viewMode] * 2; if (mem->viewMode == MemoryWindow::VM_ASCII) { viewMaxWidth = (viewWidth - 2) & (~0xF); viewColumns = std::min(viewMaxWidth / cAsciiCharWidth, mem->dataWidth); viewCellWidth = 7; } if (mem->viewMode == MemoryWindow::VM_PMODE4_NTSC) viewOffset = GetPaletteType() == 2 ? 4 : 0; // reposition view so hex is always visible const float rounding = 0.000001f; // adjust for rounding float pos = mem->dataWidth <= hexColumns ? 0 : (float)mem->dataPosX / (mem->dataWidth - hexColumns); viewPosX = roundDn(std::max(0, (int)((mem->dataWidth - viewColumns) * (pos + rounding))), viewStep); } // // left edge of hex column // int HexLeft() const { return left + cAddressWidth + 5; } // // left edge of view // int ViewLeft() const { return right - viewWidth; } // // left/right pos of hex window in view // int ViewHexLeft() const { return ViewLeft() + (int)(viewCellWidth * (mem->dataPosX - viewPosX)); } int ViewHexRight() const { return ViewHexLeft() + (int)(viewCellWidth * hexColumns); } // // return pos (pixel offset) of hex value column n // int HexColumnPos(int n) const { // hex cell spacing const int minorSpacing = hexDigitsWidth; // gutter spacing after each 8 values const int majorSpacing = 10; // calculate minor & major column position int minorColumn = n & 7; int majorColumn = n / 8; return HexLeft() + minorColumn * minorSpacing + majorColumn * (minorSpacing * 8 + majorSpacing); } // // reverse of hexColumnPos(x) given relative pixel offset // int HexPosColumn(int x) const { // move origin x -= HexLeft(); const int minorSpacing = hexDigitsWidth; const int majorSpacing = 10; int minorColumnWidth = minorSpacing; int majorColumnWidth = minorSpacing * 8 + majorSpacing; // calculate major column int majorColumn = x / majorColumnWidth; // get remainder x -= majorColumn * majorColumnWidth; // if inside gutter return invalid if (x > minorSpacing * 8) return -1; // calculate minor column int minorColumn = x / minorColumnWidth; // return column index return majorColumn * 8 + minorColumn; } // // left edge of address column // int RowAddressPos() const { return left + 10; } // // return current row, centered for text // int RowTextY() const { return currLineTop + (lineHeight - fontHeight) / 2; } }; MemoryWindow::MemoryWindow(int index) : hDlgMem(nullptr), hScrollBar(nullptr), hHorzScrollBar(nullptr), hEditAdrBeg(nullptr), hEditAdrEnd(nullptr), hEditVal(nullptr), hStatic(nullptr), ramCache(nullptr), ramPos(-1), addrMode(NotSet), viewMode(VM_SG4), winIndex(index), memSize(0), memOffset(0), selectionRangeBeg(1), selectionRangeEnd(1), rom(nullptr), isEditing(false), showHex(1), showWideView(0), editAddress(0), dataWidth(16), dataPosX(0) { } void MemoryWindow::ResetMemoryCache() { ramPos = -1; delete[] ramCache; ramCache = nullptr; } void MemoryBackBufferInfo::Init(HWND hDlgMem) { dataWidth = 640; dataHeight = 32; dataStride = dataWidth * 4; data = new char[dataStride * dataHeight]; HDC hdc = GetDC(hDlgMem); RECT frc; SetRect(&frc, 0, 0, 7 * 16, 14); // Set display Font font = CreateFont(14, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, FIXED_PITCH, TEXT("Consolas")); // Set display pen color pen = CreatePen(PS_SOLID, 1, RGB(192, 192, 192)); UINT fmt = DT_LEFT | DT_VCENTER | DT_SINGLELINE; // cache main hex font (black) fontDC = CreateCompatibleDC(hdc); fontBitmap = CreateCompatibleBitmap(hdc, 7 * 16, 14); SelectObject(fontDC, fontBitmap); SelectObject(fontDC, font); DrawText(fontDC, "0123456789ABCDEF", 32, &frc, fmt); // cache secondary hex font (red) fontRedDC = CreateCompatibleDC(hdc); fontRedBitmap = CreateCompatibleBitmap(hdc, 7 * 16, 14); SelectObject(fontRedDC, fontRedBitmap); SelectObject(fontRedDC, font); SetTextColor(fontRedDC, RGB(255, 0, 0)); // Red DrawText(fontRedDC, "0123456789ABCDEF", 32, &frc, fmt); // cache ascii font frc.right = 7 * 96; fontAsciiDC = CreateCompatibleDC(hdc); fontAsciiBitmap = CreateCompatibleBitmap(hdc, 7 * 96, 14); SelectObject(fontAsciiDC, fontAsciiBitmap); SelectObject(fontAsciiDC, font); DrawText(fontAsciiDC, "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[.]^_`abcdefghijklmnopqrstuvwxyz{|}~.", 96, &frc, fmt); ReleaseDC(hDlgMem, hdc); } void MemoryBackBufferInfo::CleanupPen() { DeleteObject(pen); pen = nullptr; } void MemoryBackBufferInfo::CleanupFont() { DeleteObject(font); font = nullptr; } void MemoryBackBufferInfo::CleanupFonts(HWND hWnd) { DeleteObject(fontBitmap); DeleteObject(fontRedBitmap); DeleteObject(fontAsciiBitmap); ReleaseDC(hWnd, fontDC); DeleteDC(fontDC); fontDC = nullptr; ReleaseDC(hWnd, fontRedDC); DeleteDC(fontRedDC); fontRedDC = nullptr; ReleaseDC(hWnd, fontAsciiDC); DeleteDC(fontAsciiDC); fontAsciiDC = nullptr; } void MemoryBackBufferInfo::Cleanup(HWND hWnd) { delete[] data; data = nullptr; CleanupFonts(hWnd); CleanupFont(); CleanupPen(); CleanupBitmap(); CleanupDC(hWnd); } // // refresh the whole window // void MemoryWindow::RepaintAll() { ResetMemoryCache(); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); // clear backbuffer HBRUSH brush = (HBRUSH)GetStockObject(WHITE_BRUSH); FillRect(BackBuf.DeviceContext, &BackBuf.Rect, brush); // redraw headers DrawForm(BackBuf.DeviceContext, &BackBuf.Rect); } // // adjust vertical scroll bar based on data width // void MemoryWindow::UpdateVertScrollBar() { SCROLLINFO si = { 0 }; int visible = 32 * dataWidth; si.cbSize = sizeof(si); si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE; si.nMin = 0; si.nPage = visible; si.nMax = (memSize > visible) ? memSize - 1 : 0; si.nPos = memOffset; SetScrollInfo(hScrollBar, SB_CTL, &si, TRUE); } // // adjust horizontal scroll bar based on data width // void MemoryWindow::UpdateHorzScrollBar() { Measurements m(this,&BackBuf.Rect); int visible = (cHorzScrollFactor * (showHex ? m.hexColumns : m.viewColumns)) / m.viewStep; int total = (cHorzScrollFactor * dataWidth) / m.viewStep; int pos = (cHorzScrollFactor * dataPosX) / m.viewStep; SCROLLINFO si = { 0 }; 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(hHorzScrollBar, SB_CTL, &si, TRUE); } // // show current width // void MemoryWindow::UpdateWidthDisplay() { char info[64]; sprintf(info, "%d", dataWidth); HWND hCtl = GetDlgItem(hDlgMem, IDC_MEM_WIDTH); SendMessage(hCtl, WM_SETTEXT, 0, (LPARAM)info); } // // on user entering a new width // void MemoryWindow::CommitWidth() { char info[64]; HWND hCtl = GetDlgItem(hDlgMem, IDC_MEM_WIDTH); ComboBox_GetText(hCtl, info, 64); CommitWidth(info); } // // commit new width value or revert // void MemoryWindow::CommitWidth(const char* value) { Measurements m(this, &BackBuf.Rect); SetFocus(hEditAdrBeg); int width = atoi(value); if (width < m.viewStep || width > 256) { UpdateWidthDisplay(); return; } dataWidth = width; // if goes over end step back one line if (dataPosX + m.hexColumns > dataWidth) dataPosX = std::max(0, dataWidth - m.hexColumns); if (memOffset + 32*dataWidth + dataPosX > memSize) { dataPosX = 0; memOffset = memSize - 32*dataWidth; } ResetMemoryCache(); UpdateWidthDisplay(); UpdateHorzScrollBar(); UpdateVertScrollBar(); RepaintAll(); } // // on user picking new width from combo box // void MemoryWindow::SelectWidth() { char info[64]; strcpy(info, "-1"); HWND hCtl = GetDlgItem(hDlgMem, IDC_MEM_WIDTH); int index = (int)SendMessage(hCtl, CB_GETCURSEL, 0, 0); if (index != CB_ERR) SendMessage(hCtl, CB_GETLBTEXT, index, (LPARAM)info); CommitWidth(info); } // // setup new type of view // void MemoryWindow::SetViewType() { HWND hCtl = GetDlgItem(hDlgMem, IDC_VIEW_TYPE); ViewMode mode = (ViewMode)SendMessage(hCtl, CB_GETCURSEL, 0, 0); if (viewMode == mode) return; viewMode = mode; if (viewMode == VM_TEXT40 || viewMode == VM_TEXT80) { memOffset = roundDn(memOffset, 2); dataWidth = roundDn(dataWidth, 2); } } // // save memory window state // void MemoryWindow::SaveSettings() { RECT CurWindow; ::GetWindowRect(hDlgMem, &CurWindow); RECT CurScreen; ::GetClientRect(hDlgMem, &CurScreen); int clientWidth = (int)CurScreen.right; int clientHeight = (int)CurScreen.bottom; //if (!IsMaximized(DFState) && !DFState->FullScreen && !DFState->Exiting) { 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& section = winIndex ? cMemoryWindow2 : cMemoryWindow; auto write = [&](const std::string& key, int value) { s.write(section, key, value); }; write(cWindowSizeX, rect.w); write(cWindowSizeY, rect.h); write(cWindowPosX, rect.x); write(cWindowPosY, rect.y); // other state write(cAddress, memOffset); write(cAddressMode, (int)addrMode); write(cViewMode, (int)viewMode); write(cHex, (int)showHex); write(cWide, (int)showWideView); write(cDataWidth, dataWidth); write(cDataPosX, dataPosX); } } // // load memory window state // void MemoryWindow::LoadSettings() { auto& s = Setting(); auto& section = winIndex ? cMemoryWindow2 : cMemoryWindow; auto read = [&](const std::string& key, int& value) { value = s.read(section, key, value); }; // assign default if not read addrMode = Cpu; read(cAddress, memOffset); read(cAddressMode, (int&)addrMode); read(cViewMode, (int&)viewMode); read(cHex, (int&)showHex); read(cWide, (int&)showWideView); read(cDataWidth, dataWidth); read(cDataPosX, dataPosX); if (GetAsyncKeyState(VK_SHIFT)) { dataPosX = 0; dataWidth = 16; showWideView = 0; showHex = 1; viewMode = VM_SG4; addrMode = Cpu; memOffset = 0; } } // // setup for new data width // void MemoryWindow::SetupDataWidth(int delta) { Measurements m(this,&BackBuf.Rect); if (delta < 0) { if (GetAsyncKeyState(VK_SHIFT)) { dataWidth = (dataWidth & 7) ? dataWidth & (~7) : dataWidth - 8; if (dataWidth < m.viewStep) dataWidth = m.viewStep; } else dataWidth = dataWidth > m.viewStep ? dataWidth - m.viewStep : dataWidth; } else if (delta > 0) { if (GetAsyncKeyState(VK_SHIFT)) { dataWidth = (dataWidth & 7) ? (dataWidth + 8) & (~7) : dataWidth + 8; if (dataWidth > 256) dataWidth = 256; } else dataWidth = dataWidth < (257 - m.viewStep) ? dataWidth + m.viewStep : dataWidth; } if (dataPosX + m.hexColumns > dataWidth) dataPosX = std::max(0, dataWidth - m.hexColumns); UpdateWidthDisplay(); ResetMemoryCache(); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); // clear backbuffer HBRUSH brush = (HBRUSH)GetStockObject(WHITE_BRUSH); FillRect(BackBuf.DeviceContext, &BackBuf.Rect, brush); // adjust vertical scrolling size UpdateVertScrollBar(); UpdateHorzScrollBar(); // redraw headers DrawForm(BackBuf.DeviceContext, &BackBuf.Rect); } // // shutdown the memory window // void MemoryWindow::Shutdown() { if (hDlgMem) { SaveSettings(); KillTimer(hDlgMem, IDT_MEM_TIMER); BackBuf.Cleanup(hDlgMem); //DestroyWindow(hDlgMem); hDlgMem = nullptr; ResetMemoryCache(); } } void MemoryWindow::OnTimer(HWND hDlg) { if (addrMode == AddrMode::Cpu || addrMode == AddrMode::Real) { InvalidateRect(hDlg, &BackBuf.Rect, FALSE); } } void MemoryWindow::Paint(HWND hDlg) { if (DrawMemory(BackBuf.DeviceContext, &BackBuf.Rect)) { PAINTSTRUCT ps; HDC hdc = BeginPaint(hDlg, &ps); BitBlt(hdc, 0, 0, BackBuf.Width, BackBuf.Height, BackBuf.DeviceContext, 0, 0, SRCCOPY); EndPaint(hDlg, &ps); } } void MemoryWindow::Help(HWND hDlg) { MessageBox(hDlg,cDbgHelp,"Usage",0); SetFocus(hEditAdrBeg); } void MemoryWindow::Export() { LocateMemory(); ExportMemory(); SetFocus(hEditAdrBeg); } void MemoryWindow::ViewType() { SetViewType(); UpdateVertScrollBar(); UpdateHorzScrollBar(); RepaintAll(); UpdateWidthDisplay(); } void MemoryWindow::MemType(HWND hDlg) { SetMemType(); UpdateVertScrollBar(); UpdateHorzScrollBar(); ResetMemoryCache(); InvalidateRect(hDlg, &BackBuf.Rect, FALSE); } void MemoryWindow::LeftButton(int x, int y) { if (addrMode == AddrMode::PAK) FlashDialogWindow(); else SetEditPosition(x,y); } //------------------------------------------------------------------ // Display Memory Dialog //------------------------------------------------------------------ LRESULT CALLBACK MemoryWindowSubclassProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_ERASEBKGND: return 1; case WM_GETMINMAXINFO: { MINMAXINFO* mmi = (MINMAXINFO*)lParam; // Set minimum tracking size (width, height) mmi->ptMinTrackSize.x = 540; // Minimum width in pixels mmi->ptMinTrackSize.y = 540; // Minimum height in pixels return 0; } case WM_SIZE: { UINT width = LOWORD(lParam); UINT height = HIWORD(lParam); memoryWindow()->ResizeWindow(width, height); return 0; } case WM_LBUTTONDOWN: memoryWindow()->LeftButton(LOWORD(lParam), HIWORD(lParam)); break; case WM_VSCROLL: memoryWindow()->DoScroll(wParam); break; case WM_HSCROLL: memoryWindow()->DoHorzScroll(wParam); break; case WM_MOUSEWHEEL: { auto delta = GET_WHEEL_DELTA_WPARAM(wParam); auto amount = (delta / 30) != 0 ? (delta / 30) : delta; auto param = amount > 0 ? (WPARAM)SB_LINEUP : (WPARAM)SB_LINEDOWN; auto mw = memoryWindow(); for (int i = 0; i < std::abs(amount); ++i) mw->DoScroll((WPARAM)param); break; } case WM_PAINT: { memoryWindow()->Paint(hDlg); break; } case WM_TIMER: switch (wParam) { case IDT_MEM_TIMER: memoryWindow()->OnTimer(hDlg); } break; case WM_CLOSE: DestroyWindow(hDlg); break; case WM_NCDESTROY: { auto mw = memoryWindow(); if (mw) { mw->Shutdown(); gMemoryWindows[mw->winIndex] = nullptr; delete mw; } RemoveWindowSubclass(hDlg, MemoryWindowSubclassProc, uIdSubclass); break; } case WM_COMMAND: { switch (LOWORD(wParam)) { case IDC_MEM_TYPE: memoryWindow()->MemType(hDlg); break; case IDC_VIEW_TYPE: memoryWindow()->ViewType(); break; case IDC_BTN_EXPORT_MEM: memoryWindow()->Export(); break; case IDC_BTN_HELP: memoryWindow()->Help(hDlg); break; case IDCLOSE: break; } break; } } return DefSubclassProc(hDlg, uMsg, wParam, lParam); } // // resize the window // void MemoryWindow::ResizeWindow(int width, int height) { RECT Rect; GetClientRect(hDlgMem, &Rect); // recreate the back buffer ResetMemoryCache(); SetBackBuffer(Rect); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); DrawForm(BackBuf.DeviceContext, &BackBuf.Rect); // reposition scroll bar MoveWindow(hScrollBar, Rect.right - cVertScrollBarWidth, cTopBarHeight, cVertScrollBarWidth, Rect.bottom - cTopBarHeight, TRUE); MoveWindow(hHorzScrollBar, Rect.left, Rect.bottom - cHorzScrollBarHeight, Rect.right - cVertScrollBarWidth, cHorzScrollBarHeight, TRUE); MoveWindow(hStatic, Rect.left, 0, Rect.right, cTopBarHeight, TRUE); } void MemoryWindow::Escape() { SetEditing(false); UpdateWidthDisplay(); SetFocus(hEditAdrBeg); ResetMemoryCache(); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); } // // Subclassed Edit Value Proc // LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_CHAR: case WM_KEYUP: { switch (wParam) { case '[': case ']': case '{': case '}': case VK_OEM_4: case VK_OEM_6: case VK_RETURN: case VK_ESCAPE: return 0; } break; } case WM_KEYDOWN: { switch (wParam) { case VK_RETURN: memoryWindow()->CommitValue(); return 0; case VK_TAB: case VK_ESCAPE: memoryWindow()->Escape(); return 0; case VK_UP: case VK_DOWN: case VK_PRIOR: case VK_NEXT: case VK_HOME: case VK_END: memoryWindow()->FlashDialogWindow(); return 0; case VK_OEM_4: case VK_OEM_6: return 0; } break; } case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &EditSubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } // // width combo box edit field handling // LRESULT CALLBACK MemWidthEditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_CHAR: case WM_KEYDOWN: { switch (wParam) { case VK_RETURN: memoryWindow()->CommitWidth(); return 0; case VK_TAB: case VK_ESCAPE: memoryWindow()->Escape(); return 0; } break; } case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &MemWidthEditSubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } // // width combo box handling // LRESULT CALLBACK MemWidthComboSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_COMMAND: { switch (HIWORD(wParam)) { case CBN_SELCHANGE: case CBN_EDITCHANGE: memoryWindow()->SelectWidth(); return 0; } break; } case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &MemWidthComboSubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } void MemoryWindow::SelectAdrEnd() { LocateMemory(); SendMessage(hEditAdrEnd, EM_SETSEL, 0, -1); SetFocus(hEditAdrEnd); } void MemoryWindow::SelectAdrBeg() { LocateMemory(); SetFocus(hEditAdrBeg); } // // Subclassed Edit Address Proc // LRESULT CALLBACK EditAdrBegSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_KEYUP: case WM_CHAR: { switch (wParam) { case '[': case ']': case '{': case '}': case VK_OEM_4: case VK_OEM_6: return 0; } } break; case WM_KEYDOWN: switch (wParam) { case VK_RETURN: memoryWindow()->LocateMemory(); return 0; case VK_TAB: memoryWindow()->SelectAdrEnd(); return 0; case VK_UP: memoryWindow()->DoScroll((WPARAM)SB_LINEUP); return 0; case VK_DOWN: memoryWindow()->DoScroll((WPARAM)SB_LINEDOWN); return 0; case VK_PRIOR: memoryWindow()->DoScroll((WPARAM)SB_PAGEUP); return 0; case VK_NEXT: memoryWindow()->DoScroll((WPARAM)SB_PAGEDOWN); return 0; case VK_HOME: memoryWindow()->DoScroll((WPARAM)SB_TOP); return 0; case VK_END: memoryWindow()->DoScroll((WPARAM)SB_BOTTOM); return 0; case VK_OEM_4: memoryWindow()->SetupDataWidth(-1); return 0; case VK_OEM_6: memoryWindow()->SetupDataWidth(1); return 0; } break; case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &EditAdrBegSubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } LRESULT CALLBACK EditAdrEndSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { auto memoryWindow = [dwRefData]() { return (MemoryWindow*)dwRefData; }; switch (uMsg) { case WM_CHAR: case WM_KEYUP: { switch (wParam) { case '[': case ']': case '{': case '}': case VK_OEM_4: case VK_OEM_6: return 0; } } break; case WM_KEYDOWN: switch (wParam) { case VK_RETURN: memoryWindow()->LocateMemory(); return 0; case VK_TAB: memoryWindow()->SelectAdrBeg(); return 0; case VK_UP: memoryWindow()->DoScroll((WPARAM)SB_LINEUP); return 0; case VK_DOWN: memoryWindow()->DoScroll((WPARAM)SB_LINEDOWN); return 0; case VK_PRIOR: memoryWindow()->DoScroll((WPARAM)SB_PAGEUP); return 0; case VK_NEXT: memoryWindow()->DoScroll((WPARAM)SB_PAGEDOWN); return 0; case VK_HOME: memoryWindow()->DoScroll((WPARAM)SB_TOP); return 0; case VK_END: memoryWindow()->DoScroll((WPARAM)SB_BOTTOM); return 0; case VK_OEM_4: memoryWindow()->SetupDataWidth(-1); return 0; case VK_OEM_6: memoryWindow()->SetupDataWidth(1); return 0; } break; case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &EditAdrEndSubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } //------------------------------------------------------------------ // Read a byte from Coco Memory //------------------------------------------------------------------ unsigned char MemoryWindow::ReadMemory(int addr) { switch (addrMode) { case AddrMode::Cpu: return SafeMemRead8(addr & 0xFFFF); case AddrMode::Real: return (unsigned char) GetMem(addr); case AddrMode::ROM: if (rom == nullptr) rom = Getint_rom_pointer(); return rom[addr & 0x7FFF]; case AddrMode::PAK: return PackMem8Read(addr & 0x7FFF); } return 0; } //------------------------------------------------------------------ // Write a byte to Coco Memory //------------------------------------------------------------------ void MemoryWindow::WriteMemory(int addr, unsigned char value) { switch (addrMode) { case AddrMode::Cpu: EmuState.Debugger.QueueWrite(addr & 0xFFFF, value); break; case AddrMode::Real: SetMem(addr,value); break; case AddrMode::ROM: if (rom == nullptr) rom = Getint_rom_pointer(); rom[addr & 0x7FFF] = value; break; case AddrMode::PAK: FlashDialogWindow(); } } //------------------------------------------------------------------ // Setup back buffer for data display //------------------------------------------------------------------ void MemoryWindow::SetBackBuffer(const RECT& rc) { RECT topBar = {0}; topBar.left = rc.left + cTopBarStaticWidth; topBar.right = rc.right; topBar.top = rc.top; topBar.bottom = cTopBarHeight; // Adjust backing buffer location on client BackBuf.Rect.left = rc.left; BackBuf.Rect.right = rc.right - cVertScrollBarWidth; BackBuf.Rect.top = rc.top + cTopBarHeight; BackBuf.Rect.bottom = rc.bottom + cTopBarHeight - cHorzScrollBarHeight; BackBuf.Width = BackBuf.Rect.right - BackBuf.Rect.left; BackBuf.Height = BackBuf.Rect.bottom - BackBuf.Rect.top; HDC hdc = GetDC(hDlgMem); BackBuf.CleanupBitmap(); BackBuf.CleanupDC(hDlgMem); BackBuf.DeviceContext = CreateCompatibleDC(hdc); BackBuf.Bitmap = CreateCompatibleBitmap(hdc, BackBuf.Width, BackBuf.Height); HBITMAP old = (HBITMAP) SelectObject(BackBuf.DeviceContext, BackBuf.Bitmap); DeleteObject(old); ReleaseDC(hDlgMem, hdc); SelectObject(BackBuf.DeviceContext, BackBuf.pen); SelectObject(BackBuf.DeviceContext, BackBuf.font); } //------------------------------------------------------------------ // Create vertical scroll bar //------------------------------------------------------------------ void MemoryWindow::CreateScrollBar(const RECT& Rect) { hScrollBar = CreateWindowEx( 0, "SCROLLBAR", nullptr, WS_VISIBLE | WS_CHILD | SBS_VERT, Rect.right - cVertScrollBarWidth, //top x cTopBarHeight, //top y cVertScrollBarWidth, //width Rect.bottom - cTopBarHeight, //height hDlgMem, (HMENU)IDC_MEM_VSCROLLBAR, (HINSTANCE)GetWindowLong(hDlgMem, GWL_HINSTANCE), this); if (!hScrollBar) { MessageBox(nullptr, "Vertical Scroll Bar Failed.", "Error", MB_OK | MB_ICONERROR); } hHorzScrollBar = CreateWindowEx( 0, "SCROLLBAR", nullptr, WS_VISIBLE | WS_CHILD | SBS_HORZ, Rect.left, //top x Rect.bottom - cHorzScrollBarHeight, //top y Rect.right - cVertScrollBarWidth, //width cHorzScrollBarHeight, //height hDlgMem, (HMENU)IDC_MEM_HSCROLLBAR, (HINSTANCE)GetWindowLong(hDlgMem, GWL_HINSTANCE), this); if (!hHorzScrollBar) { MessageBox(nullptr, "Horizontal Scroll Bar Failed.", "Error", MB_OK | MB_ICONERROR); } } //------------------------------------------------------------------ // Draw display form with header and vert guide lines //------------------------------------------------------------------ void MemoryWindow::DrawForm(HDC hdc,LPCRECT clientRect) { RECT rc; Measurements m(this,clientRect); // Clear background. HBRUSH brush = (HBRUSH)GetStockObject(WHITE_BRUSH); FillRect(hdc, clientRect, brush); // Format for text UINT fmt = DT_CENTER | DT_VCENTER | DT_SINGLELINE; // Draw separator lines for border, address, and ascii MoveToEx(hdc, m.left, m.top + cHeaderHeight, nullptr); LineTo(hdc, m.right, m.top + cHeaderHeight); MoveToEx(hdc, m.left + cAddressWidth, m.top, nullptr); LineTo(hdc, m.left + cAddressWidth, m.bottom - 1); MoveToEx(hdc, m.right - m.viewWidth - 2, m.top, nullptr); LineTo(hdc, m.right - m.viewWidth - 2, m.bottom); // Horizontal separators every four rows for (int lnum = 0; lnum <= 32; lnum += 4) { MoveToEx(hdc, m.left, m.currLineTop, nullptr); LineTo(hdc, m.right, m.currLineTop); m.currLineTop += m.lineHeight * 4; } // Draw header SetTextColor(hdc, RGB(138, 27, 255)); SetRect(&rc, m.left, m.top, m.left + cAddressWidth, m.top + cHeaderHeight); DrawText(hdc, "Address", 7, &rc, fmt); if (!m.showHex) { rc.left = m.HexColumnPos(0) + 10; DrawText(hdc, ">", 1, &rc, fmt); } for (int n = 0; n < m.hexColumns; n++) { SetRect(&rc, m.HexColumnPos(n), m.top, m.HexColumnPos(n) + m.hexDigitsWidth - 4, m.top + cHeaderHeight); const std::string s(ToHexString(dataPosX + n, 2, false)); DrawText(hdc, s.c_str(), 2, &rc, fmt); } SetRect(&rc, m.right - m.viewWidth - 2, m.top, m.right - 5, m.top + cHeaderHeight); const char* viewModes[] = { "ASCII", "Semi Graphics 4", "PMODE 0 SCREEN 0 (2 colors)", "PMODE 0 SCREEN 1 (2 colors)", "PMODE 1 SCREEN 0 (4 colors)", "PMODE 1 SCREEN 1 (4 colors)", "PMODE 2 SCREEN 0 (2 colors)", "PMODE 2 SCREEN 1 (2 colors)", "PMODE 3 SCREEN 0 (4 colors)", "PMODE 3 SCREEN 1 (4 colors)", "PMODE 4 SCREEN 0 RGB (2 colors)", "PMODE 4 SCREEN 1 RGB (2 colors)", "PMODE 4 NTSC (artifact colors)", "TEXT 40", "TEXT 80", "HSCREEN 1 (4 Colors)", "HSCREEN 2 (16 Colors)", "HSCREEN 3 (2 Colors)", "HSCREEN 4 (4 Colors)" }; char temp[80]; strcpy(temp, viewModes[viewMode]); if (showWideView) strcat(temp, " - Wide"); DrawText(hdc, temp, strlen(temp), &rc, fmt); // draw hex region int left = std::max(m.ViewLeft(), m.ViewHexLeft()); int right = m.ViewHexRight(); SetRect(&rc, left, m.top + cHeaderHeight - 4, right, m.top + cHeaderHeight - 2); // draw horz bar HBRUSH blackBrush = (HBRUSH)GetStockObject(BLACK_BRUSH); FillRect(BackBuf.DeviceContext, &rc, blackBrush); auto drawBarEnd = [blackBrush,this](RECT rc, int x) { rc.top -= 2; rc.bottom += 2; rc.left = x; rc.right = x + 1; FillRect(BackBuf.DeviceContext, &rc, blackBrush); }; drawBarEnd(rc,left); drawBarEnd(rc,right - 1); } //------------------------------------------------------------------ // Fill memory data on form //------------------------------------------------------------------ bool MemoryWindow::DrawMemory(HDC hdc, LPCRECT clientRect) { bool dirty = false; bool forcedUpdate = false; memGpu.GimeReset(); memGpu.SetCompatMode(1); memGpu.SetDefaultPalette(); memGpu.SetMonitorType(1); // if palette changes pixels will need rewriting if (viewMode != VM_SG4 && memGpu.CopyPalette(gGimeGpu)) ResetMemoryCache(); auto pmode = [this](int mode, int mode2) { memGpu.SetGimeVdgMode(mode); memGpu.SetGimeVdgMode2(mode2); }; auto mon = [this](int monitor) { memGpu.SetMonitorType(monitor); }; auto gime = [this](int mode, int vres) { memGpu.SetCompatMode(0); memGpu.SetGimeVmode(mode); memGpu.SetGimeVres(vres); }; if (viewMode == VM_SG4) memGpu.SetVidMask(524287); else if (viewMode == VM_PMODE4_NTSC) pmode(6,31),mon(0); else if (viewMode == VM_PMODE0_S0) pmode(3,22); else if (viewMode == VM_PMODE0_S1) pmode(3,23); else if (viewMode == VM_PMODE1_S0) pmode(4,24); else if (viewMode == VM_PMODE1_S1) pmode(4,25); else if (viewMode == VM_PMODE2_S0) pmode(5,26); else if (viewMode == VM_PMODE2_S1) pmode(5,27); else if (viewMode == VM_PMODE3_S0) pmode(6,28); else if (viewMode == VM_PMODE3_S1) pmode(6,29); else if (viewMode == VM_PMODE4_RGB_S0) pmode(6,30),mon(1); else if (viewMode == VM_PMODE4_RGB_S1) pmode(6,31); else if (viewMode == VM_TEXT40) gime(3,5); else if (viewMode == VM_TEXT80) gime(3,21); else if (viewMode == VM_HSCREEN1) gime(128,21); else if (viewMode == VM_HSCREEN2) gime(128,122); else if (viewMode == VM_HSCREEN3) gime(128,20); else if (viewMode == VM_HSCREEN4) gime(128,29); memGpu.SetupDisplay(); memGpu.VertCenter = 0; memGpu.HorzCenter = 0; Measurements m(this,clientRect); int pixelHeight = memGpu.LinesperRow; bool hlfound = false; UINT fmt = DT_CENTER | DT_VCENTER | DT_SINGLELINE; if (!ramCache) { forcedUpdate = true; ramCache = new unsigned char[dataWidth * 32]; } // if not the same address then it will need repainting if (memOffset != ramPos) { dirty = true; ramPos = memOffset; } for (int lnum = 0; lnum < 32; lnum++, m.currLineTop += m.lineHeight) { unsigned int offset = lnum * dataWidth; unsigned int address = memOffset + offset; int x = m.RowAddressPos(); int y = m.RowTextY()+1; // Draw address of start of line BitBlt(hdc, x, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 20) & 15), 1, SRCCOPY); BitBlt(hdc, x + 7, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 16) & 15), 1, SRCCOPY); BitBlt(hdc, x + 14, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 12) & 15), 1, SRCCOPY); BitBlt(hdc, x + 21, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 8) & 15), 1, SRCCOPY); BitBlt(hdc, x + 28, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 4) & 15), 1, SRCCOPY); BitBlt(hdc, x + 35, y, 7, 12, BackBuf.fontDC, 7 * ((address >> 0) & 15), 1, SRCCOPY); // update ram cache bool update = isEditing || forcedUpdate; for (int a = 0; a < dataWidth; ++a) { auto b = ReadMemory(address + a); if (b != ramCache[offset + a]) ramCache[offset + a] = b, update = true; } // skip nothing to update if (!update) { continue; } dirty = true; // draw hex columns & view for (int n = 0; n < m.hexColumns; n++) { // Get data unsigned char val = ramCache[dataPosX + offset + n]; // Highlight data if cell is being edited bool isRed = isEditing && editAddress == address + dataPosX + n; if (isRed) hlfound = true; x = m.HexColumnPos(n); BitBlt(hdc, x, y, 7, 11, isRed ? BackBuf.fontRedDC : BackBuf.fontDC, 7 * (val >> 4), 1, SRCCOPY); BitBlt(hdc, x + 7, y, 7, 11, isRed ? BackBuf.fontRedDC : BackBuf.fontDC, 7 * (val & 15), 1, SRCCOPY); } // render ascii if (m.showAscii) { for (int n = 0; n < m.viewColumns; n++) { unsigned char val = ramCache[offset + n + m.viewPosX]; auto ch = val >= 32 && val < 127 ? val : '.'; x = m.right - m.viewWidth + n * 7 + 1; BitBlt(hdc, x, y, 7, 11, BackBuf.fontAsciiDC, cAsciiCharWidth * (ch - 34), 1, SRCCOPY); } } else { float columns = (float)m.viewMaxWidth / m.viewColumns; int columnCount = (m.viewColumns + m.viewMaxColumns - 1) / m.viewMaxColumns; int left = m.right - m.viewWidth; for (int s = 0; s < columnCount; ++s) { // reset address start to zero memGpu.TagY = 0; memGpu.StartofVidram = 0; memGpu.NewStartofVidram = 0; int columnPos = s * m.viewMaxColumns; int columnRem = std::min(m.viewMaxColumns, m.viewColumns - columnPos); // bytes to copy memGpu.BytesperRow = columnRem; // render 12 lines for (int j = 0; j < pixelHeight; ++j) memGpu.UpdateScreen32To(ramCache + lnum * dataWidth + m.viewPosX + columnPos, (unsigned int*)BackBuf.data, j, BackBuf.dataWidth, false); // blit to back buffer HBITMAP bm = CreateBitmap(BackBuf.dataWidth, BackBuf.dataHeight, 1, 32, BackBuf.data); HDC src = CreateCompatibleDC(hdc); auto obj = SelectObject(src, bm); int width = (int)(columnRem * columns); int renderedWidth = std::min(columnRem * 2 * m.pixelViewWidth[viewMode], m.viewWinWidth); StretchBlt(hdc, left, m.currLineTop, width, m.lineHeight, src, m.viewOffset, 0, renderedWidth, pixelHeight * 2, SRCCOPY); left += width; SelectObject(src, obj); DeleteObject(bm); DeleteDC(src); } } } // Not editmode if no cell highlighted. if (isEditing && !hlfound) { SetEditing(false); } return dirty; } //------------------------------------------------------------------ // Determine byte to edit based on click location //------------------------------------------------------------------ void MemoryWindow::SetEditPosition(int xPos, int yPos) { Measurements m(this,&BackBuf.Rect); auto edit = [this](bool b) { SetEditing(b); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); }; // ignore tool bar area if (yPos < cHeaderHeight) return edit(false); // check title area if (yPos < m.currLineTop) { // in title then collapse hex if (xPos > m.HexColumnPos(0) - 10 && xPos < m.HexColumnPos(m.showHex ? m.hexColumns : 1)) { showHex ^= 1; UpdateHorzScrollBar(); RepaintAll(); } else if (xPos > m.HexColumnPos(m.showHex ? m.hexColumns : 1)) { showWideView ^= 1; UpdateHorzScrollBar(); RepaintAll(); } return edit(false); } // work out which row int row = (yPos - m.currLineTop) / m.lineHeight; // if out of bounds abort if (row < 0 || row >= 32) return edit(false); // work out which column int col = m.HexPosColumn(xPos); // if out of bounds abort if (col < 0 || col >= m.hexColumns) return edit(false); // hit editAddress = memOffset + col + row * dataWidth + dataPosX; return edit(true); } //------------------------------------------------------------------ // Determine data to display based on address box //------------------------------------------------------------------ void MemoryWindow::LocateMemory() { char buf[32] = {0}; SendDlgItemMessage(hDlgMem, IDC_EDIT_RANGE_BEG, WM_GETTEXT, sizeof(buf), (LPARAM) buf); selectionRangeBeg = CStrToHex(buf); SendDlgItemMessage(hDlgMem, IDC_EDIT_RANGE_END, WM_GETTEXT, sizeof(buf), (LPARAM)buf); selectionRangeEnd = CStrToHex(buf); if (selectionRangeEnd < selectionRangeBeg) { selectionRangeEnd = selectionRangeBeg; } std::string begStr = ToHexString(selectionRangeBeg, 6, true); std::string endStr = ToHexString(selectionRangeEnd, 6, true); SetDlgItemText(hDlgMem, IDC_EDIT_RANGE_BEG, begStr.c_str()); SetDlgItemText(hDlgMem, IDC_EDIT_RANGE_END, endStr.c_str()); if (selectionRangeBeg < 0) { selectionRangeBeg = selectionRangeEnd = -1; FlashDialogWindow(); SetEditing(false); return; } SCROLLINFO si = {0}; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hScrollBar, SB_CTL, &si); si.nPos = roundDn(selectionRangeBeg, dataWidth); si.fMask = SIF_POS; SetScrollInfo(hScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hScrollBar, SB_CTL, &si); memOffset = si.nPos; InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); } //------------------------------------------------------------------ // Export the selected range to disk //------------------------------------------------------------------ void MemoryWindow::ExportMemory() { if (selectionRangeBeg < 0 || selectionRangeEnd < 0) { FlashDialogWindow(); SetEditing(false); return; } FileDialog dlg; dlg.setFilter("BIN\0*.bin\0\0"); dlg.setDefExt("bin"); dlg.setTitle(TEXT("Export Memory Range")); dlg.setFlags(OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT); if (dlg.show(1)) { std::ofstream fout(dlg.path(), std::ios::out | std::ios::trunc | std::ios::binary); for (int adr = selectionRangeBeg; adr <= selectionRangeEnd; adr++) { unsigned char val = ReadMemory(adr); fout.write(reinterpret_cast(&val), sizeof(val)); } MessageBox(hDlgMem, "Export Complete", "Export", 0); } } //------------------------------------------------------------------ // Commit edit value to memory //------------------------------------------------------------------ void MemoryWindow::CommitValue() { if (!isEditing) { FlashDialogWindow(); SetDlgItemText(hDlgMem, IDC_EDIT_VALUE, ""); return; } // Fetch then clear the data to commit char buf[32] = {0}; SendDlgItemMessage(hDlgMem, IDC_EDIT_VALUE, WM_GETTEXT, sizeof(buf), (LPARAM) buf); SetDlgItemText(hDlgMem, IDC_EDIT_VALUE, ""); int val = CStrToHex(buf); if (val < 0 || val > 255) { FlashDialogWindow(); return; } // Commit the value to memory WriteMemory(editAddress, (unsigned char) val); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); // Attempt to advance to next cell editAddress += 1; if (editAddress >= memSize) { FlashDialogWindow(); editAddress = 0; SetEditing(false); } else { SetEditing(true); } } //------------------------------------------------------------------ // Set memory type and size as per combobox index //------------------------------------------------------------------ void MemoryWindow::SetMemType() { int PhySiz[4] = { 0x20000,0x80000,0x200000,0x800000 }; HWND hCtl = GetDlgItem(hDlgMem, IDC_MEM_TYPE); AddrMode mode = (AddrMode)SendMessage(hCtl, CB_GETCURSEL, 0, 0); if (addrMode == mode) return; // Not changed addrMode = mode; switch (addrMode) { case AddrMode::Cpu: memSize = 0x10000; break; case AddrMode::Real: memSize = PhySiz[EmuState.RamSize]; break; case AddrMode::ROM: memSize = 0x8000; break; case AddrMode::PAK: memSize = 0x8000; break; } if (memOffset > memSize) memOffset = 0; } //------------------------------------------------------------------ // Memory Dialog initialization //------------------------------------------------------------------ void MemoryWindow::InitializeDialog(HWND hDlg) { hDlgMem = hDlg; RECT Rect; GetClientRect(hDlg, &Rect); BackBuf.Init(hDlg); SetBackBuffer(Rect); CreateScrollBar(Rect); hStatic = GetDlgItem(hDlg,-1); //Subclass edit boxes hEditAdrBeg = GetDlgItem(hDlg, IDC_EDIT_RANGE_BEG); SetWindowSubclass(hEditAdrBeg, &EditAdrBegSubclassProc, (UINT_PTR)this, (DWORD_PTR)this); hEditAdrEnd = GetDlgItem(hDlg, IDC_EDIT_RANGE_END); SetWindowSubclass(hEditAdrEnd, &EditAdrEndSubclassProc, (UINT_PTR)this, (DWORD_PTR)this); hEditVal = GetDlgItem(hDlg, IDC_EDIT_VALUE); SetWindowSubclass(hEditVal, &EditSubclassProc, (UINT_PTR)this, (DWORD_PTR)this); SetTimer(hDlg, IDT_MEM_TIMER, 1000/60, nullptr); // Dropdown to select memory type displayed HWND hCtl = GetDlgItem(hDlg, IDC_MEM_TYPE); SendMessage(hCtl,CB_ADDSTRING,(WPARAM) 0, (LPARAM) "CPU"); SendMessage(hCtl,CB_ADDSTRING,(WPARAM) 0, (LPARAM) "REAL"); SendMessage(hCtl,CB_ADDSTRING,(WPARAM) 0, (LPARAM) "ROM"); SendMessage(hCtl,CB_ADDSTRING,(WPARAM) 0, (LPARAM) "PAK"); SendMessage(hCtl,CB_SETCURSEL,(WPARAM)addrMode, (LPARAM) 0); // force this to update to set MemSize correctly addrMode = NotSet; SetMemType(); hCtl = GetDlgItem(hDlg, IDC_VIEW_TYPE); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"ASCII"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"SG4"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE0 S0"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE0 S1"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE1 S0"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE1 S1"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE2 S0"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE2 S1"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE3 S0"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE3 S1"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE4 S0 RGB"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE4 S1 RGB"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"PMODE4 NTSC"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"TEXT40"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"TEXT80"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"HSCREEN1"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"HSCREEN2"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"HSCREEN3"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"HSCREEN4"); SendMessage(hCtl, CB_SETCURSEL, (WPARAM)viewMode, (LPARAM)0); hCtl = GetDlgItem(hDlg, IDC_MEM_WIDTH); COMBOBOXINFO cbi = { sizeof(cbi) }; if (GetComboBoxInfo(hCtl, &cbi) && cbi.hwndItem) SetWindowSubclass(cbi.hwndItem, &MemWidthEditSubclassProc, (UINT_PTR)this, (DWORD_PTR)this); SetWindowSubclass(hCtl, &MemWidthComboSubclassProc, (UINT_PTR)this, (DWORD_PTR)this); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"16"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"20"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"32"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"40"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"64"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"80"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"128"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"160"); SendMessage(hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)"256"); SetBackBuffer(Rect); // Draw the form for memory data DrawForm(BackBuf.DeviceContext, &BackBuf.Rect); // Not edit mode SetEditing(false); UpdateVertScrollBar(); UpdateHorzScrollBar(); } void MemoryWindow::DoHorzScroll(WPARAM wParam) { SCROLLINFO si = { 0 }; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hHorzScrollBar, SB_CTL, &si); int pos = si.nPos; switch ((int)LOWORD(wParam)) { case SB_THUMBPOSITION: case SB_THUMBTRACK: si.nPos = si.nTrackPos; break; case SB_PAGEUP: si.nPos -= si.nPage; break; case SB_PAGEDOWN: si.nPos += si.nPage; 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 -= cHorzScrollFactor; break; case SB_LINEDOWN: si.nPos += cHorzScrollFactor; break; } si.fMask = SIF_POS; SetScrollInfo(hHorzScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hHorzScrollBar, SB_CTL, &si); if (pos != si.nPos) { Measurements m(this,&BackBuf.Rect); dataPosX = (si.nPos / cHorzScrollFactor) * m.viewStep; SetEditing(false); RepaintAll(); } } //------------------------------------------------------------------ // Scroll handler //------------------------------------------------------------------ void MemoryWindow::DoScroll(WPARAM wParam) { SCROLLINFO si = {0}; si.cbSize = sizeof(si); si.fMask = SIF_ALL; GetScrollInfo(hScrollBar, SB_CTL, &si); switch ((int)LOWORD(wParam)) { case SB_PAGEUP: si.nPos -= dataWidth * 32; break; case SB_PAGEDOWN: si.nPos += dataWidth * 32; break; case SB_THUMBPOSITION: 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 -= dataWidth; break; case SB_LINEDOWN: si.nPos += dataWidth; break; } si.fMask = SIF_POS; SetScrollInfo(hScrollBar, SB_CTL, &si, TRUE); GetScrollInfo(hScrollBar, SB_CTL, &si); memOffset = roundDn(si.nPos,dataWidth); InvalidateRect(hDlgMem, &BackBuf.Rect, FALSE); } //------------------------------------------------------------------ // Convert hexadecimal string to a positive long. Return -1 on error //------------------------------------------------------------------ int MemoryWindow::CStrToHex(const char * buf) { char *p; if (*buf == 0) return -1; //long n = strtoul(buf, &p, 16); int n = strtoul(buf, &p, 16); if (*p != 0) return -1; return n; } //------------------------------------------------------------------ // Set edit mode //------------------------------------------------------------------ void MemoryWindow::SetEditing(bool tf) { isEditing = tf; if (isEditing) { std::string s = "Editing " + ToHexString(editAddress,6,true); SetDlgItemText(hDlgMem, IDC_ADRTXT, s.c_str()); ShowWindow(hEditVal, SW_SHOW); SetFocus(hEditVal); } else { ResetMemoryCache(); UpdateWidthDisplay(); SetFocus(hEditAdrBeg); SetDlgItemText(hDlgMem, IDC_ADRTXT, ""); ShowWindow(hEditVal, SW_HIDE); } SetDlgItemText(hDlgMem, IDC_EDIT_VALUE, ""); } //------------------------------------------------------------------ // Input error flash //------------------------------------------------------------------ void MemoryWindow::FlashDialogWindow() { FlashWindow(hDlgMem,true); Sleep(350); FlashWindow(hDlgMem,false); } void MemoryWindow::SetWindowRect() { if (hDlgMem != nullptr) { Rect rect; rect.x = CW_USEDEFAULT; rect.y = CW_USEDEFAULT; rect.w = 620; rect.h = 570; if (!GetAsyncKeyState(VK_SHIFT)) { auto& s = Setting(); auto& section = winIndex ? cMemoryWindow2 : cMemoryWindow; auto read = [&](const std::string& key, int& value) { value = s.read(section, 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(hDlgMem, &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(hDlgMem, nullptr, x, y, width, height, flags); } } bool MemoryWindow::Init() { if (hDlgMem == nullptr) { return false; } ShowWindow(hDlgMem, SW_SHOWNORMAL); SetFocus(hEditAdrBeg); SetWindowRect(); return true; } // // main dialog procecure, only contains initdialog // INT_PTR CALLBACK MemoryWindowDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { if (uMsg == WM_INITDIALOG) { auto memoryWindow = [lParam]() { return (MemoryWindow*)lParam; }; SetWindowSubclass(hDlg, MemoryWindowSubclassProc, lParam, lParam); memoryWindow()->InitializeDialog(hDlg); // set focus return TRUE; } return FALSE; } } // end namespace //------------------------------------------------------------------ // Launch Memory Dialog //------------------------------------------------------------------ void VCC::Debugger::UI::OpenMemoryMapWindow(HINSTANCE hInst,HWND parent) { int i = 0; while (i < 2 && gMemoryWindows[i]) ++i; if (i == 2) return; auto memoryWindow = gMemoryWindows[i] = new MemoryWindow(i); memoryWindow->LoadSettings(); CreateDialogParam( hInst, MAKEINTRESOURCE(IDD_MEMORY_MAP), parent, MemoryWindowDialogProc, (LPARAM)memoryWindow); if (!memoryWindow->Init()) { MessageBox(nullptr, "CreateDialog", "Error", MB_OK | MB_ICONERROR); delete memoryWindow; } }