478 lines
15 KiB
C++
478 lines
15 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
void App::desktop_checkpoint(const Json &before) {
|
|
if (undo_.empty() || undo_.back() != before ||
|
|
(!undo_themes_.empty() && undo_themes_.back() != theme_)) {
|
|
undo_.push_back(before);
|
|
undo_themes_.push_back(theme_);
|
|
}
|
|
if (undo_.size() > 40) {
|
|
undo_.erase(undo_.begin());
|
|
undo_themes_.erase(undo_themes_.begin());
|
|
}
|
|
}
|
|
void App::desktop_cancel_drag() {
|
|
if (!drag_.active)
|
|
return;
|
|
if (drag_.moved && !drag_.pinned && !undo_.empty()) {
|
|
desktop_ = undo_.back();
|
|
if (undo_.size() > drag_undo_size_) {
|
|
undo_.pop_back();
|
|
if (!undo_themes_.empty())
|
|
undo_themes_.pop_back();
|
|
}
|
|
}
|
|
drag_ = {};
|
|
suppress_click_ = true;
|
|
refresh();
|
|
}
|
|
void App::desktop_raise(const std::string &id) {
|
|
int highest = 0;
|
|
for (const auto &[key, o] : desktop_.at("objects").items())
|
|
highest = std::max(highest, o.value("z", 1));
|
|
if (highest >= 9900) {
|
|
int index = 0;
|
|
for (auto &[key, o] : desktop_["objects"].items())
|
|
o["z"] = ++index;
|
|
highest = index;
|
|
}
|
|
desktop_["objects"][id]["z"] = highest + 1;
|
|
}
|
|
void App::widget_remember_scroll() {
|
|
if (auto *pane = element("widget-gallery"))
|
|
widget_gallery_scroll_ = pane->GetScrollTop();
|
|
}
|
|
bool App::widget_change(Rml::Element *target) {
|
|
if (menu_ != "widgets" || !target)
|
|
return false;
|
|
if (target->GetId() == "widget-search") {
|
|
widget_query_ = field("widget-search");
|
|
widget_gallery_scroll_ = 0;
|
|
setting_menu_markup_ = true;
|
|
if (auto *gallery = element("widget-gallery"))
|
|
gallery->SetInnerRML(render_widget_gallery_items());
|
|
setting_menu_markup_ = false;
|
|
context_->Update();
|
|
center_selects(*doc_);
|
|
context_->Update();
|
|
if (auto *gallery = element("widget-gallery"))
|
|
gallery->SetScrollTop(0);
|
|
dirty_ = true;
|
|
return true;
|
|
}
|
|
if (target->HasAttribute("data-widget-size")) {
|
|
const auto id = target->GetAttribute<Rml::String>("data-widget-size", "");
|
|
const auto value = field(target->GetId());
|
|
const auto at = value.find('x');
|
|
if (at != value.npos)
|
|
widget_choices_[id] = {std::stoi(value.substr(0, at)),
|
|
std::stoi(value.substr(at + 1))};
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool App::widget_action(const std::string &action, Rml::Element *target) {
|
|
if (action == "context-undo") {
|
|
focus_after_render_ =
|
|
context_id_.empty() ? "desktop-identity" : "object-" + context_id_;
|
|
desktop_undo();
|
|
context_open_ = false;
|
|
return true;
|
|
}
|
|
if (action == "widget-add") {
|
|
if (menu_ != "widgets" || !target)
|
|
return true;
|
|
widget_remember_scroll();
|
|
const auto id = target->GetAttribute<Rml::String>("data-id", "");
|
|
std::pair<int, int> span{0, 0};
|
|
for (const auto &d : widget_catalogue())
|
|
if (d.at("id") == id) {
|
|
const auto &v = d.at("spans").at(d.at("size").get<std::string>());
|
|
span = {v[0], v[1]};
|
|
}
|
|
if (widget_choices_.contains(id))
|
|
span = widget_choices_.at(id);
|
|
auto before = desktop_;
|
|
if (add_desktop_widget(desktop_, id, span.first, span.second)) {
|
|
desktop_raise(id);
|
|
desktop_checkpoint(before);
|
|
widget_notice_ = "Widget hinzugefügt. Du kannst es direkt auf dem "
|
|
"Desktop verschieben.";
|
|
} else
|
|
widget_notice_ = "Kein freier Rasterplatz. Entferne ein Widget oder "
|
|
"wähle eine kleinere Größe.";
|
|
focus_after_render_ = "widget-size-" + id;
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "widget-warning" && target) {
|
|
widget_warning_ = target->GetAttribute<Rml::String>("data-id", "");
|
|
menu_ = "warning";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "widget-background") {
|
|
widget_notice_ = "Stadion bei Nacht ist ausgewählt.";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "context-grid") {
|
|
focus_after_render_ = "desktop-identity";
|
|
auto before = desktop_;
|
|
if (set_desktop_grid(desktop_, !desktop_.value("grid", true))) {
|
|
desktop_checkpoint(before);
|
|
refresh();
|
|
} else
|
|
message("Nicht genug freier Platz. Die Anordnung bleibt erhalten.");
|
|
context_open_ = false;
|
|
return true;
|
|
}
|
|
if (action == "context-widgets") {
|
|
widget_query_.clear();
|
|
widget_notice_.clear();
|
|
widget_gallery_scroll_ = 0;
|
|
widget_choices_.clear();
|
|
return false;
|
|
}
|
|
if (action == "context-background") {
|
|
widget_notice_.clear();
|
|
return false;
|
|
}
|
|
if (action == "context-quit") {
|
|
desktop_cancel_drag();
|
|
context_open_ = false;
|
|
quit_origin_menu_ = menu_;
|
|
menu_ = "quit";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "desktop-quit-cancel") {
|
|
quit_after_save_ = false;
|
|
quit_closes_app_ = false;
|
|
menu_ = quit_origin_menu_;
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "desktop-quit-save") {
|
|
quit_after_save_ = true;
|
|
reset_files();
|
|
menu_ = "save";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "desktop-quit-discard" || action == "desktop-quit-confirm") {
|
|
finish_desktop_quit();
|
|
return true;
|
|
}
|
|
if (action == "context-remove" &&
|
|
desktop_.at("objects").at(context_id_).at("pinned") == true)
|
|
return true;
|
|
if (action == "close" && menu_ == "quit") {
|
|
widget_action("desktop-quit-cancel", nullptr);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool App::widget_event(Rml::Event &event) {
|
|
if (!popup_.empty() || amount_)
|
|
return false;
|
|
const auto type = event.GetType();
|
|
auto *target = event.GetTargetElement();
|
|
if (menu_ == "widgets") {
|
|
if (type == "input" || type == "change") {
|
|
if (auto *select = dynamic_cast<Rml::ElementFormControlSelect *>(target);
|
|
select && select->IsSelectBoxVisible()) {
|
|
pending_selects_.insert(select->GetId());
|
|
dirty_ = true;
|
|
return true;
|
|
}
|
|
return widget_change(target);
|
|
}
|
|
}
|
|
if (type != "keydown" || (scene_ != "desktop" && menu_ != "quit"))
|
|
return false;
|
|
const auto key =
|
|
Rml::Input::KeyIdentifier(event.GetParameter<int>("key_identifier", 0));
|
|
const bool shift = event.GetParameter<int>("shift_key", 0) != 0,
|
|
control = event.GetParameter<int>("ctrl_key", 0) ||
|
|
event.GetParameter<int>("meta_key", 0);
|
|
if (context_open_) {
|
|
if (key == Rml::Input::KI_UP || key == Rml::Input::KI_DOWN ||
|
|
key == Rml::Input::KI_HOME || key == Rml::Input::KI_END) {
|
|
Rml::ElementList buttons;
|
|
if (auto *root = element("desktop-context"))
|
|
root->QuerySelectorAll(buttons, "button");
|
|
std::erase_if(buttons, [](auto *button) {
|
|
return button->HasAttribute("disabled");
|
|
});
|
|
if (!buttons.empty()) {
|
|
auto it = std::find(buttons.begin(), buttons.end(),
|
|
context_->GetFocusElement());
|
|
int n = int(buttons.size()),
|
|
index = it == buttons.end() ? 0 : int(it - buttons.begin());
|
|
index = key == Rml::Input::KI_HOME ? 0
|
|
: key == Rml::Input::KI_END
|
|
? n - 1
|
|
: (index + (key == Rml::Input::KI_UP ? -1 : 1) + n) % n;
|
|
buttons[size_t(index)]->Focus(true);
|
|
}
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
if (key == Rml::Input::KI_ESCAPE || key == Rml::Input::KI_TAB) {
|
|
context_open_ = false;
|
|
if (auto *opener = context_id_.empty() ? doc_->QuerySelector(".identity")
|
|
: element("object-" + context_id_))
|
|
opener->Focus(true);
|
|
dirty_ = true;
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
}
|
|
if (key == Rml::Input::KI_ESCAPE && drag_.active) {
|
|
desktop_cancel_drag();
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
if (key == Rml::Input::KI_TAB && menu_ == "quit") {
|
|
Rml::ElementList buttons;
|
|
if (auto *modal = doc_->QuerySelector(".desktop-modal-layer"))
|
|
modal->QuerySelectorAll(buttons, "button");
|
|
std::erase_if(buttons, [](auto *button) {
|
|
return !button->IsVisible(true) || button->HasAttribute("disabled");
|
|
});
|
|
if (!buttons.empty()) {
|
|
const auto found = std::find(buttons.begin(), buttons.end(), context_->GetFocusElement());
|
|
const int count = int(buttons.size());
|
|
const int old = found == buttons.end() ? (shift ? 0 : -1) : int(found - buttons.begin());
|
|
buttons[size_t((old + (shift ? -1 : 1) + count) % count)]->Focus(true);
|
|
}
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
if (key == Rml::Input::KI_ESCAPE && menu_ == "quit") {
|
|
widget_action("desktop-quit-cancel", nullptr);
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
if (!menu_.empty())
|
|
return false;
|
|
if (control && key == Rml::Input::KI_Z) {
|
|
desktop_undo();
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
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;
|
|
}
|
|
if (key == Rml::Input::KI_APPS || (shift && key == Rml::Input::KI_F10)) {
|
|
const auto at = target->GetAbsoluteOffset(Rml::BoxArea::Border);
|
|
context_menu(id, int(at.x + 30), int(at.y + 30));
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
if (id.empty())
|
|
return false;
|
|
const auto &o = desktop_.at("objects").at(id);
|
|
const bool widget = o.at("widget"), pinned = o.at("pinned");
|
|
if (key == Rml::Input::KI_RETURN || key == Rml::Input::KI_SPACE) {
|
|
if (widget) {
|
|
for (const auto &d : widget_catalogue())
|
|
if (d.at("id") == id && !d.value("route", "").empty()) {
|
|
dispatch("open:" + d.at("route").get<std::string>(), target);
|
|
break;
|
|
}
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (key == Rml::Input::KI_DELETE) {
|
|
if (widget && !pinned) {
|
|
desktop_checkpoint(desktop_);
|
|
desktop_["objects"][id]["visible"] = false;
|
|
refresh();
|
|
}
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
const int dx = key == Rml::Input::KI_LEFT ? -1
|
|
: key == Rml::Input::KI_RIGHT ? 1
|
|
: 0,
|
|
dy = key == Rml::Input::KI_UP ? -1
|
|
: key == Rml::Input::KI_DOWN ? 1
|
|
: 0;
|
|
if (!dx && !dy)
|
|
return false;
|
|
if (!pinned) {
|
|
auto before = desktop_;
|
|
const int step = desktop_.value("grid", true) ? 248 : shift ? 96 : 24;
|
|
if (place_desktop_object(desktop_, id, o.at("x").get<int>() + dx * step,
|
|
o.at("y").get<int>() + dy * step)) {
|
|
desktop_raise(id);
|
|
desktop_checkpoint(before);
|
|
focus_after_render_ = "object-" + id;
|
|
refresh();
|
|
}
|
|
}
|
|
event.StopImmediatePropagation();
|
|
return true;
|
|
}
|
|
void App::files_loaded_success() {
|
|
ticket_.reset();
|
|
reset_settings();
|
|
reset_news();
|
|
pending_selects_.clear();
|
|
undo_.clear();
|
|
undo_themes_.clear();
|
|
drag_ = {};
|
|
context_open_ = false;
|
|
lineup_drag_ = Json();
|
|
lineup_drag_world_.reset();
|
|
lineup_selected_.clear();
|
|
lineup_ignore_click_ = false;
|
|
lineup_pitch_ = true;
|
|
lineup_data_ = lineup_page_ = 0;
|
|
lineup_side_ = "formations";
|
|
transfer_view_ = Json::object();
|
|
transfer_draft_ = transfer_search_draft_ = Json();
|
|
transfer_dialog_.clear();
|
|
transfer_picker_.clear();
|
|
transfer_world_.reset();
|
|
career_view_ = Json::object();
|
|
rankings_view_ = Json::object();
|
|
statistics_view_ = Json::object();
|
|
statistics_trophy_ = Json::object();
|
|
statistics_scrolls_ = Json::object();
|
|
stadium_view_ = Json::object();
|
|
stadium_world_.reset();
|
|
stadium_source_ = nullptr;
|
|
advertising_world_.reset();
|
|
advertising_selected_ = -1;
|
|
toto_dialog_.clear();
|
|
amount_.reset();
|
|
contracts_dialog_.clear();
|
|
contract_draft_ = Json();
|
|
contracts_world_.reset();
|
|
bank_view_ = "entrance";
|
|
bank_hint_.clear();
|
|
balance_future_ = false;
|
|
report_detail_kind_.clear();
|
|
report_detail_player_.clear();
|
|
report_detail_club_.clear();
|
|
report_picker_.clear();
|
|
planning_dialog_.clear();
|
|
almanac_year_ = 0;
|
|
almanac_day_.clear();
|
|
almanac_match_.clear();
|
|
almanac_tab_ = "lineups";
|
|
widget_data_ = Json();
|
|
ticket_ = std::make_unique<TicketPopover>(*context_, *doc_, *source_, [this] {
|
|
focus_ticket_ = true;
|
|
refresh();
|
|
});
|
|
menu_.clear();
|
|
scene_ = "desktop";
|
|
quit_after_save_ = false;
|
|
quit_closes_app_ = false;
|
|
refresh();
|
|
}
|
|
void App::files_saved_success(bool career) {
|
|
if (career && quit_after_save_) {
|
|
finish_desktop_quit();
|
|
return;
|
|
}
|
|
if (career) {
|
|
files_revision_ = snap().revision;
|
|
files_desktop_base_ = desktop_;
|
|
files_theme_base_ = theme_;
|
|
files_reload(files_selected_);
|
|
focus_after_render_ = "files-confirm";
|
|
refresh();
|
|
return;
|
|
}
|
|
menu_.clear();
|
|
reset_files();
|
|
}
|
|
void App::finish_desktop_quit() {
|
|
const bool exit = quit_closes_app_;
|
|
quit_after_save_ = false;
|
|
quit_closes_app_ = false;
|
|
if (exit) {
|
|
closed_ = true;
|
|
return;
|
|
}
|
|
ticket_.reset();
|
|
source_ = std::make_unique<DemoSource>(world_);
|
|
saved_desktop_ = desktop_;
|
|
files_loaded_success();
|
|
scene_ = "main";
|
|
menu_.clear();
|
|
refresh();
|
|
}
|
|
|
|
void App::persist_working_desktop() {
|
|
if (!source_ || scene_ != "desktop" || files_capturing_ || drag_.active ||
|
|
!working_desktop_initialized_ || desktop_ == working_desktop_base_)
|
|
return;
|
|
try {
|
|
fs::create_directories(user_dir());
|
|
editor::write_atomic(user_dir() / "working-desktop.json", desktop_.dump(2));
|
|
} catch (const std::exception &) {
|
|
message("Die Desktopanordnung bleibt in dieser Sitzung erhalten, konnte "
|
|
"aber nicht gespeichert werden.");
|
|
}
|
|
working_desktop_base_ = desktop_;
|
|
}
|
|
|
|
void App::desktop_undo() {
|
|
if (undo_.empty())
|
|
return;
|
|
const auto theme = undo_themes_.empty() ? theme_ : undo_themes_.back();
|
|
if (theme != theme_) {
|
|
auto preferences = ui_preferences_;
|
|
preferences["theme"] = theme;
|
|
try {
|
|
save_ui_preferences(ui_preferences_file(), preferences);
|
|
} catch (const std::exception &) {
|
|
message("Die Gestaltung konnte nicht wiederhergestellt werden.");
|
|
return;
|
|
}
|
|
ui_preferences_ = std::move(preferences);
|
|
theme_ = theme;
|
|
ui_preferences_loaded_ = true;
|
|
}
|
|
desktop_ = undo_.back();
|
|
undo_.pop_back();
|
|
if (!undo_themes_.empty())
|
|
undo_themes_.pop_back();
|
|
refresh();
|
|
}
|
|
|
|
Picture App::files_default_thumbnail() {
|
|
const auto key = content::sha256(snap().state.dump() + theme_);
|
|
if (key != files_default_key_) {
|
|
files_default_request_ = key;
|
|
files_default_pending_ = true;
|
|
}
|
|
return key == files_default_key_ ? files_default_picture_ : Picture();
|
|
}
|
|
void App::update_files_default_thumbnail() {
|
|
const auto layout = desktop_;
|
|
files_default_pending_ = false;
|
|
try {
|
|
desktop_ = default_desktop();
|
|
const auto png = files_capture_preview();
|
|
desktop_ = layout;
|
|
files_default_picture_ = renderer_.generated_png("default-desktop", png);
|
|
files_default_key_ = files_default_request_;
|
|
} catch (const std::exception &) {
|
|
desktop_ = layout;
|
|
files_default_key_ = files_default_request_;
|
|
files_default_picture_ = Picture();
|
|
files_feedback_ = "Die Standardvorschau konnte nicht aufgenommen werden.";
|
|
}
|
|
}
|