// SPDX-License-Identifier: GPL-3.0-only // Implementation of SettingsScreen, SettingsReadmeScreen and settings_from_game() (settings.hpp): row/column // layout from the executable, toggle and arrow handling, availability rules, and the readme text viewer. // Raw bytes are preserved; availability bits and the value 2 are not treated as booleans. #include "formats/executable_layout.hpp" #include "ui/settings.hpp" #include #include #include #include #include #include "game/messages.hpp" #include "game/state.hpp" #include "ui/manager.hpp" #include "ui/setup.hpp" namespace bmh::ui { namespace { void blit_cell(Image& out, const Image& atlas, int sx, int sy, int x, int y, bool overlay = false) { if (sx < 0 || sy < 0 || sx + 23 > atlas.width || sy + 9 > atlas.height) throw FormatError("settings: cell outside Original atlas"); for (int yy = 0; yy < 9; ++yy) for (int xx = 0; xx < 23; ++xx) { const auto color = atlas.pixels[size_t(sy + yy) * atlas.width + sx + xx]; // UsesForTheseSprites compares against active DesktopRuntimeField=0 in this path. // Its 0xff argument is a blit mask, not the indexed software compare key. if (!overlay || color != 0) out.at(x + xx, y + yy) = color; } } void blit_button_strip(Image& out, const Image& atlas, int x, int y) { // FormatError3 normal button path (w=53,h=10): first 31 pixels from // KB/0.VGA (24,74), a 2-pixel middle tile from (24,84), then 20 pixels // from (25,94). PaletteOverride(0,0,0,0,1) supplies this Original atlas. auto copy = [&](int sx, int sy, int width, int dx) { for (int yy = 0; yy < 10; ++yy) for (int xx = 0; xx < width; ++xx) { const auto color = atlas.pixels[size_t(sy + yy) * size_t(atlas.width) + size_t(sx + xx)]; if (dx + xx >= 0 && dx + xx < out.width && y + yy >= 0 && y + yy < out.height) out.at(dx + xx, y + yy) = color; } }; copy(24, 74, 31, x); copy(24, 84, 2, x + 31); copy(25, 94, 20, x + 33); } std::string number(int value) { // Replace(..., 2): the Original percent glyph pads a two-digit field. auto s = std::to_string(value); if (s.size() < 2) s.insert(s.begin(), '%'); return s; } } namespace { std::string& product_version() { static std::string version; return version; } } void set_settings_product_version(std::string version) { product_version() = std::move(version); } std::array project_settings_availability( const std::array& raw_cells, const SettingsAvailabilityInputs& in, const LeImage& exe) { auto cells = raw_cells; auto cell = [&](int row, int col) -> uint8_t& { return cells.at(size_t(row * 9 + col)); }; auto lock = [&](int row, int col) { cell(row, col) |= 0x80; }; // ProjectSettingsAvailability first strips the prior dynamic lock bit from columns 1–7. for (int row = 0; row < 20; ++row) for (int col = 0; col < 7; ++col) cell(row, col) &= 0x7f; if (in.music_configuration_locked != 0) lock(0, 5); // Audio_OriginalAudioOptions_ExecutableField if (in.effects_configuration_locked != 0) lock(0, 6); // Audio_OriginalAudioOptions_ExecutableField2 bool all_column7_rows4to8_nonzero = true; for (int row = 3; row < 8; ++row) if (cell(row, 6) == 0) all_column7_rows4to8_nonzero = false; if (all_column7_rows4to8_nonzero) lock(2, 6); // C7, Controller_FormatError_RuntimeField2 bool all_column4_nonzero = true; for (int row = 0; row < 20; ++row) if (cell(row, 3) == 0) all_column4_nonzero = false; if (all_column4_nonzero) for (int row = 2; row < 8; ++row) lock(row, 6); // C7-H7, Audio_OriginalAudioOptions_ExecutableField2 + row*9 if (in.mode != 3) lock(1, 4); // B5, CareerSession_DispatchLiveTactic_RuntimeField3 if (in.mode < 3) { lock(16, 4); // Q5, CalendarState_FormatError_RuntimeField lock(17, 4); // R5, CalendarState_FormatError_RuntimeField2 } if (in.mode == 1) lock(15, 4); // P5, MatchdaySetup_WinterPostponements_RuntimeField2 if ((in.competitions & 1u) == 0) { for (int col = 0; col < 4; ++col) for (int row = 0; row < 20; ++row) if ((row < 9 || row > 12) && row != 15) lock(row, col); lock(6, 6); // G7, SportschauAwards_FinishSportschauAwards_RuntimeField } if ((in.competitions & 2u) == 0) for (int col = 0; col < 4; ++col) for (int row = 9; row < 13; ++row) lock(row, col); // Original link tables are in BMH.exe. Each trigger coordinate is tested // for raw value exactly 1; its [start,end) dependent coordinates get bit 7. for (uint32_t trigger = 0; trigger < 7; ++trigger) { const uint8_t encoded = exe.u8(::bmh::layout::Settings_ProjectSettingsAvailability_RuntimeField + trigger); const int col = encoded & 7; const int row = encoded >> 3; if (cell(row, col) != 1) continue; const uint8_t begin = exe.u8(::bmh::layout::Settings_ProjectSettingsAvailability_RuntimeField2 + trigger); const uint8_t end = exe.u8(::bmh::layout::Settings_ProjectSettingsAvailability_RuntimeField3 + trigger); for (uint32_t i = begin; i < end; ++i) { const uint8_t dependent = exe.u8(::bmh::layout::Settings_ProjectSettingsAvailability_RuntimeField4 + i); lock(dependent >> 3, dependent & 7); } } return cells; } SettingsState settings_from_game(const GameState& g, int manager, uint64_t revision, const LeImage& exe, std::optional sound) { if (manager < 0 || manager > 3 || manager >= int(g.manager_teams.size())) throw FormatError("settings: invalid manager"); SettingsState state; state.manager_slot = manager; state.revision = revision; state.audio_config_known = sound.has_value(); for (size_t i = 0; i < state.cells.size(); ++i) { const uint32_t address = ::bmh::layout::LeaguePresentationOptions + uint32_t(i); if (!g.memory.has(address)) throw FormatError("settings: missing switch block"); state.cells[i] = g.memory.u8(address); } if (g.memory.has(::bmh::layout::GameMode) && g.memory.has(::bmh::layout::CompetitionSelection) && g.memory.has(::bmh::layout::Settings_FormatError_RuntimeField)) { auto display = project_settings_availability(state.cells, {g.memory.u8(::bmh::layout::GameMode), g.memory.u32(::bmh::layout::CompetitionSelection), uint8_t(sound && !sound->music), uint8_t(sound && !sound->effects)}, exe); // A6/A7 depend on runtime sound setup. Preserve raw flags for headless // callers without a host capability provider. None of the seven // Original link-table triggers references either cell, so every other // availability result is independent of these two unknown inputs. if (!sound) { display[5] = state.cells[5]; display[6] = state.cells[6]; } state.display_cells = std::move(display); } state.decorated_background = !g.memory.has(::bmh::layout::PlainBackground) || g.memory.u8(::bmh::layout::PlainBackground) == 0; state.title = original_to_utf8(message_text(g, ::bmh::layout::Settings_FormatError_TextPointer3)); state.footer = original_to_utf8(message_text(g, ::bmh::layout::Settings_FormatError_TextPointer4)); state.version = original_to_utf8(message_text(g, ::bmh::layout::Settings_FormatError_TextPointer5) + exe.string_at_pointer(::bmh::layout::Settings_FormatError_TextPointer)); for (size_t i = 0; i < 3; ++i) state.button_labels[i] = original_to_utf8(message_text(g, ::bmh::layout::Settings_FormatError_TextPointer2 + uint32_t(i) * 4)); return state; } SettingsScreen::SettingsScreen(const std::filesystem::path& data, SettingsState state, int origin_item_id) : state_(std::move(state)), origin_item_id_(origin_item_id), background_(load_vga(asset_path(data / "KB", "129.VGA"))), atlas_(load_vga(asset_path(data / "KB", "15.VGA"))), button_atlas_(load_vga(asset_path(data / "KB", "0.VGA"))), font_(load_font(asset_path(data / "F", "BMH3.FNT"))), exe_(load_le(asset_path(data, "BMH.exe"))), sprite_font_(data) { if (state_.manager_slot < 0 || state_.manager_slot > 3 || background_.width != 320 || background_.height != 240 || atlas_.width != 138 || atlas_.height != 18 || button_atlas_.width != 77 || button_atlas_.height != 112) throw FormatError("settings: invalid state or Original asset dimensions"); for (const auto& s : {state_.title, state_.footer, state_.version}) (void)utf8_to_original(s); for (const auto& s : state_.button_labels) (void)utf8_to_original(s); } void SettingsScreen::text(Image& out, int x, int baseline, std::string_view original, uint8_t color, int right) const { std::string bytes(original); while (!bytes.empty() && font_.text_width(bytes) > right - x) bytes.pop_back(); const int y = baseline - font_.baseline; if (x < 0 || y < 0 || y + font_.height > out.height) return; // The original indexed-VGA settings screen uses Mask's six-row // FNT3 color table when settings cell TextGradientDisabled is zero and TextGradientMode has its // normal value 2. The shadow call from DrawnFirstBy is drawn first by // SolidColorMustBypassThisForegroundMap with solid color 0x40 and must bypass this foreground map. // TextWidth2 maps the incoming palette token through Advertising_Text_RuntimeField2; U83 // then paints each set FNT bit with that row's Advertising_Text_RuntimeField color. Zero remains // transparent in the scratch bitmap copied by CopyCrop. const auto gradient_disabled = state_.display_cells ? (*state_.display_cells)[::bmh::layout::TextGradientDisabled - ::bmh::layout::LeaguePresentationOptions] : state_.cells[::bmh::layout::TextGradientDisabled - ::bmh::layout::LeaguePresentationOptions]; if (gradient_disabled != 0 || exe_.u8(::bmh::layout::TextGradientMode) != 2 || color == 0x40) { font_.draw(out, x, y, bytes, color); return; } unsigned slot = 0; for (; slot < 32 && exe_.u8(::bmh::layout::Advertising_Text_RuntimeField2 + slot) != color; ++slot) {} int pen_x = x; for (unsigned char ch : bytes) { const auto& glyph = font_.glyph(ch); for (int row = 0; row < font_.height; ++row) { const uint8_t row_color = exe_.u8(::bmh::layout::Advertising_Text_RuntimeField + slot * 6 + row); if (row_color == 0) continue; for (int col = 0; col < glyph.bit_width; ++col) { const int bit = glyph.bit_offset + col; if (!(font_.bitmap[size_t(row) * font_.modulo + bit / 8] & (0x80 >> (bit % 8)))) continue; const int px = pen_x + col; if (px >= 0 && px < out.width) out.at(px, y + row) = row_color; } } pen_x += glyph.advance; } } Image SettingsScreen::render() const { auto out = state_.decorated_background ? background_ : Image(320, 240); if (!state_.decorated_background) { for (int y = 4; y <= 16; ++y) for (int x = 0; x < 320; ++x) out.at(x, y) = 0x44; for (int y = 5; y <= 15; ++y) for (int x = 1; x < 319; ++x) out.at(x, y) = 0x39; for (int y = 228; y <= 237; ++y) for (int x = 0; x < 320; ++x) out.at(x, y) = 0x44; for (int y = 229; y <= 236; ++y) for (int x = 1; x < 319; ++x) out.at(x, y) = 0x39; } sprite_font_.draw(out, SpriteFont::centered_title_x(sprite_font_.text_width(state_.title)), 13, state_.title); sprite_font_.draw(out, 5, 235, state_.footer); // OpenBMH deviates from the original: the settings page names the product and its build version instead of the original's version text. if (product_version().empty()) { text(out, 2, 41, utf8_to_original(state_.version), 0x5f, 58); } else { text(out, 2, 41, "OpenBMH", 0x5f, 58); text(out, 2, 49, utf8_to_original(product_version()), 0x5f, 58); } for (int col = 0; col < 9; ++col) { const auto label = std::to_string(col + 1); // DrawnFirstBy uses x directly when right=-1 and shadow=0x40. text(out, 78 + col * 24, 24, label, 0x40); text(out, 76 + col * 24, 22, label, 0x5f); for (int row = 0; row < 20; ++row) { const int x = 67 + col * 24, y = 24 + row * 10; if (col == 0) { const std::string letter(1, char('A' + row)); text(out, 61, y + 9, letter, 0x40); text(out, 59, y + 7, letter, 0x5f); } const uint8_t raw = state_.display_cells ? (*state_.display_cells)[size_t(row * 9 + col)] : state_.cells[size_t(row * 9 + col)]; const uint8_t value = col < 7 ? raw & 0x3f : raw; const bool unavailable = col < 7 && (raw & 0xc0) && value != 2; // BlitCell selects KB/15 x=0 blank, x=46 off, x=115 on; // numeric values >=200 denote a blank cell, not malformed input. const int source = col < 7 ? value == 2 ? 0 : value == 1 ? 46 : 115 : raw < 200 ? 23 : 0; blit_cell(out, atlas_, source, 0, x, y); if (unavailable) blit_cell(out, atlas_, 0, 9, x, y, true); if (col >= 7 && raw < 200) { const auto label = number(col == 8 ? raw / 2 : raw); text(out, 74 + col * 24, y + 7, label, exe_.u8(::bmh::layout::Settings_Letter_TextPointer + (raw != 0)), x + 23); } } } blit_cell(out, atlas_, 0, 0, 259, 214); for (size_t i = 0; i < 3; ++i) { // SettingsSourceRefusal calls FormatError3 at x=1, y=0xbc+i*0xd, w=0x35, // h=10. The fill tiles KB/0.VGA; the normal (param8=0) outline is // ColorBottomRightBevel's color-0x40 bottom/right bevel. const int y = 188 + int(i) * 13; blit_button_strip(out, button_atlas_, 1, y); for (int yy = y + 2; yy <= y + 11; ++yy) { out.at(54, yy) = 0x40; out.at(55, yy) = 0x40; } for (int x = 3; x <= 55; ++x) { out.at(x, y + 10) = 0x40; out.at(x, y + 11) = 0x40; } const int width = sprite_font_.text_width(state_.button_labels[i]); sprite_font_.draw(out, 1 + std::max(0, (53 - width) / 2), y + 7, state_.button_labels[i], 6); } if (!feedback_.empty()) text(out, 5, 235, utf8_to_original(feedback_), 0x5f, 318); return out; } bool SettingsScreen::click(int x, int y, bool right) { if (closed_ || pending_ || pending_file_ || x < 0 || y < 0 || x >= 320 || y >= 240) return false; if (right) { closed_ = true; return true; } // SettingsSourceRefusal's three Original controls overlay the lower settings rows: // Read me (index 0), load EIN (1), save EIN (2). if (x >= 1 && x < 55 && y >= 188 && y < 224) { const int index = (y - 188) / 13; if (index == 1 || index == 2) { pending_file_ = SaveLoadRequest{index == 1 ? SaveLoadAction::load : SaveLoadAction::save, state_.manager_slot, state_.revision, {}, false, SaveLoadFileKind::settings, origin_item_id_}; feedback_.clear(); return true; } readme_requested_ = true; feedback_.clear(); return true; } if (x >= 67 && x <= 281 && y >= 26 && y <= 224) { const uint8_t column = uint8_t((x - 67) / 24); const uint8_t row = uint8_t((y - 25) / 10); pending_ = SettingsWriteRequest{state_.manager_slot, state_.revision, state_.cells, row, column, column < 7 ? SettingsEdit::toggle_binary : (x - (67 + int(column) * 24) < 11 ? SettingsEdit::increment : SettingsEdit::decrement)}; feedback_.clear(); return true; } return false; } SettingsReadmeScreen::SettingsReadmeScreen(const std::filesystem::path& data, bool decorated_background) : background_(decorated_background ? load_vga(asset_path(data / "KB", "129.VGA")) : Image(320, 240)), font_(load_font(asset_path(data / "F", "BMH3.FNT"))), exe_(load_le(asset_path(data, "BMH.exe"))), texts_(load_textd(asset_path(data, "TEXTD.BLK"))), decorated_background_(decorated_background) { if (background_.width != 320 || background_.height != 240) throw FormatError("settings readme: invalid Original background dimensions"); // Use the same TEXTD filename that SourceName appends to SettingsRuntimeField. // DOS resolves it case-insensitively; also try its uppercase spelling on // case-sensitive host filesystems. const std::filesystem::path source_name(texts_[839]); std::ifstream file(data / source_name, std::ios::binary); if (!file) { auto uppercase_name = source_name.string(); std::transform(uppercase_name.begin(), uppercase_name.end(), uppercase_name.begin(), [](unsigned char c) { return char(std::toupper(c)); }); file.open(data / uppercase_name, std::ios::binary); } if (!file) return; file_available_ = true; std::array bytes{}; file.read(bytes.data(), std::streamsize(bytes.size())); content_.assign(bytes.data(), size_t(file.gcount())); pages_.emplace_back(); int x = 0, baseline = 19; bool emphasized = false, new_page_before_next_byte = false; const auto source_map = exe_.string_at_pointer(::bmh::layout::Settings_File_ExecutableField); // Startup assigns SettingsRuntimeField2 to this EXE string, but load_le() does not // execute that initializer; read the proven target map directly. const auto target_map = exe_.cstring(::bmh::layout::Settings_File_ExecutableField2); for (size_t i = 0; i < content_.size(); ++i) { if (new_page_before_next_byte) { pages_.emplace_back(); x = 0; baseline = 19; new_page_before_next_byte = false; } const unsigned char ch = static_cast(content_[i]); if (ch == '\n') { x = 0; baseline += 8; if (baseline > 230) new_page_before_next_byte = true; continue; } if (ch == '\t' && x < 0x11d) { x = (x / 20 + 1) * 20; continue; } if (ch == '#') { if (i + 1 >= content_.size()) break; const char code = content_[i + 1]; if (code == '0') emphasized = false; else if (code == '1') emphasized = true; else break; // Source treats an unrecognized directive as end-of-text. ++i; continue; } // Source wraps a completed glyph before it would place another glyph // beyond x=0x136. This is normally reached by a full-width glyph. if (x > 0x136) { x = 0; baseline += 8; if (baseline > 230) { new_page_before_next_byte = true; continue; } } char mapped = char(ch); if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) { const auto index = source_map.find(mapped); if (index != std::string::npos && index < target_map.size()) mapped = target_map[index]; } const int advance = font_.glyph(uint8_t(mapped)).advance; // SettingsReadmeScreen measures the translated byte after Back. pages_.back().push_back({x, baseline, uint8_t(mapped), emphasized}); x += advance; if (x > 0x136) { x = 0; baseline += 8; if (baseline > 230) new_page_before_next_byte = true; } } if (pages_.empty()) pages_.emplace_back(); } Image SettingsReadmeScreen::render() const { Image out = background_; if (!decorated_background_) { // PlainWindowFrameUsedBy's plain-window frame used by Fill4. std::fill(out.pixels.begin(), out.pixels.end(), uint8_t(0)); auto rect = [&](int x1, int y1, int x2, int y2, uint8_t color) { for (int y = std::max(0, y1); y <= std::min(out.height - 1, y2); ++y) for (int x = std::max(0, x1); x <= std::min(out.width - 1, x2); ++x) out.at(x, y) = color; }; rect(0, 4, 319, 16, 0x44); rect(0, 228, 319, 237, 0x44); rect(1, 5, 318, 15, 0x39); rect(1, 229, 318, 236, 0x39); } auto draw = [&](int x, int baseline, std::string_view value, uint8_t color) { font_.draw(out, x, baseline - font_.baseline, value, color); }; if (!file_available_) { const std::string missing = exe_.u8(::bmh::layout::LeagueSizes) == 20 ? "No readme file is available." : exe_.cstring(::bmh::layout::MissingInfofileText); draw((out.width - font_.text_width(missing)) / 2, 100, missing, 0x5f); } else { // TEXTD#840 (`SettingsRuntimeField3`) is the complete source title. SettingsReadmeScreen // centers it in DrawnFirstBy's 0..0x13f horizontal bounds, then draws // a one-pixel separator. draw((out.width - font_.text_width(texts_[840])) / 2, 7, texts_[840], 0x5f); for (int x = 0; x < 320; ++x) out.at(x, 9) = 0x5f; if (page_index_ < pages_.size()) for (const auto& glyph : pages_[page_index_]) { const std::string text(1, char(glyph.character)); if (glyph.emphasized) draw(glyph.x + 1, glyph.baseline + 1, text, 0xf3); draw(glyph.x, glyph.baseline, text, 0x5f); } } draw(0x113, 0xee, texts_[841], 0x5f); // PointerDown: TEXTD#841, `KLICK!`. return out; } bool SettingsReadmeScreen::pointer_down(bool left_or_right) { if (close_requested_ || !left_or_right) return false; if (file_available_ && page_index_ + 1 < pages_.size()) ++page_index_; else close_requested_ = true; return true; } bool SettingsScreen::pointer_down(int x, int y, bool right) { if (closed_ || pending_ || pending_file_) return false; // SettingsSourceRefusal cell edits and right-click return act on press; its three // footer controls are handled on release by ExpireQuestion. if (right || (x >= 67 && x <= 281 && y >= 26 && y <= 224)) { const bool changed = click(x, y, right); if (changed) release_barrier_ = true; return changed; } return false; } std::optional settings_source_refusal(const GameState& state, const SettingsWriteRequest& request, uint64_t revision) { if (request.revision != revision || request.manager_slot < 0 || request.manager_slot > 3 || size_t(request.manager_slot) >= state.manager_teams.size() || request.operation != SettingsEdit::toggle_binary || request.column != 4 || (request.row != 16 && request.row != 17) || !state.memory.has(::bmh::layout::GameMode) || state.memory.u8(::bmh::layout::GameMode) < 3) return {}; for (size_t i = 0; i < request.expected_raw.size(); ++i) { const uint32_t address = ::bmh::layout::LeaguePresentationOptions + uint32_t(i); if (!state.memory.has(address) || state.memory.u8(address) != request.expected_raw[i]) return {}; } const uint8_t raw = request.expected_raw[size_t(request.row) * 9 + request.column]; if (raw >= 2) return {}; // Source availability locks cannot create a rule notice. if (request.row == 16 && state.season_day() >= 110 && state.season_day() <= 230) return ::bmh::layout::CareerSession_DispatchSettings_TextPointer; if (request.row == 17 && raw != 0 && state.league_rounds.size() > 5 && state.league_rounds[5] != 0) return ::bmh::layout::CareerSession_DispatchSettings_TextPointer2; return {}; } bool SettingsScreen::key(std::string_view) { // SettingsSourceRefusal returns on mouse event 8 (right-button press). Keyboard input // does not close the settings page, including when embedded in a match. return false; } void SettingsScreen::acknowledge(SettingsState state) { if (!pending_ || state.manager_slot != pending_->manager_slot || pending_->revision == std::numeric_limits::max() || state.revision != pending_->revision + 1) throw FormatError("settings acknowledgement does not match pending action"); const size_t index = size_t(pending_->row) * 9 + pending_->column; if (pending_->row >= 20 || pending_->column >= 9 || index >= state.cells.size()) throw FormatError("settings acknowledgement has invalid cell identity"); for (size_t i = 0; i < state.cells.size(); ++i) { const bool numeric_column = (i % 9) >= 7; const uint8_t mask = numeric_column ? 0xff : 0x7f; if (i != index && ((state.cells[i] ^ pending_->expected_raw[i]) & mask) != 0) throw FormatError("settings acknowledgement changed unrelated cells"); } const uint8_t old = pending_->expected_raw[index]; const uint8_t actual = state.cells[index]; uint8_t expected = old; if (pending_->operation == SettingsEdit::toggle_binary && (old & 0x7f) <= 1) expected = uint8_t((old & 0x7f) ^ 1); else if (pending_->column == 8) { // SettingsSourceRefusal edits the delay column in two raw units. The ACK must // validate the same edit as the Session, including odd saved values. if (pending_->operation == SettingsEdit::increment && old < 198) expected = uint8_t(old + 2); else if (pending_->operation == SettingsEdit::decrement && old > 1 && old < 200) expected = uint8_t(old - 2); } else if (pending_->operation == SettingsEdit::increment && old < 200) expected = uint8_t(old + 1); else if (pending_->operation == SettingsEdit::decrement && old > 0 && old < 200) expected = uint8_t(old - 1); if (((actual ^ expected) & (pending_->column < 7 ? 0x7f : 0xff)) != 0) throw FormatError("settings acknowledgement does not match requested edit"); // Validate the incoming projection before consuming the pending action. // Flow acknowledgements copy this screen and bypass its constructor. for (const auto& text : {state.title, state.footer, state.version}) (void)utf8_to_original(text); for (const auto& text : state.button_labels) (void)utf8_to_original(text); pending_.reset(); state_ = std::move(state); feedback_.clear(); } void SettingsScreen::acknowledge_file(SettingsState state) { if (state.manager_slot != state_.manager_slot || state.revision != state_.revision + 1) throw FormatError("settings file acknowledgement does not match the pending request"); for (const auto& text : {state.title, state.footer, state.version}) (void)utf8_to_original(text); for (const auto& text : state.button_labels) (void)utf8_to_original(text); pending_file_.reset(); state_ = std::move(state); feedback_.clear(); } void SettingsScreen::reject_file(std::string reason) { if (reason.empty()) throw FormatError("settings file rejection requires a reason"); pending_file_.reset(); feedback_ = std::move(reason); } void SettingsScreen::reject(std::string reason) { if (!pending_) throw FormatError("settings rejection without pending action"); pending_.reset(); feedback_ = std::move(reason); } void SettingsScreen::reject_close(std::string reason) { if (!closed_ || reason.empty()) throw FormatError("settings close rejection without close request"); closed_ = false; feedback_ = std::move(reason); } std::string SettingsScreen::state_json() const { std::ostringstream out; out << "{\"screen\":\"settings\",\"read_only\":false,\"manager_slot\":" << state_.manager_slot << ",\"revision\":" << state_.revision << ",\"close_requested\":" << (closed_ ? "true" : "false") << ",\"pending\":" << (pending_ ? "true" : "false") << ",\"availability\":" << json_quote(state_.display_cells ? (state_.audio_config_known ? "entry_projection_sound_known" : "entry_projection_sound_unknown") : "raw_snapshot") << ",\"feedback\":" << json_quote(feedback_) << ",\"cells\":["; for (size_t i = 0; i < state_.cells.size(); ++i) { if (i) out << ','; out << unsigned(state_.cells[i]); } return out.str() + "]}"; } } // namespace bmh::ui