mirror of
https://gitlab.freedesktop.org/wayland/weston
synced 2024-09-06 18:05:39 +00:00
![Arnaud Vrac](/assets/img/avatar_default.png)
Remove the output transform from the view transform list when its surface is destroyed. The surface destruction also triggers the freeing of its views, so the next access to the output transform link could crash. Reviewed-by: Quentin Glidic <sardemff7+git@sardemff7.net>
936 lines
25 KiB
C
936 lines
25 KiB
C
/*
|
|
* Copyright © 2013 Jason Ekstrand
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include "compositor.h"
|
|
#include "fullscreen-shell-unstable-v1-server-protocol.h"
|
|
#include "shared/helpers.h"
|
|
|
|
struct fullscreen_shell {
|
|
struct wl_client *client;
|
|
struct wl_listener client_destroyed;
|
|
struct weston_compositor *compositor;
|
|
|
|
struct weston_layer layer;
|
|
struct wl_list output_list;
|
|
struct wl_listener output_created_listener;
|
|
|
|
struct wl_listener seat_created_listener;
|
|
|
|
/* List of one surface per client, presented for the NULL output
|
|
*
|
|
* This is implemented as a list in case someone fixes the shell
|
|
* implementation to support more than one client.
|
|
*/
|
|
struct wl_list default_surface_list; /* struct fs_client_surface::link */
|
|
};
|
|
|
|
struct fs_output {
|
|
struct fullscreen_shell *shell;
|
|
struct wl_list link;
|
|
|
|
struct weston_output *output;
|
|
struct wl_listener output_destroyed;
|
|
|
|
struct {
|
|
struct weston_surface *surface;
|
|
struct wl_listener surface_destroyed;
|
|
struct wl_resource *mode_feedback;
|
|
|
|
int presented_for_mode;
|
|
enum zwp_fullscreen_shell_v1_present_method method;
|
|
int32_t framerate;
|
|
} pending;
|
|
|
|
struct weston_surface *surface;
|
|
struct wl_listener surface_destroyed;
|
|
struct weston_view *view;
|
|
struct weston_view *black_view;
|
|
struct weston_transform transform; /* matrix from x, y */
|
|
|
|
int presented_for_mode;
|
|
enum zwp_fullscreen_shell_v1_present_method method;
|
|
uint32_t framerate;
|
|
};
|
|
|
|
struct pointer_focus_listener {
|
|
struct fullscreen_shell *shell;
|
|
struct wl_listener pointer_focus;
|
|
struct wl_listener seat_caps;
|
|
struct wl_listener seat_destroyed;
|
|
};
|
|
|
|
struct fs_client_surface {
|
|
struct weston_surface *surface;
|
|
enum zwp_fullscreen_shell_v1_present_method method;
|
|
struct wl_list link; /* struct fullscreen_shell::default_surface_list */
|
|
struct wl_listener surface_destroyed;
|
|
};
|
|
|
|
static void
|
|
remove_default_surface(struct fs_client_surface *surf)
|
|
{
|
|
wl_list_remove(&surf->surface_destroyed.link);
|
|
wl_list_remove(&surf->link);
|
|
free(surf);
|
|
}
|
|
|
|
static void
|
|
default_surface_destroy_listener(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fs_client_surface *surf;
|
|
|
|
surf = container_of(listener, struct fs_client_surface, surface_destroyed);
|
|
|
|
remove_default_surface(surf);
|
|
}
|
|
|
|
static void
|
|
replace_default_surface(struct fullscreen_shell *shell, struct weston_surface *surface,
|
|
enum zwp_fullscreen_shell_v1_present_method method)
|
|
{
|
|
struct fs_client_surface *surf, *prev = NULL;
|
|
|
|
if (!wl_list_empty(&shell->default_surface_list))
|
|
prev = container_of(shell->default_surface_list.prev,
|
|
struct fs_client_surface, link);
|
|
|
|
surf = zalloc(sizeof *surf);
|
|
if (!surf)
|
|
return;
|
|
|
|
surf->surface = surface;
|
|
surf->method = method;
|
|
|
|
if (prev)
|
|
remove_default_surface(prev);
|
|
|
|
wl_list_insert(shell->default_surface_list.prev, &surf->link);
|
|
|
|
surf->surface_destroyed.notify = default_surface_destroy_listener;
|
|
wl_signal_add(&surface->destroy_signal, &surf->surface_destroyed);
|
|
}
|
|
|
|
static void
|
|
pointer_focus_changed(struct wl_listener *listener, void *data)
|
|
{
|
|
struct weston_pointer *pointer = data;
|
|
|
|
if (pointer->focus && pointer->focus->surface->resource)
|
|
weston_seat_set_keyboard_focus(pointer->seat, pointer->focus->surface);
|
|
}
|
|
|
|
static void
|
|
seat_caps_changed(struct wl_listener *l, void *data)
|
|
{
|
|
struct weston_seat *seat = data;
|
|
struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
|
|
struct weston_pointer *pointer = weston_seat_get_pointer(seat);
|
|
struct pointer_focus_listener *listener;
|
|
struct fs_output *fsout;
|
|
|
|
listener = container_of(l, struct pointer_focus_listener, seat_caps);
|
|
|
|
/* no pointer */
|
|
if (pointer) {
|
|
if (!listener->pointer_focus.link.prev) {
|
|
wl_signal_add(&pointer->focus_signal,
|
|
&listener->pointer_focus);
|
|
}
|
|
} else {
|
|
if (listener->pointer_focus.link.prev) {
|
|
wl_list_remove(&listener->pointer_focus.link);
|
|
}
|
|
}
|
|
|
|
if (keyboard && keyboard->focus != NULL) {
|
|
wl_list_for_each(fsout, &listener->shell->output_list, link) {
|
|
if (fsout->surface) {
|
|
weston_seat_set_keyboard_focus(seat, fsout->surface);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
seat_destroyed(struct wl_listener *l, void *data)
|
|
{
|
|
struct pointer_focus_listener *listener;
|
|
|
|
listener = container_of(l, struct pointer_focus_listener,
|
|
seat_destroyed);
|
|
|
|
free(listener);
|
|
}
|
|
|
|
static void
|
|
seat_created(struct wl_listener *l, void *data)
|
|
{
|
|
struct weston_seat *seat = data;
|
|
struct pointer_focus_listener *listener;
|
|
|
|
listener = zalloc(sizeof *listener);
|
|
if (!listener)
|
|
return;
|
|
|
|
listener->shell = container_of(l, struct fullscreen_shell,
|
|
seat_created_listener);
|
|
listener->pointer_focus.notify = pointer_focus_changed;
|
|
listener->seat_caps.notify = seat_caps_changed;
|
|
listener->seat_destroyed.notify = seat_destroyed;
|
|
|
|
wl_signal_add(&seat->destroy_signal, &listener->seat_destroyed);
|
|
wl_signal_add(&seat->updated_caps_signal, &listener->seat_caps);
|
|
|
|
seat_caps_changed(&listener->seat_caps, seat);
|
|
}
|
|
|
|
static void
|
|
black_surface_committed(struct weston_surface *es, int32_t sx, int32_t sy)
|
|
{
|
|
}
|
|
|
|
static struct weston_view *
|
|
create_black_surface(struct weston_compositor *ec, struct fs_output *fsout,
|
|
float x, float y, int w, int h)
|
|
{
|
|
struct weston_surface *surface = NULL;
|
|
struct weston_view *view;
|
|
|
|
surface = weston_surface_create(ec);
|
|
if (surface == NULL) {
|
|
weston_log("no memory\n");
|
|
return NULL;
|
|
}
|
|
view = weston_view_create(surface);
|
|
if (!view) {
|
|
weston_surface_destroy(surface);
|
|
weston_log("no memory\n");
|
|
return NULL;
|
|
}
|
|
|
|
surface->committed = black_surface_committed;
|
|
surface->committed_private = fsout;
|
|
weston_surface_set_color(surface, 0.0f, 0.0f, 0.0f, 1.0f);
|
|
pixman_region32_fini(&surface->opaque);
|
|
pixman_region32_init_rect(&surface->opaque, 0, 0, w, h);
|
|
pixman_region32_fini(&surface->input);
|
|
pixman_region32_init_rect(&surface->input, 0, 0, w, h);
|
|
|
|
weston_surface_set_size(surface, w, h);
|
|
weston_view_set_position(view, x, y);
|
|
|
|
return view;
|
|
}
|
|
|
|
static void
|
|
fs_output_set_surface(struct fs_output *fsout, struct weston_surface *surface,
|
|
enum zwp_fullscreen_shell_v1_present_method method,
|
|
int32_t framerate, int presented_for_mode);
|
|
static void
|
|
fs_output_apply_pending(struct fs_output *fsout);
|
|
static void
|
|
fs_output_clear_pending(struct fs_output *fsout);
|
|
|
|
static void
|
|
fs_output_destroy(struct fs_output *fsout)
|
|
{
|
|
fs_output_set_surface(fsout, NULL, 0, 0, 0);
|
|
fs_output_clear_pending(fsout);
|
|
|
|
wl_list_remove(&fsout->link);
|
|
|
|
if (fsout->output)
|
|
wl_list_remove(&fsout->output_destroyed.link);
|
|
}
|
|
|
|
static void
|
|
output_destroyed(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fs_output *output = container_of(listener,
|
|
struct fs_output,
|
|
output_destroyed);
|
|
fs_output_destroy(output);
|
|
}
|
|
|
|
static void
|
|
surface_destroyed(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fs_output *fsout = container_of(listener,
|
|
struct fs_output,
|
|
surface_destroyed);
|
|
fsout->surface = NULL;
|
|
fsout->view = NULL;
|
|
wl_list_remove(&fsout->transform.link);
|
|
wl_list_init(&fsout->transform.link);
|
|
}
|
|
|
|
static void
|
|
pending_surface_destroyed(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fs_output *fsout = container_of(listener,
|
|
struct fs_output,
|
|
pending.surface_destroyed);
|
|
fsout->pending.surface = NULL;
|
|
}
|
|
|
|
static void
|
|
configure_presented_surface(struct weston_surface *surface, int32_t sx,
|
|
int32_t sy);
|
|
|
|
static struct fs_output *
|
|
fs_output_create(struct fullscreen_shell *shell, struct weston_output *output)
|
|
{
|
|
struct fs_output *fsout;
|
|
struct fs_client_surface *surf;
|
|
|
|
fsout = zalloc(sizeof *fsout);
|
|
if (!fsout)
|
|
return NULL;
|
|
|
|
fsout->shell = shell;
|
|
wl_list_insert(&shell->output_list, &fsout->link);
|
|
|
|
fsout->output = output;
|
|
fsout->output_destroyed.notify = output_destroyed;
|
|
wl_signal_add(&output->destroy_signal, &fsout->output_destroyed);
|
|
|
|
fsout->surface_destroyed.notify = surface_destroyed;
|
|
fsout->pending.surface_destroyed.notify = pending_surface_destroyed;
|
|
fsout->black_view = create_black_surface(shell->compositor, fsout,
|
|
output->x, output->y,
|
|
output->width, output->height);
|
|
fsout->black_view->surface->is_mapped = true;
|
|
fsout->black_view->is_mapped = true;
|
|
weston_layer_entry_insert(&shell->layer.view_list,
|
|
&fsout->black_view->layer_link);
|
|
wl_list_init(&fsout->transform.link);
|
|
|
|
if (!wl_list_empty(&shell->default_surface_list)) {
|
|
surf = container_of(shell->default_surface_list.prev,
|
|
struct fs_client_surface, link);
|
|
|
|
fs_output_set_surface(fsout, surf->surface, surf->method, 0, 0);
|
|
configure_presented_surface(surf->surface, 0, 0);
|
|
}
|
|
|
|
return fsout;
|
|
}
|
|
|
|
static struct fs_output *
|
|
fs_output_for_output(struct weston_output *output)
|
|
{
|
|
struct wl_listener *listener;
|
|
|
|
if (!output)
|
|
return NULL;
|
|
|
|
listener = wl_signal_get(&output->destroy_signal, output_destroyed);
|
|
|
|
return container_of(listener, struct fs_output, output_destroyed);
|
|
}
|
|
|
|
static void
|
|
restore_output_mode(struct weston_output *output)
|
|
{
|
|
if (output && output->original_mode)
|
|
weston_output_mode_switch_to_native(output);
|
|
}
|
|
|
|
/*
|
|
* Returns the bounding box of a surface and all its sub-surfaces,
|
|
* in surface-local coordinates. */
|
|
static void
|
|
surface_subsurfaces_boundingbox(struct weston_surface *surface, int32_t *x,
|
|
int32_t *y, int32_t *w, int32_t *h) {
|
|
pixman_region32_t region;
|
|
pixman_box32_t *box;
|
|
struct weston_subsurface *subsurface;
|
|
|
|
pixman_region32_init_rect(®ion, 0, 0,
|
|
surface->width,
|
|
surface->height);
|
|
|
|
wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
|
|
pixman_region32_union_rect(®ion, ®ion,
|
|
subsurface->position.x,
|
|
subsurface->position.y,
|
|
subsurface->surface->width,
|
|
subsurface->surface->height);
|
|
}
|
|
|
|
box = pixman_region32_extents(®ion);
|
|
if (x)
|
|
*x = box->x1;
|
|
if (y)
|
|
*y = box->y1;
|
|
if (w)
|
|
*w = box->x2 - box->x1;
|
|
if (h)
|
|
*h = box->y2 - box->y1;
|
|
|
|
pixman_region32_fini(®ion);
|
|
}
|
|
|
|
static void
|
|
fs_output_center_view(struct fs_output *fsout)
|
|
{
|
|
int32_t surf_x, surf_y, surf_width, surf_height;
|
|
float x, y;
|
|
struct weston_output *output = fsout->output;
|
|
|
|
surface_subsurfaces_boundingbox(fsout->view->surface, &surf_x, &surf_y,
|
|
&surf_width, &surf_height);
|
|
|
|
x = output->x + (output->width - surf_width) / 2 - surf_x / 2;
|
|
y = output->y + (output->height - surf_height) / 2 - surf_y / 2;
|
|
|
|
weston_view_set_position(fsout->view, x, y);
|
|
}
|
|
|
|
static void
|
|
fs_output_scale_view(struct fs_output *fsout, float width, float height)
|
|
{
|
|
float x, y;
|
|
int32_t surf_x, surf_y, surf_width, surf_height;
|
|
struct weston_matrix *matrix;
|
|
struct weston_view *view = fsout->view;
|
|
struct weston_output *output = fsout->output;
|
|
|
|
surface_subsurfaces_boundingbox(view->surface, &surf_x, &surf_y,
|
|
&surf_width, &surf_height);
|
|
|
|
if (output->width == surf_width && output->height == surf_height) {
|
|
weston_view_set_position(view,
|
|
fsout->output->x - surf_x,
|
|
fsout->output->y - surf_y);
|
|
} else {
|
|
matrix = &fsout->transform.matrix;
|
|
weston_matrix_init(matrix);
|
|
|
|
weston_matrix_scale(matrix, width / surf_width,
|
|
height / surf_height, 1);
|
|
wl_list_remove(&fsout->transform.link);
|
|
wl_list_insert(&fsout->view->geometry.transformation_list,
|
|
&fsout->transform.link);
|
|
|
|
x = output->x + (output->width - width) / 2 - surf_x;
|
|
y = output->y + (output->height - height) / 2 - surf_y;
|
|
|
|
weston_view_set_position(view, x, y);
|
|
}
|
|
}
|
|
|
|
static void
|
|
fs_output_configure(struct fs_output *fsout, struct weston_surface *surface);
|
|
|
|
static void
|
|
fs_output_configure_simple(struct fs_output *fsout,
|
|
struct weston_surface *configured_surface)
|
|
{
|
|
struct weston_output *output = fsout->output;
|
|
float output_aspect, surface_aspect;
|
|
int32_t surf_x, surf_y, surf_width, surf_height;
|
|
|
|
if (fsout->pending.surface == configured_surface)
|
|
fs_output_apply_pending(fsout);
|
|
|
|
assert(fsout->view);
|
|
|
|
restore_output_mode(fsout->output);
|
|
|
|
wl_list_remove(&fsout->transform.link);
|
|
wl_list_init(&fsout->transform.link);
|
|
|
|
surface_subsurfaces_boundingbox(fsout->view->surface,
|
|
&surf_x, &surf_y,
|
|
&surf_width, &surf_height);
|
|
|
|
output_aspect = (float) output->width / (float) output->height;
|
|
surface_aspect = (float) surf_width / (float) surf_height;
|
|
|
|
switch (fsout->method) {
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_DEFAULT:
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_CENTER:
|
|
fs_output_center_view(fsout);
|
|
break;
|
|
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_ZOOM:
|
|
if (output_aspect < surface_aspect)
|
|
fs_output_scale_view(fsout,
|
|
output->width,
|
|
output->width / surface_aspect);
|
|
else
|
|
fs_output_scale_view(fsout,
|
|
output->height * surface_aspect,
|
|
output->height);
|
|
break;
|
|
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_ZOOM_CROP:
|
|
if (output_aspect < surface_aspect)
|
|
fs_output_scale_view(fsout,
|
|
output->height * surface_aspect,
|
|
output->height);
|
|
else
|
|
fs_output_scale_view(fsout,
|
|
output->width,
|
|
output->width / surface_aspect);
|
|
break;
|
|
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_STRETCH:
|
|
fs_output_scale_view(fsout, output->width, output->height);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
weston_view_set_position(fsout->black_view,
|
|
fsout->output->x - surf_x,
|
|
fsout->output->y - surf_y);
|
|
weston_surface_set_size(fsout->black_view->surface,
|
|
fsout->output->width,
|
|
fsout->output->height);
|
|
}
|
|
|
|
static void
|
|
fs_output_configure_for_mode(struct fs_output *fsout,
|
|
struct weston_surface *configured_surface)
|
|
{
|
|
int32_t surf_x, surf_y, surf_width, surf_height;
|
|
struct weston_mode mode;
|
|
int ret;
|
|
|
|
if (fsout->pending.surface != configured_surface) {
|
|
/* Nothing to really reconfigure. We'll just recenter the
|
|
* view in case they played with subsurfaces */
|
|
fs_output_center_view(fsout);
|
|
return;
|
|
}
|
|
|
|
/* We have a pending surface */
|
|
surface_subsurfaces_boundingbox(fsout->pending.surface,
|
|
&surf_x, &surf_y,
|
|
&surf_width, &surf_height);
|
|
|
|
/* The actual output mode is in physical units. We need to
|
|
* transform the surface size to physical unit size by flipping ans
|
|
* possibly scaling it.
|
|
*/
|
|
switch (fsout->output->transform) {
|
|
case WL_OUTPUT_TRANSFORM_90:
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
|
|
case WL_OUTPUT_TRANSFORM_270:
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
|
|
mode.width = surf_height * fsout->output->native_scale;
|
|
mode.height = surf_width * fsout->output->native_scale;
|
|
break;
|
|
|
|
case WL_OUTPUT_TRANSFORM_NORMAL:
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED:
|
|
case WL_OUTPUT_TRANSFORM_180:
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
|
|
default:
|
|
mode.width = surf_width * fsout->output->native_scale;
|
|
mode.height = surf_height * fsout->output->native_scale;
|
|
}
|
|
mode.flags = 0;
|
|
mode.refresh = fsout->pending.framerate;
|
|
|
|
ret = weston_output_mode_switch_to_temporary(fsout->output, &mode,
|
|
fsout->output->native_scale);
|
|
|
|
if (ret != 0) {
|
|
/* The mode switch failed. Clear the pending and
|
|
* reconfigure as per normal */
|
|
if (fsout->pending.mode_feedback) {
|
|
zwp_fullscreen_shell_mode_feedback_v1_send_mode_failed(
|
|
fsout->pending.mode_feedback);
|
|
wl_resource_destroy(fsout->pending.mode_feedback);
|
|
fsout->pending.mode_feedback = NULL;
|
|
}
|
|
|
|
fs_output_clear_pending(fsout);
|
|
return;
|
|
}
|
|
|
|
if (fsout->pending.mode_feedback) {
|
|
zwp_fullscreen_shell_mode_feedback_v1_send_mode_successful(
|
|
fsout->pending.mode_feedback);
|
|
wl_resource_destroy(fsout->pending.mode_feedback);
|
|
fsout->pending.mode_feedback = NULL;
|
|
}
|
|
|
|
fs_output_apply_pending(fsout);
|
|
|
|
weston_view_set_position(fsout->view,
|
|
fsout->output->x - surf_x,
|
|
fsout->output->y - surf_y);
|
|
}
|
|
|
|
static void
|
|
fs_output_configure(struct fs_output *fsout,
|
|
struct weston_surface *surface)
|
|
{
|
|
if (fsout->pending.surface == surface) {
|
|
if (fsout->pending.presented_for_mode)
|
|
fs_output_configure_for_mode(fsout, surface);
|
|
else
|
|
fs_output_configure_simple(fsout, surface);
|
|
} else {
|
|
if (fsout->presented_for_mode)
|
|
fs_output_configure_for_mode(fsout, surface);
|
|
else
|
|
fs_output_configure_simple(fsout, surface);
|
|
}
|
|
|
|
weston_output_schedule_repaint(fsout->output);
|
|
}
|
|
|
|
static void
|
|
configure_presented_surface(struct weston_surface *surface, int32_t sx,
|
|
int32_t sy)
|
|
{
|
|
struct fullscreen_shell *shell = surface->committed_private;
|
|
struct fs_output *fsout;
|
|
|
|
if (surface->committed != configure_presented_surface)
|
|
return;
|
|
|
|
wl_list_for_each(fsout, &shell->output_list, link)
|
|
if (fsout->surface == surface ||
|
|
fsout->pending.surface == surface)
|
|
fs_output_configure(fsout, surface);
|
|
}
|
|
|
|
static void
|
|
fs_output_apply_pending(struct fs_output *fsout)
|
|
{
|
|
assert(fsout->pending.surface);
|
|
|
|
if (fsout->surface && fsout->surface != fsout->pending.surface) {
|
|
wl_list_remove(&fsout->surface_destroyed.link);
|
|
|
|
weston_view_destroy(fsout->view);
|
|
fsout->view = NULL;
|
|
|
|
if (wl_list_empty(&fsout->surface->views)) {
|
|
fsout->surface->committed = NULL;
|
|
fsout->surface->committed_private = NULL;
|
|
}
|
|
|
|
fsout->surface = NULL;
|
|
}
|
|
|
|
fsout->method = fsout->pending.method;
|
|
fsout->framerate = fsout->pending.framerate;
|
|
fsout->presented_for_mode = fsout->pending.presented_for_mode;
|
|
|
|
if (fsout->surface != fsout->pending.surface) {
|
|
fsout->surface = fsout->pending.surface;
|
|
|
|
fsout->view = weston_view_create(fsout->surface);
|
|
if (!fsout->view) {
|
|
weston_log("no memory\n");
|
|
return;
|
|
}
|
|
fsout->view->is_mapped = true;
|
|
|
|
wl_signal_add(&fsout->surface->destroy_signal,
|
|
&fsout->surface_destroyed);
|
|
weston_layer_entry_insert(&fsout->shell->layer.view_list,
|
|
&fsout->view->layer_link);
|
|
}
|
|
|
|
fs_output_clear_pending(fsout);
|
|
}
|
|
|
|
static void
|
|
fs_output_clear_pending(struct fs_output *fsout)
|
|
{
|
|
if (!fsout->pending.surface)
|
|
return;
|
|
|
|
if (fsout->pending.mode_feedback) {
|
|
zwp_fullscreen_shell_mode_feedback_v1_send_present_cancelled(
|
|
fsout->pending.mode_feedback);
|
|
wl_resource_destroy(fsout->pending.mode_feedback);
|
|
fsout->pending.mode_feedback = NULL;
|
|
}
|
|
|
|
wl_list_remove(&fsout->pending.surface_destroyed.link);
|
|
fsout->pending.surface = NULL;
|
|
}
|
|
|
|
static void
|
|
fs_output_set_surface(struct fs_output *fsout, struct weston_surface *surface,
|
|
enum zwp_fullscreen_shell_v1_present_method method,
|
|
int32_t framerate, int presented_for_mode)
|
|
{
|
|
fs_output_clear_pending(fsout);
|
|
|
|
if (surface) {
|
|
if (!surface->committed) {
|
|
surface->committed = configure_presented_surface;
|
|
surface->committed_private = fsout->shell;
|
|
}
|
|
|
|
fsout->pending.surface = surface;
|
|
wl_signal_add(&fsout->pending.surface->destroy_signal,
|
|
&fsout->pending.surface_destroyed);
|
|
|
|
fsout->pending.method = method;
|
|
fsout->pending.framerate = framerate;
|
|
fsout->pending.presented_for_mode = presented_for_mode;
|
|
} else if (fsout->surface) {
|
|
/* we clear immediately */
|
|
wl_list_remove(&fsout->surface_destroyed.link);
|
|
|
|
weston_view_destroy(fsout->view);
|
|
fsout->view = NULL;
|
|
|
|
if (wl_list_empty(&fsout->surface->views)) {
|
|
fsout->surface->committed = NULL;
|
|
fsout->surface->committed_private = NULL;
|
|
}
|
|
|
|
fsout->surface = NULL;
|
|
|
|
weston_output_schedule_repaint(fsout->output);
|
|
}
|
|
}
|
|
|
|
static void
|
|
fullscreen_shell_release(struct wl_client *client,
|
|
struct wl_resource *resource)
|
|
{
|
|
wl_resource_destroy(resource);
|
|
}
|
|
|
|
static void
|
|
fullscreen_shell_present_surface(struct wl_client *client,
|
|
struct wl_resource *resource,
|
|
struct wl_resource *surface_res,
|
|
uint32_t method,
|
|
struct wl_resource *output_res)
|
|
{
|
|
struct fullscreen_shell *shell =
|
|
wl_resource_get_user_data(resource);
|
|
struct weston_output *output;
|
|
struct weston_surface *surface;
|
|
struct weston_seat *seat;
|
|
struct fs_output *fsout;
|
|
|
|
surface = surface_res ? wl_resource_get_user_data(surface_res) : NULL;
|
|
|
|
switch(method) {
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_DEFAULT:
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_CENTER:
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_ZOOM:
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_ZOOM_CROP:
|
|
case ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_STRETCH:
|
|
break;
|
|
default:
|
|
wl_resource_post_error(resource,
|
|
ZWP_FULLSCREEN_SHELL_V1_ERROR_INVALID_METHOD,
|
|
"Invalid presentation method");
|
|
}
|
|
|
|
if (output_res) {
|
|
output = wl_resource_get_user_data(output_res);
|
|
fsout = fs_output_for_output(output);
|
|
fs_output_set_surface(fsout, surface, method, 0, 0);
|
|
} else {
|
|
replace_default_surface(shell, surface, method);
|
|
|
|
wl_list_for_each(fsout, &shell->output_list, link)
|
|
fs_output_set_surface(fsout, surface, method, 0, 0);
|
|
}
|
|
|
|
if (surface) {
|
|
wl_list_for_each(seat, &shell->compositor->seat_list, link) {
|
|
struct weston_keyboard *keyboard =
|
|
weston_seat_get_keyboard(seat);
|
|
|
|
if (keyboard && !keyboard->focus)
|
|
weston_seat_set_keyboard_focus(seat, surface);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
mode_feedback_destroyed(struct wl_resource *resource)
|
|
{
|
|
struct fs_output *fsout = wl_resource_get_user_data(resource);
|
|
|
|
fsout->pending.mode_feedback = NULL;
|
|
}
|
|
|
|
static void
|
|
fullscreen_shell_present_surface_for_mode(struct wl_client *client,
|
|
struct wl_resource *resource,
|
|
struct wl_resource *surface_res,
|
|
struct wl_resource *output_res,
|
|
int32_t framerate,
|
|
uint32_t feedback_id)
|
|
{
|
|
struct fullscreen_shell *shell =
|
|
wl_resource_get_user_data(resource);
|
|
struct weston_output *output;
|
|
struct weston_surface *surface;
|
|
struct weston_seat *seat;
|
|
struct fs_output *fsout;
|
|
|
|
output = wl_resource_get_user_data(output_res);
|
|
fsout = fs_output_for_output(output);
|
|
|
|
if (surface_res == NULL) {
|
|
fs_output_set_surface(fsout, NULL, 0, 0, 0);
|
|
return;
|
|
}
|
|
|
|
surface = wl_resource_get_user_data(surface_res);
|
|
fs_output_set_surface(fsout, surface, 0, framerate, 1);
|
|
|
|
fsout->pending.mode_feedback =
|
|
wl_resource_create(client,
|
|
&zwp_fullscreen_shell_mode_feedback_v1_interface,
|
|
1, feedback_id);
|
|
wl_resource_set_implementation(fsout->pending.mode_feedback, NULL,
|
|
fsout, mode_feedback_destroyed);
|
|
|
|
wl_list_for_each(seat, &shell->compositor->seat_list, link) {
|
|
struct weston_keyboard *keyboard =
|
|
weston_seat_get_keyboard(seat);
|
|
|
|
if (keyboard && !keyboard->focus)
|
|
weston_seat_set_keyboard_focus(seat, surface);
|
|
}
|
|
}
|
|
|
|
struct zwp_fullscreen_shell_v1_interface fullscreen_shell_implementation = {
|
|
fullscreen_shell_release,
|
|
fullscreen_shell_present_surface,
|
|
fullscreen_shell_present_surface_for_mode,
|
|
};
|
|
|
|
static void
|
|
output_created(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fullscreen_shell *shell;
|
|
|
|
shell = container_of(listener, struct fullscreen_shell,
|
|
output_created_listener);
|
|
|
|
fs_output_create(shell, data);
|
|
}
|
|
|
|
static void
|
|
client_destroyed(struct wl_listener *listener, void *data)
|
|
{
|
|
struct fullscreen_shell *shell = container_of(listener,
|
|
struct fullscreen_shell,
|
|
client_destroyed);
|
|
shell->client = NULL;
|
|
}
|
|
|
|
static void
|
|
bind_fullscreen_shell(struct wl_client *client, void *data, uint32_t version,
|
|
uint32_t id)
|
|
{
|
|
struct fullscreen_shell *shell = data;
|
|
struct wl_resource *resource;
|
|
|
|
if (shell->client != NULL && shell->client != client)
|
|
return;
|
|
else if (shell->client == NULL) {
|
|
shell->client = client;
|
|
wl_client_add_destroy_listener(client, &shell->client_destroyed);
|
|
}
|
|
|
|
resource = wl_resource_create(client,
|
|
&zwp_fullscreen_shell_v1_interface,
|
|
1, id);
|
|
wl_resource_set_implementation(resource,
|
|
&fullscreen_shell_implementation,
|
|
shell, NULL);
|
|
|
|
if (shell->compositor->capabilities & WESTON_CAP_CURSOR_PLANE)
|
|
zwp_fullscreen_shell_v1_send_capability(resource,
|
|
ZWP_FULLSCREEN_SHELL_V1_CAPABILITY_CURSOR_PLANE);
|
|
|
|
if (shell->compositor->capabilities & WESTON_CAP_ARBITRARY_MODES)
|
|
zwp_fullscreen_shell_v1_send_capability(resource,
|
|
ZWP_FULLSCREEN_SHELL_V1_CAPABILITY_ARBITRARY_MODES);
|
|
}
|
|
|
|
WL_EXPORT int
|
|
module_init(struct weston_compositor *compositor,
|
|
int *argc, char *argv[])
|
|
{
|
|
struct fullscreen_shell *shell;
|
|
struct weston_seat *seat;
|
|
struct weston_output *output;
|
|
|
|
shell = zalloc(sizeof *shell);
|
|
if (shell == NULL)
|
|
return -1;
|
|
|
|
shell->compositor = compositor;
|
|
wl_list_init(&shell->default_surface_list);
|
|
|
|
shell->client_destroyed.notify = client_destroyed;
|
|
|
|
weston_layer_init(&shell->layer, &compositor->cursor_layer.link);
|
|
|
|
wl_list_init(&shell->output_list);
|
|
shell->output_created_listener.notify = output_created;
|
|
wl_signal_add(&compositor->output_created_signal,
|
|
&shell->output_created_listener);
|
|
wl_list_for_each(output, &compositor->output_list, link)
|
|
fs_output_create(shell, output);
|
|
|
|
shell->seat_created_listener.notify = seat_created;
|
|
wl_signal_add(&compositor->seat_created_signal,
|
|
&shell->seat_created_listener);
|
|
wl_list_for_each(seat, &compositor->seat_list, link)
|
|
seat_created(NULL, seat);
|
|
|
|
wl_global_create(compositor->wl_display,
|
|
&zwp_fullscreen_shell_v1_interface, 1, shell,
|
|
bind_fullscreen_shell);
|
|
|
|
return 0;
|
|
}
|