1// Mini memory editor for Dear ImGui (to embed in your game/tools) 2// Animated GIF: https://twitter.com/ocornut/status/894242704317530112 3// Get latest version at http://www.github.com/ocornut/imgui_club 4// 5// Right-click anywhere to access the Options menu! 6// You can adjust the keyboard repeat delay/rate in ImGuiIO. 7// The code assume a mono-space font for simplicity! If you don't use the default font, use ImGui::PushFont()/PopFont() to switch to a mono-space font before caling this. 8// 9// Usage: 10// static MemoryEditor mem_edit_1; // store your state somewhere 11// mem_edit_1.DrawWindow("Memory Editor", mem_block, mem_block_size, 0x0000); // create a window and draw memory editor (if you already have a window, use DrawContents()) 12// 13// Usage: 14// static MemoryEditor mem_edit_2; 15// ImGui::Begin("MyWindow") 16// mem_edit_2.DrawContents(this, sizeof(*this), (size_t)this); 17// ImGui::End(); 18// 19// Changelog: 20// - v0.10: initial version 21// - v0.11: always refresh active text input with the latest byte from source memory if it's not being edited. 22// - v0.12: added OptMidRowsCount to allow extra spacing every XX rows. 23// - v0.13: added optional ReadFn/WriteFn handlers to access memory via a function. various warning fixes for 64-bits. 24// - v0.14: added GotoAddr member, added GotoAddrAndHighlight() and highlighting. fixed minor scrollbar glitch when resizing. 25// - v0.15: added maximum window width. minor optimization. 26// - v0.16: added OptGreyOutZeroes option. various sizing fixes when resizing using the "Rows" drag. 27// - v0.17: added HighlightFn handler for optional non-contiguous highlighting. 28// - v0.18: fixes for displaying 64-bits addresses, fixed mouse click gaps introduced in recent changes, cursor tracking scrolling fixes. 29// - v0.19: fixed auto-focus of next byte leaving WantCaptureKeyboard=false for one frame. we now capture the keyboard during that transition. 30// - v0.20: added options menu. added OptShowAscii checkbox. added optional HexII display. split Draw() in DrawWindow()/DrawContents(). fixing glyph width. refactoring/cleaning code. 31// - v0.21: fixes for using DrawContents() in our own window. fixed HexII to actually be useful and not on the wrong side. 32// - v0.22: clicking Ascii view select the byte in the Hex view. Ascii view highlight selection. 33// - v0.23: fixed right-arrow triggering a byte write. 34// - v0.24: changed DragInt("Rows" to use a %d data format (which is desirable since imgui 1.61). 35// - v0.25: fixed wording: all occurrences of "Rows" renamed to "Columns". 36// - v0.26: fixed clicking on hex region 37// - v0.30: added data preview for common data types 38// - v0.31: added OptUpperCaseHex option to select lower/upper casing display [@samhocevar] 39// - v0.32: changed signatures to use void* instead of unsigned char* 40// - v0.33: added OptShowOptions option to hide all the interactive option setting. 41// 42// Todo/Bugs: 43// - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text cursor appear at position 1 for one frame. 44// - Using InputText() is awkward and maybe overkill here, consider implementing something custom. 45 46#pragma once 47#include <stdio.h> // sprintf, scanf 48#include <stdint.h> // uint8_t, etc. 49 50#ifdef _MSC_VER 51#define _PRISizeT "I" 52#define snprintf _snprintf 53#else 54#define _PRISizeT "z" 55#endif 56 57struct MemoryEditor 58{ 59 typedef unsigned char u8; 60 61 enum DataType 62 { 63 DataType_S8, 64 DataType_U8, 65 DataType_S16, 66 DataType_U16, 67 DataType_S32, 68 DataType_U32, 69 DataType_S64, 70 DataType_U64, 71 DataType_Float, 72 DataType_Double, 73 DataType_COUNT 74 }; 75 76 enum DataFormat 77 { 78 DataFormat_Bin = 0, 79 DataFormat_Dec = 1, 80 DataFormat_Hex = 2, 81 DataFormat_COUNT 82 }; 83 84 // Settings 85 bool Open; // = true // set to false when DrawWindow() was closed. ignore if not using DrawWindow(). 86 bool ReadOnly; // = false // disable any editing. 87 int Cols; // = 16 // number of columns to display. 88 bool OptShowOptions; // = true // display options button/context menu. when disabled, options will be locked unless you provide your own UI for them. 89 bool OptShowDataPreview; // = false // display a footer previewing the decimal/binary/hex/float representation of the currently selected bytes. 90 bool OptShowHexII; // = false // display values in HexII representation instead of regular hexadecimal: hide null/zero bytes, ascii values as ".X". 91 bool OptShowAscii; // = true // display ASCII representation on the right side. 92 bool OptGreyOutZeroes; // = true // display null/zero bytes using the TextDisabled color. 93 bool OptUpperCaseHex; // = true // display hexadecimal values as "FF" instead of "ff". 94 int OptMidColsCount; // = 8 // set to 0 to disable extra spacing between every mid-cols. 95 int OptAddrDigitsCount; // = 0 // number of addr digits to display (default calculated based on maximum displayed addr). 96 ImU32 HighlightColor; // // background color of highlighted bytes. 97 u8 (*ReadFn)(const u8* data, size_t off); // = NULL // optional handler to read bytes. 98 void (*WriteFn)(u8* data, size_t off, u8 d); // = NULL // optional handler to write bytes. 99 bool (*HighlightFn)(const u8* data, size_t off);//NULL // optional handler to return Highlight property (to support non-contiguous highlighting). 100 101 // [Internal State] 102 bool ContentsWidthChanged; 103 size_t DataPreviewAddr; 104 size_t DataEditingAddr; 105 bool DataEditingTakeFocus; 106 char DataInputBuf[32]; 107 char AddrInputBuf[32]; 108 size_t GotoAddr; 109 size_t HighlightMin, HighlightMax; 110 int PreviewEndianess; 111 DataType PreviewDataType; 112 113 MemoryEditor() 114 { 115 // Settings 116 Open = true; 117 ReadOnly = false; 118 Cols = 16; 119 OptShowOptions = true; 120 OptShowDataPreview = false; 121 OptShowHexII = false; 122 OptShowAscii = true; 123 OptGreyOutZeroes = true; 124 OptUpperCaseHex = true; 125 OptMidColsCount = 8; 126 OptAddrDigitsCount = 0; 127 HighlightColor = IM_COL32(255, 255, 255, 50); 128 ReadFn = NULL; 129 WriteFn = NULL; 130 HighlightFn = NULL; 131 132 // State/Internals 133 ContentsWidthChanged = false; 134 DataPreviewAddr = DataEditingAddr = (size_t)-1; 135 DataEditingTakeFocus = false; 136 memset(DataInputBuf, 0, sizeof(DataInputBuf)); 137 memset(AddrInputBuf, 0, sizeof(AddrInputBuf)); 138 GotoAddr = (size_t)-1; 139 HighlightMin = HighlightMax = (size_t)-1; 140 PreviewEndianess = 0; 141 PreviewDataType = DataType_S32; 142 } 143 144 void GotoAddrAndHighlight(size_t addr_min, size_t addr_max) 145 { 146 GotoAddr = addr_min; 147 HighlightMin = addr_min; 148 HighlightMax = addr_max; 149 } 150 151 struct Sizes 152 { 153 int AddrDigitsCount; 154 float LineHeight; 155 float GlyphWidth; 156 float HexCellWidth; 157 float SpacingBetweenMidCols; 158 float PosHexStart; 159 float PosHexEnd; 160 float PosAsciiStart; 161 float PosAsciiEnd; 162 float WindowWidth; 163 }; 164 165 void CalcSizes(Sizes& s, size_t mem_size, size_t base_display_addr) 166 { 167 ImGuiStyle& style = ImGui::GetStyle(); 168 s.AddrDigitsCount = OptAddrDigitsCount; 169 if (s.AddrDigitsCount == 0) 170 for (size_t n = base_display_addr + mem_size - 1; n > 0; n >>= 4) 171 s.AddrDigitsCount++; 172 s.LineHeight = ImGui::GetTextLineHeight(); 173 s.GlyphWidth = ImGui::CalcTextSize("F").x + 1; // We assume the font is mono-space 174 s.HexCellWidth = (float)(int)(s.GlyphWidth * 2.5f); // "FF " we include trailing space in the width to easily catch clicks everywhere 175 s.SpacingBetweenMidCols = (float)(int)(s.HexCellWidth * 0.25f); // Every OptMidColsCount columns we add a bit of extra spacing 176 s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth; 177 s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols); 178 s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd; 179 if (OptShowAscii) 180 { 181 s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1; 182 if (OptMidColsCount > 0) 183 s.PosAsciiStart += ((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols; 184 s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth; 185 } 186 s.WindowWidth = s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth; 187 } 188 189 // Standalone Memory Editor window 190 void DrawWindow(const char* title, void* mem_data, size_t mem_size, size_t base_display_addr = 0x0000) 191 { 192 Sizes s; 193 CalcSizes(s, mem_size, base_display_addr); 194 ImGui::SetNextWindowSizeConstraints(ImVec2(0.0f, 0.0f), ImVec2(s.WindowWidth, FLT_MAX)); 195 196 Open = true; 197 if (ImGui::Begin(title, &Open, ImGuiWindowFlags_NoScrollbar)) 198 { 199 if (ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows) && ImGui::IsMouseClicked(1)) 200 ImGui::OpenPopup("context"); 201 DrawContents(mem_data, mem_size, base_display_addr); 202 if (ContentsWidthChanged) 203 { 204 CalcSizes(s, mem_size, base_display_addr); 205 ImGui::SetWindowSize(ImVec2(s.WindowWidth, ImGui::GetWindowSize().y)); 206 } 207 } 208 ImGui::End(); 209 } 210 211 // Memory Editor contents only 212 void DrawContents(void* mem_data_void_ptr, size_t mem_size, size_t base_display_addr = 0x0000) 213 { 214 u8* mem_data = (u8*)mem_data_void_ptr; 215 Sizes s; 216 CalcSizes(s, mem_size, base_display_addr); 217 ImGuiStyle& style = ImGui::GetStyle(); 218 219 // We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window. 220 // This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move. 221 const float height_separator = style.ItemSpacing.y; 222 float footer_height = 0; 223 if (OptShowOptions) 224 footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1; 225 if (OptShowDataPreview) 226 footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 + ImGui::GetTextLineHeightWithSpacing() * 3; 227 ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove); 228 ImDrawList* draw_list = ImGui::GetWindowDrawList(); 229 230 ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0)); 231 ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0)); 232 233 const int line_total_count = (int)((mem_size + Cols - 1) / Cols); 234 ImGuiListClipper clipper(line_total_count, s.LineHeight); 235 const size_t visible_start_addr = clipper.DisplayStart * Cols; 236 const size_t visible_end_addr = clipper.DisplayEnd * Cols; 237 238 bool data_next = false; 239 240 if (ReadOnly || DataEditingAddr >= mem_size) 241 DataEditingAddr = (size_t)-1; 242 if (DataPreviewAddr >= mem_size) 243 DataPreviewAddr = (size_t)-1; 244 245 size_t preview_data_type_size = OptShowDataPreview ? DataTypeGetSize(PreviewDataType) : 0; 246 247 size_t data_editing_addr_backup = DataEditingAddr; 248 size_t data_editing_addr_next = (size_t)-1; 249 if (DataEditingAddr != (size_t)-1) 250 { 251 // Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered) 252 if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataEditingAddr >= (size_t)Cols) { data_editing_addr_next = DataEditingAddr - Cols; DataEditingTakeFocus = true; } 253 else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataEditingAddr < mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; DataEditingTakeFocus = true; } 254 else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataEditingAddr > 0) { data_editing_addr_next = DataEditingAddr - 1; DataEditingTakeFocus = true; } 255 else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataEditingAddr < mem_size - 1) { data_editing_addr_next = DataEditingAddr + 1; DataEditingTakeFocus = true; } 256 } 257 if (data_editing_addr_next != (size_t)-1 && (data_editing_addr_next / Cols) != (data_editing_addr_backup / Cols)) 258 { 259 // Track cursor movements 260 const int scroll_offset = ((int)(data_editing_addr_next / Cols) - (int)(data_editing_addr_backup / Cols)); 261 const bool scroll_desired = (scroll_offset < 0 && data_editing_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_editing_addr_next > visible_end_addr - Cols * 2); 262 if (scroll_desired) 263 ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight); 264 } 265 266 // Draw vertical separator 267 ImVec2 window_pos = ImGui::GetWindowPos(); 268 if (OptShowAscii) 269 draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border)); 270 271 const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text); 272 const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text; 273 274 const char* format_address = OptUpperCaseHex ? "%0*" _PRISizeT "X: " : "%0*" _PRISizeT "x: "; 275 const char* format_data = OptUpperCaseHex ? "%0*" _PRISizeT "X" : "%0*" _PRISizeT "x"; 276 const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x"; 277 const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x"; 278 const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x "; 279 280 for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines 281 { 282 size_t addr = (size_t)(line_i * Cols); 283 ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr); 284 285 // Draw Hexadecimal 286 for (int n = 0; n < Cols && addr < mem_size; n++, addr++) 287 { 288 float byte_pos_x = s.PosHexStart + s.HexCellWidth * n; 289 if (OptMidColsCount > 0) 290 byte_pos_x += (n / OptMidColsCount) * s.SpacingBetweenMidCols; 291 ImGui::SameLine(byte_pos_x); 292 293 // Draw highlight 294 bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax); 295 bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr)); 296 bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size); 297 if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview) 298 { 299 ImVec2 pos = ImGui::GetCursorScreenPos(); 300 float highlight_width = s.GlyphWidth * 2; 301 bool is_next_byte_highlighted = (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1))); 302 if (is_next_byte_highlighted || (n + 1 == Cols)) 303 { 304 highlight_width = s.HexCellWidth; 305 if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0) 306 highlight_width += s.SpacingBetweenMidCols; 307 } 308 draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), HighlightColor); 309 } 310 311 if (DataEditingAddr == addr) 312 { 313 // Display text input on current byte 314 bool data_write = false; 315 ImGui::PushID((void*)addr); 316 if (DataEditingTakeFocus) 317 { 318 ImGui::SetKeyboardFocusHere(); 319 ImGui::CaptureKeyboardFromApp(true); 320 sprintf(AddrInputBuf, format_data, s.AddrDigitsCount, base_display_addr + addr); 321 sprintf(DataInputBuf, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]); 322 } 323 ImGui::PushItemWidth(s.GlyphWidth * 2); 324 struct UserData 325 { 326 // FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here. 327 static int Callback(ImGuiInputTextCallbackData* data) 328 { 329 UserData* user_data = (UserData*)data->UserData; 330 if (!data->HasSelection()) 331 user_data->CursorPos = data->CursorPos; 332 if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen) 333 { 334 // When not editing a byte, always rewrite its content (this is a bit tricky, since InputText technically "owns" the master copy of the buffer we edit it in there) 335 data->DeleteChars(0, data->BufTextLen); 336 data->InsertChars(0, user_data->CurrentBufOverwrite); 337 data->SelectionStart = 0; 338 data->SelectionEnd = data->CursorPos = 2; 339 } 340 return 0; 341 } 342 char CurrentBufOverwrite[3]; // Input 343 int CursorPos; // Output 344 }; 345 UserData user_data; 346 user_data.CursorPos = -1; 347 sprintf(user_data.CurrentBufOverwrite, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]); 348 ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysInsertMode | ImGuiInputTextFlags_CallbackAlways; 349 if (ImGui::InputText("##data", DataInputBuf, 32, flags, UserData::Callback, &user_data)) 350 data_write = data_next = true; 351 else if (!DataEditingTakeFocus && !ImGui::IsItemActive()) 352 DataEditingAddr = data_editing_addr_next = (size_t)-1; 353 DataEditingTakeFocus = false; 354 ImGui::PopItemWidth(); 355 if (user_data.CursorPos >= 2) 356 data_write = data_next = true; 357 if (data_editing_addr_next != (size_t)-1) 358 data_write = data_next = false; 359 int data_input_value; 360 if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1) 361 { 362 if (WriteFn) 363 WriteFn(mem_data, addr, (u8)data_input_value); 364 else 365 mem_data[addr] = (u8)data_input_value; 366 } 367 ImGui::PopID(); 368 } 369 else 370 { 371 // NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on. 372 u8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]; 373 374 if (OptShowHexII) 375 { 376 if ((b >= 32 && b < 128)) 377 ImGui::Text(".%c ", b); 378 else if (b == 0xFF && OptGreyOutZeroes) 379 ImGui::TextDisabled("## "); 380 else if (b == 0x00) 381 ImGui::Text(" "); 382 else 383 ImGui::Text(format_byte_space, b); 384 } 385 else 386 { 387 if (b == 0 && OptGreyOutZeroes) 388 ImGui::TextDisabled("00 "); 389 else 390 ImGui::Text(format_byte_space, b); 391 } 392 if (!ReadOnly && ImGui::IsItemHovered() && ImGui::IsMouseClicked(0)) 393 { 394 DataEditingTakeFocus = true; 395 data_editing_addr_next = addr; 396 } 397 } 398 } 399 400 if (OptShowAscii) 401 { 402 // Draw ASCII values 403 ImGui::SameLine(s.PosAsciiStart); 404 ImVec2 pos = ImGui::GetCursorScreenPos(); 405 addr = line_i * Cols; 406 ImGui::PushID(line_i); 407 if (ImGui::InvisibleButton("ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight))) 408 { 409 DataEditingAddr = DataPreviewAddr = addr + (size_t)((ImGui::GetIO().MousePos.x - pos.x) / s.GlyphWidth); 410 DataEditingTakeFocus = true; 411 } 412 ImGui::PopID(); 413 for (int n = 0; n < Cols && addr < mem_size; n++, addr++) 414 { 415 if (addr == DataEditingAddr) 416 { 417 draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg)); 418 draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg)); 419 } 420 unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]; 421 char display_c = (c < 32 || c >= 128) ? '.' : c; 422 draw_list->AddText(pos, (display_c == '.') ? color_disabled : color_text, &display_c, &display_c + 1); 423 pos.x += s.GlyphWidth; 424 } 425 } 426 } 427 clipper.End(); 428 ImGui::PopStyleVar(2); 429 ImGui::EndChild(); 430 431 if (data_next && DataEditingAddr < mem_size) 432 { 433 DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1; 434 DataEditingTakeFocus = true; 435 } 436 else if (data_editing_addr_next != (size_t)-1) 437 { 438 DataEditingAddr = DataPreviewAddr = data_editing_addr_next; 439 } 440 441 bool next_show_data_preview = OptShowDataPreview; 442 if (OptShowOptions) 443 { 444 ImGui::Separator(); 445 446 // Options menu 447 448 if (ImGui::Button("Options")) 449 ImGui::OpenPopup("context"); 450 if (ImGui::BeginPopup("context")) 451 { 452 ImGui::PushItemWidth(56); 453 if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) { ContentsWidthChanged = true; } 454 ImGui::PopItemWidth(); 455 ImGui::Checkbox("Show Data Preview", &next_show_data_preview); 456 ImGui::Checkbox("Show HexII", &OptShowHexII); 457 if (ImGui::Checkbox("Show Ascii", &OptShowAscii)) { ContentsWidthChanged = true; } 458 ImGui::Checkbox("Grey out zeroes", &OptGreyOutZeroes); 459 ImGui::Checkbox("Uppercase Hex", &OptUpperCaseHex); 460 461 ImGui::EndPopup(); 462 } 463 464 ImGui::SameLine(); 465 ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1); 466 ImGui::SameLine(); 467 ImGui::PushItemWidth((s.AddrDigitsCount + 1) * s.GlyphWidth + style.FramePadding.x * 2.0f); 468 if (ImGui::InputText("##addr", AddrInputBuf, 32, ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue)) 469 { 470 size_t goto_addr; 471 if (sscanf(AddrInputBuf, "%" _PRISizeT "X", &goto_addr) == 1) 472 { 473 GotoAddr = goto_addr - base_display_addr; 474 HighlightMin = HighlightMax = (size_t)-1; 475 } 476 } 477 ImGui::PopItemWidth(); 478 479 if (GotoAddr != (size_t)-1) 480 { 481 if (GotoAddr < mem_size) 482 { 483 ImGui::BeginChild("##scrolling"); 484 ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y + (GotoAddr / Cols) * ImGui::GetTextLineHeight()); 485 ImGui::EndChild(); 486 DataEditingAddr = DataPreviewAddr = GotoAddr; 487 DataEditingTakeFocus = true; 488 } 489 GotoAddr = (size_t)-1; 490 } 491 } 492 493 if (OptShowDataPreview) 494 { 495 ImGui::Separator(); 496 ImGui::AlignTextToFramePadding(); 497 ImGui::Text("Preview as:"); 498 ImGui::SameLine(); 499 ImGui::PushItemWidth((s.GlyphWidth * 10.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x); 500 if (ImGui::BeginCombo("##combo_type", DataTypeGetDesc(PreviewDataType), ImGuiComboFlags_HeightLargest)) 501 { 502 for (int n = 0; n < DataType_COUNT; n++) 503 if (ImGui::Selectable(DataTypeGetDesc((DataType)n), PreviewDataType == n)) 504 PreviewDataType = (DataType)n; 505 ImGui::EndCombo(); 506 } 507 ImGui::PopItemWidth(); 508 ImGui::SameLine(); 509 ImGui::PushItemWidth((s.GlyphWidth * 6.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x); 510 ImGui::Combo("##combo_endianess", &PreviewEndianess, "LE\0BE\0\0"); 511 ImGui::PopItemWidth(); 512 513 char buf[128]; 514 float x = s.GlyphWidth * 6.0f; 515 bool has_value = DataPreviewAddr != (size_t)-1; 516 if (has_value) 517 DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Dec, buf, (size_t)IM_ARRAYSIZE(buf)); 518 ImGui::Text("Dec"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A"); 519 if (has_value) 520 DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Hex, buf, (size_t)IM_ARRAYSIZE(buf)); 521 ImGui::Text("Hex"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A"); 522 if (has_value) 523 DisplayPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Bin, buf, (size_t)IM_ARRAYSIZE(buf)); 524 ImGui::Text("Bin"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A"); 525 } 526 527 OptShowDataPreview = next_show_data_preview; 528 529 // Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child) 530 ImGui::SetCursorPosX(s.WindowWidth); 531 } 532 533 // Utilities for Data Preview 534 const char* DataTypeGetDesc(DataType data_type) const 535 { 536 const char* descs[] = { "Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Int64", "Uint64", "Float", "Double" }; 537 IM_ASSERT(data_type >= 0 && data_type < DataType_COUNT); 538 return descs[data_type]; 539 } 540 541 size_t DataTypeGetSize(DataType data_type) const 542 { 543 const size_t sizes[] = { 1, 1, 2, 2, 4, 4, 8, 8, 4, 8 }; 544 IM_ASSERT(data_type >= 0 && data_type < DataType_COUNT); 545 return sizes[data_type]; 546 } 547 548 const char* DataFormatGetDesc(DataFormat data_format) const 549 { 550 const char* descs[] = { "Bin", "Dec", "Hex" }; 551 IM_ASSERT(data_format >= 0 && data_format < DataFormat_COUNT); 552 return descs[data_format]; 553 } 554 555 bool IsBigEndian() const 556 { 557 uint16_t x = 1; 558 char c[2]; 559 memcpy(c, &x, 2); 560 return c[0] != 0; 561 } 562 563 static void* EndianessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian) 564 { 565 if (is_little_endian) 566 { 567 uint8_t* dst = (uint8_t*)_dst; 568 uint8_t* src = (uint8_t*)_src + s - 1; 569 for (int i = 0, n = (int)s; i < n; ++i) 570 memcpy(dst++, src--, 1); 571 return _dst; 572 } 573 else 574 { 575 return memcpy(_dst, _src, s); 576 } 577 } 578 579 static void* EndianessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian) 580 { 581 if (is_little_endian) 582 { 583 return memcpy(_dst, _src, s); 584 } 585 else 586 { 587 uint8_t* dst = (uint8_t*)_dst; 588 uint8_t* src = (uint8_t*)_src + s - 1; 589 for (int i = 0, n = (int)s; i < n; ++i) 590 memcpy(dst++, src--, 1); 591 return _dst; 592 } 593 } 594 595 void* EndianessCopy(void *dst, void *src, size_t size) const 596 { 597 static void *(*fp)(void *, void *, size_t, int) = NULL; 598 if (fp == NULL) 599 fp = IsBigEndian() ? EndianessCopyBigEndian : EndianessCopyLittleEndian; 600 return fp(dst, src, size, PreviewEndianess); 601 } 602 603 const char* FormatBinary(const uint8_t* buf, int width) const 604 { 605 IM_ASSERT(width <= 64); 606 size_t out_n = 0; 607 static char out_buf[64 + 8 + 1]; 608 for (int j = 0, n = width / 8; j < n; ++j) 609 { 610 for (int i = 0; i < 8; ++i) 611 out_buf[out_n++] = (buf[j] & (1 << (7 - i))) ? '1' : '0'; 612 out_buf[out_n++] = ' '; 613 } 614 out_buf[out_n] = 0; 615 IM_ASSERT(out_n < IM_ARRAYSIZE(out_buf)); 616 return out_buf; 617 } 618 619 void DisplayPreviewData(size_t addr, const u8* mem_data, size_t mem_size, DataType data_type, DataFormat data_format, char* out_buf, size_t out_buf_size) const 620 { 621 uint8_t buf[8]; 622 size_t elem_size = DataTypeGetSize(data_type); 623 size_t size = addr + elem_size > mem_size ? mem_size - addr : elem_size; 624 if (ReadFn) 625 for (int i = 0, n = (int)size; i < n; ++i) 626 buf[i] = ReadFn(mem_data, addr + i); 627 else 628 memcpy(buf, mem_data + addr, size); 629 630 if (data_format == DataFormat_Bin) 631 { 632 snprintf(out_buf, out_buf_size, "%s", FormatBinary(buf, (int)size * 8)); 633 return; 634 } 635 636 out_buf[0] = 0; 637 switch (data_type) 638 { 639 case DataType_S8: 640 { 641 int8_t int8 = 0; 642 EndianessCopy(&int8, buf, size); 643 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hhd", int8); return; } 644 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%02x", int8 & 0xFF); return; } 645 break; 646 } 647 case DataType_U8: 648 { 649 uint8_t uint8 = 0; 650 EndianessCopy(&uint8, buf, size); 651 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hhu", uint8); return; } 652 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%02x", uint8 & 0XFF); return; } 653 break; 654 } 655 case DataType_S16: 656 { 657 int16_t int16 = 0; 658 EndianessCopy(&int16, buf, size); 659 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hd", int16); return; } 660 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%04x", int16 & 0xFFFF); return; } 661 break; 662 } 663 case DataType_U16: 664 { 665 uint16_t uint16 = 0; 666 EndianessCopy(&uint16, buf, size); 667 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%hu", uint16); return; } 668 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%04x", uint16 & 0xFFFF); return; } 669 break; 670 } 671 case DataType_S32: 672 { 673 int32_t int32 = 0; 674 EndianessCopy(&int32, buf, size); 675 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%d", int32); return; } 676 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%08x", int32); return; } 677 break; 678 } 679 case DataType_U32: 680 { 681 uint32_t uint32 = 0; 682 EndianessCopy(&uint32, buf, size); 683 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%u", uint32); return; } 684 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%08x", uint32); return; } 685 break; 686 } 687 case DataType_S64: 688 { 689 int64_t int64 = 0; 690 EndianessCopy(&int64, buf, size); 691 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%lld", (long long)int64); return; } 692 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%016llx", (long long)int64); return; } 693 break; 694 } 695 case DataType_U64: 696 { 697 uint64_t uint64 = 0; 698 EndianessCopy(&uint64, buf, size); 699 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%llu", (long long)uint64); return; } 700 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "0x%016llx", (long long)uint64); return; } 701 break; 702 } 703 case DataType_Float: 704 { 705 float float32 = 0.0f; 706 EndianessCopy(&float32, buf, size); 707 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%f", float32); return; } 708 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "%a", float32); return; } 709 break; 710 } 711 case DataType_Double: 712 { 713 double float64 = 0.0; 714 EndianessCopy(&float64, buf, size); 715 if (data_format == DataFormat_Dec) { snprintf(out_buf, out_buf_size, "%f", float64); return; } 716 if (data_format == DataFormat_Hex) { snprintf(out_buf, out_buf_size, "%a", float64); return; } 717 break; 718 } 719 } // Switch 720 IM_ASSERT(0); // Shouldn't reach 721 } 722}; 723 724#undef _PRISizeT 725