From 3f8e4d515e95dc134b16a3cab8c1e261ff4ed743 Mon Sep 17 00:00:00 2001 From: Carlos Garnacho Date: Tue, 21 Dec 2021 21:11:05 +0100 Subject: [PATCH] frames: Add new X11 frames client This small X11 client takes care of creating frames for client windows, Mutter will use this client to delegate window frame rendering and event handling. The MetaWindowTracker object will keep track of windows created from other clients, and will await for _MUTTER_NEEDS_FRAME property updates on those (coming from Mutter), indicating the need for a frame window. This process is resilient to restarts of the frames client, existing windows will be queried during start, and the existence of relevant properties checked. Mutter will be able to just hide/show SSD-decorated windows while the frames client restarts. The frames are created through GTK4 widgets, the MetaWindowContent widget acts as a replacement prop for the actual client window, and the MetaFrameHeader wraps GtkHeaderBar so that windows can be overshrunk, but otherwise a MetaFrame is a 100% true GTK4 GtkWindow. After a frame window is created for a client window, the _MUTTER_FRAME_FOR property will be set on the frame window, indicating to mutter the correspondence between both Windows. Additionally, the pixel sizes of the visible left/right/top/bottom borders of the frame will be set through the _MUTTER_FRAME_EXTENTS property, set on the frame window. In order to make the frame window behave as the frame for the client window, a number of properties will be tracked from the client window to update the relevant frame behavior (window title, resizability, availability of actions...), and also some forwarding of events happening in the frame will be forwarded to the client window (mainly, WM_DELETE_WINDOW when the close button is clicked). Other than that, the frames are pretty much CSD GTK4 windows, so window drags and resizes, and window context menus are forwarded for the WM to handle. Part-of: --- meson.build | 2 + src/frames/main.c | 72 ++++++ src/frames/meson.build | 24 ++ src/frames/meta-frame-content.c | 199 ++++++++++++++++ src/frames/meta-frame-content.h | 37 +++ src/frames/meta-frame-header.c | 125 ++++++++++ src/frames/meta-frame-header.h | 31 +++ src/frames/meta-frame.c | 314 ++++++++++++++++++++++++ src/frames/meta-frame.h | 35 +++ src/frames/meta-window-tracker.c | 393 +++++++++++++++++++++++++++++++ src/frames/meta-window-tracker.h | 33 +++ src/meson.build | 1 + 12 files changed, 1266 insertions(+) create mode 100644 src/frames/main.c create mode 100644 src/frames/meson.build create mode 100644 src/frames/meta-frame-content.c create mode 100644 src/frames/meta-frame-content.h create mode 100644 src/frames/meta-frame-header.c create mode 100644 src/frames/meta-frame-header.h create mode 100644 src/frames/meta-frame.c create mode 100644 src/frames/meta-frame.h create mode 100644 src/frames/meta-window-tracker.c create mode 100644 src/frames/meta-window-tracker.h diff --git a/meson.build b/meson.build index 6a310376e..709759f96 100644 --- a/meson.build +++ b/meson.build @@ -20,6 +20,7 @@ glib_req = '>= 2.69.0' gi_req = '>= 0.9.5' graphene_req = '>= 1.10.2' gtk3_req = '>= 3.19.8' +gtk4_req = '>= 4.0.0' gdk_pixbuf_req = '>= 2.0' uprof_req = '>= 0.3' pango_req = '>= 1.46.0' @@ -105,6 +106,7 @@ mutter_installed_tests_libexecdir = join_paths( m_dep = cc.find_library('m', required: true) graphene_dep = dependency('graphene-gobject-1.0', version: graphene_req) gtk3_dep = dependency('gtk+-3.0', version: gtk3_req) +gtk4_dep = dependency('gtk4', version: gtk4_req) gdk_pixbuf_dep = dependency('gdk-pixbuf-2.0') pango_dep = dependency('pango', version: pango_req) cairo_dep = dependency('cairo', version: cairo_req) diff --git a/src/frames/main.c b/src/frames/main.c new file mode 100644 index 000000000..b6e429b4d --- /dev/null +++ b/src/frames/main.c @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#include "config.h" + +#include "meta-window-tracker.h" + +#include +#include +#include + +static gboolean +on_sigterm (gpointer user_data) +{ + GMainLoop *main_loop = user_data; + + g_main_loop_quit (main_loop); + + return G_SOURCE_REMOVE; +} + +int +main (int argc, + char *argv[]) +{ + g_autoptr (MetaWindowTracker) window_tracker = NULL; + GdkDisplay *display; + GMainLoop *loop; + Display *xdisplay; + + /* We do know the desired GDK backend, don't let + * anyone tell us otherwise. + */ + g_unsetenv ("GDK_BACKEND"); + + gdk_set_allowed_backends ("x11"); + + g_set_prgname ("mutter-x11-frames"); + + gtk_init (); + + display = gdk_display_get_default (); + + xdisplay = gdk_x11_display_get_xdisplay (display); + XFixesSetClientDisconnectMode (xdisplay, + XFixesClientDisconnectFlagTerminate); + + window_tracker = meta_window_tracker_new (display); + + loop = g_main_loop_new (NULL, FALSE); + g_unix_signal_add (SIGTERM, on_sigterm, loop); + g_main_loop_run (loop); + g_main_loop_unref (loop); + + return 0; +} diff --git a/src/frames/meson.build b/src/frames/meson.build new file mode 100644 index 000000000..1ddccff23 --- /dev/null +++ b/src/frames/meson.build @@ -0,0 +1,24 @@ +x11_frames_sources = [ + 'main.c', + 'meta-frame.c', + 'meta-frame-content.c', + 'meta-frame-header.c', + 'meta-window-tracker.c', +] + +x11_frames = executable('mutter-x11-frames', + sources: x11_frames_sources, + dependencies: [ + gtk4_dep, + x11_dep, + xext_dep, + xfixes_dep, + xi_dep, + ], + c_args: [ + '-DG_LOG_DOMAIN="mutter-x11-frames"', + ], + include_directories: top_includepath, + install: true, + install_dir: get_option('libexecdir'), +) diff --git a/src/frames/meta-frame-content.c b/src/frames/meta-frame-content.c new file mode 100644 index 000000000..bd9965179 --- /dev/null +++ b/src/frames/meta-frame-content.c @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#include "config.h" + +#include "meta-frame-content.h" + +struct _MetaFrameContent +{ + GtkWidget parent_instance; + Window window; + GtkBorder border; +}; + +enum { + PROP_0, + PROP_XWINDOW, + PROP_BORDER, + N_PROPS +}; + +static GParamSpec *props[N_PROPS] = { 0, }; + +G_DEFINE_TYPE (MetaFrameContent, meta_frame_content, GTK_TYPE_WIDGET) + +static void +meta_frame_content_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + MetaFrameContent *frame_content = META_FRAME_CONTENT (object); + + switch (prop_id) + { + case PROP_XWINDOW: + frame_content->window = (Window) g_value_get_ulong (value); + break; + case PROP_BORDER: + frame_content->border = *(GtkBorder*) g_value_get_boxed (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +meta_frame_content_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + MetaFrameContent *frame_content = META_FRAME_CONTENT (object); + + switch (prop_id) + { + case PROP_XWINDOW: + g_value_set_ulong (value, (gulong) frame_content->window); + break; + case PROP_BORDER: + g_value_set_boxed (value, &frame_content->border); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +meta_frame_content_measure (GtkWidget *widget, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + *minimum_baseline = *natural_baseline = -1; + *minimum = *natural = 1; +} + +static void +meta_frame_content_update_border (MetaFrameContent *content, + GtkBorder border) +{ + if (content->border.left == border.left && + content->border.right == border.right && + content->border.top == border.top && + content->border.bottom == border.bottom) + return; + + content->border = border; + g_object_notify (G_OBJECT (content), "border"); +} + +static void +meta_frame_content_size_allocate (GtkWidget *widget, + int width, + int height, + int baseline) +{ + MetaFrameContent *content = META_FRAME_CONTENT (widget); + GtkWindow *window = GTK_WINDOW (gtk_widget_get_root (widget)); + double x = 0, y = 0, scale; + + gtk_widget_translate_coordinates (widget, + GTK_WIDGET (window), + x, y, + &x, &y); + + scale = gdk_surface_get_scale_factor (gtk_native_get_surface (GTK_NATIVE (window))); + + meta_frame_content_update_border (content, + /* FIXME: right/bottom are broken, if they + * are ever other than 0. + */ + (GtkBorder) { + x * scale, 0, + y * scale, 0, + }); +} + +static void +meta_frame_content_class_init (MetaFrameContentClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->set_property = meta_frame_content_set_property; + object_class->get_property = meta_frame_content_get_property; + + widget_class->measure = meta_frame_content_measure; + widget_class->size_allocate = meta_frame_content_size_allocate; + + props[PROP_XWINDOW] = g_param_spec_ulong ("xwindow", + "X window", + "X window", + 0, G_MAXULONG, 0, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_NICK | + G_PARAM_STATIC_BLURB); + props[PROP_BORDER] = g_param_spec_boxed ("border", + "Border", + "Border", + GTK_TYPE_BORDER, + G_PARAM_READABLE | + G_PARAM_EXPLICIT_NOTIFY | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_NICK | + G_PARAM_STATIC_BLURB); + + g_object_class_install_properties (object_class, + G_N_ELEMENTS (props), + props); +} + +static void +meta_frame_content_init (MetaFrameContent *content) +{ +} + +GtkWidget * +meta_frame_content_new (Window window) +{ + return g_object_new (META_TYPE_FRAME_CONTENT, + "xwindow", window, + NULL); +} + +Window +meta_frame_content_get_window (MetaFrameContent *content) +{ + return content->window; +} + +GtkBorder +meta_frame_content_get_border (MetaFrameContent *content) +{ + return content->border; +} diff --git a/src/frames/meta-frame-content.h b/src/frames/meta-frame-content.h new file mode 100644 index 000000000..6125ef931 --- /dev/null +++ b/src/frames/meta-frame-content.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#ifndef META_FRAME_CONTENT_H +#define META_FRAME_CONTENT_H + +#include + +#include + +#define META_TYPE_FRAME_CONTENT (meta_frame_content_get_type ()) +G_DECLARE_FINAL_TYPE (MetaFrameContent, meta_frame_content, + META, FRAME_CONTENT, GtkWidget) + +GtkWidget * meta_frame_content_new (Window window); + +Window meta_frame_content_get_window (MetaFrameContent *content); + +GtkBorder meta_frame_content_get_border (MetaFrameContent *content); + +#endif /* META_FRAME_CONTENT_H */ diff --git a/src/frames/meta-frame-header.c b/src/frames/meta-frame-header.c new file mode 100644 index 000000000..5f2cda1c5 --- /dev/null +++ b/src/frames/meta-frame-header.c @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#include "config.h" + +#include "meta-frame-header.h" + +struct _MetaFrameHeader +{ + GtkWidget parent_instance; +}; + +G_DEFINE_TYPE (MetaFrameHeader, meta_frame_header, GTK_TYPE_WIDGET) + +static void +meta_frame_header_dispose (GObject *object) +{ + GtkWidget *widget = GTK_WIDGET (object); + GtkWidget *child; + + child = gtk_widget_get_first_child (widget); + if (child) + gtk_widget_unparent (child); + + G_OBJECT_CLASS (meta_frame_header_parent_class)->dispose (object); +} + +static void +meta_frame_header_measure (GtkWidget *widget, + GtkOrientation orientation, + int for_size, + int *minimum, + int *natural, + int *minimum_baseline, + int *natural_baseline) +{ + *minimum_baseline = *natural_baseline = -1; + + if (orientation == GTK_ORIENTATION_HORIZONTAL) + { + *minimum = *natural = 1; + } + else + { + GtkWidget *child; + + child = gtk_widget_get_first_child (widget); + gtk_widget_measure (child, + orientation, for_size, + minimum, natural, + minimum_baseline, + natural_baseline); + } +} + +static void +meta_frame_header_size_allocate (GtkWidget *widget, + int width, + int height, + int baseline) +{ + GtkWidget *child; + int minimum; + gboolean shrunk; + GtkAllocation child_allocation; + + child = gtk_widget_get_first_child (widget); + + gtk_widget_measure (child, + GTK_ORIENTATION_HORIZONTAL, + height, + &minimum, NULL, NULL, NULL); + + shrunk = width < minimum; + + child_allocation.x = shrunk ? width - minimum : 0; + child_allocation.y = 0; + child_allocation.width = shrunk ? minimum : width; + child_allocation.height = height; + + gtk_widget_size_allocate (child, &child_allocation, baseline); +} + +static void +meta_frame_header_class_init (MetaFrameHeaderClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->dispose = meta_frame_header_dispose; + + widget_class->measure = meta_frame_header_measure; + widget_class->size_allocate = meta_frame_header_size_allocate; +} + +static void +meta_frame_header_init (MetaFrameHeader *content) +{ + GtkWidget *header_bar; + + header_bar = gtk_header_bar_new (); + gtk_widget_insert_before (header_bar, GTK_WIDGET (content), NULL); +} + +GtkWidget * +meta_frame_header_new (void) +{ + return g_object_new (META_TYPE_FRAME_HEADER, NULL); +} diff --git a/src/frames/meta-frame-header.h b/src/frames/meta-frame-header.h new file mode 100644 index 000000000..758fac8e7 --- /dev/null +++ b/src/frames/meta-frame-header.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#ifndef META_FRAME_HEADER_H +#define META_FRAME_HEADER_H + +#include + +#define META_TYPE_FRAME_HEADER (meta_frame_header_get_type ()) +G_DECLARE_FINAL_TYPE (MetaFrameHeader, meta_frame_header, + META, FRAME_HEADER, GtkWidget) + +GtkWidget * meta_frame_header_new (void); + +#endif /* META_FRAME_HEADER_H */ diff --git a/src/frames/meta-frame.c b/src/frames/meta-frame.c new file mode 100644 index 000000000..26d0e1f1a --- /dev/null +++ b/src/frames/meta-frame.c @@ -0,0 +1,314 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#include "config.h" + +#include "meta-frame.h" + +#include "meta-frame-content.h" +#include "meta-frame-header.h" + +#include +#include + +struct _MetaFrame +{ + GtkWindow parent_instance; + GtkWidget *content; +}; + +typedef struct +{ + unsigned long flags; + unsigned long functions; + unsigned long decorations; + long input_mode; + unsigned long status; +} MotifWmHints; + +#define MWM_FUNC_ALL (1L << 0) +#define MWM_FUNC_RESIZE (1L << 1) +#define MWM_FUNC_MINIMIZE (1L << 3) +#define MWM_FUNC_MAXIMIZE (1L << 4) +#define MWM_FUNC_CLOSE (1L << 5) + +G_DEFINE_TYPE (MetaFrame, meta_frame, GTK_TYPE_WINDOW) + +static void +meta_frame_class_init (MetaFrameClass *klass) +{ +} + +static gboolean +on_frame_close_request (GtkWindow *window, + gpointer user_data) +{ + GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (window)); + GtkWidget *content; + XClientMessageEvent ev; + Window client_xwindow; + + content = gtk_window_get_child (window); + if (!content) + return FALSE; + + client_xwindow = + meta_frame_content_get_window (META_FRAME_CONTENT (content)); + + ev.type = ClientMessage; + ev.window = client_xwindow; + ev.message_type = + gdk_x11_get_xatom_by_name_for_display (display, "WM_PROTOCOLS"); + ev.format = 32; + ev.data.l[0] = + gdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW"); + ev.data.l[1] = 0; /* FIXME: missing timestamp */ + + gdk_x11_display_error_trap_push (display); + XSendEvent (gdk_x11_display_get_xdisplay (display), + client_xwindow, False, 0, (XEvent*) &ev); + gdk_x11_display_error_trap_pop_ignored (display); + + return TRUE; +} + +static void +meta_frame_init (MetaFrame *frame) +{ + g_signal_connect (frame, "close-request", + G_CALLBACK (on_frame_close_request), NULL); +} + +static void +meta_frame_update_extents (MetaFrame *frame, + GtkBorder border) +{ + GtkWindow *window = GTK_WINDOW (frame); + GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (frame)); + GdkSurface *surface; + Window xframe; + unsigned long data[4]; + + surface = gtk_native_get_surface (GTK_NATIVE (window)); + if (!surface) + return; + + data[0] = border.left; + data[1] = border.right; + data[2] = border.top; + data[3] = border.bottom; + + xframe = gdk_x11_surface_get_xid (surface); + XChangeProperty (gdk_x11_display_get_xdisplay (display), + xframe, + gdk_x11_get_xatom_by_name_for_display (display, "_MUTTER_FRAME_EXTENTS"), + XA_CARDINAL, + 32, + PropModeReplace, + (guchar *) &data, 4); +} + +static void +on_border_changed (GObject *object, + GParamSpec *pspec, + gpointer user_data) +{ + MetaFrame *frame = user_data; + GtkWidget *content; + GtkBorder border; + + content = gtk_window_get_child (GTK_WINDOW (frame)); + border = meta_frame_content_get_border (META_FRAME_CONTENT (content)); + meta_frame_update_extents (frame, border); +} + +static void +frame_sync_title (GtkWindow *frame, + Window client_window) +{ + GdkDisplay *display; + char *title = NULL; + int format; + Atom type; + unsigned long nitems, bytes_after; + + display = gtk_widget_get_display (GTK_WIDGET (frame)); + + XGetWindowProperty (gdk_x11_display_get_xdisplay (display), + client_window, + gdk_x11_get_xatom_by_name_for_display (display, + "_NET_WM_NAME"), + 0, G_MAXLONG, False, + gdk_x11_get_xatom_by_name_for_display (display, + "UTF8_STRING"), + &type, &format, + &nitems, &bytes_after, + (unsigned char **) &title); + + gtk_window_set_title (frame, title); + g_free (title); +} + +static void +frame_sync_motif_wm_hints (GtkWindow *frame, + Window client_window) +{ + GdkDisplay *display; + MotifWmHints *mwm_hints = NULL; + int format; + Atom type; + unsigned long nitems, bytes_after; + gboolean deletable = TRUE; + + display = gtk_widget_get_display (GTK_WIDGET (frame)); + + XGetWindowProperty (gdk_x11_display_get_xdisplay (display), + client_window, + gdk_x11_get_xatom_by_name_for_display (display, + "_MOTIF_WM_HINTS"), + 0, sizeof (MotifWmHints) / sizeof (long), + False, AnyPropertyType, + &type, &format, + &nitems, &bytes_after, + (unsigned char **) &mwm_hints); + + if (mwm_hints) + { + if ((mwm_hints->functions & MWM_FUNC_ALL) == 0) + deletable = (mwm_hints->functions & MWM_FUNC_CLOSE) != 0; + else + deletable = (mwm_hints->functions & MWM_FUNC_CLOSE) == 0; + + g_free (mwm_hints); + } + + gtk_window_set_deletable (frame, deletable); +} + +static void +frame_sync_wm_normal_hints (GtkWindow *frame, + Window client_window) +{ + GdkDisplay *display; + XSizeHints size_hints; + long nitems; + gboolean resizable = TRUE; + + display = gtk_widget_get_display (GTK_WIDGET (frame)); + + XGetWMNormalHints (gdk_x11_display_get_xdisplay (display), + client_window, + &size_hints, + &nitems); + + if (nitems > 0) + { + resizable = ((size_hints.flags & PMinSize) == 0 || + (size_hints.flags & PMaxSize) == 0 || + size_hints.min_width != size_hints.max_width || + size_hints.min_height != size_hints.max_height); + } + + gtk_window_set_resizable (frame, resizable); +} + +GtkWidget * +meta_frame_new (Window window) +{ + GtkWidget *frame, *header, *content; + GdkSurface *surface; + int frame_height; + double scale; + + frame = g_object_new (META_TYPE_FRAME, NULL); + + header = meta_frame_header_new (); + + gtk_window_set_titlebar (GTK_WINDOW (frame), header); + + content = meta_frame_content_new (window); + gtk_window_set_child (GTK_WINDOW (frame), content); + + g_signal_connect (content, "notify::border", + G_CALLBACK (on_border_changed), frame); + + gtk_widget_realize (GTK_WIDGET (frame)); + surface = gtk_native_get_surface (GTK_NATIVE (frame)); + gdk_x11_surface_set_frame_sync_enabled (surface, FALSE); + + gtk_widget_measure (header, + GTK_ORIENTATION_VERTICAL, 1, + &frame_height, + NULL, NULL, NULL); + + scale = gdk_surface_get_scale_factor (gtk_native_get_surface (GTK_NATIVE (frame))); + + meta_frame_update_extents (META_FRAME (frame), + (GtkBorder) { + 0, 0, + frame_height * scale, 0, + }); + + frame_sync_title (GTK_WINDOW (frame), window); + frame_sync_motif_wm_hints (GTK_WINDOW (frame), window); + frame_sync_wm_normal_hints (GTK_WINDOW (frame), window); + + return frame; +} + +void +meta_frame_handle_xevent (MetaFrame *frame, + Window window, + XEvent *xevent) +{ + GdkDisplay *display; + GtkWidget *content; + gboolean is_frame, is_content; + GdkSurface *surface; + + surface = gtk_native_get_surface (GTK_NATIVE (frame)); + if (!surface) + return; + + content = gtk_window_get_child (GTK_WINDOW (frame)); + if (!content) + return; + + is_frame = window == gdk_x11_surface_get_xid (surface); + is_content = + window == meta_frame_content_get_window (META_FRAME_CONTENT (content)); + + if (!is_frame && !is_content) + return; + + display = gtk_widget_get_display (GTK_WIDGET (frame)); + + if (is_content && xevent->type == PropertyNotify) + { + if (xevent->xproperty.atom == + gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_NAME")) + frame_sync_title (GTK_WINDOW (frame), xevent->xproperty.window); + else if (xevent->xproperty.atom == + gdk_x11_get_xatom_by_name_for_display (display, "_MOTIF_WM_HINTS")) + frame_sync_motif_wm_hints (GTK_WINDOW (frame), xevent->xproperty.window); + else if (xevent->xproperty.atom == + gdk_x11_get_xatom_by_name_for_display (display, "WM_NORMAL_HINTS")) + frame_sync_wm_normal_hints (GTK_WINDOW (frame), xevent->xproperty.window); + } +} diff --git a/src/frames/meta-frame.h b/src/frames/meta-frame.h new file mode 100644 index 000000000..d39dc8218 --- /dev/null +++ b/src/frames/meta-frame.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#ifndef META_FRAME_H +#define META_FRAME_H + +#include +#include + +#define META_TYPE_FRAME (meta_frame_get_type ()) +G_DECLARE_FINAL_TYPE (MetaFrame, meta_frame, META, FRAME, GtkWindow) + +GtkWidget * meta_frame_new (Window window); + +void meta_frame_handle_xevent (MetaFrame *frame, + Window window, + XEvent *xevent); + +#endif /* META_FRAME_CONTENT_H */ diff --git a/src/frames/meta-window-tracker.c b/src/frames/meta-window-tracker.c new file mode 100644 index 000000000..7487904c4 --- /dev/null +++ b/src/frames/meta-window-tracker.c @@ -0,0 +1,393 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#include "config.h" + +#include "meta-window-tracker.h" + +#include "meta-frame.h" + +#include +#include +#include + +struct _MetaWindowTracker +{ + GObject parent_instance; + GdkDisplay *display; + GHashTable *frames; + GHashTable *client_windows; + int xinput_opcode; +}; + +enum { + PROP_0, + PROP_DISPLAY, + N_PROPS +}; + +static GParamSpec *props[N_PROPS] = { 0, }; + +G_DEFINE_TYPE (MetaWindowTracker, meta_window_tracker, G_TYPE_OBJECT) + +static void +meta_window_tracker_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + MetaWindowTracker *window_tracker = META_WINDOW_TRACKER (object); + + switch (prop_id) + { + case PROP_DISPLAY: + window_tracker->display = g_value_get_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +meta_window_tracker_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + MetaWindowTracker *window_tracker = META_WINDOW_TRACKER (object); + + switch (prop_id) + { + case PROP_DISPLAY: + g_value_set_object (value, window_tracker->display); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +set_up_frame (MetaWindowTracker *window_tracker, + Window xwindow) +{ + GdkDisplay *display = window_tracker->display; + Display *xdisplay = gdk_x11_display_get_xdisplay (display); + GdkSurface *surface; + Window xframe; + unsigned long data[1]; + GtkWidget *frame; + + /* Double check it's not a request for a frame of our own. */ + if (g_hash_table_contains (window_tracker->frames, + GUINT_TO_POINTER (xwindow))) + return; + + /* Create a frame window */ + frame = meta_frame_new (xwindow); + surface = gtk_native_get_surface (GTK_NATIVE (frame)); + xframe = gdk_x11_surface_get_xid (surface); + + XAddToSaveSet (xdisplay, xwindow); + + data[0] = xwindow; + XChangeProperty (xdisplay, + xframe, + gdk_x11_get_xatom_by_name_for_display (display, "_MUTTER_FRAME_FOR"), + XA_WINDOW, + 32, + PropModeReplace, + (guchar *) data, 1); + + g_hash_table_insert (window_tracker->frames, + GUINT_TO_POINTER (xframe), frame); + g_hash_table_insert (window_tracker->client_windows, + GUINT_TO_POINTER (xwindow), frame); + gtk_widget_show (GTK_WIDGET (frame)); +} + +static void +listen_set_up_frame (MetaWindowTracker *window_tracker, + Window xwindow) +{ + GdkDisplay *display = window_tracker->display; + Display *xdisplay = gdk_x11_display_get_xdisplay (display); + int format; + Atom type; + unsigned long nitems, bytes_after; + unsigned char *data; + + gdk_x11_display_error_trap_push (display); + + XSelectInput (xdisplay, xwindow, + PropertyChangeMask | StructureNotifyMask); + + XGetWindowProperty (xdisplay, + xwindow, + gdk_x11_get_xatom_by_name_for_display (display, + "_MUTTER_NEEDS_FRAME"), + 0, 1, + False, XA_CARDINAL, + &type, &format, + &nitems, &bytes_after, + (unsigned char **) &data); + + if (gdk_x11_display_error_trap_pop (display)) + return; + + if (nitems > 0 && data[0]) + set_up_frame (window_tracker, xwindow); + + XFree (data); +} + +static void +remove_frame (MetaWindowTracker *window_tracker, + Window xwindow) +{ + GdkDisplay *display = window_tracker->display; + Display *xdisplay = gdk_x11_display_get_xdisplay (display); + GtkWidget *frame; + GdkSurface *surface; + Window xframe; + + frame = g_hash_table_lookup (window_tracker->client_windows, + GUINT_TO_POINTER (xwindow)); + if (!frame) + return; + + surface = gtk_native_get_surface (GTK_NATIVE (frame)); + xframe = gdk_x11_surface_get_xid (surface); + + gdk_x11_display_error_trap_push (display); + XRemoveFromSaveSet (xdisplay, xwindow); + gdk_x11_display_error_trap_pop_ignored (display); + + g_hash_table_remove (window_tracker->client_windows, + GUINT_TO_POINTER (xwindow)); + g_hash_table_remove (window_tracker->frames, + GUINT_TO_POINTER (xframe)); +} + +static gboolean +on_xevent (GdkDisplay *display, + XEvent *xevent, + gpointer user_data) +{ + Window xroot = gdk_x11_display_get_xrootwindow (display); + Window xwindow = xevent->xany.window; + MetaWindowTracker *window_tracker = user_data; + GtkWidget *frame; + + if (xevent->type == CreateNotify && + xevent->xcreatewindow.parent == xroot && + !xevent->xcreatewindow.override_redirect && + !g_hash_table_contains (window_tracker->frames, + GUINT_TO_POINTER (xevent->xcreatewindow.window))) + { + xwindow = xevent->xcreatewindow.window; + listen_set_up_frame (window_tracker, xwindow); + } + else if (xevent->type == DestroyNotify) + { + xwindow = xevent->xdestroywindow.window; + remove_frame (window_tracker, xwindow); + } + else if (xevent->type == PropertyNotify && + xevent->xproperty.atom == + gdk_x11_get_xatom_by_name_for_display (display, "_MUTTER_NEEDS_FRAME")) + { + if (xevent->xproperty.state == PropertyNewValue) + set_up_frame (window_tracker, xwindow); + else if (xevent->xproperty.state == PropertyDelete) + remove_frame (window_tracker, xwindow); + } + else if (xevent->type == PropertyNotify) + { + frame = g_hash_table_lookup (window_tracker->frames, + GUINT_TO_POINTER (xwindow)); + + if (!frame) + { + frame = g_hash_table_lookup (window_tracker->client_windows, + GUINT_TO_POINTER (xwindow)); + } + + if (frame) + meta_frame_handle_xevent (META_FRAME (frame), xwindow, xevent); + } + else if (xevent->type == GenericEvent && + xevent->xcookie.extension == window_tracker->xinput_opcode) + { + Display *xdisplay = gdk_x11_display_get_xdisplay (display); + XIEvent *xi_event; + + xi_event = (XIEvent *) xevent->xcookie.data; + + if (xi_event->evtype == XI_Leave) + { + XILeaveEvent *crossing = (XILeaveEvent *) xi_event; + + xwindow = crossing->event; + frame = g_hash_table_lookup (window_tracker->frames, + GUINT_TO_POINTER (xwindow)); + + /* When crossing from the frame to the client + * window, we may need to restore the cursor to + * its default. + */ + if (frame && crossing->detail == XINotifyInferior) + XIUndefineCursor (xdisplay, crossing->deviceid, xwindow); + } + } + + return GDK_EVENT_PROPAGATE; +} + +static gboolean +query_xi_extension (MetaWindowTracker *window_tracker, + Display *xdisplay) +{ + int major = 2, minor = 3; + int unused; + + if (XQueryExtension (xdisplay, + "XInputExtension", + &window_tracker->xinput_opcode, + &unused, + &unused)) + { + if (XIQueryVersion (xdisplay, &major, &minor) == Success) + return TRUE; + } + + return FALSE; +} + +static void +meta_window_tracker_constructed (GObject *object) +{ + MetaWindowTracker *window_tracker = META_WINDOW_TRACKER (object); + GdkDisplay *display = window_tracker->display; + Display *xdisplay = gdk_x11_display_get_xdisplay (display); + Window xroot = gdk_x11_display_get_xrootwindow (display); + Window *windows, ignored1, ignored2; + unsigned int i, n_windows; + + G_OBJECT_CLASS (meta_window_tracker_parent_class)->constructed (object); + + query_xi_extension (window_tracker, xdisplay); + + XSelectInput (xdisplay, xroot, + KeyPressMask | + PropertyChangeMask); + + g_signal_connect (display, "xevent", + G_CALLBACK (on_xevent), object); + + gdk_x11_display_error_trap_push (display); + + XQueryTree (xdisplay, + xroot, + &ignored1, &ignored2, + &windows, &n_windows); + + if (gdk_x11_display_error_trap_pop (display)) + { + g_warning ("Could not query existing windows"); + return; + } + + for (i = 0; i < n_windows; i++) + { + XWindowAttributes attrs; + + gdk_x11_display_error_trap_push (display); + + XGetWindowAttributes (xdisplay, + windows[i], + &attrs); + + if (gdk_x11_display_error_trap_pop (display)) + continue; + + if (attrs.override_redirect) + continue; + + listen_set_up_frame (window_tracker, windows[i]); + } + + XFree (windows); +} + +static void +meta_window_tracker_finalize (GObject *object) +{ + MetaWindowTracker *window_tracker = META_WINDOW_TRACKER (object); + + g_clear_pointer (&window_tracker->frames, + g_hash_table_unref); + g_clear_pointer (&window_tracker->client_windows, + g_hash_table_unref); + + G_OBJECT_CLASS (meta_window_tracker_parent_class)->finalize (object); +} + +static void +meta_window_tracker_class_init (MetaWindowTrackerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->set_property = meta_window_tracker_set_property; + object_class->get_property = meta_window_tracker_get_property; + object_class->constructed = meta_window_tracker_constructed; + object_class->finalize = meta_window_tracker_finalize; + + props[PROP_DISPLAY] = g_param_spec_object ("display", + "Display", + "Display", + GDK_TYPE_DISPLAY, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_NICK | + G_PARAM_STATIC_BLURB); + + g_object_class_install_properties (object_class, + G_N_ELEMENTS (props), + props); +} + +static void +meta_window_tracker_init (MetaWindowTracker *window_tracker) +{ + window_tracker->frames = + g_hash_table_new_full (NULL, NULL, NULL, + (GDestroyNotify) gtk_window_destroy); + window_tracker->client_windows = g_hash_table_new (NULL, NULL); +} + +MetaWindowTracker * +meta_window_tracker_new (GdkDisplay *display) +{ + return g_object_new (META_TYPE_WINDOW_TRACKER, + "display", display, + NULL); +} diff --git a/src/frames/meta-window-tracker.h b/src/frames/meta-window-tracker.h new file mode 100644 index 000000000..4b52b33e9 --- /dev/null +++ b/src/frames/meta-window-tracker.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2022 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * Author: Carlos Garnacho + */ + +#ifndef META_WINDOW_TRACKER_H +#define META_WINDOW_TRACKER_H + +#include +#include + +#define META_TYPE_WINDOW_TRACKER (meta_window_tracker_get_type ()) +G_DECLARE_FINAL_TYPE (MetaWindowTracker, meta_window_tracker, + META, WINDOW_TRACKER, + GObject) + +MetaWindowTracker * meta_window_tracker_new (GdkDisplay *display); + +#endif /* META_WINDOW_TRACKER_H */ diff --git a/src/meson.build b/src/meson.build index 91cf29adb..6a995f3d4 100644 --- a/src/meson.build +++ b/src/meson.build @@ -1189,6 +1189,7 @@ pkg.generate(libmutter, ) subdir('compositor/plugins') +subdir('frames') if have_core_tests subdir('tests')