21#include "imgui_stdlib.h"
33using namespace std::literals;
35static constexpr int MidColsCount = 8;
36static constexpr auto HighlightColor = IM_COL32(255, 255, 255, 50);
40 , symbolManager(manager.getReactor().getSymbolManager())
41 , title(
std::move(debuggableName_))
43 debuggableNameSize = title.size();
57 parseSearchString(searchString);
65DebuggableEditor::Sizes DebuggableEditor::calcSizes(
unsigned memSize)
const
68 const auto& style = ImGui::GetStyle();
70 s.addrDigitsCount = 0;
71 for (
unsigned n = memSize - 1; n > 0; n >>= 4) {
75 s.lineHeight = ImGui::GetTextLineHeight();
77 s.hexCellWidth = truncf(s.glyphWidth * 2.5f);
78 s.spacingBetweenMidCols = truncf(s.hexCellWidth * 0.25f);
79 s.posHexStart = float(s.addrDigitsCount + 2) * s.glyphWidth;
80 auto posHexEnd = s.posHexStart + (s.hexCellWidth * float(columns));
81 s.posAsciiStart = s.posAsciiEnd = posHexEnd;
83 int numMacroColumns = (columns + MidColsCount - 1) / MidColsCount;
84 s.posAsciiStart = posHexEnd + s.glyphWidth + float(numMacroColumns) * s.spacingBetweenMidCols;
85 s.posAsciiEnd = s.posAsciiStart + float(columns) * s.glyphWidth;
87 s.windowWidth = s.posAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.glyphWidth;
93 if (!
open || !motherBoard)
return;
96 if (!debuggable)
return;
100 unsigned memSize = debuggable->getSize();
101 columns = std::min(columns, narrow<int>(memSize));
102 auto s = calcSizes(memSize);
103 ImGui::SetNextWindowSize(ImVec2(s.windowWidth, s.windowWidth * 0.60f), ImGuiCond_FirstUseEver);
105 im::Window(title.c_str(), &
open, ImGuiWindowFlags_NoScrollbar, [&]{
106 if (ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows) &&
107 ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
108 ImGui::OpenPopup(
"context");
110 drawContents(s, *debuggable, memSize);
114[[nodiscard]]
static unsigned DataTypeGetSize(ImGuiDataType dataType)
116 std::array<unsigned, ImGuiDataType_COUNT - 2> sizes = { 1, 1, 2, 2, 4, 4, 8, 8 };
117 assert(dataType >= 0 && dataType < (ImGuiDataType_COUNT - 2));
118 return sizes[dataType];
121[[nodiscard]]
static std::optional<int> parseHexDigit(
char c)
123 if (
'0' <= c && c <=
'9')
return c -
'0';
124 if (
'a' <= c && c <=
'f')
return c -
'a' + 10;
125 if (
'A' <= c && c <=
'F')
return c -
'A' + 10;
129[[nodiscard]]
static std::optional<uint8_t> parseDataValue(std::string_view str)
131 if (str.size() == 1) {
132 return parseHexDigit(str[0]);
133 }
else if (str.size() == 2) {
134 if (
auto digit0 = parseHexDigit(str[0])) {
135 if (
auto digit1 = parseHexDigit(str[1])) {
136 return 16 * *digit0 + *digit1;
151 if (str.empty())
return r;
161 r.
addr = TclObject(str).eval(interp).getInt(interp);
162 }
catch (CommandException& e) {
168[[nodiscard]]
static std::string formatData(uint8_t val)
170 return strCat(hex_string<2, HexCase::upper>(val));
173[[nodiscard]]
static char formatAsciiData(uint8_t val)
175 return (val < 32 || val >= 128) ?
'.' : char(val);
178[[nodiscard]] std::string DebuggableEditor::formatAddr(
const Sizes& s,
unsigned addr)
const
180 return strCat(hex_string<HexCase::upper>(
Digits{size_t(s.addrDigitsCount)}, addr));
182void DebuggableEditor::setStrings(
const Sizes& s, Debuggable& debuggable)
184 addrStr =
strCat(
"0x", formatAddr(s, currentAddr));
185 auto b = debuggable.read(currentAddr);
186 if (dataEditingActive == HEX ) dataInput = formatData(b);
187 if (dataEditingActive == ASCII) dataInput = std::string(1, formatAsciiData(b));
189bool DebuggableEditor::setAddr(
const Sizes& s, Debuggable& debuggable,
unsigned memSize,
unsigned addr)
191 addr = std::min(addr, memSize - 1);
192 if (currentAddr == addr)
return false;
194 setStrings(s, debuggable);
197void DebuggableEditor::scrollAddr(
const Sizes& s, Debuggable& debuggable,
unsigned memSize,
unsigned addr)
199 if (setAddr(s, debuggable, memSize, addr)) {
201 int row = narrow<int>(currentAddr) / columns;
202 ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y +
float(row) * ImGui::GetTextLineHeight());
207void DebuggableEditor::drawContents(
const Sizes& s, Debuggable& debuggable,
unsigned memSize)
209 const auto& style = ImGui::GetStyle();
212 auto addr = currentAddr;
214 scrollAddr(s, debuggable, memSize, addr);
217 setAddr(s, debuggable, memSize, currentAddr);
220 float footerHeight = 0.0f;
222 footerHeight += style.ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
225 footerHeight += style.ItemSpacing.y + 2 * ImGui::GetFrameHeightWithSpacing();
227 if (showDataPreview) {
228 footerHeight += style.ItemSpacing.y + ImGui::GetFrameHeightWithSpacing() + 3 * ImGui::GetTextLineHeightWithSpacing();
232 int cFlags = ImGuiWindowFlags_NoMove;
237 cFlags |= ImGuiWindowFlags_HorizontalScrollbar;
238 ImGui::BeginChild(
"##scrolling", ImVec2(0, -footerHeight), ImGuiChildFlags_None, cFlags);
239 ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
240 ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
242 std::optional<unsigned> nextAddr;
244 if (addrMode == CURSOR) {
245 const auto& shortcuts = manager.getShortcuts();
246 if ((
int(currentAddr) >= columns) &&
247 shortcuts.checkShortcut({.keyChord = ImGuiKey_UpArrow, .repeat = true})) {
248 nextAddr = currentAddr - columns;
250 if ((
int(currentAddr) <
int(memSize - columns)) &&
251 shortcuts.checkShortcut({.keyChord = ImGuiKey_DownArrow, .repeat = true})) {
252 nextAddr = currentAddr + columns;
254 if ((
int(currentAddr) > 0) &&
255 shortcuts.checkShortcut({.keyChord = ImGuiKey_LeftArrow, .repeat = true})) {
256 nextAddr = currentAddr - 1;
258 if ((
int(currentAddr) <
int(memSize - 1)) &&
259 shortcuts.checkShortcut({.keyChord = ImGuiKey_RightArrow, .repeat = true})) {
260 nextAddr = currentAddr + 1;
265 auto* drawList = ImGui::GetWindowDrawList();
266 ImVec2 windowPos = ImGui::GetWindowPos();
268 drawList->AddLine(ImVec2(windowPos.x + s.posAsciiStart - s.glyphWidth, windowPos.y),
269 ImVec2(windowPos.x + s.posAsciiStart - s.glyphWidth, windowPos.y + 9999),
270 ImGui::GetColorU32(ImGuiCol_Border));
273 auto handleInput = [&](
unsigned addr,
int width,
auto formatData,
auto parseData,
int extraFlags = 0) {
275 if (dataEditingTakeFocus) {
276 ImGui::SetKeyboardFocusHere();
277 setStrings(s, debuggable);
281 static int Callback(ImGuiInputTextCallbackData* data) {
282 auto* userData =
static_cast<UserData*
>(data->UserData);
283 if (!data->HasSelection()) {
284 userData->cursorPos = data->CursorPos;
286 if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen) {
289 data->DeleteChars(0, data->BufTextLen);
290 userData->format(data);
293 data->SelectionStart = 0;
298 std::function<void(ImGuiInputTextCallbackData* data)>
format;
302 userData.format = formatData;
303 ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue
304 | ImGuiInputTextFlags_AutoSelectAll
305 | ImGuiInputTextFlags_NoHorizontalScroll
306 | ImGuiInputTextFlags_CallbackAlways
307 | ImGuiInputTextFlags_AlwaysOverwrite
309 ImGui::SetNextItemWidth(s.glyphWidth *
float(width));
310 bool dataWrite =
false;
312 if (ImGui::InputText(
"##data", &dataInput, flags, UserData::Callback, &userData)) {
314 }
else if (!ImGui::IsItemActive()) {
315 setStrings(s, debuggable);
318 dataEditingTakeFocus =
false;
319 dataWrite |= userData.cursorPos >= width;
320 if (nextAddr) dataWrite =
false;
322 if (
auto value = parseData(dataInput)) {
323 debuggable.write(addr, *value);
325 nextAddr = currentAddr + 1;
330 const auto totalLineCount = int((memSize + columns - 1) / columns);
332 auto addr = unsigned(line) * columns;
333 ImGui::StrCat(formatAddr(s, addr),
':');
335 auto previewDataTypeSize = DataTypeGetSize(previewDataType);
336 auto inside = [](unsigned a, unsigned start, unsigned size) {
337 return (start <= a) && (a < (start + size));
339 auto highLightDataPreview = [&](
unsigned a) {
340 return inside(a, currentAddr, previewDataTypeSize);
342 auto highLightSearch = [&](
unsigned a) {
343 if (!searchPattern)
return false;
344 auto len = narrow<unsigned>(searchPattern->size());
345 if (searchHighlight ==
static_cast<int>(SearchHighlight::SINGLE)) {
347 return inside(a, *searchResult, len);
349 }
else if (searchHighlight ==
static_cast<int>(SearchHighlight::ALL)) {
350 int start = std::max(0,
int(a - len + 1));
351 for (
unsigned i = start; i <= a; ++i) {
352 if (
match(debuggable, memSize, i))
return true;
357 auto highLight = [&](
unsigned a) {
358 return highLightDataPreview(a) || highLightSearch(a);
362 for (
int n = 0; n < columns && addr < memSize; ++n, ++addr) {
363 int macroColumn = n / MidColsCount;
364 float bytePosX = s.posHexStart + float(n) * s.hexCellWidth
365 + float(macroColumn) * s.spacingBetweenMidCols;
366 ImGui::SameLine(bytePosX);
369 if (highLight(addr)) {
370 ImVec2 pos = ImGui::GetCursorScreenPos();
371 float highlightWidth = s.glyphWidth * 2;
372 if (highLight(addr + 1)) {
373 highlightWidth = s.hexCellWidth;
374 if (n > 0 && (n + 1) < columns && ((n + 1) % MidColsCount) == 0) {
375 highlightWidth += s.spacingBetweenMidCols;
378 drawList->AddRectFilled(pos, ImVec2(pos.x + highlightWidth, pos.y + s.lineHeight), HighlightColor);
381 if (currentAddr == addr && (dataEditingActive == HEX)) {
383 [&](ImGuiInputTextCallbackData* data) {
384 auto valStr = formatData(debuggable.read(addr));
385 data->InsertChars(0, valStr.data(), valStr.data() + valStr.size());
386 data->SelectionEnd = 2;
388 [&](std::string_view data) {
389 return parseDataValue(data);
391 ImGuiInputTextFlags_CharsHexadecimal);
393 uint8_t b = debuggable.read(addr);
397 if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0)) {
398 dataEditingActive = HEX;
399 dataEditingTakeFocus =
true;
407 ImGui::SameLine(s.posAsciiStart);
408 gl::vec2 pos = ImGui::GetCursorPos();
409 gl::vec2 scrnPos = ImGui::GetCursorScreenPos();
410 addr = unsigned(line) * columns;
415 if (ImGui::InvisibleButton(
"ascii", ImVec2(s.posAsciiEnd - s.posAsciiStart, s.lineHeight))) {
416 dataEditingActive = ASCII;
417 dataEditingTakeFocus = true;
418 nextAddr = addr + unsigned((ImGui::GetIO().MousePos.x - scrnPos.x) / s.glyphWidth);
422 for (
int n = 0; n < columns && addr < memSize; ++n, ++addr) {
423 if (highLight(addr)) {
424 auto start = scrnPos +
gl::vec2(
float(n) * s.glyphWidth, 0.0f);
425 drawList->AddRectFilled(start, start +
gl::vec2(s.glyphWidth, s.lineHeight), ImGui::GetColorU32(HighlightColor));
428 ImGui::SetCursorPos(pos);
429 if (currentAddr == addr && (dataEditingActive == ASCII)) {
431 [&](ImGuiInputTextCallbackData* data) {
432 char valChar = formatAsciiData(debuggable.read(addr));
433 data->InsertChars(0, &valChar, &valChar + 1);
434 data->SelectionEnd = 1;
436 [&](std::string_view data) -> std::optional<uint8_t> {
437 if (data.empty())
return {};
439 if (b < 32 || b >= 128)
return {};
443 uint8_t c = debuggable.read(addr);
444 char display = formatAsciiData(c);
449 pos.x += s.glyphWidth;
453 ImGui::PopStyleVar(2);
457 setAddr(s, debuggable, memSize, *nextAddr);
458 dataEditingTakeFocus =
true;
464 ImGui::AlignTextToFramePadding();
467 ImGui::SetNextItemWidth(2.0f * style.FramePadding.x +
ImGui::CalcTextSize(
"Expression").x + ImGui::GetFrameHeight());
468 if (ImGui::Combo(
"##mode", &addrMode,
"Cursor\0Expression\0Link BC\0Link DE\0Link HL\0")) {
469 dataEditingTakeFocus =
true;
471 static constexpr std::array linkExpr = {
472 "[reg bc]",
"[reg de]",
"[reg hl]"
474 addrExpr = linkExpr[addrMode - 2];
475 addrMode = EXPRESSION;
480 std::string* as = addrMode == CURSOR ? &addrStr : &addrExpr;
481 auto r = parseAddressExpr(*as, symbolManager, manager.getInterpreter());
483 if (addrMode == EXPRESSION && r.
error.empty()) {
484 scrollAddr(s, debuggable, memSize, r.addr);
486 if (manager.getShortcuts().checkShortcut(Shortcuts::ID::HEX_GOTO_ADDR)) {
487 ImGui::SetKeyboardFocusHere();
489 ImGui::SetNextItemWidth(15.0f * ImGui::GetFontSize());
490 if (ImGui::InputText(
"##addr", as, ImGuiInputTextFlags_EnterReturnsTrue)) {
491 auto r2 = parseAddressExpr(addrStr, symbolManager, manager.getInterpreter());
492 if (r2.error.empty()) {
493 scrollAddr(s, debuggable, memSize, r2.addr);
494 dataEditingTakeFocus =
true;
503 HelpMarker(
"Address-mode:\n"
504 " Cursor: view the cursor position\n"
505 " Expression: continuously re-evaluate an expression and view that address\n"
507 "Addresses can be entered as:\n"
508 " Decimal or hexadecimal values (e.g. 0x1234)\n"
509 " A calculation like 0x1234 + 7*22\n"
510 " The name of a label (e.g. CHPUT)\n"
511 " A Tcl expression (e.g. [reg hl] to follow the content of register HL)\n"
513 "Right-click to configure this view.");
518 drawSearch(s, debuggable, memSize);
520 if (showDataPreview) {
522 drawPreviewLine(s, debuggable, memSize);
526 ImGui::SetNextItemWidth(7.5f * s.glyphWidth + 2.0f * style.FramePadding.x);
527 if (ImGui::InputInt(
"Columns", &columns, 1, 0)) {
528 columns = std::clamp(columns, 1, MAX_COLUMNS);
530 ImGui::Checkbox(
"Show Address bar", &showAddress);
531 ImGui::Checkbox(
"Show Search pane", &showSearch);
532 ImGui::Checkbox(
"Show Data Preview", &showDataPreview);
533 ImGui::Checkbox(
"Show Ascii", &showAscii);
534 ImGui::Checkbox(
"Grey out zeroes", &greyOutZeroes);
541[[nodiscard]]
static const char* DataTypeGetDesc(ImGuiDataType dataType)
543 std::array<
const char*, ImGuiDataType_COUNT - 2> desc = {
544 "Int8",
"Uint8",
"Int16",
"Uint16",
"Int32",
"Uint32",
"Int64",
"Uint64"
546 assert(dataType >= 0 && dataType < (ImGuiDataType_COUNT - 2));
547 return desc[dataType];
551[[nodiscard]]
static T read(std::span<const uint8_t> buf)
553 assert(buf.size() >=
sizeof(T));
555 memcpy(&
t, buf.data(),
sizeof(T));
559static void formatDec(std::span<const uint8_t> buf, ImGuiDataType dataType)
562 case ImGuiDataType_S8:
565 case ImGuiDataType_U8:
568 case ImGuiDataType_S16:
571 case ImGuiDataType_U16:
574 case ImGuiDataType_S32:
577 case ImGuiDataType_U32:
580 case ImGuiDataType_S64:
583 case ImGuiDataType_U64:
591static void formatHex(std::span<const uint8_t> buf, ImGuiDataType data_type)
594 case ImGuiDataType_S8:
595 case ImGuiDataType_U8:
598 case ImGuiDataType_S16:
599 case ImGuiDataType_U16:
602 case ImGuiDataType_S32:
603 case ImGuiDataType_U32:
606 case ImGuiDataType_S64:
607 case ImGuiDataType_U64:
615static void formatBin(std::span<const uint8_t> buf)
617 for (
int i =
int(buf.size()) - 1; i >= 0; --i) {
619 if (i != 0) ImGui::SameLine();
623void DebuggableEditor::parseSearchString(std::string_view str)
625 searchPattern.reset();
626 searchResult.reset();
627 std::vector<uint8_t> result;
629 if (searchType ==
static_cast<int>(SearchType::ASCII)) {
630 const auto*
begin = std::bit_cast<const uint8_t*>(str.data());
631 const auto*
end =
begin + str.size();
634 assert(searchType ==
static_cast<int>(SearchType::HEX));
635 std::optional<int> partial;
637 if (c ==
' ')
continue;
638 auto digit = parseHexDigit(c);
641 result.push_back(narrow<uint8_t>(16 * *partial + *digit));
650 searchPattern = std::move(result);
653void DebuggableEditor::drawSearch(
const Sizes& s, Debuggable& debuggable,
unsigned memSize)
655 const auto& style = ImGui::GetStyle();
657 bool doSearch =
false;
659 ImGui::SetNextItemWidth(-(buttonSize + style.WindowPadding.x));
661 auto callback = [](ImGuiInputTextCallbackData* data) {
662 if (data->EventFlag == ImGuiInputTextFlags_CallbackEdit) {
663 auto& self = *
static_cast<DebuggableEditor*
>(data->UserData);
664 self.parseSearchString(std::string_view(data->Buf, data->BufTextLen));
668 ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue
669 | ImGuiInputTextFlags_CallbackEdit;
670 if (ImGui::InputText(
"##search_string", &searchString, flags, callback,
this)) {
676 doSearch |= ImGui::Button(
"Search");
678 if (!searchPattern) {
679 simpleToolTip(
"Must be an even number of hex digits, optionally separated by spaces");
681 if (searchPattern && doSearch) {
682 search(s, debuggable, memSize);
685 auto arrowSize = ImGui::GetFrameHeight();
686 auto extra = arrowSize + 2.0f * style.FramePadding.x;
687 ImGui::AlignTextToFramePadding();
691 if (ImGui::Combo(
"##search_type", &searchType,
"Hex\0Ascii\0\0")) {
692 parseSearchString(searchString);
695 ImGui::SameLine(0.0f, 2 * ImGui::GetFontSize());
699 ImGui::Combo(
"##search_direction", &searchDirection,
"Forwards\0Backwards\0\0");
701 ImGui::SameLine(0.0f, 2 * ImGui::GetFontSize());
705 ImGui::Combo(
"##search_highlight", &searchHighlight,
"None\0Single\0All\0\0");
708bool DebuggableEditor::match(Debuggable& debuggable,
unsigned memSize,
unsigned addr)
710 assert(searchPattern);
711 if ((addr + searchPattern->size()) > memSize)
return false;
712 for (
auto [i, c] :
enumerate(*searchPattern)) {
713 if (debuggable.read(narrow<unsigned>(addr + i)) != c)
return false;
718void DebuggableEditor::search(
const Sizes& s, Debuggable& debuggable,
unsigned memSize)
720 std::optional<unsigned> found;
721 auto test = [&](
unsigned addr) {
722 if (
match(debuggable, memSize, addr)) {
728 if (searchDirection ==
static_cast<int>(SearchDirection::FWD)) {
729 for (
unsigned addr = currentAddr + 1; addr < memSize; ++addr) {
730 if (
test(addr))
break;
733 for (
unsigned addr = 0; addr <= currentAddr; ++addr) {
734 if (
test(addr))
break;
738 for (
int addr = currentAddr - 1; addr > 0; --addr) {
739 if (
test(
unsigned(addr)))
break;
742 for (
int addr = memSize - 1; addr >= int(currentAddr); --addr) {
743 if (
test(
unsigned(addr)))
break;
748 searchResult = *found;
749 scrollAddr(s, debuggable, memSize, *found);
750 dataEditingTakeFocus =
true;
753 searchResult.reset();
754 ImGui::OpenPopup(
"NotFound");
758void DebuggableEditor::drawPreviewLine(
const Sizes& s, Debuggable& debuggable,
unsigned memSize)
760 const auto& style = ImGui::GetStyle();
761 ImGui::AlignTextToFramePadding();
764 ImGui::SetNextItemWidth((s.glyphWidth * 10.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
765 if (ImGui::BeginCombo(
"##combo_type", DataTypeGetDesc(previewDataType), ImGuiComboFlags_HeightLargest)) {
766 for (ImGuiDataType n = 0; n < (ImGuiDataType_COUNT - 2); ++n) {
767 if (ImGui::Selectable(DataTypeGetDesc(n), previewDataType == n)) {
774 ImGui::SetNextItemWidth((s.glyphWidth * 6.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
775 ImGui::Combo(
"##combo_endianess", &previewEndianess,
"LE\0BE\0\0");
777 std::array<uint8_t, 8> dataBuf = {};
778 auto elemSize = DataTypeGetSize(previewDataType);
779 for (
auto i :
xrange(elemSize)) {
780 auto addr = currentAddr + i;
781 dataBuf[i] = (addr < memSize) ? debuggable.read(addr) : 0;
784 static constexpr bool nativeIsLittle = std::endian::native == std::endian::little;
785 if (
bool previewIsLittle = previewEndianess == LE;
786 nativeIsLittle != previewIsLittle) {
787 std::reverse(dataBuf.begin(), dataBuf.begin() + elemSize);
792 formatDec(dataBuf, previewDataType);
796 formatHex(dataBuf, previewDataType);
800 formatBin(
subspan(dataBuf, 0, elemSize));
void test(const IterableBitSet< N > &s, std::initializer_list< size_t > list)
void paint(MSXMotherBoard *motherBoard) override
DebuggableEditor(ImGuiManager &manager_, std::string debuggableName, size_t index)
std::string_view getDebuggableName() const
void loadLine(std::string_view name, zstring_view value) override
void save(ImGuiTextBuffer &buf) override
Debuggable * findDebuggable(std::string_view name)
std::optional< uint16_t > parseSymbolOrValue(std::string_view s) const
Like std::string_view, but with the extra guarantee that it refers to a zero-terminated string.
constexpr auto enumerate(Iterable &&iterable)
Heavily inspired by Nathan Reed's blog post: Python-Like enumerate() In C++17 http://reedbeta....
auto CalcTextSize(std::string_view str)
void TextUnformatted(const std::string &str)
void Window(const char *name, bool *p_open, ImGuiWindowFlags flags, std::invocable<> auto next)
void ID(const char *str_id, std::invocable<> auto next)
void StyleColor(bool active, Args &&...args)
void Child(const char *str_id, const ImVec2 &size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags, std::invocable<> auto next)
void Disabled(bool b, std::invocable<> auto next)
void Font(ImFont *font, std::invocable<> auto next)
void ListClipper(size_t count, int forceIndex, float lineHeight, std::invocable< int > auto next)
void Popup(const char *str_id, ImGuiWindowFlags flags, std::invocable<> auto next)
void format(SectorAccessibleDisk &disk, MSXBootSectorType bootType)
Format the given disk (= a single partition).
This file implemented 3 utility functions:
bool loadOnePersistent(std::string_view name, zstring_view value, C &c, const std::tuple< Elements... > &tup)
void simpleToolTip(std::string_view desc)
void savePersistent(ImGuiTextBuffer &buf, C &c, const std::tuple< Elements... > &tup)
std::optional< bool > match(const BooleanInput &binding, const Event &event, function_ref< int(JoystickId)> getJoyDeadZone)
ImU32 getColor(imColor col)
constexpr auto subspan(Range &&range, size_t offset, size_t count=std::dynamic_extent)
void strAppend(std::string &result, Ts &&...ts)
constexpr auto xrange(T e)
constexpr auto begin(const zstring_view &x)
constexpr auto end(const zstring_view &x)