[mutter] Revert "Update to latest xdg-shell protocol"
- From: Jasper St. Pierre <jstpierre src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [mutter] Revert "Update to latest xdg-shell protocol"
- Date: Wed, 23 Apr 2014 20:01:19 +0000 (UTC)
commit 2435d132aca2ab66222169b07cf99f17882dd8af
Author: Jasper St. Pierre <jstpierre mecheye net>
Date: Wed Apr 23 16:00:55 2014 -0400
Revert "Update to latest xdg-shell protocol"
This reverts commit eed03d38b022ef018aed8ceb07ea78ce19db0774.
This was pushed by accident.
src/core/window.c | 20 ++++
src/wayland/meta-wayland-surface.c | 204 ++++++++++++++++++------------------
src/wayland/meta-wayland-surface.h | 9 ++
src/wayland/protocol/xdg-shell.xml | 149 +++++++++++++++++---------
4 files changed, 227 insertions(+), 155 deletions(-)
---
diff --git a/src/core/window.c b/src/core/window.c
index aebdc40..9e32967 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -2968,6 +2968,9 @@ meta_window_maximize_internal (MetaWindow *window,
meta_window_recalc_features (window);
set_net_wm_state (window);
+ if (window->surface && window->maximized_horizontally && window->maximized_vertically)
+ meta_wayland_surface_send_maximized (window->surface);
+
g_object_freeze_notify (G_OBJECT (window));
g_object_notify (G_OBJECT (window), "maximized-horizontally");
g_object_notify (G_OBJECT (window), "maximized-vertically");
@@ -3419,6 +3422,9 @@ meta_window_unmaximize_internal (MetaWindow *window,
set_net_wm_state (window);
}
+ if (window->surface && !window->maximized_horizontally && !window->maximized_vertically)
+ meta_wayland_surface_send_unmaximized (window->surface);
+
g_object_freeze_notify (G_OBJECT (window));
g_object_notify (G_OBJECT (window), "maximized-horizontally");
g_object_notify (G_OBJECT (window), "maximized-vertically");
@@ -3525,6 +3531,9 @@ meta_window_make_fullscreen_internal (MetaWindow *window)
/* For the auto-minimize feature, if we fail to get focus */
meta_screen_queue_check_fullscreen (window->screen);
+ if (window->surface)
+ meta_wayland_surface_send_fullscreened (window->surface);
+
g_object_notify (G_OBJECT (window), "fullscreen");
}
}
@@ -3581,6 +3590,9 @@ meta_window_unmake_fullscreen (MetaWindow *window)
meta_window_update_layer (window);
+ if (window->surface)
+ meta_wayland_surface_send_unfullscreened (window->surface);
+
g_object_notify (G_OBJECT (window), "fullscreen");
}
}
@@ -5554,6 +5566,14 @@ meta_window_appears_focused_changed (MetaWindow *window)
if (window->frame)
meta_frame_queue_draw (window->frame);
+
+ if (window->surface)
+ {
+ if (meta_window_appears_focused (window))
+ meta_wayland_surface_activated (window->surface);
+ else
+ meta_wayland_surface_deactivated (window->surface);
+ }
}
/**
diff --git a/src/wayland/meta-wayland-surface.c b/src/wayland/meta-wayland-surface.c
index 77000b2..e4d3cb8 100644
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
@@ -519,42 +519,12 @@ sync_reactive (MetaWaylandSurface *surface)
surface_should_be_reactive (surface));
}
-static void
-surface_state_changed (MetaWaylandSurface *surface)
-{
- if (surface->window)
- meta_wayland_surface_configure_notify (surface,
- surface->window->rect.width,
- surface->window->rect.height);
-}
-
-static void
-window_appears_focused_changed (MetaWindow *window,
- GParamSpec *pspec,
- gpointer user_data)
-{
- MetaWaylandSurface *surface = user_data;
-
- surface_state_changed (surface);
-}
-
void
meta_wayland_surface_set_window (MetaWaylandSurface *surface,
MetaWindow *window)
{
- if (surface->window)
- {
- g_signal_handlers_disconnect_by_func (surface->window, window_appears_focused_changed, surface);
- }
-
surface->window = window;
- if (surface->window)
- {
- g_signal_connect (surface->window, "notify::appears-focused",
- G_CALLBACK (window_appears_focused_changed), surface);
- }
-
sync_reactive (surface);
}
@@ -821,48 +791,52 @@ xdg_surface_resize (struct wl_client *client,
}
static void
-xdg_surface_ack_configure (struct wl_client *client,
- struct wl_resource *resource,
- uint32_t serial)
+xdg_surface_set_output (struct wl_client *client,
+ struct wl_resource *resource,
+ struct wl_resource *output)
{
- /* Do nothing for now. In the future, we'd imagine that
- * we'd ignore attaches when we have a state pending that
- * we haven't had the client ACK'd, to prevent a race
- * condition when we have an in-flight attach when the
- * client gets the new state. */
+ g_warning ("TODO: support xdg_surface.set_output");
}
static void
-xdg_surface_set_maximized (struct wl_client *client,
- struct wl_resource *resource)
+xdg_surface_request_change_state (struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t state_type,
+ uint32_t value,
+ uint32_t serial)
{
MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
- meta_window_maximize (surface->window, META_MAXIMIZE_BOTH);
-}
-static void
-xdg_surface_unset_maximized (struct wl_client *client,
- struct wl_resource *resource)
-{
- MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
- meta_window_unmaximize (surface->window, META_MAXIMIZE_BOTH);
-}
+ surface->state_changed_serial = serial;
-static void
-xdg_surface_set_fullscreen (struct wl_client *client,
- struct wl_resource *resource,
- struct wl_resource *output_resource)
-{
- MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
- meta_window_make_fullscreen (surface->window);
+ switch (state_type)
+ {
+ case XDG_SURFACE_STATE_MAXIMIZED:
+ if (value)
+ meta_window_maximize (surface->window, META_MAXIMIZE_BOTH);
+ else
+ meta_window_unmaximize (surface->window, META_MAXIMIZE_BOTH);
+ break;
+ case XDG_SURFACE_STATE_FULLSCREEN:
+ if (value)
+ meta_window_make_fullscreen (surface->window);
+ else
+ meta_window_unmake_fullscreen (surface->window);
+ }
}
static void
-xdg_surface_unset_fullscreen (struct wl_client *client,
- struct wl_resource *resource)
+xdg_surface_ack_change_state (struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t state_type,
+ uint32_t value,
+ uint32_t serial)
{
- MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
- meta_window_unmake_fullscreen (surface->window);
+ /* Do nothing for now. In the future, we'd imagine that
+ * we'd ignore attaches when we have a state pending that
+ * we haven't had the client ACK'd, to prevent a race
+ * condition when we have an in-flight attach when the
+ * client gets the new state. */
}
static void
@@ -870,6 +844,7 @@ xdg_surface_set_minimized (struct wl_client *client,
struct wl_resource *resource)
{
MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
+
meta_window_minimize (surface->window);
}
@@ -881,11 +856,9 @@ static const struct xdg_surface_interface meta_wayland_xdg_surface_interface = {
xdg_surface_set_app_id,
xdg_surface_move,
xdg_surface_resize,
- xdg_surface_ack_configure,
- xdg_surface_set_maximized,
- xdg_surface_unset_maximized,
- xdg_surface_set_fullscreen,
- xdg_surface_unset_fullscreen,
+ xdg_surface_set_output,
+ xdg_surface_request_change_state,
+ xdg_surface_ack_change_state,
xdg_surface_set_minimized,
};
@@ -1688,55 +1661,80 @@ meta_wayland_shell_init (MetaWaylandCompositor *compositor)
g_error ("Failed to register a global wl-subcompositor object");
}
-static void
-fill_states (struct wl_array *states, MetaWindow *window)
+void
+meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
+ int new_width,
+ int new_height)
{
- uint32_t *s;
+ if (surface->xdg_surface.resource)
+ xdg_surface_send_configure (surface->xdg_surface.resource,
+ new_width, new_height);
+ else if (surface->wl_shell_surface.resource)
+ wl_shell_surface_send_configure (surface->wl_shell_surface.resource,
+ 0, new_width, new_height);
+}
- if (META_WINDOW_MAXIMIZED (window))
- {
- s = wl_array_add (states, sizeof *s);
- *s = XDG_SURFACE_STATE_MAXIMIZED;
- }
- if (meta_window_is_fullscreen (window))
- {
- s = wl_array_add (states, sizeof *s);
- *s = XDG_SURFACE_STATE_FULLSCREEN;
- }
- if (meta_grab_op_is_resizing (window->display->grab_op))
- {
- s = wl_array_add (states, sizeof *s);
- *s = XDG_SURFACE_STATE_RESIZING;
- }
- if (meta_window_appears_focused (window))
+static void
+send_change_state (MetaWaylandSurface *surface,
+ uint32_t state_type,
+ uint32_t value)
+{
+ if (surface->xdg_surface.resource)
{
- s = wl_array_add (states, sizeof *s);
- *s = XDG_SURFACE_STATE_ACTIVATED;
+ uint32_t serial;
+
+ if (surface->state_changed_serial != 0)
+ {
+ serial = surface->state_changed_serial;
+ surface->state_changed_serial = 0;
+ }
+ else
+ {
+ struct wl_client *client = wl_resource_get_client (surface->xdg_surface.resource);
+ struct wl_display *display = wl_client_get_display (client);
+ serial = wl_display_next_serial (display);
+ }
+
+ xdg_surface_send_change_state (surface->xdg_surface.resource, state_type, value, serial);
}
}
void
-meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
- int new_width,
- int new_height)
+meta_wayland_surface_send_maximized (MetaWaylandSurface *surface)
{
- if (surface->xdg_surface.resource)
- {
- struct wl_client *client = wl_resource_get_client (surface->xdg_surface.resource);
- struct wl_display *display = wl_client_get_display (client);
- uint32_t serial = wl_display_next_serial (display);
- struct wl_array states;
+ send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, TRUE);
+}
- wl_array_init (&states);
- fill_states (&states, surface->window);
+void
+meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface)
+{
+ send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, FALSE);
+}
- xdg_surface_send_configure (surface->xdg_surface.resource, new_width, new_height, &states, serial);
+void
+meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface)
+{
+ send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, TRUE);
+}
- wl_array_release (&states);
- }
- else if (surface->wl_shell_surface.resource)
- wl_shell_surface_send_configure (surface->wl_shell_surface.resource,
- 0, new_width, new_height);
+void
+meta_wayland_surface_send_unfullscreened (MetaWaylandSurface *surface)
+{
+ send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, FALSE);
+}
+
+void
+meta_wayland_surface_activated (MetaWaylandSurface *surface)
+{
+ if (surface->xdg_surface.resource)
+ xdg_surface_send_activated (surface->xdg_surface.resource);
+}
+
+void
+meta_wayland_surface_deactivated (MetaWaylandSurface *surface)
+{
+ if (surface->xdg_surface.resource)
+ xdg_surface_send_deactivated (surface->xdg_surface.resource);
}
void
diff --git a/src/wayland/meta-wayland-surface.h b/src/wayland/meta-wayland-surface.h
index 62d631e..fc744e8 100644
--- a/src/wayland/meta-wayland-surface.h
+++ b/src/wayland/meta-wayland-surface.h
@@ -106,6 +106,8 @@ struct _MetaWaylandSurface
GSList *pending_placement_ops;
} sub;
+ uint32_t state_changed_serial;
+
/* All the pending state that wl_surface.commit will apply. */
MetaWaylandPendingState pending;
};
@@ -123,6 +125,13 @@ void meta_wayland_surface_set_window (MetaWaylandSurface *surface
void meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
int width,
int height);
+void meta_wayland_surface_send_maximized (MetaWaylandSurface *surface);
+void meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface);
+void meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface);
+void meta_wayland_surface_send_unfullscreened (MetaWaylandSurface *surface);
+
+void meta_wayland_surface_activated (MetaWaylandSurface *surface);
+void meta_wayland_surface_deactivated (MetaWaylandSurface *surface);
void meta_wayland_surface_ping (MetaWaylandSurface *surface,
guint32 serial);
diff --git a/src/wayland/protocol/xdg-shell.xml b/src/wayland/protocol/xdg-shell.xml
index 3c18610..7882693 100644
--- a/src/wayland/protocol/xdg-shell.xml
+++ b/src/wayland/protocol/xdg-shell.xml
@@ -241,6 +241,40 @@
<arg name="edges" type="uint" summary="which edge or corner is being dragged"/>
</request>
+ <event name="configure">
+ <description summary="suggest resize">
+ The configure event asks the client to resize its surface.
+
+ The size is a hint, in the sense that the client is free to
+ ignore it if it doesn't resize, pick a smaller size (to
+ satisfy aspect ratio or resize in steps of NxM pixels).
+
+ The client is free to dismiss all but the last configure
+ event it received.
+
+ The width and height arguments specify the size of the window
+ in surface local coordinates.
+ </description>
+
+ <arg name="width" type="int"/>
+ <arg name="height" type="int"/>
+ </event>
+
+ <request name="set_output">
+ <description summary="set the default output used by this surface">
+ Set the default output used by this surface when it is first mapped.
+
+ If this value is NULL (default), it's up to the compositor to choose
+ which display will be used to map this surface.
+
+ When fullscreen or maximized state are set on this surface, and it
+ wasn't mapped yet, the output set with this method will be used.
+ Otherwise, the output where the surface is currently mapped will be
+ used.
+ </description>
+ <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+ </request>
+
<enum name="state">
<description summary="types of state on the surface">
The different state values used on the surface. This is designed for
@@ -263,78 +297,89 @@
0x1000 - 0x1FFF: GNOME
</description>
<entry name="maximized" value="1" summary="the surface is maximized">
- The surface is maximized. The window geometry specified in the configure
- event must be obeyed by the client.
+ A non-zero value indicates the surface is maximized. Otherwise,
+ the surface is unmaximized.
</entry>
<entry name="fullscreen" value="2" summary="the surface is fullscreen">
- The surface is fullscreen. The window geometry specified in the configure
- event must be obeyed by the client.
- </entry>
- <entry name="resizing" value="3">
- The surface is being resized. The window geometry specified in the
- configure event is a maximum; the client cannot resize beyond it.
- Clients that have aspect ratio or cell sizing configuration can use
- a smaller size, however.
- </entry>
- <entry name="activated" value="4">
- Client window decorations should be painted as if the window is
- active. Do not assume this means that the window actually has
- keyboard or pointer focus.
+ A non-zero value indicates the surface is fullscreen. Otherwise,
+ the surface is not fullscreen.
</entry>
</enum>
- <event name="configure">
- <description summary="suggest a surface chnage">
- The configure event asks the client to resize its surface.
+ <request name="request_change_state">
+ <description summary="client requests to change a surface's state">
+ This asks the compositor to change the state. If the compositor wants
+ to change the state, it will send a change_state event with the same
+ state_type, value, and serial, and the event flow continues as if it
+ it was initiated by the compositor.
- The width and height arguments specify a hint to the window
- about how its surface should be resized in surface local
- coordinates. The states listed in the event specify how the
- width/height arguments should be interpreted.
-
- A client should arrange a new surface, and then send a
- ack_configure request with the serial sent in this configure
- event before attaching a new surface.
+ If the compositor does not want to change the state, it will send a
+ change_state to the client with the old value of the state.
+ </description>
+ <arg name="state_type" type="uint" summary="the state to set"/>
+ <arg name="value" type="uint" summary="the value to change the state to"/>
+ <arg name="serial" type="uint" summary="an event serial">
+ This serial is so the client can know which change_state event corresponds
+ to which request_change_state request it sent out.
+ </arg>
+ </request>
- If the client receives multiple configure events before it
- can respond to one, it is free to discard all but the last
- event it received.
+ <event name="change_state">
+ <description summary="compositor wants to change a surface's state">
+ This event tells the client to change a surface's state. The client
+ should respond with an ack_change_state request to the compositor to
+ guarantee that the compositor knows that the client has seen it.
</description>
- <arg name="width" type="int"/>
- <arg name="height" type="int"/>
- <arg name="states" type="array"/>
- <arg name="serial" type="uint"/>
+ <arg name="state_type" type="uint" summary="the state to set"/>
+ <arg name="value" type="uint" summary="the value to change the state to"/>
+ <arg name="serial" type="uint" summary="a serial for the compositor's own tracking"/>
</event>
- <request name="ack_configure">
- <description summary="ack a configure event">
- When a configure event is received, a client should then ack it
- using the ack_configure request to ensure that the compositor
+ <request name="ack_change_state">
+ <description summary="ack a change_state event">
+ When a change_state event is received, a client should then ack it
+ using the ack_change_state request to ensure that the compositor
knows the client has seen the event.
By this point, the state is confirmed, and the next attach should
- contain the buffer drawn for the configure event you are acking.
+ contain the buffer drawn for the new state value.
+
+ The values here need to be the same as the values in the cooresponding
+ change_state event.
</description>
- <arg name="serial" type="uint" summary="a serial to configure for"/>
+ <arg name="state_type" type="uint" summary="the state to set"/>
+ <arg name="value" type="uint" summary="the value to change the state to"/>
+ <arg name="serial" type="uint" summary="a serial to pass to change_state"/>
</request>
- <request name="set_maximized" />
- <request name="unset_maximized" />
-
- <request name="set_fullscreen">
- <description summary="set the window as fullscreen on a monitor">
- Make the surface fullscreen.
-
- You can specify an output that you would prefer to be fullscreen.
- If this value is NULL, it's up to the compositor to choose which
- display will be used to map this surface.
+ <request name="set_minimized">
+ <description summary="minimize the surface">
+ Minimize the surface.
</description>
- <arg name="output" type="object" interface="wl_output" allow-null="true"/>
</request>
- <request name="unset_fullscreen" />
- <request name="set_minimized" />
+ <event name="activated">
+ <description summary="surface was activated">
+ The activated_set event is sent when this surface has been
+ activated, which means that the surface has user attention.
+ Window decorations should be updated accordingly. You should
+ not use this event for anything but the style of decorations
+ you display, use wl_keyboard.enter and wl_keyboard.leave for
+ determining keyboard focus.
+ </description>
+ </event>
+
+ <event name="deactivated">
+ <description summary="surface was deactivated">
+ The deactivate event is sent when this surface has been
+ deactivated, which means that the surface lost user attention.
+ Window decorations should be updated accordingly. You should
+ not use this event for anything but the style of decorations
+ you display, use wl_keyboard.enter and wl_keyboard.leave for
+ determining keyboard focus.
+ </description>
+ </event>
<event name="close">
<description summary="surface wants to be closed">
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
