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

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.";
}
}