492 lines
17 KiB
C++
492 lines
17 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
DemoFiles App::files_store() const {
|
|
return DemoFiles(user_dir(),
|
|
files_mode_.starts_with("view-") ? DemoFileKind::desktop
|
|
: DemoFileKind::career,
|
|
world_);
|
|
}
|
|
bool App::files_bound() const {
|
|
return source_ && files_source_ == source_.get() && files_world_ == world_ &&
|
|
files_revision_ == snap().revision &&
|
|
files_desktop_base_ == desktop_ && files_theme_base_ == theme_;
|
|
}
|
|
void App::reset_files() {
|
|
files_mode_.clear();
|
|
files_selected_.clear();
|
|
files_name_.clear();
|
|
files_feedback_.clear();
|
|
files_rows_.clear();
|
|
files_entry_.reset();
|
|
files_world_.reset();
|
|
files_source_ = nullptr;
|
|
files_desktop_base_ = Json();
|
|
files_theme_base_.clear();
|
|
files_revision_ = 0;
|
|
files_scroll_ = 0;
|
|
files_restore_scroll_ = false;
|
|
files_reveal_selected_ = false;
|
|
}
|
|
void App::files_begin(const std::string &mode) {
|
|
reset_files();
|
|
files_mode_ = mode;
|
|
files_world_ = world_;
|
|
files_source_ = source_.get();
|
|
files_desktop_base_ = desktop_;
|
|
files_theme_base_ = theme_;
|
|
if (source_)
|
|
files_revision_ = snap().revision;
|
|
const bool layouts = mode.starts_with("view-");
|
|
files_selected_ = mode == "view-load" ? "standard" : "";
|
|
try {
|
|
files_name_ =
|
|
files_store().free_name(layouts ? "Meine Ansicht" : "Spielstand 1");
|
|
files_reload();
|
|
if (mode == "load" && !files_rows_.empty())
|
|
files_select(files_rows_.front().id);
|
|
} catch (const std::exception &e) {
|
|
files_feedback_ = e.what();
|
|
}
|
|
}
|
|
void App::files_reload(const std::string &selected) {
|
|
files_rows_ = files_store().list();
|
|
if (!selected.empty())
|
|
files_selected_ = selected;
|
|
files_entry_.reset();
|
|
if (files_selected_.empty() || files_selected_ == "standard")
|
|
return;
|
|
const auto found =
|
|
std::find_if(files_rows_.begin(), files_rows_.end(),
|
|
[&](const auto &row) { return row.id == files_selected_; });
|
|
if (found == files_rows_.end()) {
|
|
files_selected_.clear();
|
|
return;
|
|
}
|
|
files_entry_ = *found;
|
|
if (!found->valid())
|
|
return;
|
|
try {
|
|
files_entry_ = files_store().read(found->id, found->token);
|
|
} catch (const std::exception &e) {
|
|
files_entry_->error = e.what();
|
|
}
|
|
}
|
|
void App::files_select(const std::string &selected) {
|
|
files_selected_ = selected;
|
|
files_feedback_.clear();
|
|
files_reload();
|
|
focus_after_render_ = selected.empty() ? "files-new"
|
|
: selected == "standard" ? "files-standard"
|
|
: "";
|
|
for (size_t i = 0; i < files_rows_.size(); ++i)
|
|
if (files_rows_[i].id == selected)
|
|
focus_after_render_ = "files-entry-" + std::to_string(i);
|
|
files_reveal_selected_ = true;
|
|
refresh();
|
|
}
|
|
void App::files_before_render() {
|
|
if (files_capturing_)
|
|
return;
|
|
const bool relevant = menu_ == "save" || menu_ == "load" ||
|
|
menu_ == "view-save" || menu_ == "view-load";
|
|
if (!relevant) {
|
|
if (!files_mode_.empty())
|
|
reset_files();
|
|
return;
|
|
}
|
|
if (files_mode_ != menu_) {
|
|
files_begin(menu_);
|
|
return;
|
|
}
|
|
if (auto *list = element("files-list")) {
|
|
files_scroll_ = list->GetScrollTop();
|
|
files_restore_scroll_ = true;
|
|
}
|
|
}
|
|
void App::files_after_render() {
|
|
if (files_capturing_ || files_mode_ != menu_)
|
|
return;
|
|
context_->Update();
|
|
if (files_restore_scroll_)
|
|
if (auto *list = element("files-list"))
|
|
list->SetScrollTop(files_scroll_);
|
|
files_restore_scroll_ = false;
|
|
if (files_reveal_selected_) {
|
|
Rml::Element *row = nullptr;
|
|
if (files_selected_.empty())
|
|
row = element("files-new");
|
|
else if (files_selected_ == "standard")
|
|
row = element("files-standard");
|
|
else
|
|
for (size_t i = 0; i < files_rows_.size(); ++i)
|
|
if (files_rows_[i].id == files_selected_)
|
|
row = element("files-entry-" + std::to_string(i));
|
|
if (row)
|
|
row->ScrollIntoView(
|
|
Rml::ScrollIntoViewOptions(Rml::ScrollAlignment::Nearest));
|
|
if (auto *list = element("files-list"))
|
|
files_scroll_ = list->GetScrollTop();
|
|
files_reveal_selected_ = false;
|
|
}
|
|
}
|
|
std::string App::files_capture_preview() {
|
|
const auto old_menu = menu_, old_scene = scene_;
|
|
files_capturing_ = true;
|
|
menu_.clear();
|
|
scene_ = "desktop";
|
|
refresh();
|
|
try {
|
|
frame();
|
|
int width = 0, height = 0;
|
|
auto pixels = video_.capture(width, height);
|
|
using Surface = std::unique_ptr<SDL_Surface, decltype(&SDL_FreeSurface)>;
|
|
Surface original(SDL_CreateRGBSurfaceWithFormatFrom(pixels.data(), width,
|
|
height, 32, width * 4,
|
|
SDL_PIXELFORMAT_RGBA32),
|
|
SDL_FreeSurface);
|
|
Surface thumb(SDL_CreateRGBSurfaceWithFormat(0, 1280, 720, 32,
|
|
SDL_PIXELFORMAT_RGBA32),
|
|
SDL_FreeSurface);
|
|
if (!original || !thumb)
|
|
throw editor::Error(
|
|
"Die Desktop-Vorschau konnte nicht aufgenommen werden.");
|
|
SDL_Rect crop{int(std::lround(canvas_left_)), int(std::lround(canvas_top_)),
|
|
int(std::lround(3840 * scale_)),
|
|
int(std::lround(2160 * scale_))};
|
|
crop.w = std::min(crop.w, width - crop.x);
|
|
crop.h = std::min(crop.h, height - crop.y);
|
|
if (SDL_SoftStretchLinear(original.get(), &crop, thumb.get(), nullptr) != 0)
|
|
throw editor::Error("Die Desktop-Vorschau konnte nicht skaliert werden.");
|
|
editor::images::Raster image{1280, 720,
|
|
std::vector<uint8_t>(1280 * 720 * 4)};
|
|
for (int y = 0; y < 720; ++y)
|
|
std::memcpy(image.pixels.data() + y * 1280 * 4,
|
|
static_cast<const uint8_t *>(thumb->pixels) +
|
|
y * thumb->pitch,
|
|
1280 * 4);
|
|
auto png = editor::images::encode_png(image);
|
|
menu_ = old_menu;
|
|
scene_ = old_scene;
|
|
files_capturing_ = false;
|
|
refresh();
|
|
return png;
|
|
} catch (...) {
|
|
menu_ = old_menu;
|
|
scene_ = old_scene;
|
|
files_capturing_ = false;
|
|
refresh();
|
|
throw;
|
|
}
|
|
}
|
|
void App::files_save(const std::string &name, const std::string &id,
|
|
const std::string &token) {
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert. Bitte "
|
|
"das Fenster neu öffnen.");
|
|
const bool layouts = files_mode_.starts_with("view-");
|
|
const auto revision = snap().revision;
|
|
Json payload =
|
|
layouts ? Json{{"layout", desktop_}, {"theme", theme_}} : snap().state;
|
|
if (!layouts)
|
|
payload["desktop"] = desktop_;
|
|
// Validate before the capture and before publishing any file.
|
|
auto store = files_store();
|
|
store.validate(payload);
|
|
const auto png = files_capture_preview();
|
|
if (!files_bound() || snap().revision != revision)
|
|
throw editor::Error("Die Karriere wurde während der Aufnahme geändert.");
|
|
const auto saved = store.put(name, payload, png, id, token);
|
|
files_selected_ = saved.id;
|
|
files_feedback_ =
|
|
layouts ? "Ansicht mit Vorschau gespeichert." : "Spielstand gespeichert.";
|
|
if (!layouts) {
|
|
if (!source_->mark_saved(revision))
|
|
throw editor::Error(
|
|
"Gespeichert; die inzwischen geänderte Karriere bleibt ungesichert.");
|
|
saved_desktop_ = desktop_;
|
|
}
|
|
files_saved_success(!layouts);
|
|
refresh();
|
|
}
|
|
void App::files_load() {
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert. Bitte "
|
|
"das Fenster neu öffnen.");
|
|
const bool layouts = files_mode_.starts_with("view-");
|
|
if (layouts) {
|
|
Json layout, preferences = ui_preferences_;
|
|
std::string theme = theme_;
|
|
if (files_selected_ == "standard")
|
|
layout = default_desktop();
|
|
else {
|
|
if (!files_entry_ || !files_entry_->valid())
|
|
return;
|
|
const auto record =
|
|
files_store().read(files_entry_->id, files_entry_->token);
|
|
layout = record.data.at("layout");
|
|
theme = record.data.at("theme").get<std::string>();
|
|
}
|
|
// Persist the global theme successfully before publishing either layout
|
|
// or theme. Other global display and sound preferences remain untouched.
|
|
preferences["theme"] = theme;
|
|
save_ui_preferences(ui_preferences_file(), preferences);
|
|
desktop_checkpoint(desktop_);
|
|
desktop_ = std::move(layout);
|
|
theme_ = theme;
|
|
ui_preferences_ = std::move(preferences);
|
|
ui_preferences_loaded_ = true;
|
|
menu_.clear();
|
|
reset_files();
|
|
refresh();
|
|
return;
|
|
}
|
|
if (!files_entry_ || !files_entry_->valid())
|
|
return;
|
|
const auto record = files_store().read(files_entry_->id, files_entry_->token);
|
|
auto next = std::make_unique<DemoSource>(world_);
|
|
auto layout = next->load_data(record.data);
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert.");
|
|
const auto selected_id = files_entry_->id, selected_name = files_entry_->name;
|
|
ticket_.reset();
|
|
source_ = std::move(next);
|
|
desktop_ = std::move(layout);
|
|
saved_desktop_ = desktop_;
|
|
reset_files();
|
|
files_loaded_success();
|
|
menu_ = "load";
|
|
files_begin("load");
|
|
files_select(selected_id);
|
|
files_feedback_ = "Spielstand „" + selected_name + "“ geladen.";
|
|
focus_after_render_ = "files-confirm";
|
|
refresh();
|
|
}
|
|
bool App::files_action(const std::string &action, Rml::Element *target) {
|
|
if (!action.starts_with("files-"))
|
|
return false;
|
|
const auto id =
|
|
target ? target->GetAttribute<Rml::String>("data-id", "") : std::string();
|
|
try {
|
|
if (action == "files-close") {
|
|
quit_after_save_ = false;
|
|
menu_.clear();
|
|
reset_files();
|
|
if (scene_ != "desktop")
|
|
scene_ = "main";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "files-select") {
|
|
files_select(id);
|
|
return true;
|
|
}
|
|
if (action == "files-new") {
|
|
files_select("");
|
|
focus_after_render_ = "files-name";
|
|
return true;
|
|
}
|
|
if (action == "files-standard") {
|
|
files_select("standard");
|
|
return true;
|
|
}
|
|
if (action == "files-load") {
|
|
files_load();
|
|
return true;
|
|
}
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert. "
|
|
"Bitte das Fenster neu öffnen.");
|
|
auto store = files_store();
|
|
if (action == "files-save") {
|
|
const auto name = files_entry_ ? files_entry_->name
|
|
: DemoFiles::clean_name(files_name_);
|
|
auto chosen = files_entry_;
|
|
if (!chosen)
|
|
for (const auto &row : files_rows_) {
|
|
bool duplicate = false;
|
|
try {
|
|
duplicate =
|
|
DemoFiles::name_key(row.name,
|
|
files_mode_.starts_with("view-")) ==
|
|
DemoFiles::name_key(name, files_mode_.starts_with("view-"));
|
|
} catch (...) {
|
|
}
|
|
if (duplicate) {
|
|
chosen = row;
|
|
break;
|
|
}
|
|
}
|
|
if (chosen) {
|
|
const auto row = *chosen;
|
|
confirmation(
|
|
(files_mode_.starts_with("view-") ? "Ansicht" : "Spielstand") +
|
|
std::string(" „") + row.name +
|
|
"“ durch den aktuellen Stand ersetzen?",
|
|
[this, name, row] { files_save(name, row.id, row.token); });
|
|
popup_accept_ = "Überschreiben";
|
|
} else
|
|
files_save(name, "", "");
|
|
return true;
|
|
}
|
|
if (action == "files-rename" && files_entry_ && files_entry_->valid()) {
|
|
const auto row = *files_entry_;
|
|
text_dialog(files_mode_.starts_with("view-") ? "Ansicht umbenennen"
|
|
: "Spielstand umbenennen",
|
|
row.name, [this, row](const std::string &name) {
|
|
if (!files_bound())
|
|
throw editor::Error(
|
|
"Die aktive Karriere wurde inzwischen geändert.");
|
|
const auto renamed =
|
|
files_store().rename(row.id, row.token, name);
|
|
files_select(renamed.id);
|
|
files_feedback_ = "Bezeichnung geändert.";
|
|
refresh();
|
|
});
|
|
popup_accept_ = "Umbenennen";
|
|
return true;
|
|
}
|
|
if (action == "files-delete" && files_entry_ &&
|
|
!files_entry_->token.empty()) {
|
|
const auto row = *files_entry_;
|
|
confirmation("„" + row.name + "“ mit Vorschau wirklich löschen?", [this,
|
|
row] {
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert.");
|
|
files_store().remove(row.id, row.token);
|
|
files_selected_ = files_mode_ == "view-load" ? "standard" : "";
|
|
files_reload();
|
|
files_feedback_ = "Datei gelöscht.";
|
|
refresh();
|
|
});
|
|
popup_accept_ = "Löschen";
|
|
return true;
|
|
}
|
|
if (action == "files-import") {
|
|
fs::path selected = config_.file_import;
|
|
if (selected.empty()) {
|
|
NFD::Guard guard;
|
|
NFD::UniquePath chosen;
|
|
const nfdfilteritem_t filters[] = {{"OpenBMH UI-Demodatei", "json"}};
|
|
const auto result = NFD::OpenDialog(chosen, filters, 1);
|
|
if (result == NFD_CANCEL)
|
|
return true;
|
|
if (result != NFD_OKAY)
|
|
throw editor::Error("Die Dateiauswahl konnte nicht geöffnet werden.");
|
|
selected = editor::path(chosen.get());
|
|
}
|
|
const auto imported = store.import_file(selected);
|
|
files_select(imported.id);
|
|
files_feedback_ =
|
|
"Datei importiert; die aktive Karriere bleibt unverändert.";
|
|
refresh();
|
|
return true;
|
|
}
|
|
if (action == "files-export" && files_entry_ && files_entry_->valid()) {
|
|
const auto row = *files_entry_;
|
|
fs::path destination = config_.file_export;
|
|
if (destination.empty()) {
|
|
NFD::Guard guard;
|
|
NFD::UniquePath chosen;
|
|
const nfdfilteritem_t filters[] = {{"OpenBMH UI-Demodatei", "json"}};
|
|
const auto result = NFD::SaveDialog(chosen, filters, 1, nullptr,
|
|
"openbmh-ui-demo.json");
|
|
if (result == NFD_CANCEL)
|
|
return true;
|
|
if (result != NFD_OKAY)
|
|
throw editor::Error("Die Dateiauswahl konnte nicht geöffnet werden.");
|
|
destination = editor::path(chosen.get());
|
|
}
|
|
const auto export_record = [this, row, destination] {
|
|
if (!files_bound())
|
|
throw editor::Error("Die aktive Karriere wurde inzwischen geändert.");
|
|
files_store().export_file(row.id, row.token, destination, true);
|
|
files_feedback_ = "Datei exportiert.";
|
|
refresh();
|
|
};
|
|
if (fs::exists(destination)) {
|
|
confirmation("Vorhandene Exportdatei ersetzen?", export_record);
|
|
popup_accept_ = "Überschreiben";
|
|
} else {
|
|
store.export_file(row.id, row.token, destination);
|
|
files_feedback_ = "Datei exportiert.";
|
|
refresh();
|
|
}
|
|
return true;
|
|
}
|
|
} catch (const std::exception &e) {
|
|
message("Dateiaktion nicht möglich: " + std::string(e.what()));
|
|
}
|
|
return true;
|
|
}
|
|
bool App::files_change(Rml::Element *target) {
|
|
if (!target || target->GetId() != "files-name")
|
|
return false;
|
|
const auto *input = dynamic_cast<Rml::ElementFormControl *>(target);
|
|
if (input)
|
|
files_name_ = input->GetValue();
|
|
if (auto *button = element("files-confirm")) {
|
|
bool valid = true;
|
|
try {
|
|
DemoFiles::clean_name(files_name_);
|
|
} catch (...) {
|
|
valid = false;
|
|
}
|
|
if (valid && files_mode_.starts_with("view-") &&
|
|
DemoFiles::name_key(files_name_, true) == "standard")
|
|
valid = false;
|
|
if (valid)
|
|
button->RemoveAttribute("disabled");
|
|
else
|
|
button->SetAttribute("disabled", "disabled");
|
|
}
|
|
return true;
|
|
}
|
|
bool App::files_event(Rml::Event &event) {
|
|
if (files_mode_.empty() || !popup_.empty())
|
|
return false;
|
|
if (event.GetType() == "input" || event.GetType() == "change")
|
|
return files_change(event.GetTargetElement());
|
|
if (event.GetType() != "keydown")
|
|
return false;
|
|
const auto key = event.GetParameter<int>("key_identifier", 0);
|
|
auto *target = event.GetTargetElement();
|
|
if (key == Rml::Input::KI_ESCAPE) {
|
|
event.StopPropagation();
|
|
return files_action("files-close", target);
|
|
}
|
|
if (target && target->GetId() == "files-name" &&
|
|
(key == Rml::Input::KI_RETURN || key == Rml::Input::KI_NUMPADENTER)) {
|
|
event.StopPropagation();
|
|
return files_action("files-save", target);
|
|
}
|
|
if (!target || !target->HasAttribute("data-file-row"))
|
|
return false;
|
|
if (key != Rml::Input::KI_UP && key != Rml::Input::KI_DOWN &&
|
|
key != Rml::Input::KI_HOME && key != Rml::Input::KI_END)
|
|
return false;
|
|
std::vector<std::pair<std::string, std::string>> ids;
|
|
if (files_mode_ == "save" || files_mode_ == "view-save")
|
|
ids.emplace_back("", "files-new");
|
|
if (files_mode_ == "view-load")
|
|
ids.emplace_back("standard", "files-standard");
|
|
for (size_t i = 0; i < files_rows_.size(); ++i)
|
|
ids.emplace_back(files_rows_[i].id, "files-entry-" + std::to_string(i));
|
|
if (ids.empty())
|
|
return false;
|
|
size_t index = 0;
|
|
for (size_t i = 0; i < ids.size(); ++i)
|
|
if (ids[i].first == files_selected_)
|
|
index = i;
|
|
if (key == Rml::Input::KI_HOME)
|
|
index = 0;
|
|
else if (key == Rml::Input::KI_END)
|
|
index = ids.size() - 1;
|
|
else if (key == Rml::Input::KI_DOWN)
|
|
index = std::min(index + 1, ids.size() - 1);
|
|
else if (index)
|
|
--index;
|
|
files_select(ids[index].first);
|
|
focus_after_render_ = ids[index].second;
|
|
event.StopPropagation();
|
|
return true;
|
|
}
|