Files
SpotiFLAC-Mobile/linux/runner/my_application.cc
T
zarzet 7bbdf03e9a feat(desktop): open the mini player on Windows and Linux
The Windows and Linux runners now answer the window channel. They turn
the window into a frameless 360x140 panel that stays above other
windows, open it where it last sat (first at the top right of the work
area), move it when the panel is dragged, and restore the frame, size,
place and maximized state when it closes. On Wayland the compositor
decides the position and stacking, so there it only shrinks.

The mini player drag area now moves a framed window too, and the
shortcut is Ctrl+Shift+M on Windows and Linux, since Ctrl+Alt is AltGr
on many keyboard layouts. macOS keeps Opt+Cmd+M.
2026-10-22 19:27:34 +07:00

392 lines
15 KiB
C++

#include "my_application.h"
#include <flutter_linux/flutter_linux.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "flutter/generated_plugin_registrant.h"
// Smallest window, in logical pixels, that the desktop layouts support.
static constexpr gint kMinimumWidth = 800;
static constexpr gint kMinimumHeight = 600;
// Gap, in logical pixels, between a new mini player and the screen corner.
static constexpr gint kMiniPlayerScreenInset = 16;
struct _MyApplication {
GtkApplication parent_instance;
char** dart_entrypoint_arguments;
GtkWindow* window;
// Answers lib/widgets/desktop/desktop_window.dart.
FlMethodChannel* window_channel;
// Whether the window shows the mini player, and what it restores.
gboolean mini_player;
gint restore_x;
gint restore_y;
gint restore_width;
gint restore_height;
gboolean restore_maximized;
// Where the mini player last sat, by its top-left corner.
gboolean has_mini_player_origin;
gint mini_player_x;
gint mini_player_y;
};
G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
static void set_minimum_size(GtkWindow* window, gint width, gint height) {
GdkGeometry geometry = {};
geometry.min_width = width;
geometry.min_height = height;
gtk_window_set_geometry_hints(window, nullptr, &geometry, GDK_HINT_MIN_SIZE);
}
// Turns the window into a small undecorated panel of |width| x |height| that
// stays above other windows, or resizes the panel when it already shows. It
// keeps its top-left corner when it resizes and opens where it last sat
// (first at the top right of the screen). Wayland compositors decide the
// position and stacking themselves, so there it only shrinks.
static gboolean open_mini_player(MyApplication* self, gdouble width,
gdouble height) {
GtkWindow* window = self->window;
if (window == nullptr) return FALSE;
GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window));
if (gdk_window != nullptr &&
(gdk_window_get_state(gdk_window) & GDK_WINDOW_STATE_FULLSCREEN)) {
return FALSE;
}
const gint panel_width = static_cast<gint>(lround(width));
const gint panel_height = static_cast<gint>(lround(height));
gint x = 0;
gint y = 0;
const gboolean opening = !self->mini_player;
if (opening) {
self->restore_maximized = gtk_window_is_maximized(window);
if (self->restore_maximized) {
// The maximized size is not a size to come back to.
self->restore_width = 1280;
self->restore_height = 800;
gtk_window_unmaximize(window);
} else {
gtk_window_get_size(window, &self->restore_width,
&self->restore_height);
}
gtk_window_get_position(window, &self->restore_x, &self->restore_y);
self->mini_player = TRUE;
gtk_window_set_decorated(window, FALSE);
gtk_window_set_keep_above(window, TRUE);
}
set_minimum_size(window, panel_width, panel_height);
gtk_window_resize(window, panel_width, panel_height);
gboolean has_origin = TRUE;
if (!opening) {
gtk_window_get_position(window, &x, &y);
} else if (self->has_mini_player_origin) {
x = self->mini_player_x;
y = self->mini_player_y;
} else {
has_origin = FALSE;
}
// Keep the whole panel on the screen it opens on.
GdkDisplay* display = gtk_widget_get_display(GTK_WIDGET(window));
GdkMonitor* monitor =
has_origin ? gdk_display_get_monitor_at_point(display, x, y)
: gdk_window != nullptr
? gdk_display_get_monitor_at_window(display, gdk_window)
: gdk_display_get_primary_monitor(display);
if (monitor == nullptr) monitor = gdk_display_get_monitor(display, 0);
if (monitor != nullptr) {
GdkRectangle work;
gdk_monitor_get_workarea(monitor, &work);
if (!has_origin) {
x = work.x + work.width - panel_width - kMiniPlayerScreenInset;
y = work.y + kMiniPlayerScreenInset;
}
x = CLAMP(x, work.x, MAX(work.x, work.x + work.width - panel_width));
y = CLAMP(y, work.y, MAX(work.y, work.y + work.height - panel_height));
}
gtk_window_move(window, x, y);
return TRUE;
}
// Returns the window to the decorations, size and place it had before.
static void close_mini_player(MyApplication* self) {
GtkWindow* window = self->window;
if (!self->mini_player || window == nullptr) return;
gtk_window_get_position(window, &self->mini_player_x, &self->mini_player_y);
self->has_mini_player_origin = TRUE;
self->mini_player = FALSE;
gtk_window_set_keep_above(window, FALSE);
gtk_window_set_decorated(window, TRUE);
set_minimum_size(window, kMinimumWidth, kMinimumHeight);
gtk_window_resize(window, self->restore_width, self->restore_height);
gtk_window_move(window, self->restore_x, self->restore_y);
if (self->restore_maximized) gtk_window_maximize(window);
}
// Moves the window with the pointer, as dragging a title bar does.
static void start_window_drag(MyApplication* self) {
GtkWindow* window = self->window;
if (window == nullptr) return;
GdkSeat* seat =
gdk_display_get_default_seat(gtk_widget_get_display(GTK_WIDGET(window)));
GdkDevice* pointer = seat != nullptr ? gdk_seat_get_pointer(seat) : nullptr;
if (pointer == nullptr) return;
gint root_x = 0;
gint root_y = 0;
gdk_device_get_position(pointer, nullptr, &root_x, &root_y);
gtk_window_begin_move_drag(window, GDK_BUTTON_PRIMARY, root_x, root_y,
GDK_CURRENT_TIME);
}
static gdouble number_argument(FlValue* arguments, const gchar* key,
gdouble fallback) {
if (arguments == nullptr ||
fl_value_get_type(arguments) != FL_VALUE_TYPE_MAP) {
return fallback;
}
FlValue* value = fl_value_lookup_string(arguments, key);
if (value == nullptr) return fallback;
switch (fl_value_get_type(value)) {
case FL_VALUE_TYPE_FLOAT:
return fl_value_get_float(value);
case FL_VALUE_TYPE_INT:
return static_cast<gdouble>(fl_value_get_int(value));
default:
return fallback;
}
}
static void window_method_call_cb(FlMethodChannel* channel,
FlMethodCall* method_call,
gpointer user_data) {
MyApplication* self = MY_APPLICATION(user_data);
const gchar* method = fl_method_call_get_name(method_call);
FlValue* arguments = fl_method_call_get_args(method_call);
g_autoptr(FlMethodResponse) response = nullptr;
if (strcmp(method, "openMiniPlayer") == 0) {
g_autoptr(FlValue) opened = fl_value_new_bool(open_mini_player(
self, number_argument(arguments, "width", 360),
number_argument(arguments, "height", 140)));
response = FL_METHOD_RESPONSE(fl_method_success_response_new(opened));
} else if (strcmp(method, "closeMiniPlayer") == 0) {
close_mini_player(self);
response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
} else if (strcmp(method, "startDrag") == 0) {
start_window_drag(self);
response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
} else {
response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
}
fl_method_call_respond(method_call, response, nullptr);
}
// Only the deb installs a desktop entry for mornye://, so the browser cannot
// hand an extension callback back to a zip or AppImage copy. Points the
// per-user handler at this copy unless the current one already starts it.
static void register_url_scheme() {
// An AppImage runs from a new mount on every launch; its file stays put.
const gchar* appimage = g_getenv("APPIMAGE");
g_autofree gchar* self_path =
appimage != nullptr ? g_strdup(appimage)
: g_file_read_link("/proc/self/exe", nullptr);
if (self_path == nullptr) return;
g_autofree gchar* self_real = realpath(self_path, nullptr);
g_autoptr(GAppInfo) current =
g_app_info_get_default_for_uri_scheme("mornye");
if (current != nullptr && self_real != nullptr) {
const char* executable = g_app_info_get_executable(current);
g_autofree gchar* found =
executable != nullptr ? g_find_program_in_path(executable) : nullptr;
g_autofree gchar* found_real =
found != nullptr ? realpath(found, nullptr) : nullptr;
if (g_strcmp0(found_real, self_real) == 0) return;
}
// GIO appends " %u" and writes a hidden entry plus the mimeapps default.
g_autofree gchar* commandline = g_shell_quote(self_path);
g_autoptr(GError) error = nullptr;
g_autoptr(GAppInfo) handler = g_app_info_create_from_commandline(
commandline, "Mornye", G_APP_INFO_CREATE_SUPPORTS_URIS, &error);
if (handler == nullptr ||
!g_app_info_set_as_default_for_type(handler, "x-scheme-handler/mornye",
&error)) {
g_warning("Could not register the mornye:// handler: %s",
error != nullptr ? error->message : "unknown error");
}
}
static void first_frame_cb(MyApplication* self, FlView* view) {
gtk_widget_show(gtk_widget_get_toplevel(GTK_WIDGET(view)));
}
static void my_application_activate(GApplication* application) {
MyApplication* self = MY_APPLICATION(application);
// Single instance: a second launch activates the running window.
GList* windows = gtk_application_get_windows(GTK_APPLICATION(application));
if (windows != nullptr) {
gtk_window_present(GTK_WINDOW(windows->data));
return;
}
register_url_scheme();
GtkWindow* window =
GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
// Use a header bar when running in GNOME as this is the common style used
// by applications and is the setup most users will be using (e.g. Ubuntu
// desktop).
// If running on X and not using GNOME then just use a traditional title bar
// in case the window manager does more exotic layout, e.g. tiling.
// If running on Wayland assume the header bar will work (may need changing
// if future cases occur).
gboolean use_header_bar = TRUE;
#ifdef GDK_WINDOWING_X11
GdkScreen* screen = gtk_window_get_screen(window);
if (GDK_IS_X11_SCREEN(screen)) {
const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
use_header_bar = FALSE;
}
}
#endif
if (use_header_bar) {
GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
gtk_widget_show(GTK_WIDGET(header_bar));
gtk_header_bar_set_title(header_bar, "Mornye");
gtk_header_bar_set_show_close_button(header_bar, TRUE);
gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
} else {
gtk_window_set_title(window, "Mornye");
}
gtk_window_set_default_size(window, 1280, 800);
set_minimum_size(window, kMinimumWidth, kMinimumHeight);
g_autofree gchar* executable = g_file_read_link("/proc/self/exe", nullptr);
if (executable != nullptr) {
g_autofree gchar* bundle_dir = g_path_get_dirname(executable);
g_autofree gchar* icon_path =
g_build_filename(bundle_dir, "data", "mornye.png", nullptr);
gtk_window_set_icon_from_file(window, icon_path, nullptr);
}
g_autoptr(FlDartProject) project = fl_dart_project_new();
fl_dart_project_set_dart_entrypoint_arguments(
project, self->dart_entrypoint_arguments);
FlView* view = fl_view_new(project);
GdkRGBA background_color;
gdk_rgba_parse(&background_color, "#000000");
fl_view_set_background_color(view, &background_color);
gtk_widget_show(GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
// Show the window when Flutter renders.
// Requires the view to be realized so we can start rendering.
g_signal_connect_swapped(view, "first-frame", G_CALLBACK(first_frame_cb),
self);
gtk_widget_realize(GTK_WIDGET(view));
fl_register_plugins(FL_PLUGIN_REGISTRY(view));
self->window = window;
g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
self->window_channel = fl_method_channel_new(
fl_engine_get_binary_messenger(fl_view_get_engine(view)),
"com.zarz.mornye/window", FL_METHOD_CODEC(codec));
fl_method_channel_set_method_call_handler(
self->window_channel, window_method_call_cb, self, nullptr);
gtk_widget_grab_focus(GTK_WIDGET(view));
}
static gboolean my_application_local_command_line(GApplication* application,
gchar*** arguments,
int* exit_status) {
MyApplication* self = MY_APPLICATION(application);
// Strip out the first argument as it is the binary name.
self->dart_entrypoint_arguments = g_strdupv(*arguments + 1);
g_autoptr(GError) error = nullptr;
if (!g_application_register(application, nullptr, &error)) {
g_warning("Failed to register: %s", error->message);
*exit_status = 1;
return TRUE;
}
// The primary instance creates its window (and registers the plugins)
// before GLib emits "command-line", so app_links sees the launch URL.
if (!g_application_get_is_remote(application)) {
g_application_activate(application);
}
*exit_status = 0;
// Not handled here: GLib sends the command line to the primary instance,
// which emits "command-line" there. app_links reads a forwarded
// mornye:// URL from it; the handler below raises the window.
return FALSE;
}
static gint my_application_command_line(GApplication* application,
GApplicationCommandLine* command_line) {
g_application_activate(application);
return 0;
}
static void my_application_startup(GApplication* application) {
G_APPLICATION_CLASS(my_application_parent_class)->startup(application);
}
static void my_application_shutdown(GApplication* application) {
G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application);
}
static void my_application_dispose(GObject* object) {
MyApplication* self = MY_APPLICATION(object);
g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
g_clear_object(&self->window_channel);
self->window = nullptr;
G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}
static void my_application_class_init(MyApplicationClass* klass) {
G_APPLICATION_CLASS(klass)->activate = my_application_activate;
G_APPLICATION_CLASS(klass)->local_command_line =
my_application_local_command_line;
G_APPLICATION_CLASS(klass)->command_line = my_application_command_line;
G_APPLICATION_CLASS(klass)->startup = my_application_startup;
G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown;
G_OBJECT_CLASS(klass)->dispose = my_application_dispose;
}
static void my_application_init(MyApplication* self) {}
MyApplication* my_application_new() {
// Set the program name to the application ID, which helps various systems
// like GTK and desktop environments map this running application to its
// corresponding .desktop file. This ensures better integration by allowing
// the application to be recognized beyond its binary name.
g_set_prgname(APPLICATION_ID);
// Unique on the session bus: later launches (for example a mornye://
// callback from the browser, `Exec=mornye %u`) forward their whole command
// line to this process. URLs arrive as arguments, so "open" is not used.
return MY_APPLICATION(g_object_new(
my_application_get_type(), "application-id", APPLICATION_ID, "flags",
G_APPLICATION_HANDLES_COMMAND_LINE, nullptr));
}