Files
Dreierpack-Manager/src/modern/ui/settings_screens.inc
T

385 lines
18 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-only
bool App::settings_global_only() const { return !engine_mode_ && (scene_ == "main" || !source_); }
fs::path App::ui_preferences_file() const {
return config_.preferences.empty()
? (config_.userdata.empty() ? root_ / "userdata" : config_.userdata) / "modern-ui-preferences.json"
: config_.preferences;
}
void App::reset_settings() {
settings_draft_ = Json();
settings_base_ = Json();
settings_notice_.clear();
settings_query_.clear();
settings_jump_ = "rules";
settings_category_ = "display";
settings_scrolls_ = Json::object();
settings_restore_scroll_ = false;
settings_rendered_category_.clear();
settings_world_.reset();
settings_source_ = nullptr;
settings_revision_ = 0;
}
void App::begin_settings() {
if (!settings_draft_.is_null())
return;
settings_draft_ = {{"global", ui_preferences_}};
if (engine_mode_) {
settings_draft_["local"] = engine_settings_value_.at("local");
engine_settings_context_ = engine_data_.at("desktop").at("meta");
settings_world_ = world_;
} else if (!settings_global_only()) {
const auto s = snap();
settings_draft_["local"] = s.state.at("settings");
settings_revision_ = s.revision;
settings_world_ = s.world;
settings_source_ = source_.get();
}
settings_base_ = settings_draft_;
}
bool App::settings_dirty() const {
return settings_draft_.is_object() && settings_draft_ != settings_base_;
}
bool App::settings_valid() const {
if (!settings_draft_.is_object() ||
!valid_ui_preferences(settings_draft_.at("global")))
return false;
if (settings_global_only())
return true;
if (engine_mode_) return engine_settings_valid();
auto copy = snap().state;
return edit_demo_settings(copy, settings_draft_.at("local")).empty();
}
std::string App::settings_row(const std::string &id, const std::string &label,
const std::string &help,
const std::string &control) const {
return "<div class=\"settings-row\"><label for=\"" + esc(id) + "\"><span>" +
esc(label) + "</span>" +
(help.empty() ? "" : "<small>" + esc(help) + "</small>") + "</label>" +
control + "</div>";
}
std::string App::settings_switch(const std::string &id,
const std::string &scope,
const std::string &key, bool on,
bool mixed) const {
return btn("settings-toggle",
"<span class=\"settings-switch-knob\" style=\"left:" +
std::string(mixed ? "25"
: on ? "45"
: "5") +
"dp;\"></span>",
"settings-switch " + std::string(on ? "checked " : "") +
(mixed ? "mixed" : ""),
"id=\"" + esc(id) + "\" role=\"switch\" aria-checked=\"" +
(mixed ? "mixed"
: on ? "true"
: "false") +
"\" data-scope=\"" + scope + "\" data-key=\"" + key + "\"");
}
std::string App::settings_select(
const std::string &id,
const std::vector<std::pair<std::string, std::string>> &rows,
const std::string &value, const std::string &scope,
const std::string &section, const std::string &key) const {
std::string out = "<select class=\"settings-select\" id=\"" + id +
"\" data-settings-scope=\"" + scope +
"\" data-settings-section=\"" + section +
"\" data-settings-key=\"" + key + "\">";
for (const auto &[v, label] : rows)
out += "<option value=\"" + esc(v) + "\" " +
(v == value ? "selected " : "") +
(id == "preference-language" && v == "en" ? "disabled " : "") + ">" +
esc(label) + "</option>";
return out + "</select>";
}
std::string App::settings_option(const Json &option) const {
const auto code = option.at("code").get<std::string>(),
id = "game-setting-" + code;
const auto &value =
settings_draft_.at("local").at("cells")[size_t(settings_index(code))];
const auto type = option.at("type").get<std::string>();
if (engine_mode_ && !engine_settings_editable("cell", code)) {
const auto shown = value.is_number_integer() ? (type == "toggle" ? (value == 1 ? std::string("An") : std::string("Aus")) : number(value)) : std::string("—");
return settings_row(id, option.at("label"), option.value("help", ""), "<span class=\"settings-readonly\">" + esc(shown) + "</span>");
}
const int maximum = engine_mode_ ? engine_settings_value_.at("cells").at(code).at("max").get<int>() : option.value("max",99);
std::string control;
if (type == "toggle")
control = settings_switch(id, "cell", code, value == 1);
else if (type == "choice") {
std::vector<std::pair<std::string, std::string>> rows;
for (const auto &choice : option.at("choices"))
rows.emplace_back(std::to_string(choice[0].get<int>()),
choice[1].get<std::string>());
control = settings_select(
id, rows,
value.is_number_integer() ? std::to_string(value.get<int>()) : "",
"cell", "", code);
} else
control =
"<input class=\"settings-number\" type=\"text\" id=\"" + id +
"\" data-settings-scope=\"number\" data-settings-key=\"" + code +
"\" data-settings-title=\"" +
esc(option.at("label").get<std::string>()) + "\" data-settings-max=\"" +
std::to_string(maximum) +
"\" maxlength=\"3\" value=\"" +
(value.is_number_integer() ? std::to_string(value.get<int>()) : "") +
"\"/>";
return settings_row(id, option.at("label").get<std::string>(),
option.value("help", ""), control);
}
const Json &App::settings_catalogue_view() const {
return engine_mode_ ? engine_settings_value_.at("catalogue")
: live_settings_catalogue();
}
std::string App::render_settings_groups(int *count) const {
std::istringstream words(settings_search_key(settings_query_));
std::vector<std::string> terms;
for (std::string word; words >> word;)
terms.push_back(word);
int found = 0;
std::string out;
for (const auto &group : settings_catalogue_view().at("groups")) {
std::string rows;
const auto matches = [&](const Json &o, const std::string &competition) {
const auto text = settings_search_key(
group.at("title").get<std::string>() + " " + competition + " " +
o.at("label").get<std::string>() + " " + o.value("help", ""));
return std::all_of(terms.begin(), terms.end(), [&](const auto &w) {
return text.find(w) != text.npos;
});
};
if (group.contains("options")) {
for (const auto &o : group.at("options"))
if (matches(o, "")) {
rows += settings_option(o);
++found;
}
} else
for (const auto &competition : group.at("competitions")) {
std::string entries;
for (const auto &o : competition.at("options"))
if (matches(o, competition.at("title").get<std::string>())) {
entries += settings_option(o);
++found;
}
if (!entries.empty())
rows += "<div class=\"settings-competition\"><h4>" +
esc(competition.at("title").get<std::string>()) + "</h4>" +
entries + "</div>";
}
if (!rows.empty())
out += "<div id=\"settings-group-" + group.at("id").get<std::string>() +
"\" class=\"settings-group\"><h3>" +
esc(group.at("title").get<std::string>()) + "</h3>" +
(group.contains("help")
? "<p class=\"settings-group-help\">" +
esc(group.at("help").get<std::string>()) + "</p>"
: "") +
rows + "</div>";
}
if (count)
*count = found;
if (!found)
out = "<p class=\"settings-search-empty\"><span>Keine Einstellungen "
"gefunden.</span><small>Versuche einen anderen "
"Suchbegriff.</small></p>";
return out;
}
std::string App::render_settings() {
begin_settings();
settings_remember_scroll();
const auto &p = settings_draft_.at("global");
std::string nav, pane;
const std::array<std::pair<const char *, const char *>, 4> categories{
{{"display", "Anzeige"},
{"sound", "Sound"},
{"game", "Spiel"},
{"automation", "Automatik"}}};
for (const auto &[id, label] : categories)
if (!settings_global_only() || std::string(id) == "display" ||
std::string(id) == "sound")
nav += btn("settings-category", "<span>" + std::string(label) + "</span>",
settings_category_ == id ? "active" : "",
"id=\"settings-tab-" + std::string(id) +
"\" role=\"tab\" aria-selected=\"" +
(settings_category_ == id ? "true" : "false") +
"\" data-id=\"" + id + "\"");
const std::map<std::string, std::pair<std::string, std::string>> captions = {
{"display", {"Anzeige", "Bildschirm und Sprache"}},
{"sound", {"Sound", "Lautstärke, Effekte und Spielton"}},
{"game", {"Spiel", "Spielablauf und Live-Ticker"}},
{"automation",
{"Automatik",
"Aufstellung, Wechsel, Taktik, Manndeckung und Training"}}};
std::string head = "<div><h2>" + captions.at(settings_category_).first +
"</h2><p>" + captions.at(settings_category_).second +
"</p></div>";
if(settings_category_=="display")head+="<span id=\"settings-transmission-style\" style=\"font-size:28dp;color:var(--muted);\">Live-Ticker · feste Darstellungsart</span>";
if (settings_category_ == "display") {
pane =
"<div class=\"settings-group\"><h3>Gestaltung</h3><p "
"class=\"settings-group-help\">Wähle deinen Look. Die Gestaltung wird "
"mit „Anwenden“ übernommen.</p><div class=\"settings-theme-options\">";
const std::array<std::array<const char *, 3>, 3> themes{
{{{"midnight", "Midnight Glass",
"Dunkles Glas · ruhige Blautöne · Mint"}},
{{"silver", "Silver Glass",
"Helles Glas · klare Schrift · Silberblau"}},
{{"matchday", "Matchday", "Graphit · klare Flächen · Vereinsrot"}}}};
for (const auto &t : themes) {
const std::string type = t[0];
const auto mini =
"<div class=\"settings-theme-preview preview-" + type +
"\"><div class=\"preview-background\">" +
img("background", 647.333333, 404.583333, false, true, 650) +
"</div><div class=\"preview-bar\"><span></span></div><div "
"class=\"preview-widget one\"></div><div class=\"preview-widget "
"two\"></div><div class=\"preview-app app-one\"></div><div "
"class=\"preview-app app-two\"></div><div class=\"preview-app "
"app-three\"></div><div class=\"preview-window\"><div "
"class=\"preview-title\"><span></span></div><div "
"class=\"preview-line line-one\"></div><div class=\"preview-line "
"line-two\"></div><div class=\"preview-line "
"line-three\"></div></div></div>";
pane +=
btn("settings-theme",
mini + "<strong>" + t[1] + "</strong><small>" + t[2] + "</small>",
"settings-theme-choice",
"id=\"settings-theme-" + type + "\" data-id=\"" + type +
"\" aria-pressed=\"" +
(p.at("theme") == type ? "true" : "false") + "\"");
}
pane += "</div></div>";
if (engine_mode_) {
int width=0,height=0; SDL_GetWindowSize(video_.window,&width,&height);
pane += "<div class=\"settings-group\"><h3>Fenster</h3><p>" + std::to_string(width) + " × " + std::to_string(height) + " · Automatische Anpassung</p></div>";
} else {
pane += "<div class=\"settings-group\"><h3>Bildschirm</h3>";
const auto pref =
[&](const char *key, const char *label,
const std::vector<std::pair<std::string, std::string>> &rows,
const char *help = "") {
return settings_row(
std::string("preference-") + key, label, help,
settings_select(std::string("preference-") + key, rows,
p.at("display").at(key).get<std::string>(),
"global", "display", key));
};
pane += pref("mode", "Modus",
{{"fullscreen", "Vollbild"}, {"window", "Fenster"}});
pane += pref("resolution", "Auflösung",
{{"1280x720", "1280 × 720"},
{"1600x900", "1600 × 900"},
{"1920x1080", "1920 × 1080"},
{"2560x1440", "2560 × 1440"},
{"3840x2160", "3840 × 2160"}},
"Beispielauflösungen für den POC.");
pane +=
pref("scale", "Skalierung",
{{"auto", "Auto"}, {"1", "1×"}, {"1.5", "1,5×"}, {"2", "2×"}}) +
"</div><div class=\"settings-group\"><h3>Sprache</h3>" +
pref("language", "Sprache", {{"de", "Deutsch"}, {"en", "Englisch"}}) +
"</div>";
}
} else if (settings_category_ == "sound") {
if (engine_mode_) {
pane="<div class=\"settings-group\"><h3>Spielton</h3>";
for (const auto &o:live_settings_catalogue().at("sound")) pane+=settings_option(o);
pane+="</div>";
} else {
const auto &s = p.at("sound");
pane = "<div class=\"settings-group\"><h3>Lautstärke und Effekte</h3>";
pane += settings_row(
"preference-volume", "Lautstärke", "",
"<div class=\"settings-volume\"><input type=\"range\" "
"id=\"preference-volume\" min=\"0\" max=\"100\" step=\"1\" value=\"" +
std::to_string(s.at("volume").get<int>()) +
"\"/><span id=\"settings-volume-value\">" +
std::to_string(s.at("volume").get<int>()) + " %</span></div>");
pane +=
settings_row("preference-effects", "Effekte", "",
settings_switch("preference-effects", "sound", "effects",
s.at("effects").get<bool>()));
pane += settings_row("preference-style", "Effektstil", "",
settings_select(
"preference-style",
{{"classic", "Klassisch"}, {"modern", "Modern"}},
s.at("style").get<std::string>(), "global",
"sound", "style")) +
"</div>";
if (!settings_global_only()) {
pane += "<div class=\"settings-group\"><h3>Ton im Spiel</h3>";
for (const auto &o : live_settings_catalogue().at("sound"))
pane += settings_option(o);
pane += "</div>";
}
}
} else if (settings_category_ == "automation") {
const auto &a = settings_draft_.at("local").at("automation");
int on = 0, total = 0;
for (const auto &[k, v] : a.items()) if (engine_settings_editable("automation",k)) { ++total; if (v == true) ++on; }
pane = "<div class=\"settings-automation-master\">" +
settings_row("automation-all", "Alles automatisch",
engine_mode_ ? "Alle verfügbaren Bereiche gemeinsam ein- oder ausschalten." : "Alle fünf Bereiche gemeinsam ein- oder ausschalten.",
settings_switch("automation-all", "automation", "all",
total > 0 && on == total, on > 0 && on < total)) +
"</div><div class=\"settings-group\"><h3>Aufgaben an den Co-Trainer "
"abgeben</h3><p class=\"settings-group-help\">Die fünf "
"Automatikfunktionen des Originals. Änderungen werden erst mit "
"„Anwenden“ übernommen.</p>";
for (const auto &o : live_settings_catalogue().at("automation")) {
const auto key = o[0].get<std::string>();
pane += settings_row("automation-" + key, o[1].get<std::string>(),
o[2].get<std::string>(),
settings_switch("automation-" + key, "automation",
key, a.at(key).get<bool>()));
}
if (engine_mode_) {
std::vector<std::pair<std::string,std::string>> choices;
for (const auto &slot:engine_settings_value_.at("formations")) choices.emplace_back(std::to_string(slot.at("value").get<int>()),slot.at("label"));
if (choices.empty()) choices.emplace_back("0","Keine gespeicherte Aufstellung");
pane += settings_row("automation-formation","Gespeicherte Aufstellung","Für die automatische Aufstellung.",settings_select("automation-formation",choices,std::to_string(settings_draft_.at("local").at("formation").get<int>()),"formation","",""));
}
pane += "</div>";
} else {
std::vector<std::pair<std::string, std::string>> groups;
for (const auto &g : settings_catalogue_view().at("groups"))
groups.emplace_back(g.at("id").get<std::string>(),
g.at("title").get<std::string>());
head += "<div class=\"settings-jump-label\"><span>Zum Abschnitt</span>" +
settings_select("settings-jump", groups, settings_jump_, "jump", "",
"") +
"</div>";
pane = "<div id=\"settings-groups\">" + render_settings_groups() + "</div>";
}
const std::string search =
settings_category_ == "game"
? "<div class=\"settings-searchbar\"><div "
"class=\"settings-search-field\">" +
glyph("search", 30) +
"<input type=\"text\" id=\"settings-search\" maxlength=\"120\" "
"value=\"" +
esc(settings_query_) +
"\" placeholder=\"Spieloption suchen …\"/>" +
btn("settings-search-clear", "×", "",
"id=\"settings-search-clear\" aria-label=\"Suche "
"leeren\"") +
"</div><span id=\"settings-search-count\"></span></div>"
: "";
settings_restore_scroll_ = true;
return "<section class=\"settings-layout\"><nav "
"class=\"settings-categories\" role=\"tablist\" "
"aria-orientation=\"vertical\">" +
nav + "</nav><div class=\"settings-pane\" data-category=\"" +
settings_category_ + "\"><header class=\"settings-pane-header\">" +
head + "</header>" + search +
"<div id=\"settings-options\" class=\"settings-scroll\" "
"tabindex=\"0\">" +
pane +
"</div></div></section><div class=\"settings-actions\"><p "
"id=\"settings-draft-status\"></p>" +
btn("settings-cancel", "Abbrechen", "", "id=\"settings-cancel\"") +
btn("settings-apply", "Anwenden", "", "id=\"settings-apply\"") +
"</div>";
}