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

1487 lines
53 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
// Input and navigation share the same paths for human and scripted events.
void App::context_menu(const std::string &id, int x, int y) {
init_desktop();
context_id_ = id;
context_x_ = x;
context_y_ = y;
context_open_ = true;
context_dirty_ = true;
dirty_ = true;
}
void App::render_context() {
auto *root = element("desktop-context");
root->SetProperty("display", context_open_ ? "block" : "none");
if (!context_open_ || !context_dirty_)
return;
std::string body;
if (!context_id_.empty()) {
const auto &o = desktop_["objects"].at(context_id_);
body += btn("context-pin",
o.value("pinned", true) ? "Fixierung lösen" : "Fixieren");
if (o.value("widget", false)) {
body += btn("context-remove", "Widget entfernen");
for (const auto &d : widget_definitions())
if (d.id == context_id_)
for (auto [w, h] : d.sizes)
body += btn("context-size",
std::to_string(w) + " × " + std::to_string(h), {},
"data-id=\"" + std::to_string(w) + "x" +
std::to_string(h) + "\"");
}
body += "<div class=\"separator\"></div>";
}
bool all_pinned = true;
for (const auto &[id, o] : desktop_["objects"].items()) {
(void)id;
if (o.value("visible", false) && !o.value("pinned", true))
all_pinned = false;
}
body +=
btn("context-undo", "Rückgängig", {}, undo_.empty() ? "disabled" : "") +
btn("context-pin-all", all_pinned ? "Alles lösen" : "Alles fixieren") +
btn("context-grid", desktop_.value("grid", true) ? "Raster ausschalten"
: "Raster einschalten") +
btn("context-arrange", "Am Raster anordnen") +
"<div class=\"separator\"></div>" +
btn("context-widgets", "Widget hinzufügen") +
btn("context-view-save", "Ansicht speichern") +
btn("context-view-load", "Ansicht laden") +
btn("context-background", "Hintergrundbild ändern") +
"<div class=\"separator\"></div>" + btn("context-quit", "Spiel beenden");
root->SetInnerRML(body);
context_->Update();
const auto size = context_->GetDimensions();
root->SetProperty(
"left",
scalar(std::clamp(context_x_, 4, std::max(4, size.x - 288))) + "px");
root->SetProperty(
"top", scalar(std::clamp(
context_y_, 4,
std::max(4, size.y - int(root->GetBox().GetSize().y) - 8))) +
"px");
context_dirty_ = false;
}
void App::drag_event(Rml::Event &event) {
const auto type = event.GetType();
if (type == "mousedown")
suppress_click_ = false;
const float x = event.GetParameter<float>("mouse_x", 0),
y = event.GetParameter<float>("mouse_y", 0);
if (type == "mousedown" && event.GetParameter<int>("button", 0) == 0 &&
scene_ == "desktop" && menu_.empty() && popup_.empty()) {
auto *target = event.GetTargetElement();
bool interactive = false;
for (auto *n = target; n && n != doc_; n = n->GetParentNode()) {
if (n->HasAttribute("data-interactive"))
interactive = true;
if (n->HasAttribute("data-object")) {
if (interactive)
return;
const auto id = n->GetAttribute<Rml::String>("data-object", "");
const auto &o = desktop_["objects"].at(id);
if (o.value("pinned", true))
return;
drag_ = {true, false, id, x, y, o.value("x", 0.0), o.value("y", 0.0)};
return;
}
}
}
if (!drag_.active)
return;
if (type == "mousemove") {
if (!drag_.moved && std::hypot(x - drag_.x, y - drag_.y) < 6)
return;
if (!drag_.moved) {
undo_.push_back(desktop_);
if (undo_.size() > 40)
undo_.erase(undo_.begin());
drag_.moved = true;
}
auto &o = desktop_["objects"][drag_.id];
if (o.value("pinned", true))
return;
const double left = std::clamp(drag_.left + (x - drag_.x) / scale_, 0.0,
3840.0 - o.value("w", 224));
const double top = std::clamp(drag_.top + (y - drag_.y) / scale_, 224.0,
2160.0 - o.value("h", 224));
o["x"] = left;
o["y"] = top;
if (auto *n = element("object-" + drag_.id)) {
n->SetProperty("left", scalar(left) + "dp");
n->SetProperty("top", scalar(top) + "dp");
}
dirty_ = true;
}
if (type == "mouseup") {
if (drag_.moved) {
suppress_click_ = true;
auto &o = desktop_["objects"][drag_.id];
auto proposed = undo_.back();
const int x = o.value("x", 64), y = o.value("y", 224);
if (place_desktop_object(proposed, drag_.id, x, y))
desktop_ = std::move(proposed);
else
desktop_ = undo_.back();
refresh();
}
drag_.active = false;
}
}
void App::ProcessEvent(Rml::Event &event) try {
const auto type = event.GetType();
if (type == "keydown")
keyboard_navigation_ = true;
else if (type == "mousedown")
keyboard_navigation_ = false;
if (type == "blur" && popup_.empty()) bank_event(event);
if (type == "blur") {
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(
event.GetTargetElement());
select && select->IsSelectBoxVisible()) {
select->CancelSelectBox();
dirty_ = true;
}
return;
}
for (auto *n = event.GetTargetElement(); n && n != doc_;
n = n->GetParentNode())
if (n->GetId() == "native-ticket-layer")
return;
if (amount_event(event)) return;
if (popup_.empty() && amount_trigger_event(event)) return;
if (popup_.empty() && contracts_event(event)) return;
if (popup_.empty() && (advertising_event(event) || toto_event(event))) return;
if (popup_.empty() && (bank_event(event) || finance_event(event))) return;
if (!planning_dialog_.empty() && popup_.empty()) {
const bool key_event = type == "keydown";
const auto key = key_event ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0)) : Rml::Input::KI_UNKNOWN;
if ((key_event && key == Rml::Input::KI_ESCAPE) ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1)) {
planning_action("planning-close", nullptr);
event.StopImmediatePropagation();
return;
}
bool inside = false;
for (auto *node = event.GetTargetElement(); node && node != doc_; node = node->GetParentNode())
if (node->GetId() == "planning-layer") inside = true;
if (!inside && (type == "click" || type == "dblclick" || type == "mousedown" ||
type == "mouseup" || (key_event && key != Rml::Input::KI_TAB))) {
event.StopImmediatePropagation();
return;
}
}
if (!report_detail_kind_.empty() && popup_.empty()) {
const bool keyboard = type == "keydown";
const auto key = keyboard
? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0))
: Rml::Input::KI_UNKNOWN;
if ((keyboard && key == Rml::Input::KI_ESCAPE) ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1)) {
report_detail_action("report-detail-close", nullptr);
event.StopImmediatePropagation();
return;
}
bool inside = false;
for (auto *n = event.GetTargetElement(); n && n != doc_; n = n->GetParentNode())
if (n->GetId() == "report-detail-layer") inside = true;
if (!inside && (type == "click" || type == "dblclick" || type == "mousedown" ||
type == "mouseup" || (keyboard && key != Rml::Input::KI_TAB))) {
event.StopImmediatePropagation();
return;
}
} else if (report_detail_kind_.empty() && planning_dialog_.empty() && popup_.empty() && report_picker_event(event))
return;
if (menu_ == "almanac" && popup_.empty() && report_picker_.empty()) {
const auto key = type == "keydown" ? Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0)) : Rml::Input::KI_UNKNOWN;
if (key == Rml::Input::KI_ESCAPE || (type == "mouseup" && event.GetParameter<int>("button", 0) == 1)) {
almanac_action("alm-back", nullptr);
event.StopImmediatePropagation();
return;
}
if (key == Rml::Input::KI_TAB && context_->GetFocusElement() &&
context_->GetFocusElement()->GetId() == "alm-heading") {
auto *next = event.GetParameter<int>("shift_key", 0) ? element("alm-back")
: !almanac_match_.empty() ? element("alm-tab-lineups")
: doc_->QuerySelector("#alm-day-list .alm-match-row");
if (!next) next = element("alm-back");
if (next) next->Focus(true);
event.StopImmediatePropagation();
return;
}
if (type == "keydown" && !almanac_match_.empty() && event.GetTargetElement()->GetId().starts_with("alm-tab-") &&
(key == Rml::Input::KI_LEFT || key == Rml::Input::KI_RIGHT || key == Rml::Input::KI_HOME || key == Rml::Input::KI_END)) {
almanac_tab_ = key == Rml::Input::KI_HOME ? "lineups" : key == Rml::Input::KI_END ? "events" : almanac_tab_ == "lineups" ? "events" : "lineups";
focus_after_render_ = "alm-tab-" + almanac_tab_;
refresh();
event.StopImmediatePropagation();
return;
}
}
if (menu_ == "friendlies" && planning_dialog_.empty() && popup_.empty() &&
snap().state.at("calendar").at("friendly_stage") == 1 &&
((type == "keydown" && event.GetParameter<int>("key_identifier", 0) == Rml::Input::KI_ESCAPE) ||
(type == "mouseup" && event.GetParameter<int>("button", 0) == 1))) {
planning_action("friendly-back", nullptr);
event.StopImmediatePropagation();
return;
}
if (type == "mouseup" && event.GetParameter<int>("button", 0) == 1) {
if (scene_ == "desktop" && !menu_.empty() && popup_.empty()) {
menu_.clear();
draft_preferences_ = nullptr;
refresh();
} else if (scene_ == "desktop" && menu_.empty() && popup_.empty()) {
std::string id;
for (auto *n = event.GetTargetElement(); n && n != doc_;
n = n->GetParentNode())
if (n->HasAttribute("data-object")) {
id = n->GetAttribute<Rml::String>("data-object", "");
break;
}
context_menu(id, event.GetParameter<int>("mouse_x", 0),
event.GetParameter<int>("mouse_y", 0));
}
event.StopPropagation();
return;
}
if (type == "mousedown" && event.GetParameter<int>("button", 0) == 0 &&
context_open_) {
bool inside = false;
for (auto *n = event.GetTargetElement(); n && n != doc_;
n = n->GetParentNode())
if (n->GetId() == "desktop-context")
inside = true;
if (!inside) {
context_open_ = false;
dirty_ = true;
event.StopPropagation();
return;
}
}
if (type == "mousedown" || type == "mousemove" || type == "mouseup") {
drag_event(event);
return;
}
auto *target = event.GetTargetElement();
if (type == "contextmenu") {
if (scene_ != "desktop" || !menu_.empty() || !popup_.empty())
return;
std::string id;
for (auto *n = target; n && n != doc_; n = n->GetParentNode())
if (n->HasAttribute("data-object")) {
id = n->GetAttribute<Rml::String>("data-object", "");
break;
}
context_menu(id, event.GetParameter<int>("mouse_x", 0),
event.GetParameter<int>("mouse_y", 0));
event.StopPropagation();
return;
}
if (type == "keydown") {
const auto key =
Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0));
Rml::ElementFormControlSelect *select = nullptr;
for (auto *n = target; n && n != doc_; n = n->GetParentNode())
if ((select = dynamic_cast<Rml::ElementFormControlSelect *>(n)))
break;
if (select && !select->HasAttribute("disabled")) {
const bool open = select->IsSelectBoxVisible();
if (open && key == Rml::Input::KI_TAB) {
select->CancelSelectBox();
dirty_ = true;
}
if ((!open && (key == Rml::Input::KI_DOWN || key == Rml::Input::KI_UP)) ||
key == Rml::Input::KI_RETURN || key == Rml::Input::KI_SPACE) {
if (open)
select->HideSelectBox();
else {
select->ShowSelectBox();
if (key == Rml::Input::KI_UP)
select->SetSelection(select->GetNumOptions() - 1);
}
event.StopImmediatePropagation();
dirty_ = true;
return;
}
if (open && (key == Rml::Input::KI_HOME || key == Rml::Input::KI_END)) {
select->SetSelection(key == Rml::Input::KI_HOME
? 0
: select->GetNumOptions() - 1);
event.StopImmediatePropagation();
dirty_ = true;
return;
}
}
if (key == Rml::Input::KI_RETURN || key == Rml::Input::KI_SPACE) {
for (auto *n = target; n && n != doc_; n = n->GetParentNode())
if (n->GetTagName() == "button") {
if (!n->HasAttribute("disabled"))
n->DispatchEvent("click", {});
event.StopImmediatePropagation();
return;
}
}
if (key == Rml::Input::KI_ESCAPE) {
Rml::ElementList selects;
doc_->QuerySelectorAll(selects, "select");
for (auto *node : selects)
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(node);
select && select->IsSelectBoxVisible()) {
select->CancelSelectBox();
select->Focus(true);
event.StopImmediatePropagation();
dirty_ = true;
return;
}
if (context_open_) {
context_open_ = false;
dirty_ = true;
} else if (!popup_.empty()) {
popup_.clear();
confirm_ = {};
text_accept_ = {};
quit_after_save_ = false;
dirty_ = true;
} else if (!menu_.empty()) {
menu_.clear();
draft_preferences_ = nullptr;
refresh();
} else if (scene_ == "manager") {
scene_ = "newgame";
refresh();
} else if (scene_ == "newgame" || scene_ == "mods") {
scene_ = "main";
refresh();
}
event.StopPropagation();
return;
}
if (key == Rml::Input::KI_Z && event.GetParameter<int>("ctrl_key", 0) &&
scene_ == "desktop" && menu_.empty() && !undo_.empty()) {
desktop_ = undo_.back();
undo_.pop_back();
refresh();
event.StopPropagation();
return;
}
if (key == Rml::Input::KI_TAB &&
(!menu_.empty() || !popup_.empty() || scene_ != "desktop")) {
Rml::ElementList controls;
auto *root = !popup_.empty() ? element("popup")
: !planning_dialog_.empty() ? element("planning-layer")
: !report_detail_kind_.empty() ? element("report-detail-layer")
: element("canvas");
root->QuerySelectorAll(
controls, !popup_.empty() || !report_detail_kind_.empty() || !planning_dialog_.empty()
? "button,input,select"
: ".window button,.window input,.window select");
controls.erase(std::remove_if(controls.begin(), controls.end(),
[](auto *n) {
return !n->IsVisible(true) ||
n->HasAttribute("disabled");
}),
controls.end());
const auto current = context_->GetFocusElement();
const auto i = std::find(controls.begin(), controls.end(), current);
if (!controls.empty()) {
const int old = i == controls.end() ? -1 : int(i - controls.begin());
const bool backwards = event.GetParameter<int>("shift_key", 0) != 0;
const auto next = (old + (backwards ? -1 : 1) + int(controls.size())) %
int(controls.size());
controls[size_t(next)]->Focus(true);
if (controls[size_t(next)]->GetId().starts_with("report-detail-player-") ||
controls[size_t(next)]->GetId().starts_with("report-club-") ||
controls[size_t(next)]->GetId().starts_with("friendly-opponent-") ||
controls[size_t(next)]->GetId().starts_with("alm-match-") ||
controls[size_t(next)]->GetId().starts_with("contract-player-"))
controls[size_t(next)]->ScrollIntoView(
Rml::ScrollIntoViewOptions(Rml::ScrollAlignment::Nearest));
event.StopImmediatePropagation();
}
return;
}
}
if (type == "change") {
if (target->HasAttribute("data-input"))
input(target);
else
change(target);
return;
}
if (type == "input") {
input(target);
return;
}
if (type != "click" && type != "dblclick")
return;
if (suppress_click_) {
suppress_click_ = false;
event.StopPropagation();
return;
}
if (type == "dblclick")
return;
for (auto *n = target; n && n != doc_; n = n->GetParentNode())
if (n->HasAttribute("data-action")) {
if (!n->HasAttribute("disabled"))
dispatch(n->GetAttribute<Rml::String>("data-action", ""), n);
return;
}
} catch (const std::exception &e) {
message(e.what());
}
void App::dispatch(const std::string &action, Rml::Element *target) {
const auto id =
target ? target->GetAttribute<Rml::String>("data-id", "") : std::string();
if (environment_action(action, target) || advertising_action(action, target) || toto_action(action, target)) return;
if (amount_action(action, target) || bank_action(action, target) || finance_action(action, target) || contracts_action(action, target)) return;
if (almanac_action(action, target) || planning_action(action, target) || indoor_action(action, target)) return;
if (report_detail_action(action, target)) {
close_report_picker(false);
return;
}
if (report_picker_action(action, target))
return;
if (action == "report-sort" || action == "report-reset" || action == "report-round") {
Json change;
if (action == "report-sort")
change = {{"kind", "sort"}, {"view", menu_}, {"key", id}};
else if (action == "report-reset")
change = {{"kind", "reset"}};
else {
if (menu_ == "other" && snap().state.value("opening_created", false) &&
snap().state.at("reports").value("competition", 0) == 3)
return;
change = {{"kind", "round"}, {"step", std::stoi(id)}, {"other", menu_ == "other"}};
}
if (apply("reports", change)) {
close_report_picker(false);
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (action == "popup-close") {
popup_.clear();
confirm_ = {};
text_accept_ = {};
quit_after_save_ = false;
dirty_ = true;
return;
}
if (action == "popup-confirm") {
auto fn = std::move(confirm_);
auto text_fn = std::move(text_accept_);
const auto text = field("popup-text");
popup_.clear();
confirm_ = {};
text_accept_ = {};
if (text_fn)
text_fn(text);
else if (fn)
fn();
dirty_ = true;
return;
}
if (action == "exit") {
closed_ = true;
return;
}
if (action == "quit-without-save") {
closed_ = true;
return;
}
if (action.starts_with("context-")) {
context_open_ = false;
dirty_ = true;
init_desktop();
if (action == "context-quit") {
if (!source_->dirty() && desktop_ == saved_desktop_) {
confirmation("Spiel beenden?", [this] { closed_ = true; });
return;
}
confirmation("Deine Änderungen wurden noch nicht gespeichert. Vor dem "
"Beenden speichern?",
[this] {
quit_after_save_ = true;
menu_ = "save";
refresh();
});
popup_accept_ = "Speichern";
popup_extra_ = btn("quit-without-save", "Nicht speichern");
return;
}
if (action == "context-widgets" || action == "context-view-save" ||
action == "context-view-load" || action == "context-background") {
menu_ = action.substr(8);
refresh();
return;
}
if (action == "context-undo") {
if (!undo_.empty()) {
desktop_ = undo_.back();
undo_.pop_back();
refresh();
}
return;
}
auto before = desktop_;
bool ok = true;
if (action == "context-pin")
desktop_["objects"][context_id_]["pinned"] =
!desktop_["objects"][context_id_].value("pinned", true);
else if (action == "context-pin-all") {
bool all = true;
for (const auto &[key, o] : desktop_["objects"].items()) {
(void)key;
if (o.value("visible", false) && !o.value("pinned", true))
all = false;
}
for (auto &[key, o] : desktop_["objects"].items()) {
(void)key;
if (o.value("visible", false))
o["pinned"] = !all;
}
} else if (action == "context-grid")
desktop_["grid"] = !desktop_.value("grid", true);
else if (action == "context-arrange")
ok = arrange_desktop(desktop_);
else if (action == "context-remove")
desktop_["objects"][context_id_]["visible"] = false;
else if (action == "context-size") {
const auto split = id.find('x');
ok = split != id.npos &&
resize_desktop_widget(desktop_, context_id_,
std::stoi(id.substr(0, split)),
std::stoi(id.substr(split + 1)));
}
if (ok && desktop_ != before) {
undo_.push_back(std::move(before));
refresh();
} else if (!ok)
message("Kein freier Platz. Fixierte Widgets zuerst lösen oder andere "
"Elemente entfernen.");
return;
}
if (action == "widget-add") {
auto before = desktop_;
auto &o = desktop_["objects"].at(id);
o["pinned"] = false;
if (place_desktop_object(desktop_, id, 64, 224)) {
undo_.push_back(before);
menu_.clear();
refresh();
} else {
desktop_ = before;
message("Für dieses Widget ist kein freier Platz vorhanden.");
}
return;
}
if (action == "view-default") {
undo_.push_back(desktop_);
desktop_ = default_desktop();
menu_.clear();
refresh();
return;
}
if (action == "view-save-confirm") {
const auto name = field("view-name");
launch::ModLibrary::validate_name(name);
const auto file = user_dir() / "layouts" / editor::path(name + ".json");
const auto save = [this, file] {
const auto old_menu = menu_;
menu_.clear();
refresh();
frame();
auto image = file;
image.replace_extension(".png");
try {
screenshot(image);
editor::write_atomic(file, desktop_.dump(2));
menu_.clear();
refresh();
} catch (...) {
menu_ = old_menu;
refresh();
throw;
}
};
if (fs::exists(file))
confirmation("Gespeicherte Ansicht überschreiben?", save);
else
save();
return;
}
if (action == "view-select") {
selections_["view"] = id;
refresh();
return;
}
if (action == "view-load-confirm") {
launch::ModLibrary::validate_name(selections_["view"]);
const auto file =
user_dir() / "layouts" / editor::path(selections_["view"] + ".json");
auto next = Json::parse(editor::read_file(file));
if (!migrate_desktop(next))
throw editor::Error("Ungültige Desktopansicht oder kein freier Platz für den Almanach.");
undo_.push_back(desktop_);
desktop_ = std::move(next);
menu_.clear();
refresh();
return;
}
if (action == "view-delete") {
const auto name = selections_["view"];
if (name.empty())
return;
launch::ModLibrary::validate_name(name);
confirmation("Ansicht „" + name + "“ löschen?", [this, name] {
const auto file = user_dir() / "layouts" / editor::path(name + ".json");
fs::remove(file);
auto image = file;
image.replace_extension(".png");
fs::remove(image);
selections_["view"].clear();
refresh();
});
return;
}
if (action == "close") {
menu_.clear();
draft_preferences_ = nullptr;
if (scene_ != "desktop")
scene_ = "main";
refresh();
return;
}
if (action == "mods") {
collect_mods();
scene_ = "mods";
refresh();
return;
}
if (action == "settings") {
settings_category_ = "display";
draft_preferences_ = nullptr;
menu_ = "settings";
refresh();
return;
}
if (action == "load") {
if (!source_) {
if (auto *m = mod(active_mod_); m && m->type == "Modern")
load_world(m->file);
else {
message("Bitte zuerst eine Modern-Mod aktivieren.");
return;
}
}
menu_ = "load";
refresh();
return;
}
if (action == "new") {
if (auto *m = mod(active_mod_); m && m->type == "Classic") {
try {
const auto contents = content::open(m->file);
launch::ModEntry entry{m->name,
"Classic",
contents->content_id,
{},
m->file.parent_path()};
launch::ModLibrary library(root_);
const auto user = library.user_directory(entry);
SDL_HideWindow(video_.window);
const int code =
launch::run_child(executable_,
{"--run-mod", editor::utf8(m->file),
"--save-directory", editor::utf8(user)},
[] {});
SDL_ShowWindow(video_.window);
if (code)
message("Classic wurde mit Fehlercode " + std::to_string(code) +
" beendet.");
refresh();
} catch (const std::exception &e) {
SDL_ShowWindow(video_.window);
message(e.what());
}
return;
}
if (!gui_.available()) {
message("Die GUI-Ressourcen für Modern fehlen. Bitte das vollständige "
"Modern-UI-Paket verwenden.");
return;
}
if (auto *m = mod(active_mod_); m && m->type == "Modern")
load_world(m->file);
if (!source_) {
message("Bitte eine Modern-Mod aktivieren.");
return;
}
scene_ = "newgame";
menu_.clear();
refresh();
return;
}
if (action == "mod-select") {
selected_mod_ = id;
refresh();
return;
}
if (action == "mod-activate") {
if (auto *m = mod(selected_mod_)) {
if (!m->error.empty()) {
message(m->error);
return;
}
active_mod_ = m->name;
}
refresh();
return;
}
if (action == "mod-remove") {
if (auto *m = mod(selected_mod_)) {
const auto name = m->name;
confirmation(
"Mod „" + name + "“ löschen? Persönliche Daten bleiben erhalten.",
[this, name] {
auto *m = mod(name);
if (!m)
return;
launch::ModLibrary library(root_);
library.remove({m->name, m->type, {}, {}, m->file.parent_path()});
if (active_mod_ == name)
active_mod_.clear();
selected_mod_.clear();
collect_mods();
refresh();
});
}
return;
}
if (action == "mod-rename") {
auto *m = mod(selected_mod_);
if (!m)
return;
const auto previous = m->name;
text_dialog("Mod umbenennen", previous,
[this, previous](const std::string &name) {
launch::ModLibrary::validate_name(name);
auto *m = mod(previous);
if (!m)
throw editor::Error("Mod ist nicht mehr vorhanden.");
launch::ModLibrary library(root_);
library.rename(
{m->name, m->type, {}, {}, m->file.parent_path()}, name);
if (active_mod_ == previous)
active_mod_ = name;
selected_mod_ = name;
collect_mods();
refresh();
});
return;
}
if (action == "import-modern") {
NFD::Guard guard;
NFD::UniquePath chosen;
const nfdfilteritem_t filter[] = {{"OpenBMH-Welt", "obw"}};
const auto result = NFD::OpenDialog(chosen, filter, 1);
if (result == NFD_CANCEL)
return;
if (result != NFD_OKAY) {
message("Die Dateiauswahl konnte nicht geöffnet werden.");
return;
}
const auto file = editor::path(chosen.get());
auto candidate = Catalog::open(file);
auto initial = candidate->title();
for (char &c : initial)
if (std::string("/\\:*?\"<>|").find(c) != std::string::npos)
c = '-';
if (initial.empty())
initial = "Modern";
text_dialog("Bezeichnung der neuen Mod", initial,
[this, file](const std::string &name) {
launch::ModLibrary::validate_name(name);
const auto destination = root_ / "mods" / editor::path(name);
if (fs::exists(destination))
throw editor::Error(
"Eine Mod mit diesem Namen ist bereits vorhanden.");
fs::create_directories(destination.parent_path());
const auto staging =
destination.parent_path() /
(".ui-import-" + std::to_string(SDL_GetTicks64()));
if (!fs::create_directory(staging))
throw editor::Error("Import wird bereits vorbereitet.");
try {
fs::copy_file(file, staging / "content.obw");
(void)Catalog::open(staging / "content.obw");
fs::rename(staging, destination);
} catch (...) {
fs::remove_all(staging);
throw;
}
collect_mods();
selected_mod_ = name;
refresh();
});
return;
}
if (action == "import-classic") {
NFD::Guard guard;
NFD::UniquePath chosen;
const auto result = NFD::PickFolder(chosen);
if (result == NFD_CANCEL)
return;
if (result != NFD_OKAY) {
message("Die Ordnerauswahl konnte nicht geöffnet werden.");
return;
}
try {
launch::AddMod request;
request.source = editor::path(chosen.get());
const auto game = launch::check_game_directory(request.source);
request.name = game.family == launch::GameFamily::english ? "FTDL-classic"
: "BMH-classic";
request.migrate = false;
text_dialog("Bezeichnung der neuen Mod", request.name,
[this, request](const std::string &name) mutable {
launch::ModLibrary::validate_name(name);
request.name = name;
launch::ModLibrary library(root_);
library.add(request, migrate_);
collect_mods();
selected_mod_ = name;
refresh();
});
} catch (const std::exception &e) {
message(e.what());
}
return;
}
if (action == "setup-step") {
const auto step = target->GetAttribute<int>("data-step", 0);
const int limit = id == "duration" ? 5
: id == "difficulty" ? 10
: id == "players"
? (start_options_.value("league", true) ? 4 : 1)
: 3;
if (id == "duration" || id == "difficulty" || id == "players" ||
id == "mode")
start_options_[id] =
std::clamp(start_options_.value(id, 1) + step, 1, limit);
refresh();
return;
}
if (action == "setup-competition") {
if (id == "league" || id == "world") {
auto next = start_options_;
next[id] = !next.value(id, true);
if ((next.value("league", true) || next.value("world", true)) &&
(next.value("league", true) || next.value("players", 1) == 1))
start_options_ = std::move(next);
}
refresh();
return;
}
if (action == "setup-next") {
managers_draft_ = Json::array();
manager_index_ = 0;
adding_manager_ = false;
manager_picker_ = false;
selections_["portrait"] = "0";
selections_["manager-name"] = "Alex Berger";
scene_ = "manager";
refresh();
return;
}
if (action == "manager-clubs") {
selections_["manager-name"] = field("manager-name");
manager_picker_ = true;
refresh();
return;
}
if (action == "manager-clubs-back") {
manager_picker_ = false;
refresh();
return;
}
if (action == "portrait-style") {
selections_["manager-name"] = field("manager-name");
selections_["portrait-style"] = id;
refresh();
return;
}
if (action == "portrait") {
selections_["manager-name"] = field("manager-name");
selections_["portrait"] = id;
refresh();
return;
}
if (action == "manager-club") {
if (!world_->manageable(id))
return;
selected_club_ = id;
country_ = "nation:de";
league_ = world_->find("clubs", id)->value("competition", league_);
manager_picker_ = false;
refresh();
return;
}
if (action == "manager-back") {
scene_ = adding_manager_ ? "desktop" : "newgame";
refresh();
return;
}
if (action == "manager-next") {
const auto name = field("manager-name");
if (name.empty() || !world_->manageable(selected_club_)) {
message("Bitte einen Namen und einen deutschen Verein wählen.");
return;
}
const Json m = {
{"name", name},
{"club", selected_club_},
{"portrait", selections_["portrait"].empty()
? 0
: std::stoi(selections_["portrait"])},
{"portrait_style",
selections_["portrait-style"] == "painted" ? "painted" : "photo"},
{"strength_choice", selections_["manager-strength"].empty()
? 1
: std::stoi(selections_["manager-strength"])}};
confirmation("Sind alle Eingaben richtig?", [this, m] {
auto candidate = managers_draft_;
candidate.push_back(m);
if (!adding_manager_ &&
manager_index_ + 1 < start_options_.value("players", 1)) {
managers_draft_ = candidate;
++manager_index_;
selections_["manager-name"] = std::array<const char *, 4>{
"Alex Berger", "Chris Winter", "Robin Meier",
"Jamie Sommer"}[size_t(manager_index_)];
for (int p = 0; p < 12; ++p)
if (std::none_of(
candidate.begin(), candidate.end(),
[&](const auto &v) { return v.value("portrait", 0) == p; })) {
selections_["portrait"] = std::to_string(p);
break;
}
refresh();
return;
}
if (!apply("managers", candidate))
return;
managers_draft_ = std::move(candidate);
apply("edit", {{"key", "setup"}, {"value", start_options_}});
scene_ = adding_manager_ || !start_options_.value("league", true)
? "desktop"
: "opening";
opening_page_ = 0;
draw_revealed_ = 0;
refresh();
});
return;
}
if (action == "opening-play") {
draw_playing_ = !draw_playing_;
draw_at_ = SDL_GetTicks64() + 900;
refresh();
return;
}
if (action == "opening-next") {
++opening_page_;
if (opening_page_ == 3)
draw_at_ = SDL_GetTicks64() + 900;
refresh();
return;
}
if (action == "opening-all") {
draw_revealed_ = 64;
opening_page_ = 4;
refresh();
return;
}
if (action == "opening-finish") {
if (opening_page_ != 4)
return;
scene_ = "desktop";
apply("opening", "complete");
refresh();
return;
}
if (action == "desktop-context") {
context_menu({}, 0, 0);
return;
}
if (action.starts_with("open:")) {
const auto route = action.substr(5);
if (route == "kickoff")
return;
if (route == "newplayer") {
const auto existing = snap().state.at("managers");
if (existing.size() >= 4) {
message("Alle vier Mitspielerplätze sind belegt.");
return;
}
managers_draft_ = existing;
manager_index_ = int(existing.size());
adding_manager_ = true;
manager_picker_ = false;
selections_["manager-name"] = std::array<const char *, 4>{
"Alex Berger", "Chris Winter", "Robin Meier",
"Jamie Sommer"}[existing.size()];
for (int p = 0; p < 12; ++p)
if (std::none_of(existing.begin(), existing.end(), [&](const auto &v) {
return v.value("portrait", 0) == p;
})) {
selections_["portrait"] = std::to_string(p);
break;
}
menu_.clear();
scene_ = "manager";
refresh();
return;
}
static const std::set<std::string> available = {
"tables", "strengths", "camp", "settings",
"save", "load", "training", "tactics", "calendar", "league", "other", "postpone", "friendlies", "indoor", "almanac", "bank", "balance", "contracts", "environment", "advertising", "toto"};
if (!available.contains(route)) {
message("Diese native Ansicht wird im nächsten Menüpaket übertragen.");
return;
}
if (route == "bank") { bank_view_ = "entrance"; bank_hint_.clear(); }
menu_ = route;
report_picker_.clear();
report_detail_kind_.clear();
planning_dialog_.clear();
if (route == "settings") {
settings_category_ = "display";
draft_preferences_ = nullptr;
}
refresh();
return;
}
if (action == "training-auto" || action == "training-auto-all" ||
action == "training-ball") {
Json change;
if (action == "training-auto-all")
change = {{"kind", "auto-all"}};
else if (action == "training-auto")
change = {{"kind", "auto"}, {"index", std::stoi(id)}};
else {
const auto group = target->GetAttribute<Rml::String>("data-group", "");
change = {{"kind", "ball"},
{"group", group},
{"index", std::stoi(id)},
{"value", target->GetAttribute<int>("data-value", 1)}};
if (group == "player")
change["player"] = target->GetAttribute<Rml::String>("data-player", "");
}
if (apply("training", change)) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (action == "calendar-select") {
if (apply("calendar", {{"kind", "select"}, {"value", std::stoi(id)}})) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (action == "tactic-cycle") {
const int i = std::stoi(id);
if (i < 0 || i > 6)
return;
if (apply("tactics", {{"kind", "cycle"}, {"index", i}})) {
last_tactic_ = i;
focus_after_render_ = "tactic-cycle-" + id;
refresh();
}
return;
}
if (action == "ticket") {
if (ticket_) {
ticket_->open(target, device_ratio_);
dirty_ = true;
}
return;
}
if (action == "camp-region") {
selections_["camp-region"] = id;
refresh();
return;
}
if (action == "camp-select") {
apply("camp.select", id);
refresh();
return;
}
if (action == "camp-remember") {
if (apply("camp.remember", {}))
message("Trainingslager für die Demo vorgemerkt.");
return;
}
if (action == "settings-category") {
settings_category_ = id;
refresh();
return;
}
if (action == "settings-theme") {
draft_preferences_["theme"] = id;
refresh();
return;
}
if (action == "settings-apply") {
if (settings_category_ == "display") {
for (const auto *key : {"mode", "resolution", "scale"}) {
const auto value = field(std::string("display-") + key);
if (!value.empty())
draft_preferences_[key] = value;
}
}
if (settings_category_ == "sound") {
draft_preferences_["effects"] =
element("sound-effects")->HasAttribute("checked");
draft_preferences_["sound-style"] = field("sound-style");
}
if (source_ && !apply("preferences", draft_preferences_))
return;
theme_ = draft_preferences_.value("theme", theme_);
draft_preferences_ = nullptr;
menu_.clear();
refresh();
return;
}
if (action == "save-select") {
selections_["save"] = id;
refresh();
return;
}
if (action == "save-new") {
selections_["save"].clear();
refresh();
return;
}
if (action == "save-confirm") {
auto name =
selections_["save"].empty() ? field("save-name") : selections_["save"];
try {
launch::ModLibrary::validate_name(name);
const auto file = user_dir() / "saves" / editor::path(name + ".json");
fs::create_directories(file.parent_path());
const auto save = [this, file] {
init_desktop();
source_->save(file, desktop_);
saved_desktop_ = desktop_;
menu_.clear();
if (quit_after_save_)
closed_ = true;
refresh();
};
if (fs::exists(file))
confirmation("Vorhandenen Demo-Spielstand überschreiben?", save);
else
save();
} catch (const std::exception &e) {
message(e.what());
}
return;
}
if (action == "load-confirm") {
const auto name = selections_["save"];
if (name.empty())
return;
try {
launch::ModLibrary::validate_name(name);
desktop_ =
source_->load(user_dir() / "saves" / editor::path(name + ".json"));
saved_desktop_ = desktop_;
theme_ = snap().state.at("preferences").value("theme", theme_);
menu_.clear();
scene_ = "desktop";
refresh();
} catch (const std::exception &e) {
message(e.what());
}
return;
}
if (action == "save-rename") {
const auto previous = selections_["save"];
if (previous.empty())
return;
text_dialog(
"Speicherstand umbenennen", previous,
[this, previous](const std::string &name) {
launch::ModLibrary::validate_name(name);
if (name == previous)
return;
const auto folder = user_dir() / "saves",
old_file = folder / editor::path(previous + ".json"),
new_file = folder / editor::path(name + ".json");
if (fs::exists(new_file))
throw editor::Error("Diese Bezeichnung ist bereits vorhanden.");
fs::rename(old_file, new_file);
selections_["save"] = name;
refresh();
});
return;
}
if (action == "save-delete") {
const auto name = selections_["save"];
if (name.empty())
return;
confirmation("Demo-Spielstand „" + name + "“ löschen?", [this, name] {
launch::ModLibrary::validate_name(name);
fs::remove(user_dir() / "saves" / editor::path(name + ".json"));
selections_["save"].clear();
refresh();
});
return;
}
if (action == "squad-tactics") {
menu_ = "tactics";
refresh();
return;
}
}
void App::change(Rml::Element *target) {
const auto kind = target->GetAttribute<Rml::String>("data-change", "");
auto *control = dynamic_cast<Rml::ElementFormControl *>(target);
if (!control)
return;
const auto value = control->GetValue();
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(target);
select && select->IsSelectBoxVisible()) {
pending_selects_.insert(target->GetId());
return;
}
if (kind == "calendar-country" || kind == "calendar-league") {
std::string league = value;
if (kind == "calendar-country") {
const auto current = snap().state.at("calendar").at("league").get<std::string>();
const auto *competition = world_->find("competitions", current);
if (competition && competition->value("nation", "") == value)
return;
const auto leagues = world_->leagues(value);
if (leagues.empty())
return;
league = leagues.front()->value("id", "");
}
if (snap().state.at("calendar").at("league") == league)
return;
if (apply("calendar", {{"kind", "league"}, {"value", league}})) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (kind == "training-focus") {
const auto player = target->GetAttribute<Rml::String>("data-player", "");
const int focus = std::stoi(value);
if (snap().state.at("training").at("players").at(player).at("focus") ==
focus)
return;
if (apply("training",
{{"kind", "focus"}, {"player", player}, {"value", focus}})) {
focus_after_render_ = target->GetId();
refresh();
}
return;
}
if (kind == "manager-country" && value == country_)
return;
if (kind == "manager-league" && value == league_)
return;
if (kind == "manager-country" || kind == "manager-league")
focus_after_render_ = target->GetId();
if (kind == "manager-country" || kind == "manager-league") {
if (!manager_picker_)
selections_["manager-name"] = field("manager-name");
if (kind == "manager-country") {
country_ = value;
league_.clear();
} else
league_ = value;
refresh();
} else if (kind == "manager-strength") {
selections_["manager-strength"] = value;
}
}
void App::input(Rml::Element *target) {
const auto kind = target->GetAttribute<Rml::String>("data-input", "");
auto *control = dynamic_cast<Rml::ElementFormControl *>(target);
if (!control)
return;
const auto value = control->GetValue();
if (kind == "tactic-effort") {
const int value = std::stoi(control->GetValue());
if (apply("tactics", {{"kind", "effort"}, {"value", value}})) {
last_tactic_ = 7;
element("tactic-effort-value")
->SetInnerRML(std::string(size_t(value), '!'));
element("tactic-hint")
->SetInnerRML("Einsatz: " + std::to_string(value) + " / 11");
dirty_ = true;
}
return;
}
if (kind == "sound-volume") {
const int n = std::stoi(value);
draft_preferences_["volume"] = n;
element("volume-value")->SetInnerRML(std::to_string(n) + " %");
dirty_ = true;
}
if (kind == "camp-focus") {
const auto i = std::stoi(target->GetAttribute<Rml::String>("data-id", "0"));
if (i < 0 || i > 2)
return;
auto focus = snap().state.at("camp").at("focus");
focus[size_t(i)] = std::stoi(value);
if (apply("camp.focus", focus)) {
element("camp-value-" + std::to_string(i))->SetInnerRML(value + " / 15");
const int rest =
15 -
(focus[0].get<int>() + focus[1].get<int>() + focus[2].get<int>()) / 3;
element("camp-value-3")->SetInnerRML(std::to_string(rest) + " / 15");
if (auto *c =
dynamic_cast<Rml::ElementFormControl *>(element("camp-focus-3")))
c->SetValue(std::to_string(rest));
dirty_ = true;
}
}
}
void App::script() {
std::ifstream stream(config_.commands);
if (!stream)
throw editor::Error("UI-Skript kann nicht gelesen werden.");
const auto locate = [&](const Json &command) {
if (command.contains("selector")) {
context_->Update();
auto *node =
doc_->QuerySelector(command.at("selector").get<std::string>());
if (!node || !node->IsVisible(true))
throw editor::Error("UI-Skript: Element nicht sichtbar.");
const auto at = node->GetAbsoluteOffset(Rml::BoxArea::Border),
size = node->GetBox().GetSize(Rml::BoxArea::Border);
return Rml::Vector2i{int(at.x + size.x * .5f), int(at.y + size.y * .5f)};
}
return Rml::Vector2i{command.at("x").get<int>(),
command.at("y").get<int>()};
};
std::string line;
size_t index = 0;
while (std::getline(stream, line)) {
++index;
if (line.empty())
continue;
try {
const auto command = Json::parse(line);
const auto type = command.value("type", std::string());
if (type == "click" || type == "right") {
const auto point = locate(command);
const int button = type == "right" ? 1 : 0;
context_->ProcessMouseMove(point.x, point.y, 0);
context_->ProcessMouseButtonDown(button, 0);
context_->ProcessMouseButtonUp(button, 0);
} else if (type == "drag") {
const auto point = locate(command),
end = Rml::Vector2i{command.at("to_x"), command.at("to_y")};
context_->ProcessMouseMove(point.x, point.y, 0);
context_->ProcessMouseButtonDown(0, 0);
for (int i = 1; i <= 12; ++i)
context_->ProcessMouseMove(point.x + (end.x - point.x) * i / 12,
point.y + (end.y - point.y) * i / 12, 0);
context_->ProcessMouseButtonUp(0, 0);
} else if (type == "text")
context_->ProcessTextInput(command.value("value", std::string()));
else if (type == "key") {
const std::map<std::string, Rml::Input::KeyIdentifier> keys = {
{"ESC", Rml::Input::KI_ESCAPE}, {"ENTER", Rml::Input::KI_RETURN}, {"NUMENTER", Rml::Input::KI_NUMPADENTER},
{"TAB", Rml::Input::KI_TAB}, {"SPACE", Rml::Input::KI_SPACE},
{"HOME", Rml::Input::KI_HOME}, {"END", Rml::Input::KI_END},
{"LEFT", Rml::Input::KI_LEFT}, {"RIGHT", Rml::Input::KI_RIGHT},
{"UP", Rml::Input::KI_UP}, {"DOWN", Rml::Input::KI_DOWN},
{"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}, {"V", Rml::Input::KI_V},
{"BACKSPACE", Rml::Input::KI_BACK}, {"DELETE", Rml::Input::KI_DELETE}, {"F4", Rml::Input::KI_F4},
{"0", Rml::Input::KI_0}, {"1", Rml::Input::KI_1}, {"2", Rml::Input::KI_2}, {"3", Rml::Input::KI_3},
{"4", Rml::Input::KI_4}, {"5", Rml::Input::KI_5}, {"6", Rml::Input::KI_6}, {"7", Rml::Input::KI_7},
{"8", Rml::Input::KI_8}, {"9", Rml::Input::KI_9}};
const auto name = command.at("value").get<std::string>();
if (!keys.contains(name))
throw editor::Error("Unbekannte UI-Skripttaste.");
const int mods =
(command.value("ctrl", false) ? Rml::Input::KM_CTRL : 0) |
(command.value("shift", false) ? Rml::Input::KM_SHIFT : 0);
context_->ProcessKeyDown(keys.at(name), mods);
context_->ProcessKeyUp(keys.at(name), mods);
} else if (type == "screenshot")
screenshot(editor::path(command.at("path").get<std::string>()));
else if (type == "checkpoint") {
init_desktop();
source_->save(editor::path(command.at("path").get<std::string>()),
desktop_);
} else if (type == "snapshot")
editor::write_atomic(
editor::path(command.at("path").get<std::string>()),
Json{{"scene", scene_},
{"menu", menu_},
{"report_picker", report_picker_},
{"planning_dialog", planning_dialog_},
{"bank_view", bank_view_}, {"bank_property", bank_property_}, {"bank_stock", bank_stock_},
{"balance_future", balance_future_},
{"advertising_view", {{"selected", advertising_selected_}, {"offer", advertising_offer_}}},
{"toto_view", {{"column", toto_column_}, {"dialog", toto_dialog_}}},
{"contracts_view", {{"dialog", contracts_dialog_}, {"player", contracts_player_}, {"tab", contracts_tab_}, {"draft", contract_draft_}}},
{"amount_editor", amount_ ? Json{{"title", amount_->request.title}, {"raw", amount_->raw}, {"review", amount_->review}, {"error", amount_error()}} : Json()},
{"source_revision", source_ ? Json(snap().revision) : Json()},
{"game_dirty", source_ && source_->dirty()},
{"desktop_dirty", desktop_ != saved_desktop_},
{"almanac_view", {{"year", almanac_year_}, {"date", almanac_day_}, {"id", almanac_match_}, {"tab", almanac_tab_}}},
{"report_detail", {{"kind", report_detail_kind_},
{"club", report_detail_club_},
{"player", report_detail_player_}}},
{"desktop", desktop_},
{"demo", source_ ? snap().state : Json()}}
.dump(2));
else if (type == "dom")
editor::write_atomic(
editor::path(command.at("path").get<std::string>()),
doc_->GetInnerRML());
else if (type == "assert") {
if (command.contains("scene") &&
scene_ != command.at("scene").get<std::string>())
throw editor::Error("UI-Skript: falsche Szene.");
if (command.contains("menu") &&
menu_ != command.at("menu").get<std::string>())
throw editor::Error("UI-Skript: falsches Menü.");
if (command.contains("selector")) {
auto *node =
doc_->QuerySelector(command.at("selector").get<std::string>());
const bool present = node && node->IsVisible(true);
if (present != command.value("visible", true))
throw editor::Error("UI-Skript: falsche Sichtbarkeit.");
if (command.contains("disabled") &&
(!node || node->HasAttribute("disabled") !=
command.at("disabled").get<bool>()))
throw editor::Error("UI-Skript: falscher Sperrstatus.");
}
if (command.contains("ticket") &&
snap().state.at("ticket") != command.at("ticket"))
throw editor::Error("UI-Skript: falscher Eintrittspreis.");
} else
throw editor::Error("Unbekannter UI-Skriptbefehl: " + type);
frame();
} catch (const std::exception &e) {
throw editor::Error("UI-Skript Zeile " + std::to_string(index) + ": " +
e.what());
}
}
}