isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-04 13:50:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
bc41a88c92
mutter/src/wayland/meta-wayland-shell-surface.c

396 lines
13 KiB
C
Raw Normal View History

wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
/*
* Copyright (C) 2012,2013 Intel Corporation
* Copyright (C) 2013-2017 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#include "config.h"
#include "wayland/meta-wayland-shell-surface.h"
#include "compositor/meta-surface-actor-wayland.h"
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
#include "compositor/meta-window-actor-private.h"
wayland: Move tree updating to the shell surface role The shell surface role is the one where subsurfaces may exist, and it has direct relation to the MetaWindowActorWayland which currently has the subsurface stacking logic. Instead of directly finding the window actor when dealing with subsurfaces, notify the parent surface that the subsurface state changed, so that it can outsource the application of this information to the role. For subsurface roles, this simply means forward upward to the parent; for shell surface roles, this means regenerate the surface actor layering. This allows us to move away from accessing the window directly from the surface, which in turn allows us to change the ownership structure of windows. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-08 17:32:37 -04:00
#include "compositor/meta-window-actor-wayland.h"
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
#include "wayland/meta-wayland-actor-surface.h"
#include "wayland/meta-wayland-buffer.h"
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
#include "wayland/meta-wayland-subsurface.h"
#include "wayland/meta-wayland-surface.h"
#include "wayland/meta-window-wayland.h"
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
typedef struct _MetaWaylandShellSurfacePrivate
{
MetaWindow *window;
gulong unmanaging_handler_id;
gulong effects_completed_handler_id;
} MetaWaylandShellSurfacePrivate;
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (MetaWaylandShellSurface,
meta_wayland_shell_surface,
META_TYPE_WAYLAND_ACTOR_SURFACE)
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
void
meta_wayland_shell_surface_calculate_geometry (MetaWaylandShellSurface *shell_surface,
MetaRectangle *out_geometry)
{
MetaWaylandSurfaceRole *surface_role =
META_WAYLAND_SURFACE_ROLE (shell_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
MetaRectangle geometry;
wayland: Replace manual GNode subsurface iteration with macro Similar to wl_list_foreach(), add META_WAYLAND_SURFACE_FOREACH_SUBSURFACE() that iterates over all the subsurfaces of a surface, without the caller needing to care about implementation details, such as leaf nodes vs non-leaf nodes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 12:22:47 -05:00
MetaWaylandSurface *subsurface_surface;
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
geometry = (MetaRectangle) {
wayland: Use surface size helper functions Use meta_wayland_surface_get_width / meta_wayland_surface_get_width to determine the size of a surface.
2018-06-29 11:53:21 -04:00
.width = meta_wayland_surface_get_width (surface),
.height = meta_wayland_surface_get_height (surface),
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
};
wayland: Replace manual GNode subsurface iteration with macro Similar to wl_list_foreach(), add META_WAYLAND_SURFACE_FOREACH_SUBSURFACE() that iterates over all the subsurfaces of a surface, without the caller needing to care about implementation details, such as leaf nodes vs non-leaf nodes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 12:22:47 -05:00
META_WAYLAND_SURFACE_FOREACH_SUBSURFACE (surface, subsurface_surface)
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
{
wayland: Implement subsurface.place_below() for parents Flatten the subsurface actor tree, making all surface actors children of the window actor. Save the subsurface state in a GNode tree in MetaWaylandSurface, where each surface holds two nodes, one branch, which can be the tree root or be attached to a parent surfaces branch, and a leaf, which is used to save the position relative to child branch nodes. Each time a surface is added or reordered in the tree, unparent all surface actors from the window actor, traverse all leaves of the tree and readd the corresponding surface actors back to the window actor. https://gitlab.gnome.org/GNOME/mutter/merge_requests/664
2019-06-30 09:18:46 -04:00
MetaWaylandSubsurface *subsurface;
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
wayland: Implement subsurface.place_below() for parents Flatten the subsurface actor tree, making all surface actors children of the window actor. Save the subsurface state in a GNode tree in MetaWaylandSurface, where each surface holds two nodes, one branch, which can be the tree root or be attached to a parent surfaces branch, and a leaf, which is used to save the position relative to child branch nodes. Each time a surface is added or reordered in the tree, unparent all surface actors from the window actor, traverse all leaves of the tree and readd the corresponding surface actors back to the window actor. https://gitlab.gnome.org/GNOME/mutter/merge_requests/664
2019-06-30 09:18:46 -04:00
subsurface = META_WAYLAND_SUBSURFACE (subsurface_surface->role);
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
meta_wayland_subsurface_union_geometry (subsurface,
0, 0,
&geometry);
}
*out_geometry = geometry;
}
wayland/xdg-shell: Intersect set geometry with subsurface tree geometry Currently xdg-shell applies a geometry set with set_window_geometry unconditionally. But the specification requires: > When applied, the effective window geometry will be > the set window geometry clamped to the bounding rectangle of the > combined geometry of the surface of the xdg_surface and the > associated subsurfaces. This is especially important to implement viewporter and transformation.
2018-08-18 13:41:15 -04:00
void
meta_wayland_shell_surface_determine_geometry (MetaWaylandShellSurface *shell_surface,
MetaRectangle *set_geometry,
MetaRectangle *out_geometry)
{
MetaRectangle bounding_geometry = { 0 };
MetaRectangle intersected_geometry = { 0 };
meta_wayland_shell_surface_calculate_geometry (shell_surface,
&bounding_geometry);
meta_rectangle_intersect (set_geometry, &bounding_geometry,
&intersected_geometry);
*out_geometry = intersected_geometry;
}
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
static void
clear_window (MetaWaylandShellSurface *shell_surface)
{
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
MetaWaylandSurfaceRole *surface_role =
META_WAYLAND_SURFACE_ROLE (shell_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
MetaSurfaceActor *surface_actor;
if (!priv->window)
return;
g_clear_signal_handler (&priv->unmanaging_handler_id,
priv->window);
g_clear_signal_handler (&priv->effects_completed_handler_id,
meta_window_actor_from_window (priv->window));
priv->window = NULL;
surface_actor = meta_wayland_surface_get_actor (surface);
if (surface_actor)
clutter_actor_set_reactive (CLUTTER_ACTOR (surface_actor), FALSE);
meta_wayland_surface_notify_unmapped (surface);
}
static void
window_unmanaging (MetaWindow *window,
MetaWaylandShellSurface *shell_surface)
{
clear_window (shell_surface);
}
static void
window_actor_effects_completed (MetaWindowActor *window_actor,
MetaWaylandSurface *surface)
{
meta_wayland_compositor_repick (surface->compositor);
}
wayland: Use helper to set shell surface window The helper deals with updating the surface output state. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 03:26:24 -05:00
void
meta_wayland_shell_surface_set_window (MetaWaylandShellSurface *shell_surface,
MetaWindow *window)
{
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
wayland: Use helper to set shell surface window The helper deals with updating the surface output state. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 03:26:24 -05:00
MetaWaylandSurfaceRole *surface_role =
META_WAYLAND_SURFACE_ROLE (shell_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaSurfaceActor *surface_actor;
g_assert (!priv->window);
priv->window = window;
surface_actor = meta_wayland_surface_get_actor (surface);
if (surface_actor)
clutter_actor_set_reactive (CLUTTER_ACTOR (surface_actor), TRUE);
priv->unmanaging_handler_id =
g_signal_connect (window,
"unmanaging",
G_CALLBACK (window_unmanaging),
shell_surface);
priv->effects_completed_handler_id =
g_signal_connect (meta_window_actor_from_window (window),
"effects-completed",
G_CALLBACK (window_actor_effects_completed),
surface);
wayland: Use helper to set shell surface window The helper deals with updating the surface output state. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 03:26:24 -05:00
window: Pass flag to meta_window_update_monitor() instead of bool The bool determines whether the call was directly from a user operation or not. To add more state into the call without having to add more boolenas, change the boolean to a flag (so far with 'none' and 'user-op' as possible values). No functional changes were made. https://gitlab.gnome.org/GNOME/mutter/issues/192
2018-08-24 06:54:50 -04:00
meta_window_update_monitor (window, META_WINDOW_UPDATE_MONITOR_FLAGS_NONE);
wayland: Use helper to set shell surface window The helper deals with updating the surface output state. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 03:26:24 -05:00
}
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
void
wayland: Rework asynchronous window configuration This changes how asynchronous window configuration works. Prior to this commit, it worked by MetaWindowWayland remembering the last configuration it sent, then when the Wayland client got back to it, it tried to figure out whether it was a acknowledgment of the configuration or not, and finish the move. This failed if the client had acknowledged a configuration older than the last one sent, and it had hacks to somewhat deal with wl_shell's lack of configuration serial numbers. This commits scraps that and makes the MetaWindowWayland take ownership of sent configurations, including generating serial numbers. The wl_shell implementation is changed to emulate serial numbers (assuming each commit acknowledges the last sent configure event). Each configuration sent to the client is kept around until the client one. At this point, the position used for that particular configuration is used when applying the acknowledged state, meaning cases where we have already sent a new configuration when the client acknowledges a previous one, we'll still use the correct position for the window. https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-05 12:10:14 -04:00
meta_wayland_shell_surface_configure (MetaWaylandShellSurface *shell_surface,
MetaWaylandWindowConfiguration *configuration)
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
{
MetaWaylandShellSurfaceClass *shell_surface_class =
META_WAYLAND_SHELL_SURFACE_GET_CLASS (shell_surface);
wayland: Rework asynchronous window configuration This changes how asynchronous window configuration works. Prior to this commit, it worked by MetaWindowWayland remembering the last configuration it sent, then when the Wayland client got back to it, it tried to figure out whether it was a acknowledgment of the configuration or not, and finish the move. This failed if the client had acknowledged a configuration older than the last one sent, and it had hacks to somewhat deal with wl_shell's lack of configuration serial numbers. This commits scraps that and makes the MetaWindowWayland take ownership of sent configurations, including generating serial numbers. The wl_shell implementation is changed to emulate serial numbers (assuming each commit acknowledges the last sent configure event). Each configuration sent to the client is kept around until the client one. At this point, the position used for that particular configuration is used when applying the acknowledged state, meaning cases where we have already sent a new configuration when the client acknowledges a previous one, we'll still use the correct position for the window. https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-05 12:10:14 -04:00
shell_surface_class->configure (shell_surface, configuration);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
}
void
meta_wayland_shell_surface_ping (MetaWaylandShellSurface *shell_surface,
uint32_t serial)
{
MetaWaylandShellSurfaceClass *shell_surface_class =
META_WAYLAND_SHELL_SURFACE_GET_CLASS (shell_surface);
shell_surface_class->ping (shell_surface, serial);
}
void
meta_wayland_shell_surface_close (MetaWaylandShellSurface *shell_surface)
{
MetaWaylandShellSurfaceClass *shell_surface_class =
META_WAYLAND_SHELL_SURFACE_GET_CLASS (shell_surface);
shell_surface_class->close (shell_surface);
}
void
meta_wayland_shell_surface_managed (MetaWaylandShellSurface *shell_surface,
MetaWindow *window)
{
MetaWaylandShellSurfaceClass *shell_surface_class =
META_WAYLAND_SHELL_SURFACE_GET_CLASS (shell_surface);
shell_surface_class->managed (shell_surface, window);
}
wayland/surface: Let roles set DND functions The DND functions are role specific, with Xwayland surface being the special one. Let the roles set it instead of having per role like logic in MetaWaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:53:23 -04:00
static void
meta_wayland_shell_surface_assigned (MetaWaylandSurfaceRole *surface_role)
{
MetaWaylandSurfaceRoleClass *surface_role_class =
META_WAYLAND_SURFACE_ROLE_CLASS (meta_wayland_shell_surface_parent_class);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
surface->dnd.funcs = meta_wayland_data_device_get_drag_dest_funcs ();
surface_role_class->assigned (surface_role);
}
wayland: Move calc-showing window logic to roles having windows https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:56:34 -04:00
static void
meta_wayland_shell_surface_surface_pre_apply_state (MetaWaylandSurfaceRole *surface_role,
MetaWaylandSurfaceState *pending)
{
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaWaylandShellSurface *shell_surface =
META_WAYLAND_SHELL_SURFACE (surface_role);
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
wayland: Move calc-showing window logic to roles having windows https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:56:34 -04:00
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
if (pending->newly_attached &&
wayland/surface: Put buffer reference on heap Currently a buffer use count always reaches zero before it is replaced. This is due to the fact that at the point a new buffer is attached, the last potential user releases it (the stage) since the currently displayed frame has a composited copy of the buffer. This may however change, if a buffer is scanned out directly, meaning it should not be released until the page flip callback is invoked. Prepare for this by making the buffer reference a heap allocated struct, enabling us to keep a pointer to it longer than the buffer is attached. https://gitlab.gnome.org/GNOME/mutter/merge_requests/798
2019-08-13 12:46:36 -04:00
!surface->buffer_ref->buffer &&
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
priv->window)
meta_window_queue (priv->window, META_QUEUE_CALC_SHOWING);
wayland: Move calc-showing window logic to roles having windows https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:56:34 -04:00
}
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
static void
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
meta_wayland_shell_surface_surface_apply_state (MetaWaylandSurfaceRole *surface_role,
MetaWaylandSurfaceState *pending)
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
{
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaWaylandShellSurface *shell_surface =
META_WAYLAND_SHELL_SURFACE (surface_role);
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
wayland: Push actor state instead of itself pulling Make the Wayland objects push the state relevant to their role to the MetaSurfaceActor instead of MetaSurfaceActorWayland pulling the state from the associated surface. This makes the relationship between the actor and the objects that constructs it more clear; the actor is a drawable that the protocol objects control, not the other way around. This will make it easier to "detach" a surface actor from a surface, which is necessary when unmapping a window while the underlying surface is yet to be destroyed and potentially reused. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-22 01:28:28 -05:00
MetaWaylandActorSurface *actor_surface =
META_WAYLAND_ACTOR_SURFACE (surface_role);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
MetaWaylandSurfaceRoleClass *surface_role_class;
MetaWindow *window;
MetaWaylandBuffer *buffer;
wayland/actor-surface: Set geometry scale in surface actor Now that MetaShapedTexture is a ClutterContent implemetation that is aware of its own buffer scale, it is possible to simplify the event translation routines. Set the geometry scale in MetaSurfaceActor, and stop adjusting the surface scale when translating points. Also remove the now obsoleted meta_wayland_actor_surface_calculate_scale() function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/409
2019-07-09 11:29:37 -04:00
double geometry_scale;
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
surface_role_class =
META_WAYLAND_SURFACE_ROLE_CLASS (meta_wayland_shell_surface_parent_class);
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
surface_role_class->apply_state (surface_role, pending);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
wayland/surface: Put buffer reference on heap Currently a buffer use count always reaches zero before it is replaced. This is due to the fact that at the point a new buffer is attached, the last potential user releases it (the stage) since the currently displayed frame has a composited copy of the buffer. This may however change, if a buffer is scanned out directly, meaning it should not be released until the page flip callback is invoked. Prepare for this by making the buffer reference a heap allocated struct, enabling us to keep a pointer to it longer than the buffer is attached. https://gitlab.gnome.org/GNOME/mutter/merge_requests/798
2019-08-13 12:46:36 -04:00
buffer = surface->buffer_ref->buffer;
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
if (!buffer)
return;
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
window = priv->window;
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
if (!window)
return;
wayland/actor-surface: Set geometry scale in surface actor Now that MetaShapedTexture is a ClutterContent implemetation that is aware of its own buffer scale, it is possible to simplify the event translation routines. Set the geometry scale in MetaSurfaceActor, and stop adjusting the surface scale when translating points. Also remove the now obsoleted meta_wayland_actor_surface_calculate_scale() function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/409
2019-07-09 11:29:37 -04:00
geometry_scale = meta_wayland_actor_surface_get_geometry_scale (actor_surface);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
wayland/actor-surface: Set geometry scale in surface actor Now that MetaShapedTexture is a ClutterContent implemetation that is aware of its own buffer scale, it is possible to simplify the event translation routines. Set the geometry scale in MetaSurfaceActor, and stop adjusting the surface scale when translating points. Also remove the now obsoleted meta_wayland_actor_surface_calculate_scale() function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/409
2019-07-09 11:29:37 -04:00
window->buffer_rect.width =
meta_wayland_surface_get_width (surface) * geometry_scale;
window->buffer_rect.height =
meta_wayland_surface_get_height (surface) * geometry_scale;
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
}
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
static MetaWindow *
meta_wayland_shell_surface_get_window (MetaWaylandSurfaceRole *surface_role)
{
MetaWaylandShellSurface *shell_surface =
META_WAYLAND_SHELL_SURFACE (surface_role);
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
return priv->window;
}
wayland: Move tree updating to the shell surface role The shell surface role is the one where subsurfaces may exist, and it has direct relation to the MetaWindowActorWayland which currently has the subsurface stacking logic. Instead of directly finding the window actor when dealing with subsurfaces, notify the parent surface that the subsurface state changed, so that it can outsource the application of this information to the role. For subsurface roles, this simply means forward upward to the parent; for shell surface roles, this means regenerate the surface actor layering. This allows us to move away from accessing the window directly from the surface, which in turn allows us to change the ownership structure of windows. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-08 17:32:37 -04:00
static void
meta_wayland_shell_surface_notify_subsurface_state_changed (MetaWaylandSurfaceRole *surface_role)
{
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaWaylandShellSurface *shell_surface =
META_WAYLAND_SHELL_SURFACE (surface_role);
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
wayland: Move tree updating to the shell surface role The shell surface role is the one where subsurfaces may exist, and it has direct relation to the MetaWindowActorWayland which currently has the subsurface stacking logic. Instead of directly finding the window actor when dealing with subsurfaces, notify the parent surface that the subsurface state changed, so that it can outsource the application of this information to the role. For subsurface roles, this simply means forward upward to the parent; for shell surface roles, this means regenerate the surface actor layering. This allows us to move away from accessing the window directly from the surface, which in turn allows us to change the ownership structure of windows. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-08 17:32:37 -04:00
MetaWindow *window;
MetaWindowActor *window_actor;
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
window = priv->window;
wayland: Move tree updating to the shell surface role The shell surface role is the one where subsurfaces may exist, and it has direct relation to the MetaWindowActorWayland which currently has the subsurface stacking logic. Instead of directly finding the window actor when dealing with subsurfaces, notify the parent surface that the subsurface state changed, so that it can outsource the application of this information to the role. For subsurface roles, this simply means forward upward to the parent; for shell surface roles, this means regenerate the surface actor layering. This allows us to move away from accessing the window directly from the surface, which in turn allows us to change the ownership structure of windows. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-08 17:32:37 -04:00
if (!window)
return;
window_actor = meta_window_actor_from_window (window);
meta_window_actor_wayland_rebuild_surface_tree (window_actor);
}
wayland/actor-surface: Turn get_geometry_scale() into a vfunc This allows us to implement more sophisticated logic for the different cases. For DnD surfaces, use the geometry scale of the monitor where the pointer is, instead of incorrectly assuming '1' as it was before. https://gitlab.gnome.org/GNOME/mutter/merge_requests/780
2019-09-06 09:13:24 -04:00
static double
meta_wayland_shell_surface_get_geometry_scale (MetaWaylandActorSurface *actor_surface)
{
MetaWaylandSurfaceRole *surface_role =
META_WAYLAND_SURFACE_ROLE (actor_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
MetaWindow *toplevel_window;
toplevel_window = meta_wayland_surface_get_toplevel_window (surface);
if (meta_is_stage_views_scaled () || !toplevel_window)
return 1;
else
return meta_window_wayland_get_geometry_scale (toplevel_window);
}
wayland: Move check for present window out of the actor-surface class All child classes of `MetaWaylandShellSurface` as well as `MetaWaylandSurfaceRoleXWayland` should only sync their actor if their toplevel surface has a window. Currently this check is done in the actor-surface class, but not all surface classes have a toplevel window, e.g. dnd-surfaces. Move the check to the right places. For subsurfaces this assumes that the subsurface is not the child of a window-less surface (like, as stated above, e.g. a dnd-surface). If we want to support subsurfaces of window-less surfaces in the future we have to extend the check here. But as this is not a regression, ignore this case for now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/537
2019-04-16 17:35:28 -04:00
static void
meta_wayland_shell_surface_sync_actor_state (MetaWaylandActorSurface *actor_surface)
{
MetaWaylandSurfaceRole *surface_role =
META_WAYLAND_SURFACE_ROLE (actor_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
MetaWaylandActorSurfaceClass *actor_surface_class =
META_WAYLAND_ACTOR_SURFACE_CLASS (meta_wayland_shell_surface_parent_class);
wayland: Don't access MetaWaylandSurface::window directly It'll be moved to the role owning it, accessed via a helper function implemented by the role. Currently it still just fetches the field in MetaWaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:37:04 -04:00
MetaWindow *toplevel_window;
toplevel_window = meta_wayland_surface_get_toplevel_window (surface);
if (!toplevel_window)
return;
wayland: Move check for present window out of the actor-surface class All child classes of `MetaWaylandShellSurface` as well as `MetaWaylandSurfaceRoleXWayland` should only sync their actor if their toplevel surface has a window. Currently this check is done in the actor-surface class, but not all surface classes have a toplevel window, e.g. dnd-surfaces. Move the check to the right places. For subsurfaces this assumes that the subsurface is not the child of a window-less surface (like, as stated above, e.g. a dnd-surface). If we want to support subsurfaces of window-less surfaces in the future we have to extend the check here. But as this is not a regression, ignore this case for now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/537
2019-04-16 17:35:28 -04:00
wayland: Don't access MetaWaylandSurface::window directly It'll be moved to the role owning it, accessed via a helper function implemented by the role. Currently it still just fetches the field in MetaWaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:37:04 -04:00
actor_surface_class->sync_actor_state (actor_surface);
wayland: Move check for present window out of the actor-surface class All child classes of `MetaWaylandShellSurface` as well as `MetaWaylandSurfaceRoleXWayland` should only sync their actor if their toplevel surface has a window. Currently this check is done in the actor-surface class, but not all surface classes have a toplevel window, e.g. dnd-surfaces. Move the check to the right places. For subsurfaces this assumes that the subsurface is not the child of a window-less surface (like, as stated above, e.g. a dnd-surface). If we want to support subsurfaces of window-less surfaces in the future we have to extend the check here. But as this is not a regression, ignore this case for now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/537
2019-04-16 17:35:28 -04:00
}
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
void
meta_wayland_shell_surface_destroy_window (MetaWaylandShellSurface *shell_surface)
{
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
MetaWaylandShellSurfacePrivate *priv =
meta_wayland_shell_surface_get_instance_private (shell_surface);
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
MetaWindow *window;
MetaDisplay *display;
uint32_t timestamp;
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
window = priv->window;
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
if (!window)
return;
display = meta_window_get_display (window);
timestamp = meta_display_get_current_time_roundtrip (display);
wayland: Don't access MetaWaylandSurface::window directly It'll be moved to the role owning it, accessed via a helper function implemented by the role. Currently it still just fetches the field in MetaWaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:37:04 -04:00
meta_window_unmanage (window, timestamp);
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
g_assert (!priv->window);
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
}
static void
meta_wayland_shell_surface_finalize (GObject *object)
{
MetaWaylandShellSurface *shell_surface = META_WAYLAND_SHELL_SURFACE (object);
meta_wayland_shell_surface_destroy_window (shell_surface);
G_OBJECT_CLASS (meta_wayland_shell_surface_parent_class)->finalize (object);
}
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
static void
meta_wayland_shell_surface_init (MetaWaylandShellSurface *role)
{
}
static void
meta_wayland_shell_surface_class_init (MetaWaylandShellSurfaceClass *klass)
{
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
MetaWaylandSurfaceRoleClass *surface_role_class =
META_WAYLAND_SURFACE_ROLE_CLASS (klass);
wayland: Move check for present window out of the actor-surface class All child classes of `MetaWaylandShellSurface` as well as `MetaWaylandSurfaceRoleXWayland` should only sync their actor if their toplevel surface has a window. Currently this check is done in the actor-surface class, but not all surface classes have a toplevel window, e.g. dnd-surfaces. Move the check to the right places. For subsurfaces this assumes that the subsurface is not the child of a window-less surface (like, as stated above, e.g. a dnd-surface). If we want to support subsurfaces of window-less surfaces in the future we have to extend the check here. But as this is not a regression, ignore this case for now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/537
2019-04-16 17:35:28 -04:00
MetaWaylandActorSurfaceClass *actor_surface_class =
META_WAYLAND_ACTOR_SURFACE_CLASS (klass);
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
wayland: Untie MetaWindowXwayland lifetime from the wl_surface For the most part, a MetaWindow is expected to live roughly as long as the associated wl_surface, give or take asynchronous API discrepancies. The exception to this rule is handling of reparenting when decorating or undecorating a window, when a MetaWindow on X11 is made to survive the unmap/map cycle. The fact that this didn't hold on Wayland caused various issues, such as a feedback loop where the X11 window kept being remapped. By making the MetaWindow lifetime for Xwayland windows being the same as they are on plain X11, we remove the different semantics here, which seem to lower the risk of hitting the race condition causing the feedback loop mentioned above. What this commit do is separate MetaWindow lifetime handling between native Wayland windows and Xwayland windows. Wayland windows are handled just as they were, i.e. unmanaged together as part of the wl_surface destruction; while during the Xwayland wl_surface destruction, the MetaWindow <-> MetaWaylandSurface association is simply broken. Related: https://gitlab.freedesktop.org/xorg/xserver/issues/740 Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/762 https://gitlab.gnome.org/GNOME/mutter/merge_requests/774
2019-09-04 12:35:08 -04:00
object_class->finalize = meta_wayland_shell_surface_finalize;
wayland/surface: Let roles set DND functions The DND functions are role specific, with Xwayland surface being the special one. Let the roles set it instead of having per role like logic in MetaWaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:53:23 -04:00
surface_role_class->assigned = meta_wayland_shell_surface_assigned;
wayland: Move calc-showing window logic to roles having windows https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:56:34 -04:00
surface_role_class->pre_apply_state =
meta_wayland_shell_surface_surface_pre_apply_state;
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
surface_role_class->apply_state =
meta_wayland_shell_surface_surface_apply_state;
wayland: Move tree updating to the shell surface role The shell surface role is the one where subsurfaces may exist, and it has direct relation to the MetaWindowActorWayland which currently has the subsurface stacking logic. Instead of directly finding the window actor when dealing with subsurfaces, notify the parent surface that the subsurface state changed, so that it can outsource the application of this information to the role. For subsurface roles, this simply means forward upward to the parent; for shell surface roles, this means regenerate the surface actor layering. This allows us to move away from accessing the window directly from the surface, which in turn allows us to change the ownership structure of windows. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-08 17:32:37 -04:00
surface_role_class->notify_subsurface_state_changed =
meta_wayland_shell_surface_notify_subsurface_state_changed;
wayland: Move MetaWindow ownership to window owning roles There are two surface roles owning a MetaWindow: MetaWaylandShellSurface (basis of MetaWaylandXdgToplevel, MetaWaylandXdgPopup, MetaWaylandWlShellSurface, etc), and MetaXwaylandSurface. With these two role types, the MetaWindow has two different types of life times. With MetaWaylandShellSurface, the window is owned and managed by the role itself, while with MetaXwaylandSurface, the MetaWindow is tied to the X11 window, while the Wayland surface and its role plays more the role of the backing rendering surface. Before, for historical reasons, MetaWindow was part of MetaWaylandSurface, even though just some roles used it, and before 'wayland: Untie MetaWindowXwayland lifetime from the wl_surface' had equivalent life times as well. But since that commit, the management changed. To not have the same fied in MetaWaylandSurface being managed in such drastically different ways, rearrange it so that the roles that has a MetaWindow themself manages it in the way it is meant to; meaning MetaWaylandShellSurface practically owns it, while with Xwayland, the existance of a MetaWindow is tracked via X11. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-09 03:57:40 -04:00
surface_role_class->get_window = meta_wayland_shell_surface_get_window;
wayland/actor-surface: Turn get_geometry_scale() into a vfunc This allows us to implement more sophisticated logic for the different cases. For DnD surfaces, use the geometry scale of the monitor where the pointer is, instead of incorrectly assuming '1' as it was before. https://gitlab.gnome.org/GNOME/mutter/merge_requests/780
2019-09-06 09:13:24 -04:00
actor_surface_class->get_geometry_scale =
meta_wayland_shell_surface_get_geometry_scale;
wayland: Move check for present window out of the actor-surface class All child classes of `MetaWaylandShellSurface` as well as `MetaWaylandSurfaceRoleXWayland` should only sync their actor if their toplevel surface has a window. Currently this check is done in the actor-surface class, but not all surface classes have a toplevel window, e.g. dnd-surfaces. Move the check to the right places. For subsurfaces this assumes that the subsurface is not the child of a window-less surface (like, as stated above, e.g. a dnd-surface). If we want to support subsurfaces of window-less surfaces in the future we have to extend the check here. But as this is not a regression, ignore this case for now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/537
2019-04-16 17:35:28 -04:00
actor_surface_class->sync_actor_state =
meta_wayland_shell_surface_sync_actor_state;
wayland: Restructure surface role building blocks code This commit moves out non-core wl_surface related code into separate code units, while renaming types to fit a common scheme. The changes done are: * ClutterActor based surface roles built upon MetaWalyandSurfaceRoleActorSurface. This object has been renamed to MetaWaylandActorSurface and related functionality has moved into meta-wayland-actor-surface.c. * The code related to roles backed by a MetaWindow (i.e. built upon MetaWaylandShellSurface) was moved into meta-wayland-shell-surface.c * The majority of subsurface related code was moved into into meta-wayland-subsurface.c and the object was renamed MetaWaylandSubsurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/5 https://bugzilla.gnome.org/show_bug.cgi?id=791938
2017-12-20 04:40:22 -05:00
}
Reference in New Issue Copy Permalink