isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-21 23:50:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

frames: Add new X11 frames client

Browse Source 
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: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2175>
This commit is contained in:
Carlos Garnacho 2021-12-21 21:11:05 +01:00 committed by Marge Bot
parent ad02ef6f44
commit 3f8e4d515e
12 changed files with 1266 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
meson.build
View File

@ -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)

72
src/frames/main.c Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#include "config.h"
#include "meta-window-tracker.h"
#include <gdk/x11/gdkx.h>
#include <glib-unix.h>
#include <X11/extensions/Xfixes.h>
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;
}

24
src/frames/meson.build Normal file
View File

@ -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'),
)

199
src/frames/meta-frame-content.c Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#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;
}

37
src/frames/meta-frame-content.h Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#ifndef META_FRAME_CONTENT_H
#define META_FRAME_CONTENT_H
#include <gtk/gtk.h>
#include <X11/Xlib.h>
#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 */

125
src/frames/meta-frame-header.c Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#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);
}

31
src/frames/meta-frame-header.h Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#ifndef META_FRAME_HEADER_H
#define META_FRAME_HEADER_H
#include <gtk/gtk.h>
#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 */

314
src/frames/meta-frame.c Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#include "config.h"
#include "meta-frame.h"
#include "meta-frame-content.h"
#include "meta-frame-header.h"
#include <gdk/x11/gdkx.h>
#include <X11/Xatom.h>
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);
}
}

35
src/frames/meta-frame.h Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#ifndef META_FRAME_H
#define META_FRAME_H
#include <gtk/gtk.h>
#include <X11/Xlib.h>
#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 */

393
src/frames/meta-window-tracker.c Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#include "config.h"
#include "meta-window-tracker.h"
#include "meta-frame.h"
#include <gdk/x11/gdkx.h>
#include <X11/Xatom.h>
#include <X11/extensions/XInput2.h>
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);
}

33
src/frames/meta-window-tracker.h Normal file
View File

@ -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 <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#ifndef META_WINDOW_TRACKER_H
#define META_WINDOW_TRACKER_H
#include <gtk/gtk.h>
#include <X11/Xlib.h>
#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 */

1
src/meson.build
View File

@ -1189,6 +1189,7 @@ pkg.generate(libmutter,
)
subdir('compositor/plugins')
subdir('frames')
if have_core_tests
subdir('tests')