brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wayland: Update to latest xdg-shell protocol

Browse Source
This commit is contained in:
Jasper St. Pierre 2014-05-05 19:09:22 -04:00
parent c49c37999c
commit 7732447abc
5 changed files with 148 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/core/window.c
View File

@ -2801,9 +2801,6 @@ 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");
@ -3252,9 +3249,6 @@ 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");
@ -3361,9 +3355,6 @@ 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");
}
}
@ -3420,9 +3411,6 @@ 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");
}
}

203
src/wayland/meta-wayland-surface.c
View File

@ -589,7 +589,6 @@ meta_wayland_surface_set_window (MetaWaylandSurface *surface,
MetaWindow *window)
{
surface->window = window;
sync_reactive (surface);
}
@ -857,46 +856,9 @@ xdg_surface_resize (struct wl_client *client,
}
static void
xdg_surface_set_output (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *output)
{
g_warning ("TODO: support xdg_surface.set_output");
}
static void
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);
surface->state_changed_serial = serial;
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_ack_change_state (struct wl_client *client,
struct wl_resource *resource,
uint32_t state_type,
uint32_t value,
uint32_t serial)
xdg_surface_ack_configure (struct wl_client *client,
struct wl_resource *resource,
uint32_t serial)
{
/* Do nothing for now. In the future, we'd imagine that
* we'd ignore attaches when we have a state pending that
@ -905,12 +867,44 @@ xdg_surface_ack_change_state (struct wl_client *client,
* client gets the new state. */
}
static void
xdg_surface_set_maximized (struct wl_client *client,
struct wl_resource *resource)
{
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);
}
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);
}
static void
xdg_surface_unset_fullscreen (struct wl_client *client,
struct wl_resource *resource)
{
MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
meta_window_unmake_fullscreen (surface->window);
}
static void
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);
}
@ -922,9 +916,11 @@ static const struct xdg_surface_interface meta_wayland_xdg_surface_interface = {
xdg_surface_set_app_id,
xdg_surface_move,
xdg_surface_resize,
xdg_surface_set_output,
xdg_surface_request_change_state,
xdg_surface_ack_change_state,
xdg_surface_ack_configure,
xdg_surface_set_maximized,
xdg_surface_unset_maximized,
xdg_surface_set_fullscreen,
xdg_surface_unset_fullscreen,
xdg_surface_set_minimized,
};
@ -1727,88 +1723,63 @@ 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)
{
uint32_t *s;
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))
{
s = wl_array_add (states, sizeof *s);
*s = XDG_SURFACE_STATE_ACTIVATED;
}
}
void
meta_wayland_surface_configure_notify (MetaWaylandSurface *surface,
int new_width,
int new_height)
{
/* new_width and new_height comes from window->rect,
* which is based on the buffer size, not the surface
* size. The configure event requires surface size. */
new_width /= surface->scale;
new_height /= surface->scale;
if (surface->xdg_surface.resource)
xdg_surface_send_configure (surface->xdg_surface.resource,
new_width, new_height);
{
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;
wl_array_init (&states);
fill_states (&states, surface->window);
/* new_width and new_height comes from window->rect, which is based on
* the buffer size, not the surface size. The configure event requires
* surface size. */
new_width /= surface->scale;
new_height /= surface->scale;
xdg_surface_send_configure (surface->xdg_surface.resource, new_width, new_height, &states, serial);
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);
}
static void
send_change_state (MetaWaylandSurface *surface,
uint32_t state_type,
uint32_t value)
{
if (surface->xdg_surface.resource)
{
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_send_maximized (MetaWaylandSurface *surface)
{
send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, TRUE);
}
void
meta_wayland_surface_send_unmaximized (MetaWaylandSurface *surface)
{
send_change_state (surface, XDG_SURFACE_STATE_MAXIMIZED, FALSE);
}
void
meta_wayland_surface_send_fullscreened (MetaWaylandSurface *surface)
{
send_change_state (surface, XDG_SURFACE_STATE_FULLSCREEN, TRUE);
}
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
meta_wayland_surface_ping (MetaWaylandSurface *surface,
guint32 serial)

9
src/wayland/meta-wayland-surface.h
View File

@ -109,8 +109,6 @@ struct _MetaWaylandSurface
GSList *pending_placement_ops;
} sub;
uint32_t state_changed_serial;
/* All the pending state that wl_surface.commit will apply. */
MetaWaylandPendingState pending;
};
@ -128,13 +126,6 @@ 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);

149
src/wayland/protocol/xdg-shell.xml
View File

@ -241,40 +241,6 @@
<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
@ -297,89 +263,78 @@
0x1000 - 0x1FFF: GNOME
</description>
<entry name="maximized" value="1" summary="the surface is maximized">
A non-zero value indicates the surface is maximized. Otherwise,
the surface is unmaximized.
The surface is maximized. The window geometry specified in the configure
event must be obeyed by the client.
</entry>
<entry name="fullscreen" value="2" summary="the surface is fullscreen">
A non-zero value indicates the surface is fullscreen. Otherwise,
the surface is not 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.
</entry>
</enum>
<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.
<event name="configure">
<description summary="suggest a surface chnage">
The configure event asks the client to resize its 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>
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.
<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.
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 client receives multiple configure events before it
can respond to one, it is free to discard all but the last
event it received.
</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="a serial for the compositor's own tracking"/>
<arg name="width" type="int"/>
<arg name="height" type="int"/>
<arg name="states" type="array"/>
<arg name="serial" type="uint"/>
</event>
<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
<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
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 new state value.
The values here need to be the same as the values in the cooresponding
change_state event.
contain the buffer drawn for the configure event you are acking.
</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="a serial to pass to change_state"/>
<arg name="serial" type="uint" summary="a serial to configure for"/>
</request>
<request name="set_minimized">
<description summary="minimize the surface">
Minimize the surface.
<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.
</description>
<arg name="output" type="object" interface="wl_output" allow-null="true"/>
</request>
<request name="unset_fullscreen" />
<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>
<request name="set_minimized" />
<event name="close">
<description summary="surface wants to be closed">

13
src/wayland/window-wayland.c
View File

@ -185,6 +185,14 @@ meta_window_wayland_move_resize_internal (MetaWindow *window,
}
}
static void
surface_state_changed (MetaWindow *window)
{
meta_wayland_surface_configure_notify (window->surface,
window->rect.width,
window->rect.height);
}
static void
appears_focused_changed (GObject *object,
GParamSpec *pspec,
@ -197,10 +205,7 @@ appears_focused_changed (GObject *object,
if (window->unmanaging)
return;
if (meta_window_appears_focused (window))
meta_wayland_surface_activated (window->surface);
else
meta_wayland_surface_deactivated (window->surface);
surface_state_changed (window);
}
static void