270 lines
14 KiB
C++
270 lines
14 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "launch/launcher_ui.hpp"
|
|
#include "launch/archive.hpp"
|
|
#include <gtk/gtk.h>
|
|
#include <array>
|
|
namespace bmh::launch {
|
|
namespace {
|
|
class GtkLauncher final : public LauncherUI {
|
|
GtkWidget *window_ = nullptr, *tree_ = nullptr, *progress_ = nullptr, *progress_label_ = nullptr;
|
|
GtkListStore *model_ = nullptr;
|
|
std::array<GtkWidget *, 5> buttons_{};
|
|
bool cancelled_ = false;
|
|
std::string selection_;
|
|
enum { Start = 1, Add, Delete, Rename, End };
|
|
static void selection_changed(GtkTreeSelection *selection, gpointer data) {
|
|
auto &self = *static_cast<GtkLauncher *>(data);
|
|
GtkTreeIter it;
|
|
GtkTreeModel *model;
|
|
const bool selected = gtk_tree_selection_get_selected(selection, &model, &it);
|
|
for (int id : {Start, Delete, Rename})
|
|
gtk_widget_set_sensitive(self.buttons_[size_t(id - 1)], selected);
|
|
}
|
|
GtkWidget *entry(GtkWidget *grid, int row, const char *label, const std::string &initial) {
|
|
auto *title = gtk_label_new(label);
|
|
gtk_widget_set_halign(title, GTK_ALIGN_START);
|
|
gtk_grid_attach(GTK_GRID(grid), title, 0, row, 1, 1);
|
|
auto *input = gtk_entry_new();
|
|
gtk_entry_set_text(GTK_ENTRY(input), initial.c_str());
|
|
gtk_widget_set_hexpand(input, TRUE);
|
|
gtk_grid_attach(GTK_GRID(grid), input, 1, row, 1, 1);
|
|
return input;
|
|
}
|
|
|
|
public:
|
|
GtkLauncher() {
|
|
if (!gtk_init_check(nullptr, nullptr))
|
|
throw std::runtime_error("Kein Desktop für den nativen Launcher verfügbar");
|
|
window_ = gtk_dialog_new();
|
|
gtk_window_set_title(GTK_WINDOW(window_), "OpenBMH");
|
|
gtk_window_set_default_size(GTK_WINDOW(window_), 620, 340);
|
|
auto *body = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 16);
|
|
gtk_container_set_border_width(GTK_CONTAINER(body), 16);
|
|
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window_))), body, TRUE, TRUE, 0);
|
|
model_ = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
|
|
tree_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model_));
|
|
auto *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_));
|
|
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
|
|
g_signal_connect(selection, "changed", G_CALLBACK(selection_changed), this);
|
|
for (int i = 0; i < 2; ++i) {
|
|
auto *renderer = gtk_cell_renderer_text_new();
|
|
auto *column =
|
|
gtk_tree_view_column_new_with_attributes(i ? "Art" : "Name", renderer, "text", i, nullptr);
|
|
gtk_tree_view_column_set_expand(column, i == 0);
|
|
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_), column);
|
|
}
|
|
gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(tree_), 2);
|
|
auto *scroller = gtk_scrolled_window_new(nullptr, nullptr);
|
|
gtk_widget_set_hexpand(scroller, TRUE);
|
|
gtk_widget_set_vexpand(scroller, TRUE);
|
|
gtk_container_add(GTK_CONTAINER(scroller), tree_);
|
|
gtk_box_pack_start(GTK_BOX(body), scroller, TRUE, TRUE, 0);
|
|
auto *buttons = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
|
|
gtk_box_pack_start(GTK_BOX(body), buttons, FALSE, FALSE, 0);
|
|
const char *labels[] = {"Start", "Add", "Delete", "Rename", "End"};
|
|
for (int i = 0; i < 5; ++i) {
|
|
auto *button = gtk_button_new_with_label(labels[i]);
|
|
buttons_[size_t(i)] = button;
|
|
gtk_box_pack_start(GTK_BOX(buttons), button, FALSE, FALSE, 0);
|
|
g_object_set_data(G_OBJECT(button), "response-id", GINT_TO_POINTER(i + 1));
|
|
g_signal_connect(button, "clicked", G_CALLBACK(+[](GtkButton *button, gpointer self) {
|
|
auto *window = static_cast<GtkLauncher *>(self)->window_;
|
|
gtk_dialog_response(
|
|
GTK_DIALOG(window),
|
|
GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "response-id")));
|
|
}),
|
|
this);
|
|
}
|
|
g_signal_connect(tree_, "row-activated",
|
|
G_CALLBACK(+[](GtkTreeView *, GtkTreePath *, GtkTreeViewColumn *, gpointer data) {
|
|
gtk_dialog_response(GTK_DIALOG(static_cast<GtkLauncher *>(data)->window_),
|
|
Start);
|
|
}),
|
|
this);
|
|
gtk_widget_show_all(window_);
|
|
}
|
|
~GtkLauncher() override {
|
|
finish_progress();
|
|
gtk_widget_destroy(window_);
|
|
g_object_unref(model_);
|
|
}
|
|
LauncherChoice next(const std::vector<ModEntry> &mods) override {
|
|
gtk_list_store_clear(model_);
|
|
int selected = -1;
|
|
for (size_t i = 0; i < mods.size(); ++i) {
|
|
GtkTreeIter it;
|
|
gtk_list_store_append(model_, &it);
|
|
const auto &mod = mods[i];
|
|
const auto shown = mod.error.empty() ? mod.name : mod.name + " ⚠";
|
|
gtk_list_store_set(model_, &it, 0, shown.c_str(), 1, mod.type.c_str(), 2, mod.error.c_str(), -1);
|
|
if (mod.name == selection_) {
|
|
auto *path = gtk_tree_path_new_from_indices(int(i), -1);
|
|
gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_), path, nullptr, FALSE);
|
|
gtk_tree_path_free(path);
|
|
}
|
|
}
|
|
selection_changed(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_)), this);
|
|
const int response = gtk_dialog_run(GTK_DIALOG(window_));
|
|
GtkTreeIter it;
|
|
GtkTreeModel *model;
|
|
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_)), &model, &it)) {
|
|
auto *path = gtk_tree_model_get_path(model, &it);
|
|
selected = gtk_tree_path_get_indices(path)[0];
|
|
gtk_tree_path_free(path);
|
|
if (selected >= 0 && size_t(selected) < mods.size())
|
|
selection_ = mods[size_t(selected)].name;
|
|
}
|
|
return {response == Start ? LauncherAction::start
|
|
: response == Add ? LauncherAction::add
|
|
: response == Delete ? LauncherAction::remove
|
|
: response == Rename ? LauncherAction::rename
|
|
: LauncherAction::end,
|
|
selected};
|
|
}
|
|
std::optional<std::filesystem::path> choose_folder(const std::string &title,
|
|
const std::filesystem::path &initial) override {
|
|
auto *dialog = gtk_file_chooser_dialog_new(
|
|
title.c_str(), GTK_WINDOW(window_), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "Abbrechen",
|
|
GTK_RESPONSE_CANCEL, "Auswählen", GTK_RESPONSE_ACCEPT, nullptr);
|
|
const auto folder=initial.empty()?path_from_utf8(g_get_home_dir()):initial;
|
|
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),path_to_utf8(folder).c_str());
|
|
std::optional<std::filesystem::path> result;
|
|
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
|
|
char *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
|
|
if (file) {
|
|
result = path_from_utf8(file);
|
|
g_free(file);
|
|
}
|
|
}
|
|
gtk_widget_destroy(dialog);
|
|
return result;
|
|
}
|
|
std::optional<AddMod> configure_add(AddMod initial) override {
|
|
auto *dialog = gtk_dialog_new_with_buttons("Classic-Mod hinzufügen", GTK_WINDOW(window_),
|
|
GTK_DIALOG_MODAL, "Abbrechen", GTK_RESPONSE_CANCEL,
|
|
"Importieren", GTK_RESPONSE_ACCEPT, nullptr);
|
|
gtk_window_set_default_size(GTK_WINDOW(dialog), 540, -1);
|
|
auto *grid = gtk_grid_new();
|
|
gtk_grid_set_row_spacing(GTK_GRID(grid), 12);
|
|
gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
|
|
gtk_container_set_border_width(GTK_CONTAINER(grid), 16);
|
|
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), grid, TRUE, TRUE, 0);
|
|
auto *name = entry(grid, 0, "Bezeichnung", initial.name);
|
|
auto *year = entry(grid, 1, "Startjahr (nur Anzeige)", std::to_string(initial.start_year));
|
|
auto *migrate = gtk_check_button_new_with_label("Spielstände/Einstellungen übernehmen");
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(migrate), initial.migrate);
|
|
gtk_grid_attach(GTK_GRID(grid), migrate, 0, 2, 3, 1);
|
|
auto *saves = entry(grid, 3, "Spielstandsordner", path_to_utf8(initial.saves));
|
|
auto *browse = gtk_button_new_with_label("Auswählen …");
|
|
gtk_grid_attach(GTK_GRID(grid), browse, 2, 3, 1, 1);
|
|
struct Browse {
|
|
GtkLauncher *self;
|
|
GtkWidget *input;
|
|
};
|
|
Browse context{this, saves};
|
|
g_signal_connect(
|
|
browse, "clicked", G_CALLBACK(+[](GtkButton *, gpointer p) {
|
|
auto &c = *static_cast<Browse *>(p);
|
|
if (auto path = c.self->choose_folder("Spielstandsordner wählen",
|
|
path_from_utf8(gtk_entry_get_text(GTK_ENTRY(c.input)))))
|
|
gtk_entry_set_text(GTK_ENTRY(c.input), path_to_utf8(*path).c_str());
|
|
}),
|
|
&context);
|
|
gtk_widget_show_all(dialog);
|
|
std::optional<AddMod> result;
|
|
while (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
|
|
try {
|
|
initial.name = gtk_entry_get_text(GTK_ENTRY(name));
|
|
ModLibrary::validate_name(initial.name);
|
|
std::string value = gtk_entry_get_text(GTK_ENTRY(year));
|
|
size_t end = 0;
|
|
initial.start_year = std::stoi(value, &end);
|
|
if (end != value.size() || initial.start_year < 1900 || initial.start_year > 9998)
|
|
throw std::runtime_error("Startjahr muss zwischen 1900 und 9998 liegen");
|
|
initial.saves = path_from_utf8(gtk_entry_get_text(GTK_ENTRY(saves)));
|
|
initial.migrate = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(migrate));
|
|
result = initial;
|
|
break;
|
|
} catch (const std::exception &e) {
|
|
message(e.what(), true);
|
|
}
|
|
gtk_widget_destroy(dialog);
|
|
return result;
|
|
}
|
|
std::optional<std::string> rename(const std::string &old) override {
|
|
auto *dialog =
|
|
gtk_dialog_new_with_buttons("Mod umbenennen", GTK_WINDOW(window_), GTK_DIALOG_MODAL, "Abbrechen",
|
|
GTK_RESPONSE_CANCEL, "Umbenennen", GTK_RESPONSE_ACCEPT, nullptr);
|
|
auto *input = gtk_entry_new();
|
|
gtk_entry_set_text(GTK_ENTRY(input), old.c_str());
|
|
gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), 16);
|
|
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), input, TRUE, TRUE, 0);
|
|
gtk_widget_show_all(dialog);
|
|
std::optional<std::string> result;
|
|
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
|
|
result = gtk_entry_get_text(GTK_ENTRY(input));
|
|
gtk_widget_destroy(dialog);
|
|
return result;
|
|
}
|
|
bool confirm_delete(const std::string &name) override {
|
|
auto *dialog = gtk_message_dialog_new(GTK_WINDOW(window_), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
|
|
GTK_BUTTONS_YES_NO, "Mod „%s“ löschen?", name.c_str());
|
|
gtk_message_dialog_format_secondary_text(
|
|
GTK_MESSAGE_DIALOG(dialog), "Spielstände und persönliche Einstellungen bleiben erhalten.");
|
|
const bool yes = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES;
|
|
gtk_widget_destroy(dialog);
|
|
return yes;
|
|
}
|
|
void message(const std::string &text, bool error) override {
|
|
auto *dialog = gtk_message_dialog_new(GTK_WINDOW(window_), GTK_DIALOG_MODAL,
|
|
error ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
|
|
"%s", text.c_str());
|
|
gtk_dialog_run(GTK_DIALOG(dialog));
|
|
gtk_widget_destroy(dialog);
|
|
}
|
|
void progress(const std::string &text, bool cancellable) override {
|
|
if (!progress_) {
|
|
cancelled_ = false;
|
|
progress_ = gtk_dialog_new();
|
|
gtk_window_set_title(GTK_WINDOW(progress_), "OpenBMH");
|
|
gtk_window_set_transient_for(GTK_WINDOW(progress_), GTK_WINDOW(window_));
|
|
gtk_window_set_modal(GTK_WINDOW(progress_), TRUE);
|
|
gtk_container_set_border_width(GTK_CONTAINER(progress_), 20);
|
|
progress_label_ = gtk_label_new(text.c_str());
|
|
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(progress_))), progress_label_,
|
|
TRUE, TRUE, 0);
|
|
if (cancellable)
|
|
gtk_dialog_add_button(GTK_DIALOG(progress_), "Abbrechen", GTK_RESPONSE_CANCEL);
|
|
g_signal_connect(progress_, "response", G_CALLBACK(+[](GtkDialog *, int, gpointer data) {
|
|
static_cast<GtkLauncher *>(data)->cancelled_ = true;
|
|
}),
|
|
this);
|
|
g_signal_connect(progress_, "delete-event",
|
|
G_CALLBACK(+[](GtkWidget *, GdkEvent *, gpointer data) -> gboolean {
|
|
static_cast<GtkLauncher *>(data)->cancelled_ = true;
|
|
return TRUE;
|
|
}),
|
|
this);
|
|
gtk_widget_set_sensitive(window_, FALSE);
|
|
gtk_widget_show_all(progress_);
|
|
}
|
|
gtk_label_set_text(GTK_LABEL(progress_label_), text.c_str());
|
|
}
|
|
bool pump() override {
|
|
while (gtk_events_pending())
|
|
gtk_main_iteration();
|
|
return cancelled_;
|
|
}
|
|
void finish_progress() override {
|
|
if (progress_) {
|
|
gtk_widget_destroy(progress_);
|
|
progress_ = progress_label_ = nullptr;
|
|
gtk_widget_set_sensitive(window_, TRUE);
|
|
gtk_window_present(GTK_WINDOW(window_));
|
|
}
|
|
}
|
|
};
|
|
} // namespace
|
|
std::unique_ptr<LauncherUI> make_launcher_ui() { return std::make_unique<GtkLauncher>(); }
|
|
} // namespace bmh::launch
|