AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
9026289381
gtk2/gdk/wayland/gdkwindow-wayland.c

3144 lines
96 KiB
C
Raw Normal View History

Add Wayland backend
2010-12-18 20:38:49 +00:00
/*
* Copyright © 2010 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Add Wayland backend
2010-12-18 20:38:49 +00:00
*/
#include "config.h"
#include <netinet/in.h>
#include <unistd.h>
#include "gdk.h"
#include "gdkwayland.h"
#include "gdkwindow.h"
#include "gdkwindowimpl.h"
#include "gdkdisplay-wayland.h"
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
#include "gdkglcontext-wayland.h"
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
#include "gdkframeclockprivate.h"
Add Wayland backend
2010-12-18 20:38:49 +00:00
#include "gdkprivate-wayland.h"
#include "gdkinternals.h"
#include "gdkdeviceprivate.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
wayland: Improve error messages during SHM buffer creation Use g_critical rather than fprintf and and also grab the error messages from errno and from Cairo
2012-04-19 16:18:46 +00:00
#include <errno.h>
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
enum {
COMMITTED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
Add Wayland backend
2010-12-18 20:38:49 +00:00
#define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window) \
(GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
#define WINDOW_IS_TOPLEVEL(window) \
Add Wayland backend
2010-12-18 20:38:49 +00:00
(GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
typedef struct _GdkWaylandWindow GdkWaylandWindow;
typedef struct _GdkWaylandWindowClass GdkWaylandWindowClass;
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
struct _GdkWaylandWindow
{
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWindow parent;
};
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
struct _GdkWaylandWindowClass
{
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWindowClass parent_class;
};
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
G_DEFINE_TYPE (GdkWaylandWindow, gdk_wayland_window, GDK_TYPE_WINDOW)
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
gdk_wayland_window_class_init (GdkWaylandWindowClass *wayland_window_class)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
gdk_wayland_window_init (GdkWaylandWindow *wayland_window)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
Create and attach buffer at process_updates time This way we don't try to show the buffer until we've handle the initial expose.
2011-01-06 21:51:12 +00:00
#define GDK_TYPE_WINDOW_IMPL_WAYLAND (_gdk_window_impl_wayland_get_type ())
#define GDK_WINDOW_IMPL_WAYLAND(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWayland))
#define GDK_WINDOW_IMPL_WAYLAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWaylandClass))
#define GDK_IS_WINDOW_IMPL_WAYLAND(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_WAYLAND))
#define GDK_IS_WINDOW_IMPL_WAYLAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_WAYLAND))
#define GDK_WINDOW_IMPL_WAYLAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_WAYLAND, GdkWindowImplWaylandClass))
typedef struct _GdkWindowImplWayland GdkWindowImplWayland;
typedef struct _GdkWindowImplWaylandClass GdkWindowImplWaylandClass;
struct _GdkWindowImplWayland
{
GdkWindowImpl parent_instance;
GdkWindow *wrapper;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
struct {
/* The wl_outputs that this window currently touches */
GSList *outputs;
struct wl_surface *wl_surface;
struct xdg_surface *xdg_surface;
struct xdg_popup *xdg_popup;
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
struct gtk_surface1 *gtk_surface;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
struct wl_subsurface *wl_subsurface;
struct wl_egl_window *egl_window;
struct wl_egl_window *dummy_egl_window;
} display_server;
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
EGLSurface egl_surface;
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
EGLSurface dummy_egl_surface;
Invalidate window on configure This will trigger a repaint of the window, but it may be more efficient to just copy back the old surface contents and let gtk+ just update the changed parts.
2011-01-07 15:16:17 +00:00
unsigned int mapped : 1;
Improve struct packing in GdkWindowImplWayland
2013-09-22 03:35:02 +00:00
unsigned int use_custom_surface : 1;
wayland: Handle after-paint invocations when nothing was painted If a after-paint was scheduled but nothing was painted, for example when the it was scheduled by a subsurface wanting to update its position, we'd still try to read back from the backfill cairo surface and update the committed cairo surface reference even though no buffer was attached. Fix this by adding a new state, 'pending_buffer_attached', which is only true if a buffer was attached during frame. Only when this is true will the backfill be read back and the committed cairo surface reference be updated. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 04:41:57 +00:00
unsigned int pending_buffer_attached : 1;
Improve struct packing in GdkWindowImplWayland
2013-09-22 03:35:02 +00:00
unsigned int pending_commit : 1;
wayland: Thaw the clock if we hide a GdkWindow mid-frame When a window is hidden, its surface and all its roles are destroyed, if this happens when we already issued a wl_surface_commit and are awaiting for a frame callback, the clock will remain frozen for the next time the window is shown. To avoid this, keep track of the wl_surface_frame() calls issued, and ensure the clock is thawed after hiding. If we happen to receive the frame callback, it is just ignored. https://bugzilla.gnome.org/show_bug.cgi?id=743427
2015-02-25 13:46:54 +00:00
unsigned int awaiting_frame : 1;
wayland: Don't try to guess the popup menu placement when it was set If a position was already explicitly set, don't try to guess the position of popup menus by looking at the pointer position, just use the set coordinates. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:35:21 +00:00
unsigned int position_set : 1;
wayland: Set surface type based on GdkWindow hint
2012-01-13 14:48:46 +00:00
GdkWindowTypeHint hint;
Improve struct packing in GdkWindowImplWayland
2013-09-22 03:35:02 +00:00
GdkWindow *transient_for;
Create and attach buffer at process_updates time This way we don't try to show the buffer until we've handle the initial expose.
2011-01-06 21:51:12 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
cairo_surface_t *staging_cairo_surface;
cairo_surface_t *committed_cairo_surface;
cairo_surface_t *backfill_cairo_surface;
wayland: Implement DND icon hotspot API In Wayland, the hotspot of a DND icon is set using the buffer offset in wl_buffer.attach. To implement this, add a private API to cause the next wl_surface.attach to offset the new buffer with a given offset. Setting a DND icon hotspot sets this offset while also queuing a redraw of the window to trigger the wl_surface.attach. https://bugzilla.gnome.org/show_bug.cgi?id=759168
2015-12-08 10:19:33 +00:00
int pending_buffer_offset_x;
int pending_buffer_offset_y;
wayland: Add some useful comments explaining the cairo surface behaviour
2012-03-06 21:24:20 +00:00
wayland: Set title on shell surfaces to window title We currently use this information to display the title string in the window list of the desktop shell. Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:57:17 +00:00
gchar *title;
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
struct {
gboolean was_set;
gchar *application_id;
gchar *app_menu_path;
gchar *menubar_path;
gchar *window_object_path;
gchar *application_object_path;
gchar *unique_bus_name;
} application;
wayland: Implement set_geometry_hints vfunc Our trivial implementation simply saves the passed in parameters into the Wayland private data structure.
2012-01-09 17:11:22 +00:00
GdkGeometry geometry_hints;
GdkWindowHints geometry_mask;
wayland: Store the device that does a grab for a window on the window This allows us to get the device if we need to make the window a popup. This relies on the side effect that GTK calls into GDK to take a grab before the popup window is shown.
2012-02-27 14:06:22 +00:00
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
GdkSeat *grab_input_seat;
wayland: Implement gdk_window_fullscreen & gdk_window_unfullscreen
2013-01-29 18:40:02 +00:00
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
gint64 pending_frame_counter;
Improve struct packing in GdkWindowImplWayland
2013-09-22 03:35:02 +00:00
guint32 scale;
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
int margin_left;
int margin_right;
int margin_top;
int margin_bottom;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
int initial_fullscreen_monitor;
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
cairo_region_t *opaque_region;
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
cairo_region_t *input_region;
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
cairo_region_t *staged_updates_region;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
int saved_width;
int saved_height;
Create and attach buffer at process_updates time This way we don't try to show the buffer until we've handle the initial expose.
2011-01-06 21:51:12 +00:00
};
struct _GdkWindowImplWaylandClass
{
GdkWindowImplClass parent_class;
};
wayland: Do not resize with the same size gnome-control-center is calling gtk_window_resize() on configure-event signals which leads to a busy loop. Avoids such a busy loop by not re-configuring a window with the same size, unless this is coming from and xdg-shell configure. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=764374
2016-04-04 12:55:38 +00:00
static void gdk_wayland_window_maybe_configure (GdkWindow *window,
int width,
int height,
int scale);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
static void maybe_set_gtk_surface_dbus_properties (GdkWindow *window);
wayland: Ensure modal hint gets set on map We need to be mapped to have a gtk_surface and thus be able to do requests on it so we need to save the modal hint and apply it when we get mapped so that code that sets the hint before showing a window doesn't get ignored. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:03:49 +00:00
static void maybe_set_gtk_surface_modal (GdkWindow *window);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
wayland: Always request transient commit when mapping subsurface A subsurface positioning operation only takes effect when the parent surfaces state is applied. If a subsurface is mapped and positioned, but the parent surface state is not immediately committed, the relative position of the subsurface is undefined and may be placed incorrectly. To avoid this undefined state, always request that the parent surface should be committed after mapping a subsurface so that the position operation will take effect. https://bugzilla.gnome.org/show_bug.cgi?id=751098
2015-06-17 09:31:19 +00:00
static void gdk_window_request_transient_parent_commit (GdkWindow *window);
Wayland: Fix various compiler warnings Mostly missing declarations, missing statics and unused functions.
2014-09-06 00:41:06 +00:00
GType _gdk_window_impl_wayland_get_type (void);
Add Wayland backend
2010-12-18 20:38:49 +00:00
G_DEFINE_TYPE (GdkWindowImplWayland, _gdk_window_impl_wayland, GDK_TYPE_WINDOW_IMPL)
static void
_gdk_window_impl_wayland_init (GdkWindowImplWayland *impl)
Create and attach buffer at process_updates time This way we don't try to show the buffer until we've handle the initial expose.
2011-01-06 21:51:12 +00:00
{
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
impl->scale = 1;
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
impl->initial_fullscreen_monitor = -1;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
impl->saved_width = -1;
impl->saved_height = -1;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
static void
_gdk_wayland_screen_add_orphan_dialog (GdkWindow *window)
{
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
if (!g_list_find (display_wayland->orphan_dialogs, window))
display_wayland->orphan_dialogs =
g_list_prepend (display_wayland->orphan_dialogs, window);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
static void
drop_cairo_surfaces (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
g_clear_pointer (&impl->staging_cairo_surface, cairo_surface_destroy);
g_clear_pointer (&impl->backfill_cairo_surface, cairo_surface_destroy);
/* We nullify this so if a buffer release comes in later, we won't
* try to reuse that buffer since it's no longer suitable
*/
impl->committed_cairo_surface = NULL;
}
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
static void
_gdk_wayland_window_save_size (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (window->state & (GDK_WINDOW_STATE_FULLSCREEN | GDK_WINDOW_STATE_MAXIMIZED))
return;
impl->saved_width = window->width - impl->margin_left - impl->margin_right;
impl->saved_height = window->height - impl->margin_top - impl->margin_bottom;
}
static void
_gdk_wayland_window_clear_saved_size (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (window->state & (GDK_WINDOW_STATE_FULLSCREEN | GDK_WINDOW_STATE_MAXIMIZED))
return;
impl->saved_width = -1;
impl->saved_height = -1;
}
Revert "docs: Fix broken gtk-doc formatting" This reverts commit a7562dd38fe86cfa26674f22d46fdfe24865ee13. I prefer to not confuse gtk-doc with doc comments for private functions.
2014-08-18 12:17:49 +00:00
/*
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
* gdk_wayland_window_update_size:
Add Wayland backend
2010-12-18 20:38:49 +00:00
* @drawable: a #GdkDrawableImplWayland.
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*
Add Wayland backend
2010-12-18 20:38:49 +00:00
* Updates the state of the drawable (in particular the drawable's
* cairo surface) when its size has changed.
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*/
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
static void
gdk_wayland_window_update_size (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
int32_t width,
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
int32_t height,
int scale)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
Create and attach buffer at process_updates time This way we don't try to show the buffer until we've handle the initial expose.
2011-01-06 21:51:12 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Invalidate window on configure This will trigger a repaint of the window, but it may be more efficient to just copy back the old surface contents and let gtk+ just update the changed parts.
2011-01-07 15:16:17 +00:00
GdkRectangle area;
cairo_region_t *region;
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: avoid dropping surfaces when possible If the configure-event gives us the same size as we had before, which is common for animation resizes, then try to keep the existing buffer around. This saves us a memfd_create() syscall on every frame. https://bugzilla.gnome.org/show_bug.cgi?id=763350
2016-03-17 06:35:20 +00:00
if ((window->width == width) &&
(window->height == height) &&
(impl->scale == scale))
return;
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
drop_cairo_surfaces (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: Fix resizing from other corners than just botton-right
2011-02-11 03:37:51 +00:00
window->width = width;
window->height = height;
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
impl->scale = scale;
wayland: Fix resizing from other corners than just botton-right
2011-02-11 03:37:51 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.egl_window)
wayland: Scale up wl_egl_window according to window scale In order to support window scales for EGL windows, resize the wl_egl_window to the window dimension multiplied with the window scale, just as with SHM window buffers. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 09:20:22 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_egl_window_resize (impl->display_server.egl_window,
wayland: Scale up wl_egl_window according to window scale In order to support window scales for EGL windows, resize the wl_egl_window to the window dimension multiplied with the window scale, just as with SHM window buffers. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 09:20:22 +00:00
width * scale,
height * scale,
0, 0);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_set_buffer_scale (impl->display_server.wl_surface, scale);
wayland: Scale up wl_egl_window according to window scale In order to support window scales for EGL windows, resize the wl_egl_window to the window dimension multiplied with the window scale, just as with SHM window buffers. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 09:20:22 +00:00
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
Invalidate window on configure This will trigger a repaint of the window, but it may be more efficient to just copy back the old surface contents and let gtk+ just update the changed parts.
2011-01-07 15:16:17 +00:00
area.x = 0;
area.y = 0;
area.width = window->width;
area.height = window->height;
region = cairo_region_create_rectangle (&area);
_gdk_window_invalidate_for_expose (window, region);
cairo_region_destroy (region);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
GdkWindow *
_gdk_wayland_screen_create_root_window (GdkScreen *screen,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
int width,
int height)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
GdkWaylandDisplay *display_wayland =
wayland: Don't ever try to set surface buffer scale when not supported If the compositor is too old for handling surface buffer scales, never tyr to set change it. This will effectively always leave it to its initial state, i.e. 1. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 07:00:39 +00:00
GDK_WAYLAND_DISPLAY (gdk_screen_get_display (screen));
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWindow *window;
GdkWindowImplWayland *impl;
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
window = _gdk_display_create_window (GDK_DISPLAY (display_wayland));
Add Wayland backend
2010-12-18 20:38:49 +00:00
window->impl = g_object_new (GDK_TYPE_WINDOW_IMPL_WAYLAND, NULL);
window->impl_window = window;
window->visual = gdk_screen_get_system_visual (screen);
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
impl->wrapper = GDK_WINDOW (window);
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
if (display_wayland->compositor_version >= WL_SURFACE_HAS_BUFFER_SCALE &&
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
gdk_screen_get_n_monitors (screen) > 0)
wayland: Create a cairo surface for the root window Many parts of GTK+ assume that all windows have a cairo surface assoicated with them. This change provides a logically 1x1 cairo surface (respecting scale) for the root window. https://bugzilla.gnome.org/show_bug.cgi?id=704554
2013-07-24 17:30:19 +00:00
impl->scale = gdk_screen_get_monitor_scale_factor (screen, 0);
/* logical 1x1 fake buffer */
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
impl->staging_cairo_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
impl->scale,
impl->scale);
wayland: Create a cairo surface for the root window Many parts of GTK+ assume that all windows have a cairo surface assoicated with them. This change provides a logically 1x1 cairo surface (respecting scale) for the root window. https://bugzilla.gnome.org/show_bug.cgi?id=704554
2013-07-24 17:30:19 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
cairo_surface_set_device_scale (impl->staging_cairo_surface, impl->scale, impl->scale);
Add Wayland backend
2010-12-18 20:38:49 +00:00
window->window_type = GDK_WINDOW_ROOT;
window->depth = 32;
window->x = 0;
window->y = 0;
window->abs_x = 0;
window->abs_y = 0;
window->width = width;
window->height = height;
window->viewable = TRUE;
/* see init_randr_support() in gdkscreen-wayland.c */
window->event_mask = GDK_STRUCTURE_MASK;
return window;
}
static const gchar *
get_default_title (void)
{
const char *title;
title = g_get_application_name ();
if (!title)
title = g_get_prgname ();
if (!title)
title = "";
return title;
}
wayland: when possible, fill in actual and predicted presentation times There is currently no Wayland protocol for providing presentation timestamps or hints about when drawing will be presented onscreen. However, by assuming the straightforward algorithm used by the DRM backend to Weston, we can reverse engineer the right values. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:46:31 +00:00
static void
fill_presentation_time_from_frame_time (GdkFrameTimings *timings,
guint32 frame_time)
{
/* The timestamp in a wayland frame is a msec time value that in some
* way reflects the time at which the server started drawing the frame.
* This is not useful from our perspective.
*
* However, for the DRM backend of Weston, on reasonably recent
* Linux, we know that the time is the
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
* clock_gettime (CLOCK_MONOTONIC) value at the vblank, and that
wayland: when possible, fill in actual and predicted presentation times There is currently no Wayland protocol for providing presentation timestamps or hints about when drawing will be presented onscreen. However, by assuming the straightforward algorithm used by the DRM backend to Weston, we can reverse engineer the right values. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:46:31 +00:00
* backend starts drawing immediately after receiving the vblank
* notification. If we detect this, and make the assumption that the
* compositor will finish drawing before the next vblank, we can
* then determine the presentation time as the frame time we
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
* received plus one refresh interval.
wayland: when possible, fill in actual and predicted presentation times There is currently no Wayland protocol for providing presentation timestamps or hints about when drawing will be presented onscreen. However, by assuming the straightforward algorithm used by the DRM backend to Weston, we can reverse engineer the right values. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:46:31 +00:00
*
* If a backend is using clock_gettime(CLOCK_MONOTONIC), but not
* picking values right at the vblank, then the presentation times
* we compute won't be accurate, but not really worse than then
* the alternative of not providing presentation times at all.
*
* The complexity here is dealing with the fact that we receive
* only the low 32 bits of the CLOCK_MONOTONIC value in milliseconds.
*/
gint64 now_monotonic = g_get_monotonic_time ();
gint64 now_monotonic_msec = now_monotonic / 1000;
uint32_t now_monotonic_low = (uint32_t)now_monotonic_msec;
if (frame_time - now_monotonic_low < 1000 ||
frame_time - now_monotonic_low > (uint32_t)-1000)
{
/* Timestamp we received is within one second of the current time.
*/
gint64 last_frame_time = now_monotonic + (gint64)1000 * (gint32)(frame_time - now_monotonic_low);
if ((gint32)now_monotonic_low < 0 && (gint32)frame_time > 0)
last_frame_time += (gint64)1000 * G_GINT64_CONSTANT(0x100000000);
else if ((gint32)now_monotonic_low > 0 && (gint32)frame_time < 0)
last_frame_time -= (gint64)1000 * G_GINT64_CONSTANT(0x100000000);
timings->presentation_time = last_frame_time + timings->refresh_interval;
}
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
static void
read_back_cairo_surface (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
cairo_t *cr;
cairo_region_t *paint_region = NULL;
if (!impl->backfill_cairo_surface)
goto out;
paint_region = cairo_region_copy (window->clip_region);
cairo_region_subtract (paint_region, impl->staged_updates_region);
if (cairo_region_is_empty (paint_region))
goto out;
cr = cairo_create (impl->staging_cairo_surface);
cairo_set_source_surface (cr, impl->backfill_cairo_surface, 0, 0);
gdk_cairo_region (cr, paint_region);
cairo_clip (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_flush (impl->staging_cairo_surface);
out:
g_clear_pointer (&paint_region, cairo_region_destroy);
g_clear_pointer (&impl->staged_updates_region, cairo_region_destroy);
g_clear_pointer (&impl->backfill_cairo_surface, cairo_surface_destroy);
}
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
static void
frame_callback (void *data,
struct wl_callback *callback,
uint32_t time)
{
GdkWindow *window = data;
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
GdkFrameClock *clock = gdk_window_get_frame_clock (window);
GdkFrameTimings *timings;
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("frame %p", window));
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
wl_callback_destroy (callback);
gdkwindow-wayland: Erm, put the DESTROYED check in the right spot...
2014-01-31 21:39:33 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Thaw the clock if we hide a GdkWindow mid-frame When a window is hidden, its surface and all its roles are destroyed, if this happens when we already issued a wl_surface_commit and are awaiting for a frame callback, the clock will remain frozen for the next time the window is shown. To avoid this, keep track of the wl_surface_frame() calls issued, and ensure the clock is thawed after hiding. If we happen to receive the frame callback, it is just ignored. https://bugzilla.gnome.org/show_bug.cgi?id=743427
2015-02-25 13:46:54 +00:00
if (!impl->awaiting_frame)
return;
impl->awaiting_frame = FALSE;
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
_gdk_frame_clock_thaw (clock);
timings = gdk_frame_clock_get_timings (clock, impl->pending_frame_counter);
impl->pending_frame_counter = 0;
if (timings == NULL)
return;
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
timings->refresh_interval = 16667; /* default to 1/60th of a second */
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.outputs)
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
{
/* We pick a random output out of the outputs that the window touches
* The rate here is in milli-hertz */
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
int refresh_rate =
_gdk_wayland_screen_get_output_refresh_rate (display_wayland->screen,
impl->display_server.outputs->data);
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
if (refresh_rate != 0)
timings->refresh_interval = G_GINT64_CONSTANT(1000000000) / refresh_rate;
}
wayland: when possible, fill in actual and predicted presentation times There is currently no Wayland protocol for providing presentation timestamps or hints about when drawing will be presented onscreen. However, by assuming the straightforward algorithm used by the DRM backend to Weston, we can reverse engineer the right values. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:46:31 +00:00
fill_presentation_time_from_frame_time (timings, time);
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
timings->complete = TRUE;
#ifdef G_ENABLE_DEBUG
if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0)
_gdk_frame_clock_debug_print_timings (clock, timings);
#endif
}
gdkwindow-wayland: Rename listener -> frame_listener Don't pollute the static namespace here.
2014-06-21 21:33:09 +00:00
static const struct wl_callback_listener frame_listener = {
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
frame_callback
};
static void
on_frame_clock_before_paint (GdkFrameClock *clock,
GdkWindow *window)
{
wayland: when possible, fill in actual and predicted presentation times There is currently no Wayland protocol for providing presentation timestamps or hints about when drawing will be presented onscreen. However, by assuming the straightforward algorithm used by the DRM backend to Weston, we can reverse engineer the right values. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:46:31 +00:00
GdkFrameTimings *timings = gdk_frame_clock_get_current_timings (clock);
gint64 presentation_time;
gint64 refresh_interval;
gdk_frame_clock_get_refresh_info (clock,
timings->frame_time,
&refresh_interval, &presentation_time);
if (presentation_time != 0)
{
/* Assume the algorithm used by the DRM backend of Weston - it
* starts drawing at the next vblank after receiving the commit
* for this frame, and presentation occurs at the vblank
* after that.
*/
timings->predicted_presentation_time = presentation_time + refresh_interval;
}
else
{
/* As above, but we don't actually know the phase of the vblank,
* so just assume that we're half way through a refresh cycle.
*/
timings->predicted_presentation_time = timings->frame_time + refresh_interval / 2 + refresh_interval;
}
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
}
static void
on_frame_clock_after_paint (GdkFrameClock *clock,
GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
struct wl_callback *callback;
if (!impl->pending_commit)
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
callback = wl_surface_frame (impl->display_server.wl_surface);
gdkwindow-wayland: Rename listener -> frame_listener Don't pollute the static namespace here.
2014-06-21 21:33:09 +00:00
wl_callback_add_listener (callback, &frame_listener, window);
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
_gdk_frame_clock_freeze (clock);
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
/* Before we commit a new buffer, make sure we've backfilled
* undrawn parts from any old committed buffer
*/
wayland: Handle after-paint invocations when nothing was painted If a after-paint was scheduled but nothing was painted, for example when the it was scheduled by a subsurface wanting to update its position, we'd still try to read back from the backfill cairo surface and update the committed cairo surface reference even though no buffer was attached. Fix this by adding a new state, 'pending_buffer_attached', which is only true if a buffer was attached during frame. Only when this is true will the backfill be read back and the committed cairo surface reference be updated. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 04:41:57 +00:00
if (impl->pending_buffer_attached)
read_back_cairo_surface (window);
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
/* From this commit forward, we can't write to the buffer,
* it's "live". In the future, if we need to stage more changes
* we have to allocate a new staging buffer and draw to it instead.
*
* Our one saving grace is if the compositor releases the buffer
* before we need to stage any changes, then we can take it back and
* use it again.
*/
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_commit (impl->display_server.wl_surface);
wayland: Handle after-paint invocations when nothing was painted If a after-paint was scheduled but nothing was painted, for example when the it was scheduled by a subsurface wanting to update its position, we'd still try to read back from the backfill cairo surface and update the committed cairo surface reference even though no buffer was attached. Fix this by adding a new state, 'pending_buffer_attached', which is only true if a buffer was attached during frame. Only when this is true will the backfill be read back and the committed cairo surface reference be updated. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 04:41:57 +00:00
if (impl->pending_buffer_attached)
impl->committed_cairo_surface = g_steal_pointer (&impl->staging_cairo_surface);
impl->pending_buffer_attached = FALSE;
impl->pending_commit = FALSE;
impl->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
impl->awaiting_frame = TRUE;
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
g_signal_emit (impl, signals[COMMITTED], 0);
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
}
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
static void
window_update_scale (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
guint32 scale;
GSList *l;
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
if (display_wayland->compositor_version < WL_SURFACE_HAS_BUFFER_SCALE)
gdk/wayland: cope with the compositor implementing an older protocol than us If we bind to a global with an higher version than implemented, or we make requests that appeared in a later version, we would get fatal wayland errors. https://bugzilla.gnome.org/show_bug.cgi?id=704104
2013-07-12 14:49:52 +00:00
{
/* We can't set the scale on this surface */
return;
}
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
scale = 1;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
for (l = impl->display_server.outputs; l != NULL; l = l->next)
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
{
guint32 output_scale =
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
_gdk_wayland_screen_get_output_scale (display_wayland->screen, l->data);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
scale = MAX (scale, output_scale);
}
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
/* Notify app that scale changed */
wayland: Do not resize with the same size gnome-control-center is calling gtk_window_resize() on configure-event signals which leads to a busy loop. Avoids such a busy loop by not re-configuring a window with the same size, unless this is coming from and xdg-shell configure. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=764374
2016-04-04 12:55:38 +00:00
gdk_wayland_window_maybe_configure (window, window->width, window->height, scale);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
}
static void
on_monitors_changed (GdkScreen *screen,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *window)
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
{
window_update_scale (window);
}
wayland: Create the Wayland surface for the window on impl creation Ths allows the retrieval of the wl_surface before the window is shown. The surface is still created in the original places since the surface and shell surface is destroyed when the surface is programmatically hidden.
2013-07-03 15:19:39 +00:00
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
static void gdk_wayland_window_create_surface (GdkWindow *window);
wayland: Create the Wayland surface for the window on impl creation Ths allows the retrieval of the wl_surface before the window is shown. The surface is still created in the original places since the surface and shell surface is destroyed when the surface is programmatically hidden.
2013-07-03 15:19:39 +00:00
Add Wayland backend
2010-12-18 20:38:49 +00:00
void
_gdk_wayland_display_create_window_impl (GdkDisplay *display,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *window,
GdkWindow *real_parent,
GdkScreen *screen,
GdkEventMask event_mask,
GdkWindowAttr *attributes,
gint attributes_mask)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWindowImplWayland *impl;
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
GdkFrameClock *frame_clock;
Add Wayland backend
2010-12-18 20:38:49 +00:00
const char *title;
impl = g_object_new (GDK_TYPE_WINDOW_IMPL_WAYLAND, NULL);
window->impl = GDK_WINDOW_IMPL (impl);
impl->wrapper = GDK_WINDOW (window);
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
if (window->width > 65535)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
g_warning ("Native Windows wider than 65535 pixels are not supported");
window->width = 65535;
}
if (window->height > 65535)
{
g_warning ("Native Windows taller than 65535 pixels are not supported");
window->height = 65535;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
Remove copy of grab enum that's now in wayland core
2011-01-06 20:23:52 +00:00
Add Wayland backend
2010-12-18 20:38:49 +00:00
g_object_ref (window);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
/* More likely to be right than just assuming 1 */
wayland: Clean up naming of GdkWaylandDisplay pointers The naming of pointers to GdkWaylandDisplay's were inconsistent. Running the following commands in gtk+/gdk/wayland illustrate the inconsistency: $ grep -r '\<display_wayland\>' *.[ch] | wc -l 195 $ grep -r '\<wayland_display\>' *.[ch] | wc -l 81 This patch renames all occurrences of "wayland_display" to "display_wayland". This is also consistent with naming in the X11 backend. A couple of whitespace changes were done as well in places where the rename was already done, that added line breaks to long lines that stood out. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:16:56 +00:00
if (display_wayland->compositor_version >= WL_SURFACE_HAS_BUFFER_SCALE &&
Avoid a critical under weston The ordering of globals in connection setup under weston is different from mutter, and we end up creating a the dnd window before any outputs are present. Don't cause a critical warning in that case.
2015-05-12 02:13:07 +00:00
gdk_screen_get_n_monitors (screen) > 0)
wayland: Don't ever try to set surface buffer scale when not supported If the compositor is too old for handling surface buffer scales, never tyr to set change it. This will effectively always leave it to its initial state, i.e. 1. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 07:00:39 +00:00
impl->scale = gdk_screen_get_monitor_scale_factor (screen, 0);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
wayland: Set title on shell surfaces to window title We currently use this information to display the title string in the window list of the desktop shell. Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:57:17 +00:00
impl->title = NULL;
Add Wayland backend
2010-12-18 20:38:49 +00:00
switch (GDK_WINDOW_TYPE (window))
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_TEMP:
if (attributes_mask & GDK_WA_TITLE)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
title = attributes->title;
Add Wayland backend
2010-12-18 20:38:49 +00:00
else
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
title = get_default_title ();
Add Wayland backend
2010-12-18 20:38:49 +00:00
gdk_window_set_title (window, title);
break;
case GDK_WINDOW_CHILD:
default:
break;
}
wayland: Create the Wayland surface for the window on impl creation Ths allows the retrieval of the wl_surface before the window is shown. The surface is still created in the original places since the surface and shell surface is destroyed when the surface is programmatically hidden.
2013-07-03 15:19:39 +00:00
gdk_wayland_window_create_surface (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (attributes_mask & GDK_WA_TYPE_HINT)
gdk_window_set_type_hint (window, attributes->type_hint);
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
frame_clock = gdk_window_get_frame_clock (window);
g_signal_connect (frame_clock, "before-paint",
G_CALLBACK (on_frame_clock_before_paint), window);
g_signal_connect (frame_clock, "after-paint",
G_CALLBACK (on_frame_clock_after_paint), window);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
g_signal_connect (screen, "monitors-changed",
G_CALLBACK (on_monitors_changed), window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
Clean up buffer handling a bit
2011-01-08 01:49:40 +00:00
static void
gdk_wayland_window_attach_image (GdkWindow *window)
{
gdk/wayland: cope with the compositor implementing an older protocol than us If we bind to a global with an higher version than implemented, or we make requests that appeared in a later version, we would get fatal wayland errors. https://bugzilla.gnome.org/show_bug.cgi?id=704104
2013-07-12 14:49:52 +00:00
GdkWaylandDisplay *display;
Clean up buffer handling a bit
2011-01-08 01:49:40 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Add Wayland backend
2010-12-18 20:38:49 +00:00
Clean up buffer handling a bit
2011-01-08 01:49:40 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
g_assert (_gdk_wayland_is_shm_surface (impl->staging_cairo_surface));
wayland: Don't allocate a full size SHM buffer when drawing using OpenGL Before this patch, we'd always allocate a full size SHM buffer via the wl_shm_pool, even though it would never be used. Instead allocate a logical 1x1 cairo image surface. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 10:10:07 +00:00
wayland: Add some useful comments explaining the cairo surface behaviour
2012-03-06 21:24:20 +00:00
/* Attach this new buffer to the surface */
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_attach (impl->display_server.wl_surface,
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
_gdk_wayland_shm_surface_get_wl_buffer (impl->staging_cairo_surface),
wayland: Implement DND icon hotspot API In Wayland, the hotspot of a DND icon is set using the buffer offset in wl_buffer.attach. To implement this, add a private API to cause the next wl_surface.attach to offset the new buffer with a given offset. Setting a DND icon hotspot sets this offset while also queuing a redraw of the window to trigger the wl_surface.attach. https://bugzilla.gnome.org/show_bug.cgi?id=759168
2015-12-08 10:19:33 +00:00
impl->pending_buffer_offset_x,
impl->pending_buffer_offset_y);
impl->pending_buffer_offset_x = 0;
impl->pending_buffer_offset_y = 0;
gdk/wayland: cope with the compositor implementing an older protocol than us If we bind to a global with an higher version than implemented, or we make requests that appeared in a later version, we would get fatal wayland errors. https://bugzilla.gnome.org/show_bug.cgi?id=704104
2013-07-12 14:49:52 +00:00
/* Only set the buffer scale if supported by the compositor */
display = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
if (display->compositor_version >= WL_SURFACE_HAS_BUFFER_SCALE)
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_set_buffer_scale (impl->display_server.wl_surface, impl->scale);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
wayland: Handle after-paint invocations when nothing was painted If a after-paint was scheduled but nothing was painted, for example when the it was scheduled by a subsurface wanting to update its position, we'd still try to read back from the backfill cairo surface and update the committed cairo surface reference even though no buffer was attached. Fix this by adding a new state, 'pending_buffer_attached', which is only true if a buffer was attached during frame. Only when this is true will the backfill be read back and the committed cairo surface reference be updated. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 04:41:57 +00:00
impl->pending_buffer_attached = TRUE;
GdkWaylandWindow: synchronize frame drawing Use wl_surface_frame() to get notification when the compositor paints a frame, and use this to throttle drawing to the compositor's refresh cycle. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:14:22 +00:00
impl->pending_commit = TRUE;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
static const cairo_user_data_key_t gdk_wayland_window_cairo_key;
wayland: don't handle buffer release centrally Right now we handle buffer releases coming from the compositor in a central place. We add a listener when first creating the shared buffers. This is problematic because a buffer can only have one listener on it at once so users of the buffer can't get notified when it's released. This commit moves the buffer listener code from the centrally managed display code to the cursor and window code. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 19:36:25 +00:00
static void
buffer_release_callback (void *_data,
struct wl_buffer *wl_buffer)
{
cairo_surface_t *cairo_surface = _data;
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
GdkWindowImplWayland *impl = cairo_surface_get_user_data (cairo_surface, &gdk_wayland_window_cairo_key);
g_return_if_fail (GDK_IS_WINDOW_IMPL_WAYLAND (impl));
/* The released buffer isn't the latest committed one, we have no further
* use for it, so clean it up.
*/
if (impl->committed_cairo_surface != cairo_surface)
{
/* If this fails, then the surface buffer got reused before it was
* released from the compositor
*/
g_warn_if_fail (impl->staging_cairo_surface != cairo_surface);
cairo_surface_destroy (cairo_surface);
return;
}
wayland: deal with staging buffer getting allocated prematurely The staging buffer gets allocated any time begin_paint is called on the window. This can happen even with an empty paint region, so we should cope with that situation. At the moment we crash trying to post a runtime warning. https://bugzilla.gnome.org/show_bug.cgi?id=762755
2016-02-27 21:17:38 +00:00
if (impl->staged_updates_region != NULL)
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
{
wayland: deal with staging buffer getting allocated prematurely The staging buffer gets allocated any time begin_paint is called on the window. This can happen even with an empty paint region, so we should cope with that situation. At the moment we crash trying to post a runtime warning. https://bugzilla.gnome.org/show_bug.cgi?id=762755
2016-02-27 21:17:38 +00:00
/* If this fails, then we're tracking staged updates on a staging surface
* that doesn't exist.
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
*/
wayland: deal with staging buffer getting allocated prematurely The staging buffer gets allocated any time begin_paint is called on the window. This can happen even with an empty paint region, so we should cope with that situation. At the moment we crash trying to post a runtime warning. https://bugzilla.gnome.org/show_bug.cgi?id=762755
2016-02-27 21:17:38 +00:00
g_warn_if_fail (impl->staging_cairo_surface != NULL);
/* If we've staged updates into a new buffer before the release for this
* buffer came in, then we can't reuse this buffer, so unref it. It may still
* be alive as a readback buffer though (via impl->backfill_cairo_surface).
*
* It's possible a staging surface was allocated but no updates were staged.
* If that happened, clean up that staging surface now, since the old commit
* buffer is available again, and reusing the old commit buffer for future
* updates will save having to do a read back later.
*/
if (!cairo_region_is_empty (impl->staged_updates_region))
{
g_clear_pointer (&impl->committed_cairo_surface, cairo_surface_destroy);
return;
}
else
{
g_clear_pointer (&impl->staged_updates_region, cairo_region_destroy);
g_clear_pointer (&impl->staging_cairo_surface, cairo_surface_destroy);
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
}
wayland: don't handle buffer release centrally Right now we handle buffer releases coming from the compositor in a central place. We add a listener when first creating the shared buffers. This is problematic because a buffer can only have one listener on it at once so users of the buffer can't get notified when it's released. This commit moves the buffer listener code from the centrally managed display code to the cursor and window code. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 19:36:25 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
/* Release came in, we haven't done any interim updates, so we can just use
* the old committed buffer again.
*/
impl->staging_cairo_surface = g_steal_pointer (&impl->committed_cairo_surface);
wayland: don't handle buffer release centrally Right now we handle buffer releases coming from the compositor in a central place. We add a listener when first creating the shared buffers. This is problematic because a buffer can only have one listener on it at once so users of the buffer can't get notified when it's released. This commit moves the buffer listener code from the centrally managed display code to the cursor and window code. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 19:36:25 +00:00
}
static const struct wl_buffer_listener buffer_listener = {
buffer_release_callback
};
GdkWindowWayland: make sure we attach the surface when repainting Lazily creating the cairo surface that backs a window when we first paint to it means that the call to gdk_wayland_window_attach_image() in gdk_wayland_window_process_updates_recurse() wasn't working the first time a window was painted. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:00:41 +00:00
static void
gdk_wayland_window_ensure_cairo_surface (GdkWindow *window)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Don't allocate a full size SHM buffer when drawing using OpenGL Before this patch, we'd always allocate a full size SHM buffer via the wl_shm_pool, even though it would never be used. Instead allocate a logical 1x1 cairo image surface. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 10:10:07 +00:00
/* If we are drawing using OpenGL then we only need a logical 1x1 surface. */
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.egl_window)
wayland: Don't allocate a full size SHM buffer when drawing using OpenGL Before this patch, we'd always allocate a full size SHM buffer via the wl_shm_pool, even though it would never be used. Instead allocate a logical 1x1 cairo image surface. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 10:10:07 +00:00
{
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
if (impl->staging_cairo_surface &&
_gdk_wayland_is_shm_surface (impl->staging_cairo_surface))
cairo_surface_destroy (impl->staging_cairo_surface);
impl->staging_cairo_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
impl->scale,
impl->scale);
cairo_surface_set_device_scale (impl->staging_cairo_surface,
wayland: Don't allocate a full size SHM buffer when drawing using OpenGL Before this patch, we'd always allocate a full size SHM buffer via the wl_shm_pool, even though it would never be used. Instead allocate a logical 1x1 cairo image surface. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 10:10:07 +00:00
impl->scale, impl->scale);
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
else if (!impl->staging_cairo_surface)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Merge buffer implementations
2014-02-23 18:57:24 +00:00
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_window_get_display (impl->wrapper));
wayland: don't handle buffer release centrally Right now we handle buffer releases coming from the compositor in a central place. We add a listener when first creating the shared buffers. This is problematic because a buffer can only have one listener on it at once so users of the buffer can't get notified when it's released. This commit moves the buffer listener code from the centrally managed display code to the cursor and window code. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 19:36:25 +00:00
struct wl_buffer *buffer;
wayland: Merge buffer implementations
2014-02-23 18:57:24 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
impl->staging_cairo_surface = _gdk_wayland_display_create_shm_surface (display_wayland,
impl->wrapper->width,
impl->wrapper->height,
impl->scale);
cairo_surface_set_user_data (impl->staging_cairo_surface,
&gdk_wayland_window_cairo_key,
g_object_ref (impl),
(cairo_destroy_func_t)
g_object_unref);
buffer = _gdk_wayland_shm_surface_get_wl_buffer (impl->staging_cairo_surface);
wl_buffer_add_listener (buffer, &buffer_listener, impl->staging_cairo_surface);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
GdkWindowWayland: make sure we attach the surface when repainting Lazily creating the cairo surface that backs a window when we first paint to it means that the call to gdk_wayland_window_attach_image() in gdk_wayland_window_process_updates_recurse() wasn't working the first time a window was painted. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:00:41 +00:00
}
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
/* The cairo surface returned here uses a memory segment that's shared
* with the display server. This is not a temporary buffer that gets
* copied to the display server, but the actual buffer the display server
* will ultimately end up sending to the GPU. At the time this happens
* impl->committed_cairo_surface gets set to impl->staging_cairo_surface, and
* impl->staging_cairo_surface gets nullified.
GdkWindowWayland: make sure we attach the surface when repainting Lazily creating the cairo surface that backs a window when we first paint to it means that the call to gdk_wayland_window_attach_image() in gdk_wayland_window_process_updates_recurse() wasn't working the first time a window was painted. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-24 22:00:41 +00:00
*/
static cairo_surface_t *
gdk_wayland_window_ref_cairo_surface (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (GDK_WINDOW_DESTROYED (impl->wrapper))
return NULL;
gdk_wayland_window_ensure_cairo_surface (window);
Clean up buffer handling a bit
2011-01-08 01:49:40 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
cairo_surface_reference (impl->staging_cairo_surface);
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
return impl->staging_cairo_surface;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Add custom create_similar_image implementation The fallback method is used on other backends, but it caused problems for wayland when it tried to create a surface for the root window.
2013-07-03 14:03:25 +00:00
static cairo_surface_t *
gdk_wayland_window_create_similar_image_surface (GdkWindow * window,
cairo_format_t format,
int width,
int height)
{
return cairo_image_surface_create (format, width, height);
}
wayland: Move the finalize function to allow a clear logical block of code
2012-04-04 13:05:27 +00:00
wayland: Don't use double buffers for wayland when not needed If we got the release event for the last buffer then we're fine with writing directly to the window surface, as wayland will not be looing at it. This saves us from allocating and copying more data.
2013-04-29 19:49:12 +00:00
static gboolean
gdkwindow: Don't pass the region to the impl when beginning a paint It's unused. At the same time, rename "begin_paint_region" to "begin_paint". This will help us clean up how GDK painting works in the future to allow more creative use of double-buffering.
2014-11-22 16:08:34 +00:00
gdk_window_impl_wayland_begin_paint (GdkWindow *window)
wayland: Don't use double buffers for wayland when not needed If we got the release event for the last buffer then we're fine with writing directly to the window surface, as wayland will not be looing at it. This saves us from allocating and copying more data.
2013-04-29 19:49:12 +00:00
{
gdk_wayland_window_ensure_cairo_surface (window);
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
wayland: always return FALSE from begin_paint The client and compositor share access to the window pixel buffers. After the client hands off (commits) the buffer to the compositor it's not supposed to write to it again until it's released by the compositor. The code tries to deal with this contention by allocating a temporary buffer and using that in the mean time. This temporary buffer is allocated by a higher layer of the code when begin_paint returns TRUE. Unfortunately, that layer of the code has no idea when the buffer is released, so it ends up blitting the temporary buffer back to the shared buffer prematurely. This commit changes begin_paint to always return FALSE. A future commit will address the contention problem in a different way. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 17:20:22 +00:00
return FALSE;
wayland: Don't use double buffers for wayland when not needed If we got the release event for the last buffer then we're fine with writing directly to the window surface, as wayland will not be looing at it. This saves us from allocating and copying more data.
2013-04-29 19:49:12 +00:00
}
gdkwindow-wayland: Attach new buffers and submit damage in end_paint process_updates_recurse is simply the wrong place for it to be.
2014-06-21 21:29:08 +00:00
static void
gdk_window_impl_wayland_end_paint (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
cairo_rectangle_int_t rect;
int i, n;
wayland: Only attach the buffer if there was damage There is no point in attaching and then committing the same buffer if there was no damage. This will also make us do less unnecessary backfill read backs, for the cases where we paint with an empty paint region. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 05:05:25 +00:00
if (!window->current_paint.use_gl &&
!cairo_region_is_empty (window->current_paint.region))
gdkwindow-wayland: Attach new buffers and submit damage in end_paint process_updates_recurse is simply the wrong place for it to be.
2014-06-21 21:29:08 +00:00
{
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
gdk_wayland_window_attach_image (window);
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
/* If there's a committed buffer pending, then track which
* updates are staged until the next frame, so we can back
* fill the unstaged parts of the staging buffer with the
* last frame.
*/
if (impl->committed_cairo_surface != NULL)
{
if (impl->staged_updates_region == NULL)
{
impl->staged_updates_region = cairo_region_copy (window->current_paint.region);
impl->backfill_cairo_surface = cairo_surface_reference (impl->committed_cairo_surface);
}
else
{
cairo_region_union (impl->staged_updates_region, window->current_paint.region);
}
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
n = cairo_region_num_rectangles (window->current_paint.region);
for (i = 0; i < n; i++)
{
cairo_region_get_rectangle (window->current_paint.region, i, &rect);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_damage (impl->display_server.wl_surface, rect.x, rect.y, rect.width, rect.height);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
wayland: Only attach the buffer if there was damage There is no point in attaching and then committing the same buffer if there was no damage. This will also make us do less unnecessary backfill read backs, for the cases where we paint with an empty paint region. https://bugzilla.gnome.org/show_bug.cgi?id=762120
2016-02-16 05:05:25 +00:00
impl->pending_commit = TRUE;
gdkwindow-wayland: Attach new buffers and submit damage in end_paint process_updates_recurse is simply the wrong place for it to be.
2014-06-21 21:29:08 +00:00
}
}
wayland: Add system bell support via gtk_shell Invoke the system bell by calling the request added to the gtk_shell protocol. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 04:41:31 +00:00
static gboolean
gdk_window_impl_wayland_beep (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
if (!display_wayland->gtk_shell)
return FALSE;
gtk_shell1_system_bell (display_wayland->gtk_shell,
impl->display_server.gtk_surface);
return TRUE;
}
wayland: Move the finalize function to allow a clear logical block of code
2012-04-04 13:05:27 +00:00
static void
gdk_window_impl_wayland_finalize (GObject *object)
{
GdkWindowImplWayland *impl;
g_return_if_fail (GDK_IS_WINDOW_IMPL_WAYLAND (object));
impl = GDK_WINDOW_IMPL_WAYLAND (object);
GdkWaylandWindow: Fix memory leak https://bugzilla.gnome.org/show_bug.cgi?id=706493
2013-08-21 11:09:29 +00:00
g_free (impl->title);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
g_free (impl->application.application_id);
g_free (impl->application.app_menu_path);
g_free (impl->application.menubar_path);
g_free (impl->application.window_object_path);
g_free (impl->application.application_object_path);
g_free (impl->application.unique_bus_name);
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
g_clear_pointer (&impl->opaque_region, cairo_region_destroy);
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
g_clear_pointer (&impl->input_region, cairo_region_destroy);
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
g_clear_pointer (&impl->staged_updates_region, cairo_region_destroy);
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
wayland: Move the finalize function to allow a clear logical block of code
2012-04-04 13:05:27 +00:00
G_OBJECT_CLASS (_gdk_window_impl_wayland_parent_class)->finalize (object);
}
wayland: Fix return type from gdk_wayland_window_configure() Should be void. Copy and paste error.
2012-01-30 14:04:45 +00:00
static void
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
gdk_wayland_window_configure (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
int width,
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
int height,
int scale)
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
{
GdkDisplay *display;
GdkEvent *event;
event = gdk_event_new (GDK_CONFIGURE);
gdkwindow-wayland: Pair a ref with its owner
2014-06-19 18:33:35 +00:00
event->configure.window = g_object_ref (window);
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
event->configure.send_event = FALSE;
event->configure.width = width;
event->configure.height = height;
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
gdk_wayland_window_update_size (window, width, height, scale);
wayland: ensure the clip region is updated after the window size is updated https://bugzilla.gnome.org/show_bug.cgi?id=700301
2013-05-14 14:25:30 +00:00
_gdk_window_update_size (window);
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
gdkwindow-wayland: Another slight rearrange
2014-06-19 18:34:22 +00:00
display = gdk_window_get_display (window);
wayland: Also synthesize a configure event from gdk_window_wayland_move_resize
2012-01-29 12:15:12 +00:00
_gdk_wayland_display_deliver_event (display, event);
}
wayland: Do not resize with the same size gnome-control-center is calling gtk_window_resize() on configure-event signals which leads to a busy loop. Avoids such a busy loop by not re-configuring a window with the same size, unless this is coming from and xdg-shell configure. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=764374
2016-04-04 12:55:38 +00:00
static void
gdk_wayland_window_maybe_configure (GdkWindow *window,
int width,
int height,
int scale)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (window->width == width &&
window->height == height &&
impl->scale == scale)
return;
gdk_wayland_window_configure (window, width, height, scale);
}
wayland: Map transient surfaces as such
2011-02-11 22:20:14 +00:00
static void
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
gdk_wayland_window_sync_parent (GdkWindow *window,
GdkWindow *parent)
wayland: Map transient surfaces as such
2011-02-11 22:20:14 +00:00
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
GdkWindowImplWayland *impl_parent = NULL;
wayland: Update to xdg-shell unstable v5 Only trivial changes needed. https://bugzilla.gnome.org/show_bug.cgi?id=744455
2015-02-13 06:17:49 +00:00
struct xdg_surface *parent_surface;
wayland: wl_shell_surface_set_popup requires a valid seat and serial If we don't have our own grab then get the grab from the parent.
2012-07-11 18:18:37 +00:00
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
g_assert (parent == NULL ||
gdk_window_get_display (window) == gdk_window_get_display (parent));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
return;
wayland: set the "transient inactive" flag on tooltip surfaces This prevents the tooltip surfaces from taking the focus away from the parent surface. https://bugzilla.gnome.org/show_bug.cgi?id=693313
2013-02-07 11:27:25 +00:00
wayland: Fix invalid cast in transient_for
2013-11-19 17:36:12 +00:00
if (impl->transient_for)
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
impl_parent = GDK_WINDOW_IMPL_WAYLAND (impl->transient_for->impl);
else if (parent)
impl_parent = GDK_WINDOW_IMPL_WAYLAND (parent->impl);
wayland: Fix invalid cast in transient_for
2013-11-19 17:36:12 +00:00
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (impl_parent)
{
wayland: Fix invalid cast in transient_for
2013-11-19 17:36:12 +00:00
/* XXX: Is this correct? */
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl_parent->display_server.wl_surface)
wayland: Fix invalid cast in transient_for
2013-11-19 17:36:12 +00:00
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
parent_surface = impl_parent->display_server.xdg_surface;
wayland: Fix invalid cast in transient_for
2013-11-19 17:36:12 +00:00
}
else
wayland: set_transient_for was renamed to set_parent
2014-04-11 23:55:37 +00:00
parent_surface = NULL;
wayland: set the "transient inactive" flag on tooltip surfaces This prevents the tooltip surfaces from taking the focus away from the parent surface. https://bugzilla.gnome.org/show_bug.cgi?id=693313
2013-02-07 11:27:25 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_parent (impl->display_server.xdg_surface, parent_surface);
wayland: Map transient surfaces as such
2011-02-11 22:20:14 +00:00
}
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
static void
gdk_wayland_window_update_dialogs (GdkWindow *window)
{
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
GList *l;
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
if (!display_wayland->orphan_dialogs)
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
return;
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
for (l = display_wayland->orphan_dialogs; l; l = l->next)
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
{
GdkWindow *w = l->data;
wayland: Check actual impl type in transient loop If the parent of a transient is not a native Wayland window (e.g. offscreen window), the transient loop check will crash. Check for the actual type in the transient loop check and do not assume the parent is necessarily Wayland native. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=761156 Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
2016-02-29 09:14:56 +00:00
GdkWindowImplWayland *impl;
if (!GDK_IS_WINDOW_IMPL_WAYLAND(w->impl))
continue;
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
wayland: Check actual impl type in transient loop If the parent of a transient is not a native Wayland window (e.g. offscreen window), the transient loop check will crash. Check for the actual type in the transient loop check and do not assume the parent is necessarily Wayland native. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=761156 Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
2016-02-29 09:14:56 +00:00
impl = GDK_WINDOW_IMPL_WAYLAND (w->impl);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (w == window)
continue;
if (impl->hint != GDK_WINDOW_TYPE_HINT_DIALOG)
continue;
if (impl->transient_for)
continue;
/* Update the parent relationship only for dialogs without transients */
gdk_wayland_window_sync_parent (w, window);
}
}
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
static void
gdk_wayland_window_sync_title (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
return;
if (!impl->title)
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_title (impl->display_server.xdg_surface, impl->title);
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
}
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
static void
gdk_wayland_window_sync_margin (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
gint x, y, width, height;
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
return;
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
x = impl->margin_left;
y = impl->margin_top;
width = window->width - (impl->margin_left + impl->margin_right);
height = window->height - (impl->margin_top + impl->margin_bottom);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_window_geometry (impl->display_server.xdg_surface, x, y, width, height);
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
}
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
static struct wl_region *
wl_region_from_cairo_region (GdkWaylandDisplay *display,
cairo_region_t *region)
{
struct wl_region *wl_region;
int i, n_rects;
wl_region = wl_compositor_create_region (display->compositor);
if (wl_region == NULL)
return NULL;
n_rects = cairo_region_num_rectangles (region);
for (i = 0; i < n_rects; i++)
{
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (region, i, &rect);
wl_region_add (wl_region, rect.x, rect.y, rect.width, rect.height);
}
return wl_region;
}
static void
gdk_wayland_window_sync_opaque_region (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
struct wl_region *wl_region = NULL;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
return;
if (impl->opaque_region != NULL)
wl_region = wl_region_from_cairo_region (GDK_WAYLAND_DISPLAY (gdk_window_get_display (window)),
impl->opaque_region);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_set_opaque_region (impl->display_server.wl_surface, wl_region);
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
if (wl_region != NULL)
wl_region_destroy (wl_region);
}
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
static void
gdk_wayland_window_sync_input_region (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
struct wl_region *wl_region = NULL;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
return;
if (impl->input_region != NULL)
wl_region = wl_region_from_cairo_region (GDK_WAYLAND_DISPLAY (gdk_window_get_display (window)),
impl->input_region);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_set_input_region (impl->display_server.wl_surface, wl_region);
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
if (wl_region != NULL)
wl_region_destroy (wl_region);
}
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
surface_enter (void *data,
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
struct wl_surface *wl_surface,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
struct wl_output *output)
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
{
GdkWindow *window = GDK_WINDOW (data);
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("surface enter, window %p output %p", window, output));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.outputs = g_slist_prepend (impl->display_server.outputs, output);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
window_update_scale (window);
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
surface_leave (void *data,
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
struct wl_surface *wl_surface,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
struct wl_output *output)
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
{
GdkWindow *window = GDK_WINDOW (data);
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("surface leave, window %p output %p", window, output));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.outputs = g_slist_remove (impl->display_server.outputs, output);
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
window_update_scale (window);
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
}
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static const struct wl_surface_listener surface_listener = {
surface_enter,
surface_leave
};
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
static void
on_parent_surface_committed (GdkWindowImplWayland *parent_impl,
GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
g_signal_handlers_disconnect_by_func (parent_impl,
(gpointer) on_parent_surface_committed,
window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_subsurface_set_desync (impl->display_server.wl_subsurface);
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
}
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
static void
gdk_wayland_window_create_subsurface (GdkWindow *window)
{
GdkWindowImplWayland *impl, *parent_impl = NULL;
GdkWaylandDisplay *display_wayland;
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
return; /* Bail out, surface and subsurface will be created later when shown */
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.wl_subsurface)
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
return;
if (impl->transient_for)
parent_impl = GDK_WINDOW_IMPL_WAYLAND (impl->transient_for->impl);
if (parent_impl)
{
display_wayland = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.wl_subsurface =
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
wl_subcompositor_get_subsurface (display_wayland->subcompositor,
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.wl_surface, parent_impl->display_server.wl_surface);
wl_subsurface_set_position (impl->display_server.wl_subsurface, window->x, window->y);
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
/* In order to synchronize the initial position with the initial frame
* content, wait with making the subsurface desynchronized until after
* the parent was committed.
*/
g_signal_connect_object (parent_impl, "committed",
G_CALLBACK (on_parent_surface_committed),
window, 0);
wayland: Always request transient commit when mapping subsurface A subsurface positioning operation only takes effect when the parent surfaces state is applied. If a subsurface is mapped and positioned, but the parent surface state is not immediately committed, the relative position of the subsurface is undefined and may be placed incorrectly. To avoid this undefined state, always request that the parent surface should be committed after mapping a subsurface so that the position operation will take effect. https://bugzilla.gnome.org/show_bug.cgi?id=751098
2015-06-17 09:31:19 +00:00
gdk_window_request_transient_parent_commit (window);
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
}
}
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static void
gdk_wayland_window_create_surface (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.wl_surface = wl_compositor_create_surface (display_wayland->compositor);
wl_surface_add_listener (impl->display_server.wl_surface, &surface_listener, window);
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
gdk_wayland_window_sync_opaque_region (window);
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
gdk_wayland_window_sync_input_region (window);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static void
xdg_surface_configure (void *data,
struct xdg_surface *xdg_surface,
int32_t width,
wayland: Update to latest xdg-shell protocol
2014-04-12 00:31:27 +00:00
int32_t height,
struct wl_array *states,
uint32_t serial)
wayland: Port from wl_shell to wl_surface_shell Previously all the commands that acted on the shell took the surface that was to be acted on as parameter. Now we retrieve an object from the shell that represents its state for the surface. With that wl_shell_surface object we can then call methods on that. Signed-off-by: Kristian Høgsberg <krh@bitplanet.net>
2011-12-05 15:55:37 +00:00
{
GdkWindow *window = GDK_WINDOW (data);
wayland: Constrain the window configure requests to the window's geometry When we receive a configure event from Wayland telling us to resize our surface we check against the geometry constraints for the window to ensure we do not resize below the minimum and maximum limits.
2012-01-09 17:15:00 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Update to latest xdg-shell protocol
2014-04-12 00:31:27 +00:00
GdkWindowState new_state = 0;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
gboolean maximized_or_fullscreen;
wayland: Update to latest xdg-shell protocol
2014-04-12 00:31:27 +00:00
uint32_t *p;
wayland: Port from wl_shell to wl_surface_shell Previously all the commands that acted on the shell took the surface that was to be acted on as parameter. Now we retrieve an object from the shell that represents its state for the surface. With that wl_shell_surface object we can then call methods on that. Signed-off-by: Kristian Høgsberg <krh@bitplanet.net>
2011-12-05 15:55:37 +00:00
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
wl_array_for_each (p, states)
wayland: Update to latest xdg-shell protocol
2014-04-12 00:31:27 +00:00
{
uint32_t state = *p;
switch (state)
{
case XDG_SURFACE_STATE_FULLSCREEN:
new_state |= GDK_WINDOW_STATE_FULLSCREEN;
break;
case XDG_SURFACE_STATE_MAXIMIZED:
new_state |= GDK_WINDOW_STATE_MAXIMIZED;
break;
case XDG_SURFACE_STATE_ACTIVATED:
new_state |= GDK_WINDOW_STATE_FOCUSED;
break;
case XDG_SURFACE_STATE_RESIZING:
break;
default:
/* Unknown state */
break;
}
}
gdkwindow-wayland: Make function order match listener order
2014-02-06 19:28:51 +00:00
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
maximized_or_fullscreen =
new_state & (GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN);
/* According to xdg_shell, an xdg_surface.configure with size 0x0
* should be interpreted as that it is up to the client to set a
* size.
*
* When transitioning from maximize or fullscreen state, this means
* the client should configure its size back to what it was before
* being maximize or fullscreen.
*/
if (width == 0 && height == 0 && !maximized_or_fullscreen)
{
width = impl->saved_width;
height = impl->saved_height;
}
ignore size inc when maximized/fullscreen Under Wayland, fullscreen/maximized windows may not cover the entire area when a size increment is specified. Ignore size increments for fullscreen/maximized windows just like most window managers do under X11 so that windows with size increments can still be fullscreen or fully maximized under Wayland as well. https://bugzilla.gnome.org/show_bug.cgi?id=751368
2015-06-23 09:54:48 +00:00
if (width > 0 && height > 0)
{
GdkWindowHints geometry_mask = impl->geometry_mask;
/* Ignore size increments for maximized/fullscreen windows */
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
if (maximized_or_fullscreen)
ignore size inc when maximized/fullscreen Under Wayland, fullscreen/maximized windows may not cover the entire area when a size increment is specified. Ignore size increments for fullscreen/maximized windows just like most window managers do under X11 so that windows with size increments can still be fullscreen or fully maximized under Wayland as well. https://bugzilla.gnome.org/show_bug.cgi?id=751368
2015-06-23 09:54:48 +00:00
geometry_mask &= ~GDK_HINT_RESIZE_INC;
gdk_window_constrain_size (&impl->geometry_hints,
geometry_mask,
width + impl->margin_left + impl->margin_right,
height + impl->margin_top + impl->margin_bottom,
&width,
&height);
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
/* Save size for next time we get 0x0 */
_gdk_wayland_window_save_size (window);
ignore size inc when maximized/fullscreen Under Wayland, fullscreen/maximized windows may not cover the entire area when a size increment is specified. Ignore size increments for fullscreen/maximized windows just like most window managers do under X11 so that windows with size increments can still be fullscreen or fully maximized under Wayland as well. https://bugzilla.gnome.org/show_bug.cgi?id=751368
2015-06-23 09:54:48 +00:00
gdk_wayland_window_configure (window, width, height, impl->scale);
}
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("configure, window %p %dx%d,%s%s%s",
window, width, height,
(new_state & GDK_WINDOW_STATE_FULLSCREEN) ? " fullscreen" : "",
(new_state & GDK_WINDOW_STATE_MAXIMIZED) ? " maximized" : "",
(new_state & GDK_WINDOW_STATE_FOCUSED) ? " focused" : ""));
wayland: Update to latest xdg-shell protocol
2014-04-12 00:31:27 +00:00
_gdk_set_window_state (window, new_state);
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
gdk_wayland_window_sync_margin (window);
wayland: Ack the configure immediately
2014-05-13 20:21:11 +00:00
xdg_surface_ack_configure (xdg_surface, serial);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (impl->hint != GDK_WINDOW_TYPE_HINT_DIALOG &&
new_state & GDK_WINDOW_STATE_FOCUSED)
gdk_wayland_window_update_dialogs (window);
gdkwindow-wayland: Make function order match listener order
2014-02-06 19:28:51 +00:00
}
wayland: Add support for delete event
2014-02-07 22:16:40 +00:00
static void
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
xdg_surface_close (void *data,
wayland: The xdg_surface.delete event was renamed to close
2014-04-17 17:14:44 +00:00
struct xdg_surface *xdg_surface)
wayland: Add support for delete event
2014-02-07 22:16:40 +00:00
{
GdkWindow *window = GDK_WINDOW (data);
GdkDisplay *display;
GdkEvent *event;
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("close %p", window));
wayland: Add support for delete event
2014-02-07 22:16:40 +00:00
event = gdk_event_new (GDK_DELETE);
gdkwindow-wayland: Add a forgotten ref
2014-06-19 18:55:04 +00:00
event->any.window = g_object_ref (window);
wayland: Add support for delete event
2014-02-07 22:16:40 +00:00
event->any.send_event = TRUE;
gdkwindow-wayland: Another slight rearrange
2014-06-19 18:34:22 +00:00
display = gdk_window_get_display (window);
wayland: Add support for delete event
2014-02-07 22:16:40 +00:00
_gdk_wayland_display_deliver_event (display, event);
}
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static const struct xdg_surface_listener xdg_surface_listener = {
xdg_surface_configure,
wayland: The xdg_surface.delete event was renamed to close
2014-04-17 17:14:44 +00:00
xdg_surface_close,
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
};
wayland: Protocol change: ping event on shell_surface
2012-07-11 13:15:04 +00:00
static void
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
gdk_wayland_window_create_xdg_surface (GdkWindow *window)
wayland: Protocol change: ping event on shell_surface
2012-07-11 13:15:04 +00:00
{
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
const gchar *app_id;
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
GdkScreen *screen = gdk_window_get_screen (window);
struct wl_output *fullscreen_output = NULL;
wayland: Fix initial fullscreen monitor support -1 means that we have no specific preference for an initial fullscreen monitor, and -1 is less than the number of monitors, so we would end up accessing invalid memory. Prevent that. https://bugzilla.gnome.org/show_bug.cgi?id=752875
2015-07-26 00:22:41 +00:00
if (impl->initial_fullscreen_monitor >= 0 &&
impl->initial_fullscreen_monitor < gdk_screen_get_n_monitors (screen))
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
fullscreen_output = _gdk_wayland_screen_get_wl_output (screen, impl->initial_fullscreen_monitor);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.xdg_surface = xdg_shell_get_xdg_surface (display_wayland->xdg_shell, impl->display_server.wl_surface);
xdg_surface_add_listener (impl->display_server.xdg_surface, &xdg_surface_listener, window);
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
gdk_wayland_window_sync_parent (window, NULL);
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
gdk_wayland_window_sync_title (window);
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
gdk_wayland_window_sync_margin (window);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
if (window->state & GDK_WINDOW_STATE_MAXIMIZED)
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_maximized (impl->display_server.xdg_surface);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
if (window->state & GDK_WINDOW_STATE_FULLSCREEN)
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_fullscreen (impl->display_server.xdg_surface, fullscreen_output);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
wayland: Use g_get_prgname() to get the xdg_surface.set_app_id string Prior to this patch, the ID of the GtkApplication was always used for clients which were GtkApplications. This would only be guaranteed to be correct for D-Bus activatable programs. As a result, all non-D-Bus-activatable applications would set the wrong ID making the shell unable to find the corresponding .desktop file. This change makes it so that the GDK backend always uses the name passed to g_set_prgname, or the default value if not explicitly set, as this more often corresponds to the .desktop file. This means that in order to make D-Bus activatable applications set the correct application ID, they must, for now, manually call g_set_prgname() with their application ID (basename of the .desktop file). If g_get_prgname() returns NULL, fallback to gdk_get_program_class() even though it will most likely never be correct according to the xdg_surface.set_app_id specification. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-08-18 00:38:07 +00:00
app_id = g_get_prgname ();
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
if (app_id == NULL)
app_id = gdk_get_program_class ();
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_app_id (impl->display_server.xdg_surface, app_id);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
maybe_set_gtk_surface_dbus_properties (window);
wayland: Ensure modal hint gets set on map We need to be mapped to have a gtk_surface and thus be able to do requests on it so we need to save the modal hint and apply it when we get mapped so that code that sets the hint before showing a window doesn't get ignored. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:03:49 +00:00
maybe_set_gtk_surface_modal (window);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (impl->hint == GDK_WINDOW_TYPE_HINT_DIALOG)
_gdk_wayland_screen_add_orphan_dialog (window);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
wayland: Save the serial number for the ping event
2012-07-11 16:09:23 +00:00
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static void
xdg_popup_done (void *data,
wayland: Update to xdg-shell unstable v5 Only trivial changes needed. https://bugzilla.gnome.org/show_bug.cgi?id=744455
2015-02-13 06:17:49 +00:00
struct xdg_popup *xdg_popup)
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
{
GdkWindow *window = GDK_WINDOW (data);
wayland: Add debug spew
2015-02-28 05:15:13 +00:00
GDK_NOTE (EVENTS,
g_message ("done %p", window));
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
gdk_window_hide (window);
}
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static const struct xdg_popup_listener xdg_popup_listener = {
xdg_popup_done,
wayland: Port from wl_shell to wl_surface_shell Previously all the commands that acted on the shell took the surface that was to be acted on as parameter. Now we retrieve an object from the shell that represents its state for the surface. With that wl_shell_surface object we can then call methods on that. Signed-off-by: Kristian Høgsberg <krh@bitplanet.net>
2011-12-05 15:55:37 +00:00
};
wayland: Add a giant doc comment explaining "fake root" coordinate space
2014-03-17 19:25:23 +00:00
/**
* gdk_wayland_window_get_fake_root_coords:
* @window: A #GdkWindow
* @x_out: (out): The X offset of this window
* @y_out: (out): The Y offset of this window
*
* Wayland does not have a global coordinate space shared between
* surfaces. In fact, for regular toplevels, we have no idea where
* our surfaces are positioned, relatively.
*
* However, there are some cases like popups and subsurfaces where
* we do have some amount of control over the placement of our
* window, and we can semi-accurately control the x/y position of
* these windows, if they are relative to another surface.
*
* GTK+ loves to position "relative" popups like menus in root
* window coordinates, since it was built for display servers that
* have queryable absolute coordinate spaces. In these cases, GTK+
* might ask for the root coordinates of a widget window, add a
* few values, and then call gdk_window_move() with that absolute
* value.
*
* In Wayland, we have to "reverse-engineer" this use, and figure
* out the root coordinates from the relative position, and the
* relative position from the root coordinates.
*
* We invent a coordinate space called the "fake root coordinate"
* space in which a toplevel is always at 0,0, and all popups are
* relative to that space.
*
* gdk_wayland_window_get_fake_root_coords() gives you the
* position of a #GdkWindow in "fake root" coordinates.
*/
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
static void
wayland: Add a giant doc comment explaining "fake root" coordinate space
2014-03-17 19:25:23 +00:00
gdk_wayland_window_get_fake_root_coords (GdkWindow *window,
gint *x_out,
gint *y_out)
wayland: Move some code around
2014-03-10 17:31:53 +00:00
{
gint x_offset = 0, y_offset = 0;
wayland: Fix "fake root" coords We were incorrectly summing up our own window over and over rather than the coordinates of the parent windows.
2014-03-17 19:27:13 +00:00
while (window)
wayland: Move some code around
2014-03-10 17:31:53 +00:00
{
wayland: Fix "fake root" coords We were incorrectly summing up our own window over and over rather than the coordinates of the parent windows.
2014-03-17 19:27:13 +00:00
GdkWindowImplWayland *impl;
wayland: Move some code around
2014-03-10 17:31:53 +00:00
x_offset += window->x;
y_offset += window->y;
wayland: Fix "fake root" coords We were incorrectly summing up our own window over and over rather than the coordinates of the parent windows.
2014-03-17 19:27:13 +00:00
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
window = impl->transient_for;
wayland: Move some code around
2014-03-10 17:31:53 +00:00
}
*x_out = x_offset;
*y_out = y_offset;
}
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
static void
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
gdk_wayland_window_create_xdg_popup (GdkWindow *window,
GdkWindow *parent,
struct wl_seat *seat)
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
{
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
GdkWindowImplWayland *parent_impl = GDK_WINDOW_IMPL_WAYLAND (parent->impl);
wayland: Avoid GdkDeviceManager APIs In most places, we can do with the pointer/keyboard of the default seat instead of the client pointer. We can also remove some code from gdk_input_init() because we know for sure there's no floating devices to care about here.
2015-12-16 18:12:18 +00:00
GdkSeat *gdk_seat;
wayland: Make the function to get the last serial a seat one This will be useful for primary selection. https://bugzilla.gnome.org/show_bug.cgi?id=762561
2016-02-23 19:32:31 +00:00
guint32 serial;
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
int x, y;
int parent_x, parent_y;
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
return;
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!parent_impl->display_server.wl_surface)
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
return;
wayland: add support for a private gtk-shell protocol This protocol will be used by mutter-wayland and gtk to replace the _GTK X11 properties for DBus names/paths. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:55:37 +00:00
wayland: Avoid GdkDeviceManager APIs In most places, we can do with the pointer/keyboard of the default seat instead of the client pointer. We can also remove some code from gdk_input_init() because we know for sure there's no floating devices to care about here.
2015-12-16 18:12:18 +00:00
gdk_seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
wayland: Add a giant doc comment explaining "fake root" coordinate space
2014-03-17 19:25:23 +00:00
gdk_wayland_window_get_fake_root_coords (parent, &parent_x, &parent_y);
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
x = window->x - parent_x;
y = window->y - parent_y;
wayland: Make the function to get the last serial a seat one This will be useful for primary selection. https://bugzilla.gnome.org/show_bug.cgi?id=762561
2016-02-23 19:32:31 +00:00
serial = _gdk_wayland_seat_get_last_implicit_grab_serial (gdk_seat, NULL);
wayland: Fix submenu positioning window->x / window->y are in "root window coordinates", e.g. relative to the topmost toplevel. However, the coordinates in get_xdg_popup are relative to the passed-in surface, so we need to do the reverse translation here.
2014-03-10 17:30:21 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.xdg_popup = xdg_shell_get_xdg_popup (display->xdg_shell,
impl->display_server.wl_surface,
parent_impl->display_server.wl_surface,
wayland: Make the function to get the last serial a seat one This will be useful for primary selection. https://bugzilla.gnome.org/show_bug.cgi?id=762561
2016-02-23 19:32:31 +00:00
seat, serial,
wayland: Update to xdg-shell unstable v5 Only trivial changes needed. https://bugzilla.gnome.org/show_bug.cgi?id=744455
2015-02-13 06:17:49 +00:00
x, y);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_popup_add_listener (impl->display_server.xdg_popup, &xdg_popup_listener, window);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
static struct wl_seat *
find_grab_input_seat (GdkWindow *window, GdkWindow *transient_for)
{
wayland: Fix GtkMenuButton popups in a terrible, hacky way Since you can't take grabs on unmapped windows, GtkMenu takes a grab on the menu in a convoluted way: it first grabs another window, shows the menu window, and then transfers the grab over to the GtkMenu widget. For normal menubars, this is perfectly fine, as the first window it grabs is our toplevel, and that gets picked up in our transient path. For GtkMenuButton or other spurious uses of gtk_menu_popup, it creates a new temporary input-only window which it takes the grab on, known as the "grab transfer window". Since this window isn't a transient-for of our new menu widget window, the grab isn't noticed when we go to show it, and thus the menu ends up as a new toplevel. Add a special hack to GtkMenu and the Wayland backend which lets us notice this "grab transfer window", and include it in our grab finding path. It's sort of terrible to have to hack up the widgets instead of just the backend, but the alternative would be an entirely new window type which is managed correctly by GDK. I don't want to write that.
2014-05-15 21:20:00 +00:00
GdkWindow *attached_grab_window;
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWindowImplWayland *tmp_impl;
/* Use the device that was used for the grab as the device for
* the popup window setup - so this relies on GTK+ taking the
* grab before showing the popup window.
*/
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
if (impl->grab_input_seat)
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
return gdk_wayland_seat_get_wl_seat (impl->grab_input_seat);
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
wayland: Fix GtkMenuButton popups in a terrible, hacky way Since you can't take grabs on unmapped windows, GtkMenu takes a grab on the menu in a convoluted way: it first grabs another window, shows the menu window, and then transfers the grab over to the GtkMenu widget. For normal menubars, this is perfectly fine, as the first window it grabs is our toplevel, and that gets picked up in our transient path. For GtkMenuButton or other spurious uses of gtk_menu_popup, it creates a new temporary input-only window which it takes the grab on, known as the "grab transfer window". Since this window isn't a transient-for of our new menu widget window, the grab isn't noticed when we go to show it, and thus the menu ends up as a new toplevel. Add a special hack to GtkMenu and the Wayland backend which lets us notice this "grab transfer window", and include it in our grab finding path. It's sort of terrible to have to hack up the widgets instead of just the backend, but the alternative would be an entirely new window type which is managed correctly by GDK. I don't want to write that.
2014-05-15 21:20:00 +00:00
/* HACK: GtkMenu grabs a special window known as the "grab transfer window"
* and then transfers the grab over to the correct window later. Look for
* this window when taking the grab to know it's correct.
*
* See: associate_menu_grab_transfer_window in gtkmenu.c
*/
attached_grab_window = g_object_get_data (G_OBJECT (window), "gdk-attached-grab-window");
if (attached_grab_window)
{
tmp_impl = GDK_WINDOW_IMPL_WAYLAND (attached_grab_window->impl);
if (tmp_impl->grab_input_seat)
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
return gdk_wayland_seat_get_wl_seat (tmp_impl->grab_input_seat);
wayland: Fix GtkMenuButton popups in a terrible, hacky way Since you can't take grabs on unmapped windows, GtkMenu takes a grab on the menu in a convoluted way: it first grabs another window, shows the menu window, and then transfers the grab over to the GtkMenu widget. For normal menubars, this is perfectly fine, as the first window it grabs is our toplevel, and that gets picked up in our transient path. For GtkMenuButton or other spurious uses of gtk_menu_popup, it creates a new temporary input-only window which it takes the grab on, known as the "grab transfer window". Since this window isn't a transient-for of our new menu widget window, the grab isn't noticed when we go to show it, and thus the menu ends up as a new toplevel. Add a special hack to GtkMenu and the Wayland backend which lets us notice this "grab transfer window", and include it in our grab finding path. It's sort of terrible to have to hack up the widgets instead of just the backend, but the alternative would be an entirely new window type which is managed correctly by GDK. I don't want to write that.
2014-05-15 21:20:00 +00:00
}
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
while (transient_for)
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
{
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
tmp_impl = GDK_WINDOW_IMPL_WAYLAND (transient_for->impl);
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
if (tmp_impl->grab_input_seat)
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
return gdk_wayland_seat_get_wl_seat (tmp_impl->grab_input_seat);
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
transient_for = tmp_impl->transient_for;
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
}
wayland: Clean up function to find the input seat
2014-05-15 21:14:26 +00:00
return NULL;
wayland: Clean up code to find the correct seat for a window
2014-05-15 21:12:09 +00:00
}
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
static struct wl_seat *
find_default_input_seat (GdkWindow *window)
{
GdkDisplay *display;
GdkSeat *seat;
display = gdk_window_get_display (window);
seat = gdk_display_get_default_seat (display);
return gdk_wayland_seat_get_wl_seat (seat);
}
gdkwayland-window: Don't map the grab transfer menu for GtkMenu This is a bad idea in general, but it also means that the focus for a window drops when we pop up a menu, since the grab transfer menu exists.
2014-08-13 23:01:52 +00:00
static gboolean
should_be_mapped (GdkWindow *window)
{
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
gdkwayland-window: Don't map the grab transfer menu for GtkMenu This is a bad idea in general, but it also means that the focus for a window drops when we pop up a menu, since the grab transfer menu exists.
2014-08-13 23:01:52 +00:00
/* Don't map crazy temp that GTK+ uses for internal X11 shenanigans. */
if (window->window_type == GDK_WINDOW_TEMP && window->x < 0 && window->y < 0)
return FALSE;
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (impl->hint == GDK_WINDOW_TYPE_HINT_DND)
return FALSE;
gdkwayland-window: Don't map the grab transfer menu for GtkMenu This is a bad idea in general, but it also means that the focus for a window drops when we pop up a menu, since the grab transfer menu exists.
2014-08-13 23:01:52 +00:00
return TRUE;
}
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
static gboolean
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
should_map_as_popup (GdkWindow *window)
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
{
wayland: Map windows with tooltip hint as subsurfaces Tooltips tend to be placed on top of a parent surface with a given relative coordinate, and without any input focus. So lets map them as subsurfaces. https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:48:51 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
/* Ideally, popup would be temp windows with a parent and grab */
if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP)
{
/* If a temp window has a parent and a grab, we can use a popup */
if (impl->transient_for)
{
if (impl->grab_input_seat)
return TRUE;
}
else
wayland: Reduce warning level for parentless temporaries Temp windows without parent are used frequently in our testsuite; using g_warning on them causes the tests to fail, which is not useful. Reduce the warning to a g_message.
2016-01-31 01:56:17 +00:00
g_message ("Window %p is a temporary window without parent, "
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
"application will not be able to position it on screen.",
window);
}
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
/* Yet we need to keep the window type hint tests for compatibility */
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
switch (impl->hint)
{
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
case GDK_WINDOW_TYPE_HINT_COMBO:
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
return TRUE;
wayland: Map UTILITY hinted popup windows as subsurfaces Currently used by GtkTreeView to map windows without changing focus. We can't map this as a popup, because popup implies focus change. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:21:51 +00:00
case GDK_WINDOW_TYPE_HINT_UTILITY:
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_TEMP)
wayland: Map UTILITY hinted popup windows as subsurfaces Currently used by GtkTreeView to map windows without changing focus. We can't map this as a popup, because popup implies focus change. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:21:51 +00:00
return TRUE;
break;
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
default:
break;
}
wayland: Map windows with tooltip hint as subsurfaces Tooltips tend to be placed on top of a parent surface with a given relative coordinate, and without any input focus. So lets map them as subsurfaces. https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:48:51 +00:00
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
return FALSE;
}
static gboolean
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
should_map_as_subsurface (GdkWindow *window)
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_SUBSURFACE)
return TRUE;
if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_TEMP)
return FALSE;
/* if we want a popup, we do not want a subsurface */
if (should_map_as_popup (window))
return FALSE;
if (impl->transient_for)
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
{
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
GdkWindowImplWayland *impl_parent;
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
impl_parent = GDK_WINDOW_IMPL_WAYLAND (impl->transient_for->impl);
/* subsurface require that the parent is mapped */
if (impl_parent->mapped)
wayland: Map UTILITY hinted popup windows as subsurfaces Currently used by GtkTreeView to map windows without changing focus. We can't map this as a popup, because popup implies focus change. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:21:51 +00:00
return TRUE;
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
else
g_warning ("Couldn't map window %p as susburface because its parent is not mapped.",
window);
wayland: Map UTILITY hinted popup windows as subsurfaces Currently used by GtkTreeView to map windows without changing focus. We can't map this as a popup, because popup implies focus change. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:21:51 +00:00
wayland: Make window type conditions switches In order to make it easier to add/remove in future commits. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 12:23:07 +00:00
}
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
return FALSE;
}
wayland: Don't try to use subsurfaces as popup parents If a GtkMenu (or something else that is mapped as a xdg_popup) tries to use a subsurface window as a parent, it will be terminated by the compositor due to protocol violation. So to avoid this, if a parent window is not a xdg_popup or xdg_surface, i.e. a wl_subsurface, then traverse up the transient parents until we find the right popup parent. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:03:52 +00:00
/* Get the window that can be used as a parent for a popup, i.e. a xdg_surface
* or xdg_popup. If the window is not, traverse up the transiency parents until
* we find one.
*/
static GdkWindow *
get_popup_parent (GdkWindow *window)
{
wayland: Avoid a crash We can end up in situations where NULL gets passed to get_transient_parent(). Embrace it instead of avoiding it. https://bugzilla.gnome.org/show_bug.cgi?id=758327
2015-11-19 19:39:42 +00:00
while (window)
wayland: Don't try to use subsurfaces as popup parents If a GtkMenu (or something else that is mapped as a xdg_popup) tries to use a subsurface window as a parent, it will be terminated by the compositor due to protocol violation. So to avoid this, if a parent window is not a xdg_popup or xdg_surface, i.e. a wl_subsurface, then traverse up the transient parents until we find the right popup parent. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:03:52 +00:00
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_popup || impl->display_server.xdg_surface)
wayland: Don't try to use subsurfaces as popup parents If a GtkMenu (or something else that is mapped as a xdg_popup) tries to use a subsurface window as a parent, it will be terminated by the compositor due to protocol violation. So to avoid this, if a parent window is not a xdg_popup or xdg_surface, i.e. a wl_subsurface, then traverse up the transient parents until we find the right popup parent. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:03:52 +00:00
return window;
window = impl->transient_for;
}
return NULL;
}
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
static void
gdk_wayland_window_map (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Ensure a variable is initialized clang complained about transient_for being used uninitialized.
2015-06-13 21:49:20 +00:00
GdkWindow *transient_for = NULL;
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
gdkwayland-window: Don't map the grab transfer menu for GtkMenu This is a bad idea in general, but it also means that the focus for a window drops when we pop up a menu, since the grab transfer menu exists.
2014-08-13 23:01:52 +00:00
if (!should_be_mapped (window))
return;
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (impl->mapped || impl->use_custom_surface)
return;
if (should_map_as_subsurface (window))
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
{
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (impl->transient_for)
gdk_wayland_window_create_subsurface (window);
else
wayland: prefer subsurface when possible Quite a few applications use GTK_WINDOW_POPUP to create various temporary windows and place then on screen. That works fine on X11 but on Wayland there is no global coordinate system for regular surfaces. If the application is using a gdk temp window and set a parent with gtk_window_transient_for(), the gdk wayland backend has all it needs to create a subsurface that can be placed at will by the application. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759738
2015-12-21 13:35:53 +00:00
g_warning ("Couldn't map window %p as susburface yet because it doesn't have a parent",
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
window);
}
else if (should_map_as_popup (window))
{
gboolean create_fallback = FALSE;
struct wl_seat *grab_input_seat;
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
/* Popup menus can appear without a transient parent, which means they
* cannot be positioned properly on Wayland. This attempts to guess the
* surface they should be positioned with by finding the surface beneath
wayland: Improve guessing of popup placement for detached popup menus If a menu was not attached to any widget, we try to calculate its position given where the grabbed pointer is and what window has its focus. Previously we failed to do so if a "transfer window" was used for the grab, and this patch adds a code path that, if the menu window itself didn't have the grab, look for the transfer window and get the grab device from there. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:29:22 +00:00
* the device that created the grab for the popup window.
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
*/
if (!impl->transient_for && impl->hint == GDK_WINDOW_TYPE_HINT_POPUP_MENU)
{
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
GdkDevice *grab_device = NULL;
wayland: Improve guessing of popup placement for detached popup menus If a menu was not attached to any widget, we try to calculate its position given where the grabbed pointer is and what window has its focus. Previously we failed to do so if a "transfer window" was used for the grab, and this patch adds a code path that, if the menu window itself didn't have the grab, look for the transfer window and get the grab device from there. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:29:22 +00:00
/* The popup menu window is not the grabbed window. This may mean
* that a "transfer window" (see gtkmenu.c) is used, and we need
* to find that window to get the grab device. If so is the case
* the "transfer window" can be retrieved via the
* "gdk-attached-grab-window" associated data field.
*/
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
if (!impl->grab_input_seat)
wayland: Improve guessing of popup placement for detached popup menus If a menu was not attached to any widget, we try to calculate its position given where the grabbed pointer is and what window has its focus. Previously we failed to do so if a "transfer window" was used for the grab, and this patch adds a code path that, if the menu window itself didn't have the grab, look for the transfer window and get the grab device from there. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:29:22 +00:00
{
GdkWindow *attached_grab_window =
g_object_get_data (G_OBJECT (window),
"gdk-attached-grab-window");
if (attached_grab_window)
{
GdkWindowImplWayland *attached_impl =
GDK_WINDOW_IMPL_WAYLAND (attached_grab_window->impl);
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
grab_device = gdk_seat_get_pointer (attached_impl->grab_input_seat);
wayland: Improve guessing of popup placement for detached popup menus If a menu was not attached to any widget, we try to calculate its position given where the grabbed pointer is and what window has its focus. Previously we failed to do so if a "transfer window" was used for the grab, and this patch adds a code path that, if the menu window itself didn't have the grab, look for the transfer window and get the grab device from there. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:29:22 +00:00
transient_for =
gdk_device_get_window_at_position (grab_device,
NULL, NULL);
}
}
else
{
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
grab_device = gdk_seat_get_pointer (impl->grab_input_seat);
wayland: Improve guessing of popup placement for detached popup menus If a menu was not attached to any widget, we try to calculate its position given where the grabbed pointer is and what window has its focus. Previously we failed to do so if a "transfer window" was used for the grab, and this patch adds a code path that, if the menu window itself didn't have the grab, look for the transfer window and get the grab device from there. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:29:22 +00:00
transient_for =
gdk_device_get_window_at_position (grab_device, NULL, NULL);
}
if (transient_for)
wayland: Don't crash with offscreen windows Use gdk_window_get_effective_toplevel when looking for a suitable transient parent, to skip over offscreen windows that we might encounter in the window tree. This fixes a crash in glade. https://bugzilla.gnome.org/show_bug.cgi?id=763110
2016-03-05 01:01:57 +00:00
transient_for = get_popup_parent (gdk_window_get_effective_toplevel (transient_for));
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
wayland: Don't try to guess the popup menu placement when it was set If a position was already explicitly set, don't try to guess the position of popup menus by looking at the pointer position, just use the set coordinates. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:35:21 +00:00
/* If the position was not explicitly set, start the popup at the
* position of the device that holds the grab.
*/
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
if (!impl->position_set && grab_device)
gdk_window_get_device_position (transient_for, grab_device,
wayland: Don't try to guess the popup menu placement when it was set If a position was already explicitly set, don't try to guess the position of popup menus by looking at the pointer position, just use the set coordinates. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:35:21 +00:00
&window->x, &window->y, NULL);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
else
wayland: Don't try to use subsurfaces as popup parents If a GtkMenu (or something else that is mapped as a xdg_popup) tries to use a subsurface window as a parent, it will be terminated by the compositor due to protocol violation. So to avoid this, if a parent window is not a xdg_popup or xdg_surface, i.e. a wl_subsurface, then traverse up the transient parents until we find the right popup parent. https://bugzilla.gnome.org/show_bug.cgi?id=756780
2015-10-18 13:03:52 +00:00
transient_for = get_popup_parent (impl->transient_for);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (!transient_for)
{
g_warning ("Couldn't map as window %p as popup because it doesn't have a parent",
window);
create_fallback = TRUE;
}
else
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
{
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
grab_input_seat = find_grab_input_seat (window, transient_for);
if (!grab_input_seat)
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
{
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
g_warning ("No grabbed seat found, using the default one in "
"order to map popup window %p. You may find oddities "
"ahead, gdk_seat_grab() should be used to "
"simultaneously grab input and show this popup",
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
window);
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
grab_input_seat = find_default_input_seat (window);
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
}
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (!create_fallback)
{
gdk_wayland_window_create_xdg_popup (window,
transient_for,
grab_input_seat);
}
else
{
gdk_wayland_window_create_xdg_surface (window);
}
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
}
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
else
{
gdk_wayland_window_create_xdg_surface (window);
}
impl->mapped = TRUE;
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_show (GdkWindow *window,
gboolean already_mapped)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
gdk_wayland_window_create_surface (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: Map the window immediately on show
2014-04-22 23:16:48 +00:00
gdk_wayland_window_map (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
_gdk_make_event (window, GDK_MAP, NULL, FALSE);
wayland: Fix hiding and withdrawing surfaces
2011-02-11 03:21:08 +00:00
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
if (impl->staging_cairo_surface &&
_gdk_wayland_is_shm_surface (impl->staging_cairo_surface))
wayland: Fix hiding and withdrawing surfaces
2011-02-11 03:21:08 +00:00
gdk_wayland_window_attach_image (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
static void
unmap_subsurface (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWindowImplWayland *parent_impl;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
g_return_if_fail (impl->display_server.wl_subsurface);
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
g_return_if_fail (impl->transient_for);
parent_impl = GDK_WINDOW_IMPL_WAYLAND (impl->transient_for->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_subsurface_destroy (impl->display_server.wl_subsurface);
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
g_signal_handlers_disconnect_by_func (parent_impl,
(gpointer) on_parent_surface_committed,
window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.wl_subsurface = NULL;
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
gdkwindow-wayland: Destroy the wl_surface too when hiding a window wl_surfaces can't switch roles, so destroying the xdg_surface but not the wl_surface means that we could get an error when trying to re-map the surface. We could fix this by not destroying the xdg resource and only do it at finalization time, but it's just as easy to just create a new wl_surface.
2014-06-19 19:04:09 +00:00
gdk_wayland_window_hide_surface (GdkWindow *window)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.wl_surface)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
if (impl->dummy_egl_surface)
{
Trivial formatting fix
2015-08-28 17:51:11 +00:00
eglDestroySurface (display_wayland->egl_display, impl->dummy_egl_surface);
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
impl->dummy_egl_surface = NULL;
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.dummy_egl_window)
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_egl_window_destroy (impl->display_server.dummy_egl_window);
impl->display_server.dummy_egl_window = NULL;
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
if (impl->egl_surface)
{
Trivial formatting fix
2015-08-28 17:51:11 +00:00
eglDestroySurface (display_wayland->egl_display, impl->egl_surface);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
impl->egl_surface = NULL;
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.egl_window)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_egl_window_destroy (impl->display_server.egl_window);
impl->display_server.egl_window = NULL;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
gdkwindow-wayland: Destroy the xdg roles before the wl_surface Since the xdg roles are a special case of the surface, some compositors like Weston destroy them automatically when the wl_surface is destroyed. Thus, we need to destroy these first.
2014-06-19 19:10:01 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_destroy (impl->display_server.xdg_surface);
impl->display_server.xdg_surface = NULL;
gdkwindow-wayland: Destroy the xdg roles before the wl_surface Since the xdg roles are a special case of the surface, some compositors like Weston destroy them automatically when the wl_surface is destroyed. Thus, we need to destroy these first.
2014-06-19 19:10:01 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
else if (impl->display_server.xdg_popup)
gdkwindow-wayland: Destroy the xdg roles before the wl_surface Since the xdg roles are a special case of the surface, some compositors like Weston destroy them automatically when the wl_surface is destroyed. Thus, we need to destroy these first.
2014-06-19 19:10:01 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_popup_destroy (impl->display_server.xdg_popup);
impl->display_server.xdg_popup = NULL;
gdkwindow-wayland: Destroy the xdg roles before the wl_surface Since the xdg roles are a special case of the surface, some compositors like Weston destroy them automatically when the wl_surface is destroyed. Thus, we need to destroy these first.
2014-06-19 19:10:01 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.wl_subsurface)
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
unmap_subsurface (window);
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
wayland: Thaw the clock if we hide a GdkWindow mid-frame When a window is hidden, its surface and all its roles are destroyed, if this happens when we already issued a wl_surface_commit and are awaiting for a frame callback, the clock will remain frozen for the next time the window is shown. To avoid this, keep track of the wl_surface_frame() calls issued, and ensure the clock is thawed after hiding. If we happen to receive the frame callback, it is just ignored. https://bugzilla.gnome.org/show_bug.cgi?id=743427
2015-02-25 13:46:54 +00:00
if (impl->awaiting_frame)
{
wayland: Be more careful when destroying windows We call gdk_wayland_window_hide_surface when the window gets destroyed, and in this case, the frame clock might not exist anymore. This was showing up in the displayclose testcase.
2015-08-28 17:55:23 +00:00
GdkFrameClock *frame_clock;
wayland: Thaw the clock if we hide a GdkWindow mid-frame When a window is hidden, its surface and all its roles are destroyed, if this happens when we already issued a wl_surface_commit and are awaiting for a frame callback, the clock will remain frozen for the next time the window is shown. To avoid this, keep track of the wl_surface_frame() calls issued, and ensure the clock is thawed after hiding. If we happen to receive the frame callback, it is just ignored. https://bugzilla.gnome.org/show_bug.cgi?id=743427
2015-02-25 13:46:54 +00:00
impl->awaiting_frame = FALSE;
wayland: Be more careful when destroying windows We call gdk_wayland_window_hide_surface when the window gets destroyed, and in this case, the frame clock might not exist anymore. This was showing up in the displayclose testcase.
2015-08-28 17:55:23 +00:00
frame_clock = gdk_window_get_frame_clock (window);
if (frame_clock)
_gdk_frame_clock_thaw (frame_clock);
wayland: Thaw the clock if we hide a GdkWindow mid-frame When a window is hidden, its surface and all its roles are destroyed, if this happens when we already issued a wl_surface_commit and are awaiting for a frame callback, the clock will remain frozen for the next time the window is shown. To avoid this, keep track of the wl_surface_frame() calls issued, and ensure the clock is thawed after hiding. If we happen to receive the frame callback, it is just ignored. https://bugzilla.gnome.org/show_bug.cgi?id=743427
2015-02-25 13:46:54 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.gtk_surface)
wayland: Invalidate our gtk_surface when we're unmapped Otherwise if we get mapped again we'll try to use an invalid gtk_surface and the compositor will disconnect us. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:08:30 +00:00
{
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
gtk_surface1_destroy (impl->display_server.gtk_surface);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.gtk_surface = NULL;
wayland: Invalidate our gtk_surface when we're unmapped Otherwise if we get mapped again we'll try to use an invalid gtk_surface and the compositor will disconnect us. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:08:30 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_destroy (impl->display_server.wl_surface);
impl->display_server.wl_surface = NULL;
wayland: fill in refresh_interval in GdkFrameTimings Track the outputs that a window is on, and use the refresh rate from a random one of those outputs for the refresh_interval in GdkFrameTimings. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:19:31 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
g_slist_free (impl->display_server.outputs);
impl->display_server.outputs = NULL;
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (impl->hint == GDK_WINDOW_TYPE_HINT_DIALOG && !impl->transient_for)
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
display_wayland->orphan_dialogs =
g_list_remove (display_wayland->orphan_dialogs, window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Ensure we keep our internal state when hiding a window with no surface We need to keep track of the mapped variable here.
2013-09-16 22:36:18 +00:00
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
_gdk_wayland_window_clear_saved_size (window);
wayland: Unset window_impl->commit_pending when hiding the surface A surface may be hidden when a frame is already scheduled, which may cause crashes on on_frame_clock_after_paint() when calling commit() on a NULL surface. To fix this, ensure commit_pending is also set to FALSE when the surface is gone. https://bugzilla.gnome.org/show_bug.cgi?id=735226
2014-09-01 18:20:49 +00:00
impl->pending_commit = FALSE;
wayland: Ensure we keep our internal state when hiding a window with no surface We need to keep track of the mapped variable here.
2013-09-16 22:36:18 +00:00
impl->mapped = FALSE;
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
static void
gdk_wayland_window_hide (GdkWindow *window)
{
gdkwindow-wayland: Destroy the wl_surface too when hiding a window wl_surfaces can't switch roles, so destroying the xdg_surface but not the wl_surface means that we could get an error when trying to re-map the surface. We could fix this by not destroying the xdg resource and only do it at finalization time, but it's just as easy to just create a new wl_surface.
2014-06-19 19:04:09 +00:00
gdk_wayland_window_hide_surface (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
_gdk_window_clear_update_area (window);
}
static void
gdk_window_wayland_withdraw (GdkWindow *window)
{
if (!window->destroyed)
{
if (GDK_WINDOW_IS_MAPPED (window))
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_WITHDRAWN);
Add Wayland backend
2010-12-18 20:38:49 +00:00
g_assert (!GDK_WINDOW_IS_MAPPED (window));
gdkwindow-wayland: Destroy the wl_surface too when hiding a window wl_surfaces can't switch roles, so destroying the xdg_surface but not the wl_surface means that we could get an error when trying to re-map the surface. We could fix this by not destroying the xdg resource and only do it at finalization time, but it's just as easy to just create a new wl_surface.
2014-06-19 19:04:09 +00:00
gdk_wayland_window_hide_surface (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
}
static void
gdk_window_wayland_set_events (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkEventMask event_mask)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
GDK_WINDOW (window)->event_mask = event_mask;
}
static GdkEventMask
gdk_window_wayland_get_events (GdkWindow *window)
{
if (GDK_WINDOW_DESTROYED (window))
return 0;
else
return GDK_WINDOW (window)->event_mask;
}
static void
gdk_window_wayland_raise (GdkWindow *window)
{
}
static void
gdk_window_wayland_lower (GdkWindow *window)
{
}
static void
gdk_window_wayland_restack_under (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GList *native_siblings)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_window_wayland_restack_toplevel (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *sibling,
gboolean above)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
wayland: Schedule a clock tick instead of wl_surface_commit()ting directly Instead of possibly calling wl_surface_commit() out of GdkFrameClock::after-paint, tick the transient parent clock so ::after-paint can be eventually run. This ensures that the subsurface coordinates (considered part of the state of the parent) aren't committed untimely, and guaranteed to be orderly with the wl_subsurface-relative state. This is a gtk-side fix for https://bugzilla.gnome.org/show_bug.cgi?id=738887
2014-11-04 18:26:25 +00:00
static void
gdk_window_request_transient_parent_commit (GdkWindow *window)
{
GdkWindowImplWayland *window_impl, *impl;
GdkFrameClock *frame_clock;
window_impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (!window_impl->transient_for)
return;
impl = GDK_WINDOW_IMPL_WAYLAND (window_impl->transient_for->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface || impl->pending_commit)
wayland: Schedule a clock tick instead of wl_surface_commit()ting directly Instead of possibly calling wl_surface_commit() out of GdkFrameClock::after-paint, tick the transient parent clock so ::after-paint can be eventually run. This ensures that the subsurface coordinates (considered part of the state of the parent) aren't committed untimely, and guaranteed to be orderly with the wl_subsurface-relative state. This is a gtk-side fix for https://bugzilla.gnome.org/show_bug.cgi?id=738887
2014-11-04 18:26:25 +00:00
return;
frame_clock = gdk_window_get_frame_clock (window_impl->transient_for);
if (!frame_clock)
return;
impl->pending_commit = TRUE;
gdk_frame_clock_request_phase (frame_clock,
GDK_FRAME_CLOCK_PHASE_AFTER_PAINT);
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
gdk_window_wayland_move_resize (GdkWindow *window,
wayland: Only update position if the with_move flag is set This was causing the combobox popup to be moved to (0,0) when just the size was asserted.
2012-04-20 16:57:33 +00:00
gboolean with_move,
gint x,
gint y,
gint width,
gint height)
{
wayland: Properly support changing of surface scale When the preferred surface scale changes, for example when entering a wl_output with a higher scale than any previous entered output, recreate the shm surface and redraw the window content with the new window scale. Before this patch, the internal scale would be changed, but the shm surface would not be recreated given the new scale, i.e. we'd attach a buffer for a different scale than wl_surface.set_scale specified. https://bugzilla.gnome.org/show_bug.cgi?id=745076
2015-02-24 08:11:48 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Only update position if the with_move flag is set This was causing the combobox popup to be moved to (0,0) when just the size was asserted.
2012-04-20 16:57:33 +00:00
if (with_move)
{
wayland: Make toplevels' X/Y coordinates be 0 To all effects each window has its own "root" coordinates system, so set toplevels at 0,0 in that coordinate system, so root coordinate calculations are locally right. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:39:09 +00:00
/* Each toplevel has in its own "root" coordinate system */
if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_TOPLEVEL)
{
window->x = x;
window->y = y;
wayland: Don't try to guess the popup menu placement when it was set If a position was already explicitly set, don't try to guess the position of popup menus by looking at the pointer position, just use the set coordinates. https://bugzilla.gnome.org/show_bug.cgi?id=748951
2015-06-05 05:35:21 +00:00
impl->position_set = 1;
wayland: create a wl_subsurface interface for GDK_WINDOW_SUBSURFACE windows This subsurface is currently dependent on the transient_for parent, so the subsurface is repositioned relative to it. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:31:50 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.wl_subsurface)
wayland: Ensure the parent is committed after repositioning subsurfaces Subsurface position is deemed part of the state of the parent surface, so ensure wl_surface_commit() happens on the parent surface if none is scheduled, so the repositioning takes place.
2014-08-27 10:03:28 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_subsurface_set_position (impl->display_server.wl_subsurface, x, y);
wayland: Schedule a clock tick instead of wl_surface_commit()ting directly Instead of possibly calling wl_surface_commit() out of GdkFrameClock::after-paint, tick the transient parent clock so ::after-paint can be eventually run. This ensures that the subsurface coordinates (considered part of the state of the parent) aren't committed untimely, and guaranteed to be orderly with the wl_subsurface-relative state. This is a gtk-side fix for https://bugzilla.gnome.org/show_bug.cgi?id=738887
2014-11-04 18:26:25 +00:00
gdk_window_request_transient_parent_commit (window);
wayland: Ensure the parent is committed after repositioning subsurfaces Subsurface position is deemed part of the state of the parent surface, so ensure wl_surface_commit() happens on the parent surface if none is scheduled, so the repositioning takes place.
2014-08-27 10:03:28 +00:00
}
wayland: Make toplevels' X/Y coordinates be 0 To all effects each window has its own "root" coordinates system, so set toplevels at 0,0 in that coordinate system, so root coordinate calculations are locally right. https://bugzilla.gnome.org/show_bug.cgi?id=729215
2014-08-21 15:39:09 +00:00
}
wayland: Only update position if the with_move flag is set This was causing the combobox popup to be moved to (0,0) when just the size was asserted.
2012-04-20 16:57:33 +00:00
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
wayland: Adapt move_resize vfunc implementation to match semantics Callers of this function were passing in -1, -1 for the width and height if they just wanted the window moving - rather than the size changing. We need to respect that behaviour and don't try and set the width/height to those dimensions. Now pop-up windows (ala combo-boxes) work!
2012-01-17 14:59:03 +00:00
/* If this function is called with width and height = -1 then that means
* just move the window - don't update its size
*/
if (width > 0 && height > 0)
wayland: Do not resize with the same size gnome-control-center is calling gtk_window_resize() on configure-event signals which leads to a busy loop. Avoids such a busy loop by not re-configuring a window with the same size, unless this is coming from and xdg-shell configure. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=764374
2016-04-04 12:55:38 +00:00
gdk_wayland_window_maybe_configure (window, width, height, impl->scale);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_window_wayland_set_background (GdkWindow *window,
cairo_pattern_t *pattern)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static gboolean
gdk_window_wayland_reparent (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *new_parent,
gint x,
gint y)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
return FALSE;
}
static void
gdk_window_wayland_set_device_cursor (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkDevice *device,
GdkCursor *cursor)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (GDK_IS_DEVICE (device));
if (!GDK_WINDOW_DESTROYED (window))
GDK_DEVICE_GET_CLASS (device)->set_window_cursor (device, window, cursor);
}
static void
gdk_window_wayland_get_geometry (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gint *x,
gint *y,
gint *width,
gint *height)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
if (!GDK_WINDOW_DESTROYED (window))
{
if (x)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*x = window->x;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (y)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*y = window->y;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (width)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*width = window->width;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (height)
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
*height = window->height;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
}
Remove the return value of GdkWindowImpl::get_root_coords It's unused by callers, and the historical return values are undocumented, so just remove it now.
2014-02-28 01:58:13 +00:00
static void
Add Wayland backend
2010-12-18 20:38:49 +00:00
gdk_window_wayland_get_root_coords (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gint x,
gint y,
gint *root_x,
gint *root_y)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Calculate window position offset to give emulated root coordinates This allows combo box popup windows to appear in the correct place. This is a workaround emulating root coordinates by calculating the offset for a chain of windows that that are relative to each other.
2012-04-23 16:26:49 +00:00
gint x_offset, y_offset;
wayland: Add a giant doc comment explaining "fake root" coordinate space
2014-03-17 19:25:23 +00:00
gdk_wayland_window_get_fake_root_coords (window, &x_offset, &y_offset);
wayland: Calculate window position offset to give emulated root coordinates This allows combo box popup windows to appear in the correct place. This is a workaround emulating root coordinates by calculating the offset for a chain of windows that that are relative to each other.
2012-04-23 16:26:49 +00:00
wayland: fix crash in gdk_window_wayland_get_root_coords(). Both root_x and root_y may be NULL, so check first before setting.
2013-08-30 07:23:56 +00:00
if (root_x)
*root_x = x_offset + x;
if (root_y)
*root_y = y_offset + y;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static gboolean
gdk_window_wayland_get_device_state (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkDevice *device,
gdouble *x,
gdouble *y,
GdkModifierType *mask)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
gboolean return_val;
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), FALSE);
return_val = TRUE;
if (!GDK_WINDOW_DESTROYED (window))
{
GdkWindow *child;
GDK_DEVICE_GET_CLASS (device)->query_state (device, window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
NULL, &child,
NULL, NULL,
x, y, mask);
Add Wayland backend
2010-12-18 20:38:49 +00:00
return_val = (child != NULL);
}
return return_val;
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_window_wayland_shape_combine_region (GdkWindow *window,
const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
static void
gdk_window_wayland_input_shape_combine_region (GdkWindow *window,
const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (GDK_WINDOW_DESTROYED (window))
return;
g_clear_pointer (&impl->input_region, cairo_region_destroy);
wayland: Don't translate a NULL region into an empty one cairo_region_copy(NULL) will effectively return an empty region, as this function is always meant to return valid memory. This however inverts the meaning of the NULL region and results in entirely non-clickable windows.
2014-11-07 16:16:59 +00:00
if (shape_region)
{
impl->input_region = cairo_region_copy (shape_region);
cairo_region_translate (impl->input_region, offset_x, offset_y);
}
wayland: Add support for input regions
2014-03-17 20:02:47 +00:00
gdk_wayland_window_sync_input_region (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_destroy (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean recursing,
gboolean foreign_destroy)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
g_return_if_fail (GDK_IS_WINDOW (window));
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
/* Wayland windows can't be externally destroyed; we may possibly
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
* eventually want to use this path at display close-down
*/
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
g_return_if_fail (!foreign_destroy);
gdkwindow-wayland: Destroy the wl_surface too when hiding a window wl_surfaces can't switch roles, so destroying the xdg_surface but not the wl_surface means that we could get an error when trying to re-map the surface. We could fix this by not destroying the xdg resource and only do it at finalization time, but it's just as easy to just create a new wl_surface.
2014-06-19 19:04:09 +00:00
gdk_wayland_window_hide_surface (window);
wayland: stage uncommitted changes to dedicated buffer Right now we use one buffer for both staged changes (freshly painted changes waiting for the frame clock to send to the compositor) and committed changes (changes actively being read by the compositor process). This creates a problem in the event we need to stage updates at the same time the compositor is processing committed updates: we can't change what the compositor is actively processing. The current solution for handling this contention is to allocate a temporary buffer on the spot at the time the updates are staged, and to copy that buffer back to the shared buffer later. The problem, though, is that the copy to the shared buffer currently happens as soon as the updates are finished being staged, not when the shared buffer is done being processed by the compositor. In order to address that problem, this commit changes the code to always stage changes to a dedicated staging buffer. The staging buffer is used exclusively by the client until the client is done with it, and then once that staging buffer is committed, the client never writes to that buffer again. If the client needs to stage new updates, it allocates a brand new staging buffer, draws to it, and back fills the undrawn parts of the buffer from a copy of the contents of the committed buffer. As an optimization, the compositor has the option of releasing the committed buffer back to the client. If it does so before the client needs to stage new updates, then the client will reuse the buffer for staging future updates. This optimization prevents having to allocate a new staging buffer and the associated cost of back filling that new buffer with a readback of the committed buffer. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-01-29 16:19:03 +00:00
drop_cairo_surfaces (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_window_wayland_destroy_foreign (GdkWindow *window)
{
}
static cairo_region_t *
gdk_wayland_window_get_shape (GdkWindow *window)
{
return NULL;
}
static cairo_region_t *
gdk_wayland_window_get_input_shape (GdkWindow *window)
{
return NULL;
}
static void
gdk_wayland_window_focus (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
guint32 timestamp)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Add request focus support via gtk_shell A gtk_surface.present request was added to gtk_surface which takes timestamp from some input event, and uses that timestamp to figure out whether the window can be presented or not. If we don't have a timestamp, we should just give up instead of making up our own, otherwise we might steal someones focus. https://bugzilla.gnome.org/show_bug.cgi?id=763037
2016-03-08 09:03:06 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (!impl->display_server.gtk_surface)
return;
/* We didn't have an event to fetch a time from, meaning we have nothing valid
* to send. This should rather be translated to a 'needs-attention' request or
* something.
*/
if (timestamp == GDK_CURRENT_TIME)
return;
gtk_surface1_present (impl->display_server.gtk_surface, timestamp);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_set_type_hint (GdkWindow *window,
GdkWindowTypeHint hint)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Set surface type based on GdkWindow hint
2012-01-13 14:48:46 +00:00
GdkWindowImplWayland *impl;
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Set surface type based on GdkWindow hint
2012-01-13 14:48:46 +00:00
impl->hint = hint;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static GdkWindowTypeHint
gdk_wayland_window_get_type_hint (GdkWindow *window)
{
wayland: Return properly type hints from GdkWindows This was hardcoded to GDK_WINDOW_TYPE_HINT_NORMAL, even though wayland windows store the type hint themselves. https://bugzilla.gnome.org/show_bug.cgi?id=697855
2014-08-28 12:10:00 +00:00
GdkWindowImplWayland *impl;
if (GDK_WINDOW_DESTROYED (window))
return GDK_WINDOW_TYPE_HINT_NORMAL;
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
return impl->hint;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
static void
gdk_wayland_window_init_gtk_surface (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWaylandDisplay *display =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.gtk_surface != NULL)
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface == NULL)
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
return;
if (display->gtk_shell == NULL)
return;
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
impl->display_server.gtk_surface =
gtk_shell1_get_gtk_surface (display->gtk_shell,
impl->display_server.wl_surface);
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
}
Wayland: Fix various compiler warnings Mostly missing declarations, missing statics and unused functions.
2014-09-06 00:41:06 +00:00
static void
wayland: Ensure modal hint gets set on map We need to be mapped to have a gtk_surface and thus be able to do requests on it so we need to save the modal hint and apply it when we get mapped so that code that sets the hint before showing a window doesn't get ignored. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:03:49 +00:00
maybe_set_gtk_surface_modal (GdkWindow *window)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
gdk_wayland_window_init_gtk_surface (window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.gtk_surface == NULL)
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
return;
wayland: Ensure modal hint gets set on map We need to be mapped to have a gtk_surface and thus be able to do requests on it so we need to save the modal hint and apply it when we get mapped so that code that sets the hint before showing a window doesn't get ignored. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:03:49 +00:00
if (window->modal_hint)
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
gtk_surface1_set_modal (impl->display_server.gtk_surface);
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
else
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
gtk_surface1_unset_modal (impl->display_server.gtk_surface);
wayland: Ensure modal hint gets set on map We need to be mapped to have a gtk_surface and thus be able to do requests on it so we need to save the modal hint and apply it when we get mapped so that code that sets the hint before showing a window doesn't get ignored. https://bugzilla.gnome.org/show_bug.cgi?id=753138
2015-08-01 15:03:49 +00:00
}
static void
gdk_wayland_window_set_modal_hint (GdkWindow *window,
gboolean modal)
{
window->modal_hint = modal;
maybe_set_gtk_surface_modal (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_set_skip_taskbar_hint (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean skips_taskbar)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_skip_pager_hint (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean skips_pager)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_urgency_hint (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean urgent)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_geometry_hints (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const GdkGeometry *geometry,
GdkWindowHints geom_mask)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Implement set_geometry_hints vfunc Our trivial implementation simply saves the passed in parameters into the Wayland private data structure.
2012-01-09 17:11:22 +00:00
GdkWindowImplWayland *impl;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
return;
wayland: Implement set_geometry_hints vfunc Our trivial implementation simply saves the passed in parameters into the Wayland private data structure.
2012-01-09 17:11:22 +00:00
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
impl->geometry_hints = *geometry;
impl->geometry_mask = geom_mask;
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_set_title (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const gchar *title)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Set title on shell surfaces to window title We currently use this information to display the title string in the window list of the desktop shell. Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:57:17 +00:00
GdkWindowImplWayland *impl;
Add Wayland backend
2010-12-18 20:38:49 +00:00
g_return_if_fail (title != NULL);
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Set title on shell surfaces to window title We currently use this information to display the title string in the window list of the desktop shell. Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:57:17 +00:00
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkWaylandWindow: Fix memory leak https://bugzilla.gnome.org/show_bug.cgi?id=706493
2013-08-21 11:09:29 +00:00
g_free (impl->title);
impl->title = g_strdup (title);
wayland: Allow set_title after initial showing and fix the ordering of title / app_id
2013-11-21 17:03:18 +00:00
gdk_wayland_window_sync_title (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_set_role (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const gchar *role)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_startup_id (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const gchar *startup_id)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
wayland: Check transient loop Gdk Wayland backend walks up the transient windows tree, but does not check for cycles when doing so. As a result, if two or more windows are transient to each other, the Wayland gdk backend will enter an infinite loop. While this is clearly a bug in the application, gtk+/gdk should be more robust and handle such errors more gracefully. To avoid looping infinitely at various point in the code, check for a possible loop when setting the transient relationship and deny the request to set a window transient for another if that would create a loop. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759299
2015-12-14 15:34:00 +00:00
static gboolean
check_transient_for_loop (GdkWindow *window,
GdkWindow *parent)
{
while (parent)
{
wayland: Check actual impl type in transient loop If the parent of a transient is not a native Wayland window (e.g. offscreen window), the transient loop check will crash. Check for the actual type in the transient loop check and do not assume the parent is necessarily Wayland native. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=761156 Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
2016-02-29 09:14:56 +00:00
GdkWindowImplWayland *impl;
if (!GDK_IS_WINDOW_IMPL_WAYLAND(parent->impl))
return FALSE;
wayland: Check transient loop Gdk Wayland backend walks up the transient windows tree, but does not check for cycles when doing so. As a result, if two or more windows are transient to each other, the Wayland gdk backend will enter an infinite loop. While this is clearly a bug in the application, gtk+/gdk should be more robust and handle such errors more gracefully. To avoid looping infinitely at various point in the code, check for a possible loop when setting the transient relationship and deny the request to set a window transient for another if that would create a loop. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759299
2015-12-14 15:34:00 +00:00
wayland: Check actual impl type in transient loop If the parent of a transient is not a native Wayland window (e.g. offscreen window), the transient loop check will crash. Check for the actual type in the transient loop check and do not assume the parent is necessarily Wayland native. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=761156 Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
2016-02-29 09:14:56 +00:00
impl = GDK_WINDOW_IMPL_WAYLAND (parent->impl);
wayland: Check transient loop Gdk Wayland backend walks up the transient windows tree, but does not check for cycles when doing so. As a result, if two or more windows are transient to each other, the Wayland gdk backend will enter an infinite loop. While this is clearly a bug in the application, gtk+/gdk should be more robust and handle such errors more gracefully. To avoid looping infinitely at various point in the code, check for a possible loop when setting the transient relationship and deny the request to set a window transient for another if that would create a loop. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759299
2015-12-14 15:34:00 +00:00
if (impl->transient_for == window)
return TRUE;
parent = impl->transient_for;
}
return FALSE;
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
gdk_wayland_window_set_transient_for (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *parent)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
GdkWaylandDisplay *display_wayland =
GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
GdkWindow *previous_parent;
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
g_assert (parent == NULL ||
gdk_window_get_display (window) == gdk_window_get_display (parent));
wayland: Check transient loop Gdk Wayland backend walks up the transient windows tree, but does not check for cycles when doing so. As a result, if two or more windows are transient to each other, the Wayland gdk backend will enter an infinite loop. While this is clearly a bug in the application, gtk+/gdk should be more robust and handle such errors more gracefully. To avoid looping infinitely at various point in the code, check for a possible loop when setting the transient relationship and deny the request to set a window transient for another if that would create a loop. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759299
2015-12-14 15:34:00 +00:00
if (check_transient_for_loop (window, parent))
{
g_warning ("Setting %p transient for %p would create a loop", window, parent);
return;
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.wl_subsurface)
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
unmap_subsurface (window);
wayland: Map transient surfaces as such
2011-02-11 22:20:14 +00:00
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
previous_parent = impl->transient_for;
wayland: Map transient surfaces as such
2011-02-11 22:20:14 +00:00
impl->transient_for = parent;
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
if (impl->hint == GDK_WINDOW_TYPE_HINT_DIALOG)
{
if (!parent)
_gdk_wayland_screen_add_orphan_dialog (window);
else if (!previous_parent)
wayland: Track orphaned dialogs per display Don't track all orphaned dialogs globally, as mixing them up with each other would in most cases trigger errors when we try to pass bogus values to Wayland requests. https://bugzilla.gnome.org/show_bug.cgi?id=765474
2016-04-26 03:46:25 +00:00
display_wayland->orphan_dialogs =
g_list_remove (display_wayland->orphan_dialogs, window);
wayland: Update parent of dialogs without transient X11 has the notions of "transient for group", and while it's an ICCCM violation, it's commonly used and documented that a window manager would treat a window with transient_for set to None to transient for all windows of its group. gtk uses this when an application sets a dialog type window but does not specify an explicit transient. While this works on X11, there is no such thing as groups in Wayland and the closest equivalent which is set_parent() in xdg-shell takes only one parent. This is what is used for modal dialogs. To get something similar in behavior to what is available on X11, a solution is to update the parent() of the dialogs without transient when the active surface changes. Bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=759161
2015-12-08 15:33:45 +00:00
}
gdk_wayland_window_sync_parent (window, NULL);
wayland: Clean up code determining how to map a window Restructure the mapping procedure so that its known up front what the expected way mapping is to be done (subsurface, popup or stand alone), and warn if it fails to actually map in such a way (for example a popup without a parent or device grab, a tooltip without a parent). https://bugzilla.gnome.org/show_bug.cgi?id=756496
2015-10-13 12:39:02 +00:00
if (should_map_as_subsurface (window) &&
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
parent && gdk_window_is_visible (window))
gdk_wayland_window_create_subsurface (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_get_frame_extents (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkRectangle *rect)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Fix get_frame_extents We need to traverse up the hierarchy for windows here. Just use our existing helper method for this.
2014-03-17 19:41:08 +00:00
gdk_wayland_window_get_fake_root_coords (window, &rect->x, &rect->y);
Add Wayland backend
2010-12-18 20:38:49 +00:00
rect->width = window->width;
rect->height = window->height;
}
static void
gdk_wayland_window_set_override_redirect (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean override_redirect)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_accept_focus (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean accept_focus)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_focus_on_map (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean focus_on_map)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_icon_list (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GList *pixbufs)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_icon_name (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const gchar *name)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
if (GDK_WINDOW_DESTROYED (window))
return;
}
static void
gdk_wayland_window_iconify (GdkWindow *window)
{
wayland: Implement minimize support Use the existing xdg_surface API for minimization. https://bugzilla.gnome.org/show_bug.cgi?id=695945
2015-02-10 23:06:38 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Implement minimize support Use the existing xdg_surface API for minimization. https://bugzilla.gnome.org/show_bug.cgi?id=695945
2015-02-10 23:06:38 +00:00
return;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_set_minimized (impl->display_server.xdg_surface);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_deiconify (GdkWindow *window)
{
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
return;
if (GDK_WINDOW_IS_MAPPED (window))
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_window_show (window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
else
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
/* Flip our client side flag, the real work happens on map. */
gdk_synthesize_window_state (window, GDK_WINDOW_STATE_ICONIFIED, 0);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_stick (GdkWindow *window)
{
}
static void
gdk_wayland_window_unstick (GdkWindow *window)
{
}
static void
gdk_wayland_window_maximize (GdkWindow *window)
{
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Implement gdk_window_[un]maximize This allows the buttons in the decorations to maximise the window. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=695945 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:34:57 +00:00
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
if (GDK_WINDOW_DESTROYED (window))
Add Wayland backend
2010-12-18 20:38:49 +00:00
return;
wayland: Implement gdk_window_[un]maximize This allows the buttons in the decorations to maximise the window. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=695945 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:34:57 +00:00
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
_gdk_wayland_window_save_size (window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
xdg_surface_set_maximized (impl->display_server.xdg_surface);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
else
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_MAXIMIZED);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_unmaximize (GdkWindow *window)
{
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Implement gdk_window_[un]maximize This allows the buttons in the decorations to maximise the window. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=695945 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:34:57 +00:00
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
if (GDK_WINDOW_DESTROYED (window))
Add Wayland backend
2010-12-18 20:38:49 +00:00
return;
wayland: Implement gdk_window_[un]maximize This allows the buttons in the decorations to maximise the window. Fixes: https://bugzilla.gnome.org/show_bug.cgi?id=695945 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-03-16 23:34:57 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
xdg_surface_unset_maximized (impl->display_server.xdg_surface);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
else
gdk_synthesize_window_state (window, GDK_WINDOW_STATE_MAXIMIZED, 0);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
static void
gdk_wayland_window_fullscreen_on_monitor (GdkWindow *window, gint monitor)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
GdkScreen *screen = gdk_window_get_screen (window);
struct wl_output *fullscreen_output =
_gdk_wayland_screen_get_wl_output (screen, monitor);
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
_gdk_wayland_window_save_size (window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
xdg_surface_set_fullscreen (impl->display_server.xdg_surface, fullscreen_output);
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
else {
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FULLSCREEN);
impl->initial_fullscreen_monitor = monitor;
}
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
gdk_wayland_window_fullscreen (GdkWindow *window)
{
wayland: Implement gdk_window_fullscreen & gdk_window_unfullscreen
2013-01-29 18:40:02 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Implement gdk_window_fullscreen & gdk_window_unfullscreen
2013-01-29 18:40:02 +00:00
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
impl->initial_fullscreen_monitor = -1;
wayland: Restore size when configure size is 0x0 According to xdg_shell, an xdg_surface.configure with size 0x0 should be interpreted as that it is up to the client to set a size. When transitioning from maximize or fullscreen state, this means the client should configure its size back to what it was before being maximize or fullscreen. This problem currently only occurs on weston because weston sends a configure with size 0x0 when transitioning back from maximize or fullscreen. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=762713
2016-02-26 12:35:35 +00:00
_gdk_wayland_window_save_size (window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
xdg_surface_set_fullscreen (impl->display_server.xdg_surface, NULL);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
else
gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FULLSCREEN);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_unfullscreen (GdkWindow *window)
{
wayland: Implement gdk_window_fullscreen & gdk_window_unfullscreen
2013-01-29 18:40:02 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Implement gdk_window_fullscreen & gdk_window_unfullscreen
2013-01-29 18:40:02 +00:00
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
impl->initial_fullscreen_monitor = -1;
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.xdg_surface)
xdg_surface_unset_fullscreen (impl->display_server.xdg_surface);
wayland: Apply maximized and fullscreen state We were just throwing the request away if the app asks to fullscreen or maximize a window before it has been mapped. This is something the GdkWindow API explicitly supports, so make it work by saving the state until the surface exists. This fixes things under weston. There are bugs in mutter that keep this from working correctly with gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=745303
2015-02-27 23:18:00 +00:00
else
gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FULLSCREEN, 0);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
wayland: Remove cruft in set_keep_above / set_keep_below It's been decided: these will most likely never be supported on Wayland, so remove the "stub" implementation of them.
2014-03-17 19:42:43 +00:00
gdk_wayland_window_set_keep_above (GdkWindow *window, gboolean setting)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_keep_below (GdkWindow *window, gboolean setting)
{
}
static GdkWindow *
gdk_wayland_window_get_group (GdkWindow *window)
{
return NULL;
}
static void
gdk_wayland_window_set_group (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindow *leader)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_set_decorations (GdkWindow *window,
GdkWMDecoration decorations)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static gboolean
gdk_wayland_window_get_decorations (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWMDecoration *decorations)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
return FALSE;
}
static void
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_set_functions (GdkWindow *window,
GdkWMFunction functions)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_begin_resize_drag (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkWindowEdge edge,
Wayland: Adapt to GdkWindowImpl api change
2011-11-05 05:12:26 +00:00
GdkDevice *device,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
GdkWindowImplWayland *impl;
wayland: unset sequence if the xdg surface is moved/resized through touch The latest implicit grab serial is used in order to start the compositor grab, If it belongs to a touch event, remove that touch sequence, as the rest of the sequence will be gone for good. This avoids stale sequences (and implicit grab info) after a window is moved/resized. https://bugzilla.gnome.org/show_bug.cgi?id=731380
2014-08-20 18:23:58 +00:00
GdkEventSequence *sequence;
uint32_t resize_edges, serial;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL_OR_FOREIGN (window))
return;
switch (edge)
{
case GDK_WINDOW_EDGE_NORTH_WEST:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_TOP_LEFT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_NORTH:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_TOP;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_NORTH_EAST:
wayland: Fix northeast resizing Surprisingly, the same corner that was broken for resizing under X is also broken under Wayland, for an entirely different reason.
2014-03-21 22:22:46 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_TOP_RIGHT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_WEST:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_LEFT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_EAST:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_RIGHT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_SOUTH_WEST:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_BOTTOM_LEFT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_SOUTH:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_BOTTOM;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
case GDK_WINDOW_EDGE_SOUTH_EAST:
wayland: Remove edges from configure
2014-02-07 22:16:28 +00:00
resize_edges = XDG_SURFACE_RESIZE_EDGE_BOTTOM_RIGHT;
Add Wayland backend
2010-12-18 20:38:49 +00:00
break;
default:
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
g_warning ("gdk_window_begin_resize_drag: bad resize edge %d!", edge);
Add Wayland backend
2010-12-18 20:38:49 +00:00
return;
}
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
return;
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
wayland: Make the function to get the last serial a seat one This will be useful for primary selection. https://bugzilla.gnome.org/show_bug.cgi?id=762561
2016-02-23 19:32:31 +00:00
serial = _gdk_wayland_seat_get_last_implicit_grab_serial (gdk_device_get_seat (device),
&sequence);
wayland: unset sequence if the xdg surface is moved/resized through touch The latest implicit grab serial is used in order to start the compositor grab, If it belongs to a touch event, remove that touch sequence, as the rest of the sequence will be gone for good. This avoids stale sequences (and implicit grab info) after a window is moved/resized. https://bugzilla.gnome.org/show_bug.cgi?id=731380
2014-08-20 18:23:58 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_resize (impl->display_server.xdg_surface,
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
gdk_wayland_device_get_wl_seat (device),
wayland: unset sequence if the xdg surface is moved/resized through touch The latest implicit grab serial is used in order to start the compositor grab, If it belongs to a touch event, remove that touch sequence, as the rest of the sequence will be gone for good. This avoids stale sequences (and implicit grab info) after a window is moved/resized. https://bugzilla.gnome.org/show_bug.cgi?id=731380
2014-08-20 18:23:58 +00:00
serial, resize_edges);
if (sequence)
gdk_wayland_device_unset_touch_grab (device, sequence);
wayland: Break an implicit grab when asking to be resized An implicit grab is created inside GTK+ when the button is pressed down on a window. The semantics of wl_shell_surface_resize means that you don't get a corresponding release event that would ordinarily break the implicit grab. So we must do it as part of the resize request.
2012-01-06 16:49:22 +00:00
wayland: Make the resize and move functions use gdk_device_ungrab Now that grab and ungrab vfuncs are implemented on GdkDevice then we can use gdk_device_ungrab to break the implicit grab created by the button press that triggered the resize and move.
2012-01-09 16:00:14 +00:00
/* This is needed since Wayland will absorb all the pointer events after the
* above function - FIXME: Is this always safe..?
wayland: Break an implicit grab when asking to be resized An implicit grab is created inside GTK+ when the button is pressed down on a window. The semantics of wl_shell_surface_resize means that you don't get a corresponding release event that would ordinarily break the implicit grab. So we must do it as part of the resize request.
2012-01-06 16:49:22 +00:00
*/
wayland: Replace deprecated functions We can just gdk_seat_ungrab() here. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:55:39 +00:00
gdk_seat_ungrab (gdk_device_get_seat (device));
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_begin_move_drag (GdkWindow *window,
Wayland: Adapt to GdkWindowImpl api change
2011-11-05 05:12:26 +00:00
GdkDevice *device,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
GdkWindowImplWayland *impl;
wayland: unset sequence if the xdg surface is moved/resized through touch The latest implicit grab serial is used in order to start the compositor grab, If it belongs to a touch event, remove that touch sequence, as the rest of the sequence will be gone for good. This avoids stale sequences (and implicit grab info) after a window is moved/resized. https://bugzilla.gnome.org/show_bug.cgi?id=731380
2014-08-20 18:23:58 +00:00
GdkEventSequence *sequence;
uint32_t serial;
Add Wayland backend
2010-12-18 20:38:49 +00:00
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL (window))
return;
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
return;
wayland: Make the function to get the last serial a seat one This will be useful for primary selection. https://bugzilla.gnome.org/show_bug.cgi?id=762561
2016-02-23 19:32:31 +00:00
serial = _gdk_wayland_seat_get_last_implicit_grab_serial (gdk_device_get_seat (device),
&sequence);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_move (impl->display_server.xdg_surface,
wayland: Replace wl_shell_surface with xdg_shell
2013-11-11 23:02:19 +00:00
gdk_wayland_device_get_wl_seat (device),
wayland: unset sequence if the xdg surface is moved/resized through touch The latest implicit grab serial is used in order to start the compositor grab, If it belongs to a touch event, remove that touch sequence, as the rest of the sequence will be gone for good. This avoids stale sequences (and implicit grab info) after a window is moved/resized. https://bugzilla.gnome.org/show_bug.cgi?id=731380
2014-08-20 18:23:58 +00:00
serial);
if (sequence)
gdk_wayland_device_unset_touch_grab (device, sequence);
wayland: Make the resize and move functions use gdk_device_ungrab Now that grab and ungrab vfuncs are implemented on GdkDevice then we can use gdk_device_ungrab to break the implicit grab created by the button press that triggered the resize and move.
2012-01-09 16:00:14 +00:00
/* This is needed since Wayland will absorb all the pointer events after the
* above function - FIXME: Is this always safe..?
*/
wayland: Replace deprecated functions We can just gdk_seat_ungrab() here. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:55:39 +00:00
gdk_seat_ungrab (gdk_device_get_seat (device));
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_set_opacity (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdouble opacity)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_set_composited (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gboolean composited)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
static void
gdk_wayland_window_destroy_notify (GdkWindow *window)
{
if (!GDK_WINDOW_DESTROYED (window))
{
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
g_warning ("GdkWindow %p unexpectedly destroyed", window);
Add Wayland backend
2010-12-18 20:38:49 +00:00
_gdk_window_destroy (window, TRUE);
}
g_object_unref (window);
}
static void
gdk_wayland_window_sync_rendering (GdkWindow *window)
{
}
static gboolean
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_simulate_key (GdkWindow *window,
gint x,
gint y,
guint keyval,
GdkModifierType modifiers,
GdkEventType key_pressrelease)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
return FALSE;
}
static gboolean
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
gdk_wayland_window_simulate_button (GdkWindow *window,
gint x,
gint y,
guint button,
GdkModifierType modifiers,
GdkEventType button_pressrelease)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
return FALSE;
}
static gboolean
gdk_wayland_window_get_property (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkAtom property,
GdkAtom type,
gulong offset,
gulong length,
gint pdelete,
GdkAtom *actual_property_type,
gint *actual_format_type,
gint *actual_length,
guchar **data)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
return FALSE;
}
static void
gdk_wayland_window_change_property (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkAtom property,
GdkAtom type,
gint format,
GdkPropMode mode,
const guchar *data,
gint nelements)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
wayland: Implement drag/source side of selections This has been made to work similarly to X11, requests for the data device contents are notified through GDK_SELECTION_REQUEST events, the data stored in the GDK_SELECTION property as a reaction to that event is then stored into the wayland selection implementation, and written to the fd when requested/available. https://bugzilla.gnome.org/show_bug.cgi?id=697855
2014-08-21 16:49:44 +00:00
if (property == gdk_atom_intern_static_string ("GDK_SELECTION"))
gdk_wayland_selection_store (window, type, mode, data, nelements * (format / 8));
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
static void
gdk_wayland_window_delete_property (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
GdkAtom property)
Add Wayland backend
2010-12-18 20:38:49 +00:00
{
}
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
static gint
gdk_wayland_window_get_scale_factor (GdkWindow *window)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (GDK_WINDOW_DESTROYED (window))
return 1;
return impl->scale;
}
gdk: Add opaque region setters https://bugzilla.gnome.org/show_bug.cgi?id=706922
2013-05-14 20:23:33 +00:00
static void
gdk_wayland_window_set_opaque_region (GdkWindow *window,
cairo_region_t *region)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Refactor how opaque region is handled Move to a sync system just like the rest of the properties.
2014-03-17 20:08:35 +00:00
g_clear_pointer (&impl->opaque_region, cairo_region_destroy);
impl->opaque_region = cairo_region_reference (region);
gdk_wayland_window_sync_opaque_region (window);
gdk: Add opaque region setters https://bugzilla.gnome.org/show_bug.cgi?id=706922
2013-05-14 20:23:33 +00:00
}
wayland: Add support for set_shadow_width
2014-02-07 22:20:14 +00:00
static void
gdk_wayland_window_set_shadow_width (GdkWindow *window,
int left,
int right,
int top,
int bottom)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
gint new_width, new_height;
wayland: Add support for set_shadow_width
2014-02-07 22:20:14 +00:00
if (GDK_WINDOW_DESTROYED (window))
return;
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
/* Reconfigure window to keep the same window geometry */
new_width = window->width -
(impl->margin_left + impl->margin_right) + (left + right);
new_height = window->height -
(impl->margin_top + impl->margin_bottom) + (top + bottom);
wayland: Do not resize with the same size gnome-control-center is calling gtk_window_resize() on configure-event signals which leads to a busy loop. Avoids such a busy loop by not re-configuring a window with the same size, unless this is coming from and xdg-shell configure. bugzilla: https://bugzilla.gnome.org/show_bug.cgi?id=764374
2016-04-04 12:55:38 +00:00
gdk_wayland_window_maybe_configure (window, new_width, new_height, impl->scale);
wayland: Pass shadow width to the compositor Use xdg_surface_set_window_geometry() to tell the compositor about the shadow widths, this makes some gnome-shell/mutter features (edge resistance, frames around windows in the overview, side maximization, ...) work alright with GTK+. In order to add this, some other places in gdkwindow-wayland had to gain some knowledge about margins: - xdg_surface_configure() now syncs the shadow after applying the state, and gdk_wayland_window_set_shadow_width() possibly reconfigures the window in order to preserve window geometry. This is necessary to keep shadows in sync with state/geometry changes, as this does not happen all at once. - xdg_popups relative to an xdg_surface are shown relative to buffer coordinates, so the left/top margins must be added there. https://bugzilla.gnome.org/show_bug.cgi?id=736742
2014-11-11 11:07:24 +00:00
wayland: Fix margins at startup GtkWindow calls set_shadow_width then maps the window, meaning that we never set the margin. Save it when we set and then set it when we create the XDG surface.
2014-02-27 21:54:20 +00:00
impl->margin_left = left;
impl->margin_right = right;
impl->margin_top = top;
impl->margin_bottom = bottom;
gdk_wayland_window_sync_margin (window);
wayland: Add support for set_shadow_width
2014-02-07 22:20:14 +00:00
}
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
static gboolean
gdk_wayland_window_show_window_menu (GdkWindow *window,
GdkEvent *event)
{
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
struct wl_seat *seat;
wayland: Improve implicit grab serial retrieval _gdk_wayland_device_get_button_press_serial() has been replaced by _gdk_wayland_device_get_implicit_grab_serial(), which takes a touch/pointer event and figures out the relevant serial, and _gdk_wayland_device_get_last_implicit_grab_serial() which returns the most recent serial. The button press serial was currently used when operating popping up xdg_shell/surface popups and window menus, so this is now touch aware, of some sort. https://bugzilla.gnome.org/show_bug.cgi?id=734374
2014-08-13 19:05:58 +00:00
GdkWaylandDevice *device;
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
double x, y;
switch (event->type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
wayland: Improve implicit grab serial retrieval _gdk_wayland_device_get_button_press_serial() has been replaced by _gdk_wayland_device_get_implicit_grab_serial(), which takes a touch/pointer event and figures out the relevant serial, and _gdk_wayland_device_get_last_implicit_grab_serial() which returns the most recent serial. The button press serial was currently used when operating popping up xdg_shell/surface popups and window menus, so this is now touch aware, of some sort. https://bugzilla.gnome.org/show_bug.cgi?id=734374
2014-08-13 19:05:58 +00:00
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_END:
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
break;
default:
return FALSE;
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.xdg_surface)
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
return FALSE;
wayland: Improve implicit grab serial retrieval _gdk_wayland_device_get_button_press_serial() has been replaced by _gdk_wayland_device_get_implicit_grab_serial(), which takes a touch/pointer event and figures out the relevant serial, and _gdk_wayland_device_get_last_implicit_grab_serial() which returns the most recent serial. The button press serial was currently used when operating popping up xdg_shell/surface popups and window menus, so this is now touch aware, of some sort. https://bugzilla.gnome.org/show_bug.cgi?id=734374
2014-08-13 19:05:58 +00:00
device = GDK_WAYLAND_DEVICE (gdk_event_get_device (event));
seat = gdk_wayland_device_get_wl_seat (GDK_DEVICE (device));
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
gdk_event_get_coords (event, &x, &y);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
xdg_surface_show_window_menu (impl->display_server.xdg_surface,
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
seat,
wayland: Improve implicit grab serial retrieval _gdk_wayland_device_get_button_press_serial() has been replaced by _gdk_wayland_device_get_implicit_grab_serial(), which takes a touch/pointer event and figures out the relevant serial, and _gdk_wayland_device_get_last_implicit_grab_serial() which returns the most recent serial. The button press serial was currently used when operating popping up xdg_shell/surface popups and window menus, so this is now touch aware, of some sort. https://bugzilla.gnome.org/show_bug.cgi?id=734374
2014-08-13 19:05:58 +00:00
_gdk_wayland_device_get_implicit_grab_serial (device, event),
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
x, y);
return TRUE;
}
Add Wayland backend
2010-12-18 20:38:49 +00:00
static void
_gdk_window_impl_wayland_class_init (GdkWindowImplWaylandClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_CLASS (klass);
object_class->finalize = gdk_window_impl_wayland_finalize;
impl_class->ref_cairo_surface = gdk_wayland_window_ref_cairo_surface;
wayland: Add custom create_similar_image implementation The fallback method is used on other backends, but it caused problems for wayland when it tried to create a surface for the root window.
2013-07-03 14:03:25 +00:00
impl_class->create_similar_image_surface = gdk_wayland_window_create_similar_image_surface;
Add Wayland backend
2010-12-18 20:38:49 +00:00
impl_class->show = gdk_wayland_window_show;
impl_class->hide = gdk_wayland_window_hide;
impl_class->withdraw = gdk_window_wayland_withdraw;
impl_class->set_events = gdk_window_wayland_set_events;
impl_class->get_events = gdk_window_wayland_get_events;
impl_class->raise = gdk_window_wayland_raise;
impl_class->lower = gdk_window_wayland_lower;
impl_class->restack_under = gdk_window_wayland_restack_under;
impl_class->restack_toplevel = gdk_window_wayland_restack_toplevel;
impl_class->move_resize = gdk_window_wayland_move_resize;
impl_class->set_background = gdk_window_wayland_set_background;
impl_class->reparent = gdk_window_wayland_reparent;
impl_class->set_device_cursor = gdk_window_wayland_set_device_cursor;
impl_class->get_geometry = gdk_window_wayland_get_geometry;
impl_class->get_root_coords = gdk_window_wayland_get_root_coords;
impl_class->get_device_state = gdk_window_wayland_get_device_state;
impl_class->shape_combine_region = gdk_window_wayland_shape_combine_region;
impl_class->input_shape_combine_region = gdk_window_wayland_input_shape_combine_region;
impl_class->destroy = gdk_wayland_window_destroy;
impl_class->destroy_foreign = gdk_window_wayland_destroy_foreign;
impl_class->get_shape = gdk_wayland_window_get_shape;
impl_class->get_input_shape = gdk_wayland_window_get_input_shape;
gdkwindow: Don't pass the region to the impl when beginning a paint It's unused. At the same time, rename "begin_paint_region" to "begin_paint". This will help us clean up how GDK painting works in the future to allow more creative use of double-buffering.
2014-11-22 16:08:34 +00:00
impl_class->begin_paint = gdk_window_impl_wayland_begin_paint;
gdkwindow-wayland: Attach new buffers and submit damage in end_paint process_updates_recurse is simply the wrong place for it to be.
2014-06-21 21:29:08 +00:00
impl_class->end_paint = gdk_window_impl_wayland_end_paint;
wayland: Add system bell support via gtk_shell Invoke the system bell by calling the request added to the gtk_shell protocol. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 04:41:31 +00:00
impl_class->beep = gdk_window_impl_wayland_beep;
Add Wayland backend
2010-12-18 20:38:49 +00:00
impl_class->focus = gdk_wayland_window_focus;
impl_class->set_type_hint = gdk_wayland_window_set_type_hint;
impl_class->get_type_hint = gdk_wayland_window_get_type_hint;
impl_class->set_modal_hint = gdk_wayland_window_set_modal_hint;
impl_class->set_skip_taskbar_hint = gdk_wayland_window_set_skip_taskbar_hint;
impl_class->set_skip_pager_hint = gdk_wayland_window_set_skip_pager_hint;
impl_class->set_urgency_hint = gdk_wayland_window_set_urgency_hint;
impl_class->set_geometry_hints = gdk_wayland_window_set_geometry_hints;
impl_class->set_title = gdk_wayland_window_set_title;
impl_class->set_role = gdk_wayland_window_set_role;
impl_class->set_startup_id = gdk_wayland_window_set_startup_id;
impl_class->set_transient_for = gdk_wayland_window_set_transient_for;
impl_class->get_frame_extents = gdk_wayland_window_get_frame_extents;
impl_class->set_override_redirect = gdk_wayland_window_set_override_redirect;
impl_class->set_accept_focus = gdk_wayland_window_set_accept_focus;
impl_class->set_focus_on_map = gdk_wayland_window_set_focus_on_map;
impl_class->set_icon_list = gdk_wayland_window_set_icon_list;
impl_class->set_icon_name = gdk_wayland_window_set_icon_name;
impl_class->iconify = gdk_wayland_window_iconify;
impl_class->deiconify = gdk_wayland_window_deiconify;
impl_class->stick = gdk_wayland_window_stick;
impl_class->unstick = gdk_wayland_window_unstick;
impl_class->maximize = gdk_wayland_window_maximize;
impl_class->unmaximize = gdk_wayland_window_unmaximize;
impl_class->fullscreen = gdk_wayland_window_fullscreen;
Added api to set a window to fullscreen on a given monitor. https://bugzilla.gnome.org/show_bug.cgi?id=752677
2015-07-13 16:30:42 +00:00
impl_class->fullscreen_on_monitor = gdk_wayland_window_fullscreen_on_monitor;
Add Wayland backend
2010-12-18 20:38:49 +00:00
impl_class->unfullscreen = gdk_wayland_window_unfullscreen;
impl_class->set_keep_above = gdk_wayland_window_set_keep_above;
impl_class->set_keep_below = gdk_wayland_window_set_keep_below;
impl_class->get_group = gdk_wayland_window_get_group;
impl_class->set_group = gdk_wayland_window_set_group;
impl_class->set_decorations = gdk_wayland_window_set_decorations;
impl_class->get_decorations = gdk_wayland_window_get_decorations;
impl_class->set_functions = gdk_wayland_window_set_functions;
impl_class->begin_resize_drag = gdk_wayland_window_begin_resize_drag;
impl_class->begin_move_drag = gdk_wayland_window_begin_move_drag;
impl_class->set_opacity = gdk_wayland_window_set_opacity;
impl_class->set_composited = gdk_wayland_window_set_composited;
impl_class->destroy_notify = gdk_wayland_window_destroy_notify;
Track 2.99.3 API changes
2011-02-08 13:12:59 +00:00
impl_class->get_drag_protocol = _gdk_wayland_window_get_drag_protocol;
Add Wayland backend
2010-12-18 20:38:49 +00:00
impl_class->register_dnd = _gdk_wayland_window_register_dnd;
impl_class->drag_begin = _gdk_wayland_window_drag_begin;
impl_class->sync_rendering = gdk_wayland_window_sync_rendering;
impl_class->simulate_key = gdk_wayland_window_simulate_key;
impl_class->simulate_button = gdk_wayland_window_simulate_button;
impl_class->get_property = gdk_wayland_window_get_property;
impl_class->change_property = gdk_wayland_window_change_property;
impl_class->delete_property = gdk_wayland_window_delete_property;
wayland: Support gdk_window_get_scale We track the list of outputs each window is on, and set the scale to the largest scale value of the outputs. Any time the scale changes we also emit a configure event.
2013-06-04 09:39:36 +00:00
impl_class->get_scale_factor = gdk_wayland_window_get_scale_factor;
gdk: Add opaque region setters https://bugzilla.gnome.org/show_bug.cgi?id=706922
2013-05-14 20:23:33 +00:00
impl_class->set_opaque_region = gdk_wayland_window_set_opaque_region;
wayland: Add support for set_shadow_width
2014-02-07 22:20:14 +00:00
impl_class->set_shadow_width = gdk_wayland_window_set_shadow_width;
wayland: Add support for show_window_menu
2014-05-24 03:01:27 +00:00
impl_class->show_window_menu = gdk_wayland_window_show_window_menu;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
impl_class->create_gl_context = gdk_wayland_window_create_gl_context;
impl_class->invalidate_for_new_frame = gdk_wayland_window_invalidate_for_new_frame;
wayland: Make subsurface desynchronized after first parent surface frame Initially the subsurface will be in synchronized mode and we will leave it like this until the first time the parent surface has been committed. The reason for this is because the subsurface position will be applied as part of the parent surface state, and we need to synchronize the initial position with the initial frame, so that we don't accidentally draw the subsurface at the default position (0, 0) which would happen in desynchronized mode if the subsurface content is committed before the next parent surface commit. https://bugzilla.gnome.org/show_bug.cgi?id=754839
2015-09-10 09:42:21 +00:00
signals[COMMITTED] = g_signal_new ("committed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
Add Wayland backend
2010-12-18 20:38:49 +00:00
}
wayland: Store the device that does a grab for a window on the window This allows us to get the device if we need to make the window a popup. This relies on the side effect that GTK calls into GDK to take a grab before the popup window is shown.
2012-02-27 14:06:22 +00:00
void
wayland: Improve creation of windowing surface roles We no longer need a grabbed seat, instead we'll just use the default seat if this happens, not without first warning and recommending gdk_seat_grab() for the operation. https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-12-09 11:56:26 +00:00
_gdk_wayland_window_set_grab_seat (GdkWindow *window,
GdkSeat *seat)
wayland: Store the device that does a grab for a window on the window This allows us to get the device if we need to make the window a popup. This relies on the side effect that GTK calls into GDK to take a grab before the popup window is shown.
2012-02-27 14:06:22 +00:00
{
wayland: Add NULL warning check to _gdk_wayland_window_set_device_grabbed
2012-03-05 19:41:11 +00:00
GdkWindowImplWayland *impl;
g_return_if_fail (window != NULL);
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Port to new input protocol mechanism This replaces the wl_input_device with wl_pointer, wl_keyboard, wl_touch all tied together under a wl_seat. This is quite a radical change in protocol and for now keyboard handling is disabled.
2012-07-11 13:29:43 +00:00
impl->grab_input_seat = seat;
wayland: Store the device that does a grab for a window on the window This allows us to get the device if we need to make the window a popup. This relies on the side effect that GTK calls into GDK to take a grab before the popup window is shown.
2012-02-27 14:06:22 +00:00
}
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
/**
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
* gdk_wayland_window_get_wl_surface:
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
* @window: (type GdkWaylandWindow): a #GdkWindow
*
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
* Returns the Wayland surface of a #GdkWindow.
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
*
* Returns: (transfer none): a Wayland wl_surface
*
* Since: 3.8
*/
struct wl_surface *
gdk_wayland_window_get_wl_surface (GdkWindow *window)
{
g_return_val_if_fail (GDK_IS_WAYLAND_WINDOW (window), NULL);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
return GDK_WINDOW_IMPL_WAYLAND (window->impl)->display_server.wl_surface;
wayland: Make GdkWaylandWindow public Allows to access Wayland specific window information like wl_surface and wl_shell_surface. Add gdk_wayland_window_get_wl_surface for getting the Wayland wl_surface and gdk_wayland_window_get_wl_shell_surface for getting the Wayland wl_shell_surface.
2013-01-23 21:20:05 +00:00
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
static struct wl_egl_window *
gdk_wayland_window_get_wl_egl_window (GdkWindow *window)
{
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.egl_window == NULL)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.egl_window =
wl_egl_window_create (impl->display_server.wl_surface,
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
impl->wrapper->width * impl->scale,
impl->wrapper->height * impl->scale);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
wl_surface_set_buffer_scale (impl->display_server.wl_surface, impl->scale);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
return impl->display_server.egl_window;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
EGLSurface
gdk_wayland_window_get_egl_surface (GdkWindow *window,
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
EGLConfig config)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
GdkWindowImplWayland *impl;
struct wl_egl_window *egl_window;
g_return_val_if_fail (GDK_IS_WAYLAND_WINDOW (window), NULL);
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (impl->egl_surface == NULL)
{
egl_window = gdk_wayland_window_get_wl_egl_window (window);
impl->egl_surface =
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
eglCreateWindowSurface (display->egl_display, config, egl_window, NULL);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
return impl->egl_surface;
}
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
EGLSurface
gdk_wayland_window_get_dummy_egl_surface (GdkWindow *window,
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
EGLConfig config)
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
{
wayland: Formatting fixes
2015-02-28 03:28:28 +00:00
GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (gdk_window_get_display (window));
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
GdkWindowImplWayland *impl;
g_return_val_if_fail (GDK_IS_WAYLAND_WINDOW (window), NULL);
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
if (impl->dummy_egl_surface == NULL)
{
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
impl->display_server.dummy_egl_window =
wl_egl_window_create (impl->display_server.wl_surface, 1, 1);
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
impl->dummy_egl_surface =
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
eglCreateWindowSurface (display->egl_display, config, impl->display_server.dummy_egl_window, NULL);
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
}
return impl->dummy_egl_surface;
}
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
/**
* gdk_wayland_window_set_use_custom_surface:
* @window: (type GdkWaylandWindow): a #GdkWindow
*
* Marks a #GdkWindow as a custom Wayland surface. The application is
* expected to register the surface as some type of surface using
* some Wayland interface.
*
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
* A good example would be writing a panel or on-screen-keyboard as an
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
* out-of-process helper - as opposed to having those in the compositor
docs: use apostrophes in *n't
2014-02-07 18:32:47 +00:00
* process. In this case the underlying surface isn’t an xdg_shell
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
* surface and the panel or OSK client need to identify the wl_surface
* as a panel or OSK to the compositor. The assumption is that the
* compositor will expose a private interface to the special client
* that lets the client identify the wl_surface as a panel or such.
*
* This function should be called before a #GdkWindow is shown. This is
docs: fix typo in signal link
2014-01-21 23:46:05 +00:00
* best done by connecting to the #GtkWidget::realize signal:
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
*
docs: Identify examples that are C code https://bugzilla.gnome.org/show_bug.cgi?id=723119
2014-01-27 19:55:18 +00:00
* |[<!-- language="C" -->
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
* static void
* widget_realize_cb (GtkWidget *widget)
* {
* GdkWindow *window;
* struct wl_surface *surface;
* struct input_panel_surface *ip_surface;
*
* window = gtk_widget_get_window (widget);
* gdk_wayland_window_set_custom_surface (window);
*
* surface = gdk_wayland_window_get_wl_surface (window);
* ip_surface = input_panel_get_input_panel_surface (input_panel, surface);
* input_panel_surface_set_panel (ip_surface);
* }
*
* static void
* setup_window (GtkWindow *window)
* {
* g_signal_connect (window, "realize", G_CALLBACK (widget_realize_cb), NULL);
* }
docs: use |[ ]| instead of <programlisting></programlisting> https://bugzilla.gnome.org/show_bug.cgi?id=723119
2014-01-27 17:12:55 +00:00
* ]|
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
*
* Since: 3.10
*/
void
gdk_wayland_window_set_use_custom_surface (GdkWindow *window)
{
GdkWindowImplWayland *impl;
g_return_if_fail (GDK_IS_WAYLAND_WINDOW (window));
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (!impl->display_server.wl_surface)
GdkWaylandWindow: Consolidate surface creation and destruction code Combine duplicate code for creating and destroying surfaces. To make the operation of the destroy() operation more obvious, the destruction of the (fake) root window at display dispose time is changed to not be a "foreign" destroy. https://bugzilla.gnome.org/show_bug.cgi?id=698864
2013-04-25 15:11:02 +00:00
gdk_wayland_window_create_surface (window);
wayland: Add support for custom surfaces Allow to set a GdkWindow to use a custom surface instead of a wl_shell_surface. It allows to register the surface as a custom type with some Wayland interface. https://bugzilla.gnome.org/show_bug.cgi?id=695861
2013-03-20 15:38:36 +00:00
impl->use_custom_surface = TRUE;
}
wayland: restore support for the application menu If the compositor supports the gtk-shell interface, use it to export the application ID, dbus name and paths that can be used for the application menu. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:56:45 +00:00
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
static void
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
maybe_set_gtk_surface_dbus_properties (GdkWindow *window)
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
{
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
if (impl->application.was_set)
return;
if (impl->application.application_id == NULL &&
impl->application.app_menu_path == NULL &&
impl->application.menubar_path == NULL &&
impl->application.window_object_path == NULL &&
impl->application.application_object_path == NULL &&
impl->application.unique_bus_name == NULL)
return;
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
gdk_wayland_window_init_gtk_surface (window);
wayland: move server proxy objects to substructure This commit moves the server proxy objects to a substructure for clarity. https://bugzilla.gnome.org/show_bug.cgi?id=761312
2016-02-02 16:42:52 +00:00
if (impl->display_server.gtk_surface == NULL)
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
return;
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
wayland: Don't invent our own unstable protocol semantics The gtk_shell protocol used some half baked unstable protocol semantics that worked by only allowing binding the exact version of the interface. This hack is a bit too confusing and it makes it impossible to do any compatible changes without breaking things. So, instead rename it to include a number in the interface names. This way we can add requests and events without causing compatibility issues, and we can later remove requests and events by bumping the number in the interface names. https://bugzilla.gnome.org/show_bug.cgi?id=763001
2016-03-07 03:49:35 +00:00
gtk_surface1_set_dbus_properties (impl->display_server.gtk_surface,
impl->application.application_id,
impl->application.app_menu_path,
impl->application.menubar_path,
impl->application.window_object_path,
impl->application.application_object_path,
impl->application.unique_bus_name);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
impl->application.was_set = TRUE;
}
wayland: restore support for the application menu If the compositor supports the gtk-shell interface, use it to export the application ID, dbus name and paths that can be used for the application menu. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:56:45 +00:00
void
gdk_wayland_window_set_dbus_properties_libgtk_only (GdkWindow *window,
Trivial formatting fixes
2013-09-16 21:23:29 +00:00
const char *application_id,
const char *app_menu_path,
const char *menubar_path,
const char *window_object_path,
const char *application_object_path,
const char *unique_bus_name)
wayland: restore support for the application menu If the compositor supports the gtk-shell interface, use it to export the application ID, dbus name and paths that can be used for the application menu. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:56:45 +00:00
{
GdkWindowImplWayland *impl;
g_return_if_fail (GDK_IS_WAYLAND_WINDOW (window));
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
wayland: Set a more correct xdg_surface application id The "app_id" of a xdg_surface should be the ID that can potentially be used to get the DBUS name or the .desktop file. For GtkApplication programs this is often the ID passed when creating the GtkApplication object, so when available lets use that. As fallbacks, first try g_get_prgname as it often corresponds to the basename part of the .dektop file for non-GtkApplication programs. Otherwise use gdk_get_program_class, even though that string usually doesn't conform to the expectations of xdg_surface.set_application_id. https://bugzilla.gnome.org/show_bug.cgi?id=746435
2015-03-23 05:08:09 +00:00
impl->application.application_id = g_strdup (application_id);
impl->application.app_menu_path = g_strdup (app_menu_path);
impl->application.menubar_path = g_strdup (menubar_path);
impl->application.window_object_path = g_strdup (window_object_path);
impl->application.application_object_path =
g_strdup (application_object_path);
impl->application.unique_bus_name = g_strdup (unique_bus_name);
wayland: restore support for the application menu If the compositor supports the gtk-shell interface, use it to export the application ID, dbus name and paths that can be used for the application menu. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:56:45 +00:00
wayland: Add support for gtk_window_set_modal Add two new requests to the gtk_surface interface: set_modal and unset_modal. The server will currently not do anything special with input focus, and its up to the client to ignore events on the parent surface. This commit bumps the gtk_shell interface version to 2. By connecting to a Wayland server with another gtk_shell interface version any features depending on the gtk_shell protocol will not be available. https://bugzilla.gnome.org/show_bug.cgi?id=745721
2015-03-06 03:40:12 +00:00
maybe_set_gtk_surface_dbus_properties (window);
wayland: restore support for the application menu If the compositor supports the gtk-shell interface, use it to export the application ID, dbus name and paths that can be used for the application menu. https://bugzilla.gnome.org/show_bug.cgi?id=707129
2013-08-30 11:56:45 +00:00
}
wayland: Implement DND icon hotspot API In Wayland, the hotspot of a DND icon is set using the buffer offset in wl_buffer.attach. To implement this, add a private API to cause the next wl_surface.attach to offset the new buffer with a given offset. Setting a DND icon hotspot sets this offset while also queuing a redraw of the window to trigger the wl_surface.attach. https://bugzilla.gnome.org/show_bug.cgi?id=759168
2015-12-08 10:19:33 +00:00
void
_gdk_wayland_window_offset_next_wl_buffer (GdkWindow *window,
int x,
int y)
{
GdkWindowImplWayland *impl;
g_return_if_fail (GDK_IS_WAYLAND_WINDOW (window));
impl = GDK_WINDOW_IMPL_WAYLAND (window->impl);
impl->pending_buffer_offset_x = x;
impl->pending_buffer_offset_y = y;
}
Reference in New Issue Copy Permalink