1062 lines
48 KiB
C++
1062 lines
48 KiB
C++
// 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;
|
||
const auto item=[&](const std::string &action,const std::string &label,const std::string &symbol,const std::string &extra=std::string()){
|
||
return btn(action,glyph(symbol,19./scale_)+"<span>"+esc(label)+"</span>"+((extra.find("aria-checked=\"true\"")!=std::string::npos||extra.find("data-checked=\"true\"")!=std::string::npos)?"<span class=\"context-check\">"+glyph("check",14./scale_)+"</span>":""),"context-action",extra);
|
||
};
|
||
std::string body=item("context-undo","Rückgängig","undo",undo_.empty()?"disabled":"");
|
||
if(!context_id_.empty()){
|
||
const auto &o=desktop_.at("objects").at(context_id_);
|
||
const bool pinned=o.value("pinned",true);
|
||
body+=item("context-pin",pinned?"Fixierung lösen":"Fixieren","lock");
|
||
if(o.value("widget",false)){
|
||
body+="<div class=\"context-label\">Widgetgröße</div>";
|
||
for(const auto &d:widget_definitions())if(d.id==context_id_)for(const auto &[w,h]:d.sizes){
|
||
const bool selected=o.at("w")==w*248-24 && o.at("h")==h*248-24;
|
||
body+=item("context-size",std::to_string(w)+" × "+std::to_string(h),"grid","data-id=\""+std::to_string(w)+"x"+std::to_string(h)+"\" "+(pinned?"disabled":"")+(selected?" data-checked=\"true\"":""));
|
||
}
|
||
body+=item("context-remove","Widget entfernen","trash",pinned?"disabled":"");
|
||
}
|
||
}else{
|
||
bool pinned=true;for(const auto &[id,o]:desktop_.at("objects").items())if(o.at("visible")==true&&o.at("pinned")==false)pinned=false;
|
||
body+=item("context-pin-all","Alles fixieren","lock",std::string("role=\"menuitemcheckbox\" aria-checked=\"")+(pinned?"true":"false")+"\"");
|
||
body+=item("context-arrange","Am Raster anordnen","grid");
|
||
body+=item("context-grid",desktop_.value("grid",true)?"Raster deaktivieren":"Raster aktivieren","grid",std::string("role=\"menuitemcheckbox\" aria-checked=\"")+(desktop_.value("grid",true)?"true":"false")+"\"");
|
||
body+=item("context-widgets","Widget hinzufügen","plus")+item("context-view-save","Ansicht speichern","save")+item("context-view-load","Ansicht laden","folder")+item("context-background","Hintergrundbild ändern","image")+item("context-quit","Spiel beenden","power");
|
||
}
|
||
root->SetInnerRML(body);
|
||
context_->Update();
|
||
const auto size = context_->GetDimensions();
|
||
root->SetProperty(
|
||
"left",
|
||
scalar(std::clamp(context_x_, 8, std::max(8, size.x - 278))) + "px");
|
||
root->SetProperty(
|
||
"top", scalar(std::clamp(
|
||
context_y_, 8,
|
||
std::max(8, size.y - int(root->GetBox().GetSize(Rml::BoxArea::Border).y) - 8))) +
|
||
"px");
|
||
Rml::ElementList buttons;root->QuerySelectorAll(buttons,"button");for(auto *button:buttons)if(!button->HasAttribute("disabled")){button->Focus(true);break;}
|
||
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);
|
||
drag_ = {true, false, id, x, y, o.value("x", 0.0), o.value("y", 0.0)};
|
||
drag_.pinned=o.value("pinned",true);drag_undo_size_=undo_.size();
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if (!drag_.active)
|
||
return;
|
||
if (type == "mousemove") {
|
||
if (!drag_.moved && std::hypot(x - drag_.x, y - drag_.y) < 6)
|
||
return;
|
||
if(drag_.pinned){drag_.moved=true;return;}
|
||
if (!drag_.moved) {
|
||
desktop_checkpoint(desktop_);
|
||
desktop_raise(drag_.id);
|
||
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_.pinned){suppress_click_=drag_.moved;drag_.active=false;return;}
|
||
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);
|
||
const auto &trash=desktop_.at("objects").at("trash");
|
||
const auto px=(event.GetParameter<float>("mouse_x",0)-canvas_left_)/scale_,py=(event.GetParameter<float>("mouse_y",0)-canvas_top_)/scale_;
|
||
const bool remove=drag_.id!="trash"&&o.value("widget",false)&&trash.at("visible")==true&&px>=trash.at("x").get<int>()&&px<=trash.at("x").get<int>()+trash.at("w").get<int>()&&py>=trash.at("y").get<int>()&&py<=trash.at("y").get<int>()+trash.at("h").get<int>();
|
||
if(remove){proposed["objects"][drag_.id]["visible"]=false;desktop_=std::move(proposed);}
|
||
else if (place_desktop_object(proposed, drag_.id, x, y))
|
||
{desktop_ = std::move(proposed);desktop_raise(drag_.id);}
|
||
else {desktop_ = undo_.back();if(undo_.size()>drag_undo_size_){undo_.pop_back();if(!undo_themes_.empty())undo_themes_.pop_back();}}
|
||
|
||
refresh();
|
||
}
|
||
drag_.active = false;
|
||
}
|
||
}
|
||
void App::ProcessEvent(Rml::Event &event) try {
|
||
const auto type = event.GetType();
|
||
if (engine_mode_) { engine_event(event); return; }
|
||
// Native widgets can emit intermediate selected values while their options
|
||
// are being constructed. Opening a squad menu must stay read-only.
|
||
if (setting_menu_markup_ && (menu_ == "lineup" || menu_ == "transfer" || menu_ == "news" || menu_ == "settings" || menu_=="widgets" || menu_=="save" || menu_=="load" || menu_=="view-save" || menu_=="view-load") &&
|
||
(type == "change" || type == "input")) return;
|
||
if (setting_menu_markup_ && (scene_ == "manager" || scene_ == "newgame") &&
|
||
(type == "change" || type == "input")) return;
|
||
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(front_event(event))return;
|
||
if (live_event(event)) return;
|
||
if(national_event(event))return;
|
||
if (career_event(event)) return;
|
||
if (entry_event(event)) return;
|
||
if (opening_event(event)) return;
|
||
if (amount_event(event)) return;
|
||
if (popup_.empty() && settings_event(event)) return;
|
||
if (popup_.empty() && (files_event(event) || widget_event(event))) return;
|
||
if ((menu_ == "lineup" || menu_ == "transfer" || scene_ == "manager") && (type == "change" || type == "input")) {
|
||
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(event.GetTargetElement());
|
||
select && select->IsSelectBoxVisible()) {
|
||
pending_selects_.insert(select->GetId());
|
||
dirty_ = true;
|
||
return;
|
||
}
|
||
}
|
||
if (popup_.empty() && amount_trigger_event(event)) return;
|
||
if (popup_.empty() && report_detail_kind_.empty() && (lineup_event(event) || transfer_event(event))) return;
|
||
if (popup_.empty() && report_detail_kind_.empty() && (career_report_event(event) || rankings_event(event))) return;
|
||
if (report_detail_kind_.empty() && stadium_event(event)) return;
|
||
if (popup_.empty() && contracts_event(event)) return;
|
||
if (popup_.empty() && (advertising_event(event) || toto_event(event))) return;
|
||
if (popup_.empty() && (statistics_event(event) || news_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();
|
||
quit_after_save_=false;
|
||
quit_closes_app_=false;
|
||
reset_settings();
|
||
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();
|
||
quit_after_save_=false;
|
||
quit_closes_app_=false;
|
||
reset_settings();
|
||
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")
|
||
: !career_view_.value("dialog", "").empty() ? element("career-history-layer")
|
||
: !stadium_view_.value("dialog", "").empty() ? element("stadium-modal")
|
||
: element("canvas");
|
||
root->QuerySelectorAll(
|
||
controls, !popup_.empty() || !report_detail_kind_.empty() || !planning_dialog_.empty() || !career_view_.value("dialog", "").empty() || !stadium_view_.value("dialog", "").empty()
|
||
? "button,input,select"
|
||
: ".window button,.window input,.window select");
|
||
controls.erase(std::remove_if(controls.begin(), controls.end(),
|
||
[this](auto *n) {
|
||
return !n->IsVisible(true) ||
|
||
n->HasAttribute("disabled") ||
|
||
n->template GetAttribute<int>("tabindex", 0) < 0 ||
|
||
(menu_ == "scorers" &&
|
||
n->GetId().starts_with("player-stat-tab-") &&
|
||
n->template GetAttribute<Rml::String>("aria-selected", "false") != "true");
|
||
}),
|
||
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)]->GetId().starts_with("lineup-name-") ||
|
||
controls[size_t(next)]->GetId().starts_with("lineup-detail-"))
|
||
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(front_action(action,target))return;
|
||
if (live_action(action, target)) return;
|
||
if(national_action(action,target))return;
|
||
if (career_action(action,target)) return;
|
||
if (entry_action(action, target)) return;
|
||
if (opening_action(action, target)) return;
|
||
if (settings_action(action,target)) return;
|
||
if (files_action(action,target) || widget_action(action,target)) return;
|
||
if (lineup_action(action, target) || transfer_action(action, target)) return;
|
||
if (career_report_action(action, target) || rankings_action(action, target)) return;
|
||
if (statistics_action(action, target) || dispatch_news(action, target)) return;
|
||
if (stadium_action(action, target)) return;
|
||
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;
|
||
}
|
||
focus_after_render_=context_id_.empty()?"desktop-identity":"object-"+context_id_;
|
||
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) {
|
||
desktop_checkpoint(before);
|
||
refresh();
|
||
} else if (!ok)
|
||
message("Kein freier Platz. Fixierte Widgets zuerst lösen oder andere "
|
||
"Elemente entfernen.");
|
||
return;
|
||
}
|
||
if (action == "close") {
|
||
quit_after_save_=false;
|
||
quit_closes_app_=false;
|
||
menu_.clear();
|
||
reset_settings();
|
||
if (scene_ != "desktop")
|
||
scene_ = "main";
|
||
refresh();
|
||
return;
|
||
}
|
||
if (action == "mods") {
|
||
collect_mods();
|
||
scene_ = "mods";
|
||
refresh();
|
||
return;
|
||
}
|
||
if (action == "settings") {
|
||
settings_category_ = "display";
|
||
reset_settings();
|
||
menu_ = "settings";
|
||
refresh();
|
||
return;
|
||
}
|
||
if (action == "load") {
|
||
if(auto *active=mod(active_mod_);active&&active->type=="Modern"&&(!world_||world_->source()!=fs::absolute(active->file).lexically_normal()))load_world(active->file);
|
||
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(front_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;
|
||
}
|
||
entry_begin();
|
||
return;
|
||
}
|
||
if (action == "desktop-context") {
|
||
context_menu({}, 0, 0);
|
||
return;
|
||
}
|
||
if (action.starts_with("open:")) {
|
||
const auto route = action.substr(5);
|
||
if(source_&&!demo_career_menu_available(snap().state,route)){message(snap().state.at("career").value("ended",false)?"Diese Partie ist beendet. Bitte ein neues Spiel beginnen oder einen Spielstand laden.":"Dieses Vereinsmenü ist für die Nationalmannschaft nicht verfügbar.");return;}
|
||
if (route == "kickoff")
|
||
return;
|
||
if (route == "newplayer") {
|
||
scene_="managerhub";menu_.clear();career_resign_open_=career_game_end_=false;focus_after_render_="career-resign";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", "lineup", "transfer", "achievements", "scorers", "fairplay", "highscore", "stadium", "statistics", "news"};
|
||
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";
|
||
reset_settings();
|
||
}
|
||
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 == "squad-tactics") {
|
||
menu_ = "tactics";
|
||
refresh();
|
||
return;
|
||
}
|
||
}
|
||
void App::change(Rml::Element *target) {
|
||
if (entry_change(target)) return;
|
||
if(front_change(target)||files_change(target) || widget_change(target) || settings_change(target))return;
|
||
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;
|
||
}
|
||
|
||
}
|
||
void App::input(Rml::Element *target) {
|
||
if (entry_input(target)) return;
|
||
if(front_change(target)||files_change(target) || widget_change(target) || settings_change(target))return;
|
||
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 == "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 point = script_click_point(*context_, *node);
|
||
if (!point)
|
||
throw editor::Error("UI-Skript: Elementmitte ist nicht sichtbar anklickbar oder die Transformation ist singulär.");
|
||
return *point;
|
||
}
|
||
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 == "engine-wait") {
|
||
const auto until = SDL_GetTicks64() + command.value("timeout_ms", uint64_t(300000));
|
||
while ((engine_busy_ || engine_creation_busy_ || engine_files_busy_) && SDL_GetTicks64() < until) { pump_events(); frame(); SDL_Delay(10); }
|
||
if (engine_busy_ || engine_creation_busy_ || engine_files_busy_) throw editor::Error("Engine-Vorgang hat das QA-Zeitlimit überschritten.");
|
||
} else if(type=="window-resize-probe"){
|
||
// QA-only synthetic event: no OS window or mouse coordinate is changed.
|
||
int w,h,pw,ph;SDL_GetWindowSize(video_.window,&w,&h);video_.drawable_size(pw,ph);
|
||
const auto before=context_->GetDimensions();SDL_Event probe{};probe.type=SDL_WINDOWEVENT;probe.window.windowID=SDL_GetWindowID(video_.window);probe.window.event=SDL_WINDOWEVENT_SIZE_CHANGED;probe.window.data1=std::max(1,w/2);probe.window.data2=std::max(1,h/2);handle_event(probe);
|
||
const auto after=context_->GetDimensions();const bool ok=after.x==pw&&after.y==ph;
|
||
editor::write_atomic(editor::path(command.at("path").get<std::string>()),Json{{"qa_only",true},{"logical",{w,h}},{"drawable",{pw,ph}},{"context_before",{before.x,before.y}},{"synthetic_event",{probe.window.data1,probe.window.data2}},{"context_after",{after.x,after.y}},{"passed",ok}}.dump(2));
|
||
if(!ok)throw editor::Error("QA resize probe: context dimensions were overwritten by logical event data.");
|
||
}else if(type=="front-wait"){
|
||
const auto end=SDL_GetTicks64()+command.value("timeout_ms",uint64_t(300000));
|
||
while(front_busy_&&SDL_GetTicks64()<end){front_poll();if(needs_render_||dirty_)frame();SDL_Delay(10);}
|
||
if(front_busy_)throw editor::Error("Modvorgang hat das QA-Zeitlimit überschritten.");
|
||
} else 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=="pointer-down"||type=="pointer-move"||type=="pointer-up"){
|
||
const auto point=locate(command);context_->ProcessMouseMove(point.x,point.y,0);
|
||
const int button=command.value("button",0);
|
||
if(type=="pointer-down")context_->ProcessMouseButtonDown(button,0);
|
||
if(type=="pointer-up")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 == "wheel") {
|
||
const auto point = locate(command);
|
||
const float delta = command.at("delta").get<float>();
|
||
if (!std::isfinite(delta) || std::abs(delta) > 1000)
|
||
throw editor::Error("UI-Skript: ungültiger Mausradweg.");
|
||
context_->ProcessMouseMove(point.x, point.y, 0);
|
||
context_->ProcessMouseWheel(delta, 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},
|
||
{"S", Rml::Input::KI_S}, {"O", Rml::Input::KI_O}, {"A", Rml::Input::KI_A}, {"Z", Rml::Input::KI_Z}, {"V", Rml::Input::KI_V},
|
||
{"P", Rml::Input::KI_P},
|
||
{"BACKSPACE", Rml::Input::KI_BACK}, {"DELETE", Rml::Input::KI_DELETE}, {"F4", Rml::Input::KI_F4}, {"F10", Rml::Input::KI_F10}, {"CONTEXT", Rml::Input::KI_APPS},
|
||
{"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 == "wait") {
|
||
const int milliseconds = command.at("milliseconds").get<int>();
|
||
if (milliseconds < 0 || milliseconds > 30000)
|
||
throw editor::Error("UI-Wartezeit muss zwischen 0 und 30000 ms liegen.");
|
||
const auto until = SDL_GetTicks64() + uint64_t(milliseconds);
|
||
while (!closed_ && SDL_GetTicks64() < until) {
|
||
pump_events();
|
||
front_poll();
|
||
opening_tick();
|
||
live_tick();
|
||
frame();
|
||
SDL_Delay(5);
|
||
}
|
||
} else if (type == "screenshot")
|
||
screenshot(editor::path(command.at("path").get<std::string>()));
|
||
else if (type == "checkpoint") {
|
||
if (engine_mode_) throw editor::Error("Der UI-Demo-Checkpoint speichert keine Enginekarriere. Bitte die OBS-Speicheraktion verwenden.");
|
||
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_},
|
||
{"live_view", live_snapshot()},
|
||
{"engine_view", engine_snapshot()},
|
||
{"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_}}},
|
||
{"lineup_view", {{"pitch", lineup_pitch_}, {"data", lineup_data_}, {"page", lineup_page_}, {"side", lineup_side_}, {"selected", lineup_selected_}, {"drag", lineup_drag_}}},
|
||
{"transfer_view", transfer_view_}, {"transfer_dialog", transfer_dialog_}, {"transfer_draft", transfer_draft_},
|
||
{"career_view", career_view_}, {"rankings_view", rankings_view_},
|
||
{"stadium_view", stadium_view_},
|
||
{"select_menu", select_menu_ ? select_menu_->snapshot() : Json()}, {"career_context",source_?demo_career_context(snap().state,*world_):Json()}, {"national_view",{{"dialog",national_dialog_},{"menu",national_menu_},{"portrait",national_portrait_},{"revision",national_revision_}}}, {"manager_hub",{{"resign_open",career_resign_open_},{"game_end",career_game_end_},{"owner",field("career-resign-owner")}}}, {"entry_view", entry_snapshot()}, {"front_view",front_snapshot_view()}, {"files_view",{{"mode",files_mode_},{"selected",files_selected_},{"name",files_name_},{"feedback",files_feedback_}}}, {"widget_view",{{"query",widget_query_},{"notice",widget_notice_}}}, {"ui_preferences",ui_preferences_}, {"settings_draft",settings_draft_}, {"settings_category",settings_category_}, {"settings_query",settings_query_}, {"settings_notice",settings_notice_},
|
||
{"statistics_view", statistics_view_}, {"statistics_trophy", statistics_trophy_},
|
||
{"statistics_scrolls", statistics_scrolls_},
|
||
{"news_view", news_view_}, {"news_dialog", news_dialog_},
|
||
{"news_undo", news_undo_}, {"news_scroll", element("news-feed") ? element("news-feed")->GetScrollTop() : news_scroll_},
|
||
{"focus", context_->GetFocusElement() ? context_->GetFocusElement()->GetId() : ""},
|
||
{"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()},
|
||
{"display_metrics",[&](){int w,h,pw,ph;SDL_GetWindowSize(video_.window,&w,&h);video_.drawable_size(pw,ph);const auto d=context_->GetDimensions();return Json{{"logical",{w,h}},{"drawable",{pw,ph}},{"context",{d.x,d.y}}};}()},
|
||
{"source_revision", source_ ? Json(snap().revision) : Json()},
|
||
{"game_dirty", engine_mode_ ? engine_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=="metrics"){
|
||
context_->Update();Json rows=Json::array();
|
||
for(const auto &selector:command.at("selectors")){Rml::ElementList nodes;doc_->QuerySelectorAll(nodes,selector.get<std::string>());for(auto *node:nodes){auto at=node->GetAbsoluteOffset(Rml::BoxArea::Border),size=node->GetBox().GetSize(Rml::BoxArea::Border);rows.push_back({{"selector",selector},{"id",node->GetId()},{"x",at.x},{"y",at.y},{"width",size.x},{"height",size.y},{"scroll_top",node->GetScrollTop()},{"scroll_height",node->GetScrollHeight()},{"client_height",node->GetClientHeight()},{"font_size",node->GetComputedValues().font_size()},{"rml",node->GetInnerRML()},{"visible",node->IsVisible(true)}});}}
|
||
editor::write_atomic(editor::path(command.at("path").get<std::string>()),rows.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());
|
||
}
|
||
}
|
||
}
|