2 * Copyright © 2010-2012 Intel Corporation
3 * Copyright © 2011-2012 Collabora, Ltd.
4 * Copyright © 2013 Raspberry Pi Foundation
6 * Permission to use, copy, modify, distribute, and sell this software and
7 * its documentation for any purpose is hereby granted without fee, provided
8 * that the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of the copyright holders not be used in
11 * advertising or publicity pertaining to distribution of the software
12 * without specific, written prior permission. The copyright holders make
13 * no representations about the suitability of this software for any
14 * purpose. It is provided "as is" without express or implied warranty.
16 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
20 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
21 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
22 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
31 #include <linux/input.h>
35 #include <sys/types.h>
38 #include "desktop-shell-server-protocol.h"
39 #include "workspaces-server-protocol.h"
40 #include "../shared/config-parser.h"
41 #include "xdg-shell-server-protocol.h"
43 #define DEFAULT_NUM_WORKSPACES 1
44 #define DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH 200
47 #define static_assert(cond, msg)
51 struct weston_seat *seat;
53 struct weston_surface *keyboard_focus;
55 struct wl_listener seat_destroy_listener;
56 struct wl_listener surface_destroy_listener;
59 enum shell_surface_type {
61 SHELL_SURFACE_TOPLEVEL,
63 SHELL_SURFACE_XWAYLAND
69 * Surface stacking and ordering.
71 * This is handled using several linked lists of surfaces, organised into
72 * ‘layers’. The layers are ordered, and each of the surfaces in one layer are
73 * above all of the surfaces in the layer below. The set of layers is static and
74 * in the following order (top-most first):
75 * • Lock layer (only ever displayed on its own)
83 * The list of layers may be manipulated to remove whole layers of surfaces from
84 * display. For example, when locking the screen, all layers except the lock
87 * A surface’s layer is modified on configuring the surface, in
88 * set_surface_type() (which is only called when the surface’s type change is
89 * _committed_). If a surface’s type changes (e.g. when making a window
90 * fullscreen) its layer changes too.
92 * In order to allow popup and transient surfaces to be correctly stacked above
93 * their parent surfaces, each surface tracks both its parent surface, and a
94 * linked list of its children. When a surface’s layer is updated, so are the
95 * layers of its children. Note that child surfaces are *not* the same as
96 * subsurfaces — child/parent surfaces are purely for maintaining stacking
99 * The children_link list of siblings of a surface (i.e. those surfaces which
100 * have the same parent) only contains weston_surfaces which have a
101 * shell_surface. Stacking is not implemented for non-shell_surface
102 * weston_surfaces. This means that the following implication does *not* hold:
103 * (shsurf->parent != NULL) ⇒ !wl_list_is_empty(shsurf->children_link)
106 struct shell_surface {
107 struct wl_resource *resource;
108 struct wl_signal destroy_signal;
109 struct shell_client *owner;
111 struct weston_surface *surface;
112 struct weston_view *view;
113 int32_t last_width, last_height;
114 struct wl_listener surface_destroy_listener;
115 struct wl_listener resource_destroy_listener;
117 struct weston_surface *parent;
118 struct wl_list children_list; /* child surfaces of this one */
119 struct wl_list children_link; /* sibling surfaces of this one */
120 struct desktop_shell *shell;
122 enum shell_surface_type type;
124 int32_t saved_x, saved_y;
125 int32_t saved_width, saved_height;
126 bool saved_position_valid;
127 bool saved_size_valid;
128 bool saved_rotation_valid;
129 int unresponsive, grabbed;
130 uint32_t resize_edges;
133 struct weston_transform transform;
134 struct weston_matrix rotation;
138 struct wl_list grab_link;
140 struct shell_seat *shseat;
150 enum wl_shell_surface_fullscreen_method type;
151 struct weston_transform transform; /* matrix from x, y */
153 struct weston_view *black_view;
156 struct weston_transform workspace_transform;
158 struct weston_output *fullscreen_output;
159 struct weston_output *output;
162 const struct weston_shell_client *client;
164 struct surface_state {
169 } state, next_state, requested_state; /* surface states */
171 bool state_requested;
174 int32_t x, y, width, height;
175 } geometry, next_geometry;
176 bool has_set_geometry, has_next_geometry;
182 struct weston_pointer_grab grab;
183 struct shell_surface *shsurf;
184 struct wl_listener shsurf_destroy_listener;
187 struct shell_touch_grab {
188 struct weston_touch_grab grab;
189 struct shell_surface *shsurf;
190 struct wl_listener shsurf_destroy_listener;
191 struct weston_touch *touch;
194 struct weston_move_grab {
195 struct shell_grab base;
197 int client_initiated;
200 struct weston_touch_move_grab {
201 struct shell_touch_grab base;
207 struct shell_grab base;
208 struct weston_matrix rotation;
216 struct weston_seat *seat;
217 struct wl_listener seat_destroy_listener;
218 struct weston_surface *focused_surface;
220 struct wl_listener caps_changed_listener;
221 struct wl_listener pointer_focus_listener;
222 struct wl_listener keyboard_focus_listener;
225 struct weston_pointer_grab grab;
226 struct weston_touch_grab touch_grab;
227 struct wl_list surfaces_list;
228 struct wl_client *client;
230 enum { POINTER, TOUCH } type;
234 struct shell_client {
235 struct wl_resource *resource;
236 struct wl_client *client;
237 struct desktop_shell *shell;
238 struct wl_listener destroy_listener;
239 struct wl_event_source *ping_timer;
240 uint32_t ping_serial;
244 static struct desktop_shell *
245 shell_surface_get_shell(struct shell_surface *shsurf);
248 surface_rotate(struct shell_surface *surface, struct weston_seat *seat);
251 shell_fade_startup(struct desktop_shell *shell);
253 static struct shell_seat *
254 get_shell_seat(struct weston_seat *seat);
257 get_output_panel_size(struct desktop_shell *shell,
258 struct weston_output *output,
259 int *width, int *height);
262 shell_surface_update_child_surface_layers(struct shell_surface *shsurf);
265 shell_surface_is_wl_shell_surface(struct shell_surface *shsurf);
268 shell_surface_is_xdg_surface(struct shell_surface *shsurf);
271 shell_surface_is_xdg_popup(struct shell_surface *shsurf);
274 shell_surface_set_parent(struct shell_surface *shsurf,
275 struct weston_surface *parent);
278 shell_surface_is_top_fullscreen(struct shell_surface *shsurf)
280 struct desktop_shell *shell;
281 struct weston_view *top_fs_ev;
283 shell = shell_surface_get_shell(shsurf);
285 if (wl_list_empty(&shell->fullscreen_layer.view_list.link))
288 top_fs_ev = container_of(shell->fullscreen_layer.view_list.link.next,
291 return (shsurf == get_shell_surface(top_fs_ev->surface));
295 destroy_shell_grab_shsurf(struct wl_listener *listener, void *data)
297 struct shell_grab *grab;
299 grab = container_of(listener, struct shell_grab,
300 shsurf_destroy_listener);
306 get_default_view(struct weston_surface *surface)
308 struct shell_surface *shsurf;
309 struct weston_view *view;
311 if (!surface || wl_list_empty(&surface->views))
314 shsurf = get_shell_surface(surface);
318 wl_list_for_each(view, &surface->views, surface_link)
319 if (weston_view_is_mapped(view))
322 return container_of(surface->views.next, struct weston_view, surface_link);
326 popup_grab_end(struct weston_pointer *pointer);
328 touch_popup_grab_end(struct weston_touch *touch);
331 shell_grab_start(struct shell_grab *grab,
332 const struct weston_pointer_grab_interface *interface,
333 struct shell_surface *shsurf,
334 struct weston_pointer *pointer,
335 enum desktop_shell_cursor cursor)
337 struct desktop_shell *shell = shsurf->shell;
339 popup_grab_end(pointer);
340 if (pointer->seat->touch)
341 touch_popup_grab_end(pointer->seat->touch);
343 grab->grab.interface = interface;
344 grab->shsurf = shsurf;
345 grab->shsurf_destroy_listener.notify = destroy_shell_grab_shsurf;
346 wl_signal_add(&shsurf->destroy_signal,
347 &grab->shsurf_destroy_listener);
350 weston_pointer_start_grab(pointer, &grab->grab);
351 if (shell->child.desktop_shell) {
352 desktop_shell_send_grab_cursor(shell->child.desktop_shell,
354 weston_pointer_set_focus(pointer,
355 get_default_view(shell->grab_surface),
356 wl_fixed_from_int(0),
357 wl_fixed_from_int(0));
362 get_output_panel_size(struct desktop_shell *shell,
363 struct weston_output *output,
367 struct weston_view *view;
375 wl_list_for_each(view, &shell->panel_layer.view_list.link, layer_link.link) {
378 if (view->surface->output != output)
381 switch (shell->panel_position) {
382 case DESKTOP_SHELL_PANEL_POSITION_TOP:
383 case DESKTOP_SHELL_PANEL_POSITION_BOTTOM:
385 weston_view_to_global_float(view,
386 view->surface->width, 0,
390 *height = view->surface->height + (int) y;
393 case DESKTOP_SHELL_PANEL_POSITION_LEFT:
394 case DESKTOP_SHELL_PANEL_POSITION_RIGHT:
395 weston_view_to_global_float(view,
396 0, view->surface->height,
399 *width = view->surface->width + (int) x;
404 /* we've already set width and height to
405 * fallback values. */
410 /* the correct view wasn't found */
414 get_output_work_area(struct desktop_shell *shell,
415 struct weston_output *output,
416 pixman_rectangle32_t *area)
418 int32_t panel_width = 0, panel_height = 0;
423 get_output_panel_size(shell, output, &panel_width, &panel_height);
425 switch (shell->panel_position) {
426 case DESKTOP_SHELL_PANEL_POSITION_TOP:
428 area->y = panel_height;
429 case DESKTOP_SHELL_PANEL_POSITION_BOTTOM:
430 area->width = output->width;
431 area->height = output->height - panel_height;
433 case DESKTOP_SHELL_PANEL_POSITION_LEFT:
434 area->x = panel_width;
435 case DESKTOP_SHELL_PANEL_POSITION_RIGHT:
436 area->width = output->width - panel_width;
437 area->height = output->height;
443 send_configure_for_surface(struct shell_surface *shsurf)
445 int32_t width, height;
446 struct surface_state *state;
448 if (shsurf->state_requested)
449 state = &shsurf->requested_state;
450 else if (shsurf->state_changed)
451 state = &shsurf->next_state;
453 state = &shsurf->state;
455 if (state->fullscreen) {
456 width = shsurf->output->width;
457 height = shsurf->output->height;
458 } else if (state->maximized) {
459 struct desktop_shell *shell;
460 pixman_rectangle32_t area;
462 shell = shell_surface_get_shell(shsurf);
463 get_output_work_area(shell, shsurf->output, &area);
466 height = area.height;
472 shsurf->client->send_configure(shsurf->surface, width, height);
476 shell_surface_state_changed(struct shell_surface *shsurf)
478 if (shell_surface_is_xdg_surface(shsurf))
479 send_configure_for_surface(shsurf);
483 shell_grab_end(struct shell_grab *grab)
486 wl_list_remove(&grab->shsurf_destroy_listener.link);
487 grab->shsurf->grabbed = 0;
489 if (grab->shsurf->resize_edges) {
490 grab->shsurf->resize_edges = 0;
491 shell_surface_state_changed(grab->shsurf);
495 weston_pointer_end_grab(grab->grab.pointer);
499 shell_touch_grab_start(struct shell_touch_grab *grab,
500 const struct weston_touch_grab_interface *interface,
501 struct shell_surface *shsurf,
502 struct weston_touch *touch)
504 struct desktop_shell *shell = shsurf->shell;
506 touch_popup_grab_end(touch);
507 if (touch->seat->pointer)
508 popup_grab_end(touch->seat->pointer);
510 grab->grab.interface = interface;
511 grab->shsurf = shsurf;
512 grab->shsurf_destroy_listener.notify = destroy_shell_grab_shsurf;
513 wl_signal_add(&shsurf->destroy_signal,
514 &grab->shsurf_destroy_listener);
519 weston_touch_start_grab(touch, &grab->grab);
520 if (shell->child.desktop_shell)
521 weston_touch_set_focus(touch->seat,
522 get_default_view(shell->grab_surface));
526 shell_touch_grab_end(struct shell_touch_grab *grab)
529 wl_list_remove(&grab->shsurf_destroy_listener.link);
530 grab->shsurf->grabbed = 0;
533 weston_touch_end_grab(grab->touch);
537 center_on_output(struct weston_view *view,
538 struct weston_output *output);
540 static enum weston_keyboard_modifier
541 get_modifier(char *modifier)
544 return MODIFIER_SUPER;
546 if (!strcmp("ctrl", modifier))
547 return MODIFIER_CTRL;
548 else if (!strcmp("alt", modifier))
550 else if (!strcmp("super", modifier))
551 return MODIFIER_SUPER;
553 return MODIFIER_SUPER;
556 static enum animation_type
557 get_animation_type(char *animation)
560 return ANIMATION_NONE;
562 if (!strcmp("zoom", animation))
563 return ANIMATION_ZOOM;
564 else if (!strcmp("fade", animation))
565 return ANIMATION_FADE;
566 else if (!strcmp("dim-layer", animation))
567 return ANIMATION_DIM_LAYER;
569 return ANIMATION_NONE;
573 shell_configuration(struct desktop_shell *shell)
575 struct weston_config_section *section;
579 section = weston_config_get_section(shell->compositor->config,
580 "screensaver", NULL, NULL);
581 weston_config_section_get_string(section,
582 "path", &shell->screensaver.path, NULL);
583 weston_config_section_get_int(section, "duration", &duration, 60);
584 shell->screensaver.duration = duration * 1000;
586 section = weston_config_get_section(shell->compositor->config,
587 "shell", NULL, NULL);
588 asprintf(&client, "%s/%s", weston_config_get_libexec_dir(),
589 WESTON_SHELL_CLIENT);
590 weston_config_section_get_string(section,
591 "client", &s, client);
594 weston_config_section_get_string(section,
595 "binding-modifier", &s, "super");
596 shell->binding_modifier = get_modifier(s);
599 weston_config_section_get_string(section,
600 "exposay-modifier", &s, "none");
601 if (strcmp(s, "none") == 0)
602 shell->exposay_modifier = 0;
604 shell->exposay_modifier = get_modifier(s);
607 weston_config_section_get_string(section, "animation", &s, "none");
608 shell->win_animation_type = get_animation_type(s);
610 weston_config_section_get_string(section, "close-animation", &s, "fade");
611 shell->win_close_animation_type = get_animation_type(s);
613 weston_config_section_get_string(section,
614 "startup-animation", &s, "fade");
615 shell->startup_animation_type = get_animation_type(s);
617 if (shell->startup_animation_type == ANIMATION_ZOOM)
618 shell->startup_animation_type = ANIMATION_NONE;
619 weston_config_section_get_string(section, "focus-animation", &s, "none");
620 shell->focus_animation_type = get_animation_type(s);
622 weston_config_section_get_uint(section, "num-workspaces",
623 &shell->workspaces.num,
624 DEFAULT_NUM_WORKSPACES);
627 struct weston_output *
628 get_default_output(struct weston_compositor *compositor)
630 return container_of(compositor->output_list.next,
631 struct weston_output, link);
635 /* no-op func for checking focus surface */
637 focus_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
641 static struct focus_surface *
642 get_focus_surface(struct weston_surface *surface)
644 if (surface->configure == focus_surface_configure)
645 return surface->configure_private;
651 is_focus_surface (struct weston_surface *es)
653 return (es->configure == focus_surface_configure);
657 is_focus_view (struct weston_view *view)
659 return is_focus_surface (view->surface);
662 static struct focus_surface *
663 create_focus_surface(struct weston_compositor *ec,
664 struct weston_output *output)
666 struct focus_surface *fsurf = NULL;
667 struct weston_surface *surface = NULL;
669 fsurf = malloc(sizeof *fsurf);
673 fsurf->surface = weston_surface_create(ec);
674 surface = fsurf->surface;
675 if (surface == NULL) {
680 surface->configure = focus_surface_configure;
681 surface->output = output;
682 surface->configure_private = fsurf;
684 fsurf->view = weston_view_create(surface);
685 if (fsurf->view == NULL) {
686 weston_surface_destroy(surface);
690 fsurf->view->output = output;
692 weston_surface_set_size(surface, output->width, output->height);
693 weston_view_set_position(fsurf->view, output->x, output->y);
694 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1.0);
695 pixman_region32_fini(&surface->opaque);
696 pixman_region32_init_rect(&surface->opaque, output->x, output->y,
697 output->width, output->height);
698 pixman_region32_fini(&surface->input);
699 pixman_region32_init(&surface->input);
701 wl_list_init(&fsurf->workspace_transform.link);
707 focus_surface_destroy(struct focus_surface *fsurf)
709 weston_surface_destroy(fsurf->surface);
714 focus_animation_done(struct weston_view_animation *animation, void *data)
716 struct workspace *ws = data;
718 ws->focus_animation = NULL;
722 focus_state_destroy(struct focus_state *state)
724 wl_list_remove(&state->seat_destroy_listener.link);
725 wl_list_remove(&state->surface_destroy_listener.link);
730 focus_state_seat_destroy(struct wl_listener *listener, void *data)
732 struct focus_state *state = container_of(listener,
734 seat_destroy_listener);
736 wl_list_remove(&state->link);
737 focus_state_destroy(state);
741 focus_state_surface_destroy(struct wl_listener *listener, void *data)
743 struct focus_state *state = container_of(listener,
745 surface_destroy_listener);
746 struct desktop_shell *shell;
747 struct weston_surface *main_surface, *next;
748 struct weston_view *view;
750 main_surface = weston_surface_get_main_surface(state->keyboard_focus);
753 wl_list_for_each(view,
754 &state->ws->layer.view_list.link, layer_link.link) {
755 if (view->surface == main_surface)
757 if (is_focus_view(view))
760 next = view->surface;
764 /* if the focus was a sub-surface, activate its main surface */
765 if (main_surface != state->keyboard_focus)
768 shell = state->seat->compositor->shell_interface.shell;
770 state->keyboard_focus = NULL;
771 activate(shell, next, state->seat, true);
773 if (shell->focus_animation_type == ANIMATION_DIM_LAYER) {
774 if (state->ws->focus_animation)
775 weston_view_animation_destroy(state->ws->focus_animation);
777 state->ws->focus_animation = weston_fade_run(
778 state->ws->fsurf_front->view,
779 state->ws->fsurf_front->view->alpha, 0.0, 300,
780 focus_animation_done, state->ws);
783 wl_list_remove(&state->link);
784 focus_state_destroy(state);
788 static struct focus_state *
789 focus_state_create(struct weston_seat *seat, struct workspace *ws)
791 struct focus_state *state;
793 state = malloc(sizeof *state);
797 state->keyboard_focus = NULL;
800 wl_list_insert(&ws->focus_list, &state->link);
802 state->seat_destroy_listener.notify = focus_state_seat_destroy;
803 state->surface_destroy_listener.notify = focus_state_surface_destroy;
804 wl_signal_add(&seat->destroy_signal,
805 &state->seat_destroy_listener);
806 wl_list_init(&state->surface_destroy_listener.link);
811 static struct focus_state *
812 ensure_focus_state(struct desktop_shell *shell, struct weston_seat *seat)
814 struct workspace *ws = get_current_workspace(shell);
815 struct focus_state *state;
817 wl_list_for_each(state, &ws->focus_list, link)
818 if (state->seat == seat)
821 if (&state->link == &ws->focus_list)
822 state = focus_state_create(seat, ws);
828 focus_state_set_focus(struct focus_state *state,
829 struct weston_surface *surface)
831 if (state->keyboard_focus) {
832 wl_list_remove(&state->surface_destroy_listener.link);
833 wl_list_init(&state->surface_destroy_listener.link);
836 state->keyboard_focus = surface;
838 wl_signal_add(&surface->destroy_signal,
839 &state->surface_destroy_listener);
843 restore_focus_state(struct desktop_shell *shell, struct workspace *ws)
845 struct focus_state *state, *next;
846 struct weston_surface *surface;
847 struct wl_list pending_seat_list;
848 struct weston_seat *seat, *next_seat;
850 /* Temporarily steal the list of seats so that we can keep
851 * track of the seats we've already processed */
852 wl_list_init(&pending_seat_list);
853 wl_list_insert_list(&pending_seat_list, &shell->compositor->seat_list);
854 wl_list_init(&shell->compositor->seat_list);
856 wl_list_for_each_safe(state, next, &ws->focus_list, link) {
857 wl_list_remove(&state->seat->link);
858 wl_list_insert(&shell->compositor->seat_list,
861 if (state->seat->keyboard == NULL)
864 surface = state->keyboard_focus;
866 weston_keyboard_set_focus(state->seat->keyboard, surface);
869 /* For any remaining seats that we don't have a focus state
870 * for we'll reset the keyboard focus to NULL */
871 wl_list_for_each_safe(seat, next_seat, &pending_seat_list, link) {
872 wl_list_insert(&shell->compositor->seat_list, &seat->link);
874 if (seat->keyboard == NULL)
877 weston_keyboard_set_focus(seat->keyboard, NULL);
882 replace_focus_state(struct desktop_shell *shell, struct workspace *ws,
883 struct weston_seat *seat)
885 struct focus_state *state;
887 wl_list_for_each(state, &ws->focus_list, link) {
888 if (state->seat == seat) {
889 focus_state_set_focus(state, seat->keyboard->focus);
896 drop_focus_state(struct desktop_shell *shell, struct workspace *ws,
897 struct weston_surface *surface)
899 struct focus_state *state;
901 wl_list_for_each(state, &ws->focus_list, link)
902 if (state->keyboard_focus == surface)
903 focus_state_set_focus(state, NULL);
907 animate_focus_change(struct desktop_shell *shell, struct workspace *ws,
908 struct weston_view *from, struct weston_view *to)
910 struct weston_output *output;
911 bool focus_surface_created = false;
913 /* FIXME: Only support dim animation using two layers */
914 if (from == to || shell->focus_animation_type != ANIMATION_DIM_LAYER)
917 output = get_default_output(shell->compositor);
918 if (ws->fsurf_front == NULL && (from || to)) {
919 ws->fsurf_front = create_focus_surface(shell->compositor, output);
920 if (ws->fsurf_front == NULL)
922 ws->fsurf_front->view->alpha = 0.0;
924 ws->fsurf_back = create_focus_surface(shell->compositor, output);
925 if (ws->fsurf_back == NULL) {
926 focus_surface_destroy(ws->fsurf_front);
929 ws->fsurf_back->view->alpha = 0.0;
931 focus_surface_created = true;
933 weston_layer_entry_remove(&ws->fsurf_front->view->layer_link);
934 weston_layer_entry_remove(&ws->fsurf_back->view->layer_link);
937 if (ws->focus_animation) {
938 weston_view_animation_destroy(ws->focus_animation);
939 ws->focus_animation = NULL;
943 weston_layer_entry_insert(&to->layer_link,
944 &ws->fsurf_front->view->layer_link);
946 weston_layer_entry_insert(&ws->layer.view_list,
947 &ws->fsurf_front->view->layer_link);
949 if (focus_surface_created) {
950 ws->focus_animation = weston_fade_run(
951 ws->fsurf_front->view,
952 ws->fsurf_front->view->alpha, 0.4, 300,
953 focus_animation_done, ws);
955 weston_layer_entry_insert(&from->layer_link,
956 &ws->fsurf_back->view->layer_link);
957 ws->focus_animation = weston_stable_fade_run(
958 ws->fsurf_front->view, 0.0,
959 ws->fsurf_back->view, 0.4,
960 focus_animation_done, ws);
962 weston_layer_entry_insert(&ws->layer.view_list,
963 &ws->fsurf_back->view->layer_link);
964 ws->focus_animation = weston_stable_fade_run(
965 ws->fsurf_front->view, 0.0,
966 ws->fsurf_back->view, 0.4,
967 focus_animation_done, ws);
972 workspace_destroy(struct workspace *ws)
974 struct focus_state *state, *next;
976 wl_list_for_each_safe(state, next, &ws->focus_list, link)
977 focus_state_destroy(state);
980 focus_surface_destroy(ws->fsurf_front);
982 focus_surface_destroy(ws->fsurf_back);
988 seat_destroyed(struct wl_listener *listener, void *data)
990 struct weston_seat *seat = data;
991 struct focus_state *state, *next;
992 struct workspace *ws = container_of(listener,
994 seat_destroyed_listener);
996 wl_list_for_each_safe(state, next, &ws->focus_list, link)
997 if (state->seat == seat)
998 wl_list_remove(&state->link);
1001 static struct workspace *
1002 workspace_create(void)
1004 struct workspace *ws = malloc(sizeof *ws);
1008 weston_layer_init(&ws->layer, NULL);
1010 wl_list_init(&ws->focus_list);
1011 wl_list_init(&ws->seat_destroyed_listener.link);
1012 ws->seat_destroyed_listener.notify = seat_destroyed;
1013 ws->fsurf_front = NULL;
1014 ws->fsurf_back = NULL;
1015 ws->focus_animation = NULL;
1021 workspace_is_empty(struct workspace *ws)
1023 return wl_list_empty(&ws->layer.view_list.link);
1026 static struct workspace *
1027 get_workspace(struct desktop_shell *shell, unsigned int index)
1029 struct workspace **pws = shell->workspaces.array.data;
1030 assert(index < shell->workspaces.num);
1036 get_current_workspace(struct desktop_shell *shell)
1038 return get_workspace(shell, shell->workspaces.current);
1042 activate_workspace(struct desktop_shell *shell, unsigned int index)
1044 struct workspace *ws;
1046 ws = get_workspace(shell, index);
1047 wl_list_insert(&shell->panel_layer.link, &ws->layer.link);
1049 shell->workspaces.current = index;
1053 get_output_height(struct weston_output *output)
1055 return abs(output->region.extents.y1 - output->region.extents.y2);
1059 view_translate(struct workspace *ws, struct weston_view *view, double d)
1061 struct weston_transform *transform;
1063 if (is_focus_view(view)) {
1064 struct focus_surface *fsurf = get_focus_surface(view->surface);
1065 transform = &fsurf->workspace_transform;
1067 struct shell_surface *shsurf = get_shell_surface(view->surface);
1068 transform = &shsurf->workspace_transform;
1071 if (wl_list_empty(&transform->link))
1072 wl_list_insert(view->geometry.transformation_list.prev,
1075 weston_matrix_init(&transform->matrix);
1076 weston_matrix_translate(&transform->matrix,
1078 weston_view_geometry_dirty(view);
1082 workspace_translate_out(struct workspace *ws, double fraction)
1084 struct weston_view *view;
1085 unsigned int height;
1088 wl_list_for_each(view, &ws->layer.view_list.link, layer_link.link) {
1089 height = get_output_height(view->surface->output);
1090 d = height * fraction;
1092 view_translate(ws, view, d);
1097 workspace_translate_in(struct workspace *ws, double fraction)
1099 struct weston_view *view;
1100 unsigned int height;
1103 wl_list_for_each(view, &ws->layer.view_list.link, layer_link.link) {
1104 height = get_output_height(view->surface->output);
1107 d = -(height - height * fraction);
1109 d = height + height * fraction;
1111 view_translate(ws, view, d);
1116 broadcast_current_workspace_state(struct desktop_shell *shell)
1118 struct wl_resource *resource;
1120 wl_resource_for_each(resource, &shell->workspaces.client_list)
1121 workspace_manager_send_state(resource,
1122 shell->workspaces.current,
1123 shell->workspaces.num);
1127 reverse_workspace_change_animation(struct desktop_shell *shell,
1129 struct workspace *from,
1130 struct workspace *to)
1132 shell->workspaces.current = index;
1134 shell->workspaces.anim_to = to;
1135 shell->workspaces.anim_from = from;
1136 shell->workspaces.anim_dir = -1 * shell->workspaces.anim_dir;
1137 shell->workspaces.anim_timestamp = 0;
1139 weston_compositor_schedule_repaint(shell->compositor);
1143 workspace_deactivate_transforms(struct workspace *ws)
1145 struct weston_view *view;
1146 struct weston_transform *transform;
1148 wl_list_for_each(view, &ws->layer.view_list.link, layer_link.link) {
1149 if (is_focus_view(view)) {
1150 struct focus_surface *fsurf = get_focus_surface(view->surface);
1151 transform = &fsurf->workspace_transform;
1153 struct shell_surface *shsurf = get_shell_surface(view->surface);
1154 transform = &shsurf->workspace_transform;
1157 if (!wl_list_empty(&transform->link)) {
1158 wl_list_remove(&transform->link);
1159 wl_list_init(&transform->link);
1161 weston_view_geometry_dirty(view);
1166 finish_workspace_change_animation(struct desktop_shell *shell,
1167 struct workspace *from,
1168 struct workspace *to)
1170 struct weston_view *view;
1172 weston_compositor_schedule_repaint(shell->compositor);
1174 /* Views that extend past the bottom of the output are still
1175 * visible after the workspace animation ends but before its layer
1176 * is hidden. In that case, we need to damage below those views so
1177 * that the screen is properly repainted. */
1178 wl_list_for_each(view, &from->layer.view_list.link, layer_link.link)
1179 weston_view_damage_below(view);
1181 wl_list_remove(&shell->workspaces.animation.link);
1182 workspace_deactivate_transforms(from);
1183 workspace_deactivate_transforms(to);
1184 shell->workspaces.anim_to = NULL;
1186 wl_list_remove(&shell->workspaces.anim_from->layer.link);
1190 animate_workspace_change_frame(struct weston_animation *animation,
1191 struct weston_output *output, uint32_t msecs)
1193 struct desktop_shell *shell =
1194 container_of(animation, struct desktop_shell,
1195 workspaces.animation);
1196 struct workspace *from = shell->workspaces.anim_from;
1197 struct workspace *to = shell->workspaces.anim_to;
1201 if (workspace_is_empty(from) && workspace_is_empty(to)) {
1202 finish_workspace_change_animation(shell, from, to);
1206 if (shell->workspaces.anim_timestamp == 0) {
1207 if (shell->workspaces.anim_current == 0.0)
1208 shell->workspaces.anim_timestamp = msecs;
1210 shell->workspaces.anim_timestamp =
1212 /* Invers of movement function 'y' below. */
1213 (asin(1.0 - shell->workspaces.anim_current) *
1214 DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH *
1218 t = msecs - shell->workspaces.anim_timestamp;
1224 x = t * (1.0/DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH) * M_PI_2;
1227 if (t < DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH) {
1228 weston_compositor_schedule_repaint(shell->compositor);
1230 workspace_translate_out(from, shell->workspaces.anim_dir * y);
1231 workspace_translate_in(to, shell->workspaces.anim_dir * y);
1232 shell->workspaces.anim_current = y;
1234 weston_compositor_schedule_repaint(shell->compositor);
1237 finish_workspace_change_animation(shell, from, to);
1241 animate_workspace_change(struct desktop_shell *shell,
1243 struct workspace *from,
1244 struct workspace *to)
1246 struct weston_output *output;
1250 if (index > shell->workspaces.current)
1255 shell->workspaces.current = index;
1257 shell->workspaces.anim_dir = dir;
1258 shell->workspaces.anim_from = from;
1259 shell->workspaces.anim_to = to;
1260 shell->workspaces.anim_current = 0.0;
1261 shell->workspaces.anim_timestamp = 0;
1263 output = container_of(shell->compositor->output_list.next,
1264 struct weston_output, link);
1265 wl_list_insert(&output->animation_list,
1266 &shell->workspaces.animation.link);
1268 wl_list_insert(from->layer.link.prev, &to->layer.link);
1270 workspace_translate_in(to, 0);
1272 restore_focus_state(shell, to);
1274 weston_compositor_schedule_repaint(shell->compositor);
1278 update_workspace(struct desktop_shell *shell, unsigned int index,
1279 struct workspace *from, struct workspace *to)
1281 shell->workspaces.current = index;
1282 wl_list_insert(&from->layer.link, &to->layer.link);
1283 wl_list_remove(&from->layer.link);
1287 change_workspace(struct desktop_shell *shell, unsigned int index)
1289 struct workspace *from;
1290 struct workspace *to;
1291 struct focus_state *state;
1293 if (index == shell->workspaces.current)
1296 /* Don't change workspace when there is any fullscreen surfaces. */
1297 if (!wl_list_empty(&shell->fullscreen_layer.view_list.link))
1300 from = get_current_workspace(shell);
1301 to = get_workspace(shell, index);
1303 if (shell->workspaces.anim_from == to &&
1304 shell->workspaces.anim_to == from) {
1305 restore_focus_state(shell, to);
1306 reverse_workspace_change_animation(shell, index, from, to);
1307 broadcast_current_workspace_state(shell);
1311 if (shell->workspaces.anim_to != NULL)
1312 finish_workspace_change_animation(shell,
1313 shell->workspaces.anim_from,
1314 shell->workspaces.anim_to);
1316 restore_focus_state(shell, to);
1318 if (shell->focus_animation_type != ANIMATION_NONE) {
1319 wl_list_for_each(state, &from->focus_list, link)
1320 if (state->keyboard_focus)
1321 animate_focus_change(shell, from,
1322 get_default_view(state->keyboard_focus), NULL);
1324 wl_list_for_each(state, &to->focus_list, link)
1325 if (state->keyboard_focus)
1326 animate_focus_change(shell, to,
1327 NULL, get_default_view(state->keyboard_focus));
1330 if (workspace_is_empty(to) && workspace_is_empty(from))
1331 update_workspace(shell, index, from, to);
1333 animate_workspace_change(shell, index, from, to);
1335 broadcast_current_workspace_state(shell);
1339 workspace_has_only(struct workspace *ws, struct weston_surface *surface)
1341 struct wl_list *list = &ws->layer.view_list.link;
1344 if (wl_list_empty(list))
1349 if (e->next != list)
1352 return container_of(e, struct weston_view, layer_link.link)->surface == surface;
1356 move_surface_to_workspace(struct desktop_shell *shell,
1357 struct shell_surface *shsurf,
1360 struct workspace *from;
1361 struct workspace *to;
1362 struct weston_seat *seat;
1363 struct weston_surface *focus;
1364 struct weston_view *view;
1366 if (workspace == shell->workspaces.current)
1369 view = get_default_view(shsurf->surface);
1373 assert(weston_surface_get_main_surface(view->surface) == view->surface);
1375 if (workspace >= shell->workspaces.num)
1376 workspace = shell->workspaces.num - 1;
1378 from = get_current_workspace(shell);
1379 to = get_workspace(shell, workspace);
1381 weston_layer_entry_remove(&view->layer_link);
1382 weston_layer_entry_insert(&to->layer.view_list, &view->layer_link);
1384 shell_surface_update_child_surface_layers(shsurf);
1386 drop_focus_state(shell, from, view->surface);
1387 wl_list_for_each(seat, &shell->compositor->seat_list, link) {
1388 if (!seat->keyboard)
1391 focus = weston_surface_get_main_surface(seat->keyboard->focus);
1392 if (focus == view->surface)
1393 weston_keyboard_set_focus(seat->keyboard, NULL);
1396 weston_view_damage_below(view);
1400 take_surface_to_workspace_by_seat(struct desktop_shell *shell,
1401 struct weston_seat *seat,
1404 struct weston_surface *surface;
1405 struct weston_view *view;
1406 struct shell_surface *shsurf;
1407 struct workspace *from;
1408 struct workspace *to;
1409 struct focus_state *state;
1411 surface = weston_surface_get_main_surface(seat->keyboard->focus);
1412 view = get_default_view(surface);
1414 index == shell->workspaces.current ||
1415 is_focus_view(view))
1418 from = get_current_workspace(shell);
1419 to = get_workspace(shell, index);
1421 weston_layer_entry_remove(&view->layer_link);
1422 weston_layer_entry_insert(&to->layer.view_list, &view->layer_link);
1424 shsurf = get_shell_surface(surface);
1426 shell_surface_update_child_surface_layers(shsurf);
1428 replace_focus_state(shell, to, seat);
1429 drop_focus_state(shell, from, surface);
1431 if (shell->workspaces.anim_from == to &&
1432 shell->workspaces.anim_to == from) {
1433 wl_list_remove(&to->layer.link);
1434 wl_list_insert(from->layer.link.prev, &to->layer.link);
1436 reverse_workspace_change_animation(shell, index, from, to);
1437 broadcast_current_workspace_state(shell);
1442 if (shell->workspaces.anim_to != NULL)
1443 finish_workspace_change_animation(shell,
1444 shell->workspaces.anim_from,
1445 shell->workspaces.anim_to);
1447 if (workspace_is_empty(from) &&
1448 workspace_has_only(to, surface))
1449 update_workspace(shell, index, from, to);
1451 if (shsurf != NULL &&
1452 wl_list_empty(&shsurf->workspace_transform.link))
1453 wl_list_insert(&shell->workspaces.anim_sticky_list,
1454 &shsurf->workspace_transform.link);
1456 animate_workspace_change(shell, index, from, to);
1459 broadcast_current_workspace_state(shell);
1461 state = ensure_focus_state(shell, seat);
1463 focus_state_set_focus(state, surface);
1467 workspace_manager_move_surface(struct wl_client *client,
1468 struct wl_resource *resource,
1469 struct wl_resource *surface_resource,
1472 struct desktop_shell *shell = wl_resource_get_user_data(resource);
1473 struct weston_surface *surface =
1474 wl_resource_get_user_data(surface_resource);
1475 struct weston_surface *main_surface;
1476 struct shell_surface *shell_surface;
1478 main_surface = weston_surface_get_main_surface(surface);
1479 shell_surface = get_shell_surface(main_surface);
1480 if (shell_surface == NULL)
1483 move_surface_to_workspace(shell, shell_surface, workspace);
1486 static const struct workspace_manager_interface workspace_manager_implementation = {
1487 workspace_manager_move_surface,
1491 unbind_resource(struct wl_resource *resource)
1493 wl_list_remove(wl_resource_get_link(resource));
1497 bind_workspace_manager(struct wl_client *client,
1498 void *data, uint32_t version, uint32_t id)
1500 struct desktop_shell *shell = data;
1501 struct wl_resource *resource;
1503 resource = wl_resource_create(client,
1504 &workspace_manager_interface, 1, id);
1506 if (resource == NULL) {
1507 weston_log("couldn't add workspace manager object");
1511 wl_resource_set_implementation(resource,
1512 &workspace_manager_implementation,
1513 shell, unbind_resource);
1514 wl_list_insert(&shell->workspaces.client_list,
1515 wl_resource_get_link(resource));
1517 workspace_manager_send_state(resource,
1518 shell->workspaces.current,
1519 shell->workspaces.num);
1523 touch_move_grab_down(struct weston_touch_grab *grab, uint32_t time,
1524 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
1529 touch_move_grab_up(struct weston_touch_grab *grab, uint32_t time, int touch_id)
1531 struct weston_touch_move_grab *move =
1532 (struct weston_touch_move_grab *) container_of(
1533 grab, struct shell_touch_grab, grab);
1538 if (grab->touch->num_tp == 0) {
1539 shell_touch_grab_end(&move->base);
1545 touch_move_grab_motion(struct weston_touch_grab *grab, uint32_t time,
1546 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
1548 struct weston_touch_move_grab *move = (struct weston_touch_move_grab *) grab;
1549 struct shell_surface *shsurf = move->base.shsurf;
1550 struct weston_surface *es;
1551 int dx = wl_fixed_to_int(grab->touch->grab_x + move->dx);
1552 int dy = wl_fixed_to_int(grab->touch->grab_y + move->dy);
1554 if (!shsurf || !move->active)
1557 es = shsurf->surface;
1559 weston_view_set_position(shsurf->view, dx, dy);
1561 weston_compositor_schedule_repaint(es->compositor);
1565 touch_move_grab_frame(struct weston_touch_grab *grab)
1570 touch_move_grab_cancel(struct weston_touch_grab *grab)
1572 struct weston_touch_move_grab *move =
1573 (struct weston_touch_move_grab *) container_of(
1574 grab, struct shell_touch_grab, grab);
1576 shell_touch_grab_end(&move->base);
1580 static const struct weston_touch_grab_interface touch_move_grab_interface = {
1581 touch_move_grab_down,
1583 touch_move_grab_motion,
1584 touch_move_grab_frame,
1585 touch_move_grab_cancel,
1589 surface_touch_move(struct shell_surface *shsurf, struct weston_seat *seat)
1591 struct weston_touch_move_grab *move;
1596 if (shsurf->state.fullscreen || shsurf->state.maximized)
1599 move = malloc(sizeof *move);
1604 move->dx = wl_fixed_from_double(shsurf->view->geometry.x) -
1605 seat->touch->grab_x;
1606 move->dy = wl_fixed_from_double(shsurf->view->geometry.y) -
1607 seat->touch->grab_y;
1609 shell_touch_grab_start(&move->base, &touch_move_grab_interface, shsurf,
1616 noop_grab_focus(struct weston_pointer_grab *grab)
1621 constrain_position(struct weston_move_grab *move, int *cx, int *cy)
1623 struct shell_surface *shsurf = move->base.shsurf;
1624 struct weston_pointer *pointer = move->base.grab.pointer;
1625 int x, y, panel_width, panel_height, bottom;
1626 const int safety = 50;
1628 x = wl_fixed_to_int(pointer->x + move->dx);
1629 y = wl_fixed_to_int(pointer->y + move->dy);
1631 if (shsurf->shell->panel_position == DESKTOP_SHELL_PANEL_POSITION_TOP) {
1632 get_output_panel_size(shsurf->shell, shsurf->surface->output,
1633 &panel_width, &panel_height);
1635 bottom = y + shsurf->geometry.height;
1636 if (bottom - panel_height < safety)
1637 y = panel_height + safety -
1638 shsurf->geometry.height;
1640 if (move->client_initiated &&
1641 y + shsurf->geometry.y < panel_height)
1642 y = panel_height - shsurf->geometry.y;
1650 move_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
1651 wl_fixed_t x, wl_fixed_t y)
1653 struct weston_move_grab *move = (struct weston_move_grab *) grab;
1654 struct weston_pointer *pointer = grab->pointer;
1655 struct shell_surface *shsurf = move->base.shsurf;
1658 weston_pointer_move(pointer, x, y);
1662 constrain_position(move, &cx, &cy);
1664 weston_view_set_position(shsurf->view, cx, cy);
1666 weston_compositor_schedule_repaint(shsurf->surface->compositor);
1670 move_grab_button(struct weston_pointer_grab *grab,
1671 uint32_t time, uint32_t button, uint32_t state_w)
1673 struct shell_grab *shell_grab = container_of(grab, struct shell_grab,
1675 struct weston_pointer *pointer = grab->pointer;
1676 enum wl_pointer_button_state state = state_w;
1678 if (pointer->button_count == 0 &&
1679 state == WL_POINTER_BUTTON_STATE_RELEASED) {
1680 shell_grab_end(shell_grab);
1686 move_grab_cancel(struct weston_pointer_grab *grab)
1688 struct shell_grab *shell_grab =
1689 container_of(grab, struct shell_grab, grab);
1691 shell_grab_end(shell_grab);
1695 static const struct weston_pointer_grab_interface move_grab_interface = {
1703 surface_move(struct shell_surface *shsurf, struct weston_seat *seat,
1704 int client_initiated)
1706 struct weston_move_grab *move;
1711 if (shsurf->grabbed ||
1712 shsurf->state.fullscreen || shsurf->state.maximized)
1715 move = malloc(sizeof *move);
1719 move->dx = wl_fixed_from_double(shsurf->view->geometry.x) -
1720 seat->pointer->grab_x;
1721 move->dy = wl_fixed_from_double(shsurf->view->geometry.y) -
1722 seat->pointer->grab_y;
1723 move->client_initiated = client_initiated;
1725 shell_grab_start(&move->base, &move_grab_interface, shsurf,
1726 seat->pointer, DESKTOP_SHELL_CURSOR_MOVE);
1732 common_surface_move(struct wl_resource *resource,
1733 struct wl_resource *seat_resource, uint32_t serial)
1735 struct weston_seat *seat = wl_resource_get_user_data(seat_resource);
1736 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
1737 struct weston_surface *surface;
1739 if (seat->pointer &&
1740 seat->pointer->focus &&
1741 seat->pointer->button_count > 0 &&
1742 seat->pointer->grab_serial == serial) {
1743 surface = weston_surface_get_main_surface(seat->pointer->focus->surface);
1744 if ((surface == shsurf->surface) &&
1745 (surface_move(shsurf, seat, 1) < 0))
1746 wl_resource_post_no_memory(resource);
1747 } else if (seat->touch &&
1748 seat->touch->focus &&
1749 seat->touch->grab_serial == serial) {
1750 surface = weston_surface_get_main_surface(seat->touch->focus->surface);
1751 if ((surface == shsurf->surface) &&
1752 (surface_touch_move(shsurf, seat) < 0))
1753 wl_resource_post_no_memory(resource);
1758 shell_surface_move(struct wl_client *client, struct wl_resource *resource,
1759 struct wl_resource *seat_resource, uint32_t serial)
1761 common_surface_move(resource, seat_resource, serial);
1764 struct weston_resize_grab {
1765 struct shell_grab base;
1767 int32_t width, height;
1771 resize_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
1772 wl_fixed_t x, wl_fixed_t y)
1774 struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
1775 struct weston_pointer *pointer = grab->pointer;
1776 struct shell_surface *shsurf = resize->base.shsurf;
1777 int32_t width, height;
1778 wl_fixed_t from_x, from_y;
1779 wl_fixed_t to_x, to_y;
1781 weston_pointer_move(pointer, x, y);
1786 weston_view_from_global_fixed(shsurf->view,
1787 pointer->grab_x, pointer->grab_y,
1789 weston_view_from_global_fixed(shsurf->view,
1790 pointer->x, pointer->y, &to_x, &to_y);
1792 width = resize->width;
1793 if (resize->edges & WL_SHELL_SURFACE_RESIZE_LEFT) {
1794 width += wl_fixed_to_int(from_x - to_x);
1795 } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_RIGHT) {
1796 width += wl_fixed_to_int(to_x - from_x);
1799 height = resize->height;
1800 if (resize->edges & WL_SHELL_SURFACE_RESIZE_TOP) {
1801 height += wl_fixed_to_int(from_y - to_y);
1802 } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_BOTTOM) {
1803 height += wl_fixed_to_int(to_y - from_y);
1806 shsurf->client->send_configure(shsurf->surface, width, height);
1810 send_configure(struct weston_surface *surface, int32_t width, int32_t height)
1812 struct shell_surface *shsurf = get_shell_surface(surface);
1816 if (shsurf->resource)
1817 wl_shell_surface_send_configure(shsurf->resource,
1818 shsurf->resize_edges,
1822 static const struct weston_shell_client shell_client = {
1827 resize_grab_button(struct weston_pointer_grab *grab,
1828 uint32_t time, uint32_t button, uint32_t state_w)
1830 struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
1831 struct weston_pointer *pointer = grab->pointer;
1832 enum wl_pointer_button_state state = state_w;
1834 if (pointer->button_count == 0 &&
1835 state == WL_POINTER_BUTTON_STATE_RELEASED) {
1836 shell_grab_end(&resize->base);
1842 resize_grab_cancel(struct weston_pointer_grab *grab)
1844 struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
1846 shell_grab_end(&resize->base);
1850 static const struct weston_pointer_grab_interface resize_grab_interface = {
1858 * Returns the bounding box of a surface and all its sub-surfaces,
1859 * in the surface coordinates system. */
1861 surface_subsurfaces_boundingbox(struct weston_surface *surface, int32_t *x,
1862 int32_t *y, int32_t *w, int32_t *h) {
1863 pixman_region32_t region;
1864 pixman_box32_t *box;
1865 struct weston_subsurface *subsurface;
1867 pixman_region32_init_rect(®ion, 0, 0,
1871 wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
1872 pixman_region32_union_rect(®ion, ®ion,
1873 subsurface->position.x,
1874 subsurface->position.y,
1875 subsurface->surface->width,
1876 subsurface->surface->height);
1879 box = pixman_region32_extents(®ion);
1885 *w = box->x2 - box->x1;
1887 *h = box->y2 - box->y1;
1889 pixman_region32_fini(®ion);
1893 surface_resize(struct shell_surface *shsurf,
1894 struct weston_seat *seat, uint32_t edges)
1896 struct weston_resize_grab *resize;
1897 const unsigned resize_topbottom =
1898 WL_SHELL_SURFACE_RESIZE_TOP | WL_SHELL_SURFACE_RESIZE_BOTTOM;
1899 const unsigned resize_leftright =
1900 WL_SHELL_SURFACE_RESIZE_LEFT | WL_SHELL_SURFACE_RESIZE_RIGHT;
1901 const unsigned resize_any = resize_topbottom | resize_leftright;
1903 if (shsurf->grabbed ||
1904 shsurf->state.fullscreen || shsurf->state.maximized)
1907 /* Check for invalid edge combinations. */
1908 if (edges == WL_SHELL_SURFACE_RESIZE_NONE || edges > resize_any ||
1909 (edges & resize_topbottom) == resize_topbottom ||
1910 (edges & resize_leftright) == resize_leftright)
1913 resize = malloc(sizeof *resize);
1917 resize->edges = edges;
1919 resize->width = shsurf->geometry.width;
1920 resize->height = shsurf->geometry.height;
1922 shsurf->resize_edges = edges;
1923 shell_surface_state_changed(shsurf);
1924 shell_grab_start(&resize->base, &resize_grab_interface, shsurf,
1925 seat->pointer, edges);
1931 common_surface_resize(struct wl_resource *resource,
1932 struct wl_resource *seat_resource, uint32_t serial,
1935 struct weston_seat *seat = wl_resource_get_user_data(seat_resource);
1936 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
1937 struct weston_surface *surface;
1939 if (seat->pointer == NULL ||
1940 seat->pointer->button_count == 0 ||
1941 seat->pointer->grab_serial != serial ||
1942 seat->pointer->focus == NULL)
1945 surface = weston_surface_get_main_surface(seat->pointer->focus->surface);
1946 if (surface != shsurf->surface)
1949 if (surface_resize(shsurf, seat, edges) < 0)
1950 wl_resource_post_no_memory(resource);
1954 shell_surface_resize(struct wl_client *client, struct wl_resource *resource,
1955 struct wl_resource *seat_resource, uint32_t serial,
1958 common_surface_resize(resource, seat_resource, serial, edges);
1962 busy_cursor_grab_focus(struct weston_pointer_grab *base)
1964 struct shell_grab *grab = (struct shell_grab *) base;
1965 struct weston_pointer *pointer = base->pointer;
1966 struct weston_view *view;
1969 view = weston_compositor_pick_view(pointer->seat->compositor,
1970 pointer->x, pointer->y,
1973 if (!grab->shsurf || grab->shsurf->surface != view->surface) {
1974 shell_grab_end(grab);
1980 busy_cursor_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
1981 wl_fixed_t x, wl_fixed_t y)
1983 weston_pointer_move(grab->pointer, x, y);
1987 busy_cursor_grab_button(struct weston_pointer_grab *base,
1988 uint32_t time, uint32_t button, uint32_t state)
1990 struct shell_grab *grab = (struct shell_grab *) base;
1991 struct shell_surface *shsurf = grab->shsurf;
1992 struct weston_seat *seat = grab->grab.pointer->seat;
1994 if (shsurf && button == BTN_LEFT && state) {
1995 activate(shsurf->shell, shsurf->surface, seat, true);
1996 surface_move(shsurf, seat, 0);
1997 } else if (shsurf && button == BTN_RIGHT && state) {
1998 activate(shsurf->shell, shsurf->surface, seat, true);
1999 surface_rotate(shsurf, seat);
2004 busy_cursor_grab_cancel(struct weston_pointer_grab *base)
2006 struct shell_grab *grab = (struct shell_grab *) base;
2008 shell_grab_end(grab);
2012 static const struct weston_pointer_grab_interface busy_cursor_grab_interface = {
2013 busy_cursor_grab_focus,
2014 busy_cursor_grab_motion,
2015 busy_cursor_grab_button,
2016 busy_cursor_grab_cancel,
2020 set_busy_cursor(struct shell_surface *shsurf, struct weston_pointer *pointer)
2022 struct shell_grab *grab;
2024 if (pointer->grab->interface == &busy_cursor_grab_interface)
2027 grab = malloc(sizeof *grab);
2031 shell_grab_start(grab, &busy_cursor_grab_interface, shsurf, pointer,
2032 DESKTOP_SHELL_CURSOR_BUSY);
2033 /* Mark the shsurf as ungrabbed so that button binding is able
2035 shsurf->grabbed = 0;
2039 end_busy_cursor(struct weston_compositor *compositor, struct wl_client *client)
2041 struct shell_grab *grab;
2042 struct weston_seat *seat;
2044 wl_list_for_each(seat, &compositor->seat_list, link) {
2045 if (seat->pointer == NULL)
2048 grab = (struct shell_grab *) seat->pointer->grab;
2049 if (grab->grab.interface == &busy_cursor_grab_interface &&
2050 wl_resource_get_client(grab->shsurf->resource) == client) {
2051 shell_grab_end(grab);
2058 handle_shell_client_destroy(struct wl_listener *listener, void *data);
2061 xdg_ping_timeout_handler(void *data)
2063 struct shell_client *sc = data;
2064 struct weston_seat *seat;
2065 struct shell_surface *shsurf;
2067 /* Client is not responding */
2068 sc->unresponsive = 1;
2069 wl_list_for_each(seat, &sc->shell->compositor->seat_list, link) {
2070 if (seat->pointer == NULL || seat->pointer->focus == NULL)
2072 if (seat->pointer->focus->surface->resource == NULL)
2075 shsurf = get_shell_surface(seat->pointer->focus->surface);
2077 wl_resource_get_client(shsurf->resource) == sc->client)
2078 set_busy_cursor(shsurf, seat->pointer);
2085 handle_xdg_ping(struct shell_surface *shsurf, uint32_t serial)
2087 struct weston_compositor *compositor = shsurf->shell->compositor;
2088 struct shell_client *sc = shsurf->owner;
2089 struct wl_event_loop *loop;
2090 static const int ping_timeout = 200;
2092 if (sc->unresponsive) {
2093 xdg_ping_timeout_handler(sc);
2097 sc->ping_serial = serial;
2098 loop = wl_display_get_event_loop(compositor->wl_display);
2099 if (sc->ping_timer == NULL)
2101 wl_event_loop_add_timer(loop,
2102 xdg_ping_timeout_handler, sc);
2103 if (sc->ping_timer == NULL)
2106 wl_event_source_timer_update(sc->ping_timer, ping_timeout);
2108 if (shell_surface_is_xdg_surface(shsurf) ||
2109 shell_surface_is_xdg_popup(shsurf))
2110 xdg_shell_send_ping(sc->resource, serial);
2111 else if (shell_surface_is_wl_shell_surface(shsurf))
2112 wl_shell_surface_send_ping(shsurf->resource, serial);
2116 ping_handler(struct weston_surface *surface, uint32_t serial)
2118 struct shell_surface *shsurf = get_shell_surface(surface);
2122 if (!shsurf->resource)
2124 if (shsurf->surface == shsurf->shell->grab_surface)
2127 handle_xdg_ping(shsurf, serial);
2131 handle_pointer_focus(struct wl_listener *listener, void *data)
2133 struct weston_pointer *pointer = data;
2134 struct weston_view *view = pointer->focus;
2135 struct weston_compositor *compositor;
2141 compositor = view->surface->compositor;
2142 serial = wl_display_next_serial(compositor->wl_display);
2143 ping_handler(view->surface, serial);
2147 shell_surface_lose_keyboard_focus(struct shell_surface *shsurf)
2149 if (--shsurf->focus_count == 0)
2150 shell_surface_state_changed(shsurf);
2154 shell_surface_gain_keyboard_focus(struct shell_surface *shsurf)
2156 if (shsurf->focus_count++ == 0)
2157 shell_surface_state_changed(shsurf);
2161 handle_keyboard_focus(struct wl_listener *listener, void *data)
2163 struct weston_keyboard *keyboard = data;
2164 struct shell_seat *seat = get_shell_seat(keyboard->seat);
2166 if (seat->focused_surface) {
2167 struct shell_surface *shsurf = get_shell_surface(seat->focused_surface);
2169 shell_surface_lose_keyboard_focus(shsurf);
2172 seat->focused_surface = keyboard->focus;
2174 if (seat->focused_surface) {
2175 struct shell_surface *shsurf = get_shell_surface(seat->focused_surface);
2177 shell_surface_gain_keyboard_focus(shsurf);
2182 shell_client_pong(struct shell_client *sc, uint32_t serial)
2184 if (sc->ping_serial != serial)
2187 sc->unresponsive = 0;
2188 end_busy_cursor(sc->shell->compositor, sc->client);
2190 if (sc->ping_timer) {
2191 wl_event_source_remove(sc->ping_timer);
2192 sc->ping_timer = NULL;
2198 shell_surface_pong(struct wl_client *client,
2199 struct wl_resource *resource, uint32_t serial)
2201 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2202 struct shell_client *sc = shsurf->owner;
2204 shell_client_pong(sc, serial);
2208 set_title(struct shell_surface *shsurf, const char *title)
2210 free(shsurf->title);
2211 shsurf->title = strdup(title);
2215 set_window_geometry(struct shell_surface *shsurf,
2216 int32_t x, int32_t y, int32_t width, int32_t height)
2218 shsurf->next_geometry.x = x;
2219 shsurf->next_geometry.y = y;
2220 shsurf->next_geometry.width = width;
2221 shsurf->next_geometry.height = height;
2222 shsurf->has_next_geometry = true;
2226 shell_surface_set_title(struct wl_client *client,
2227 struct wl_resource *resource, const char *title)
2229 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2231 set_title(shsurf, title);
2235 shell_surface_set_class(struct wl_client *client,
2236 struct wl_resource *resource, const char *class)
2238 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2240 free(shsurf->class);
2241 shsurf->class = strdup(class);
2245 restore_output_mode(struct weston_output *output)
2247 if (output->current_mode != output->original_mode ||
2248 (int32_t)output->current_scale != output->original_scale)
2249 weston_output_switch_mode(output,
2250 output->original_mode,
2251 output->original_scale,
2252 WESTON_MODE_SWITCH_RESTORE_NATIVE);
2256 restore_all_output_modes(struct weston_compositor *compositor)
2258 struct weston_output *output;
2260 wl_list_for_each(output, &compositor->output_list, link)
2261 restore_output_mode(output);
2264 /* The surface will be inserted into the list immediately after the link
2265 * returned by this function (i.e. will be stacked immediately above the
2266 * returned link). */
2267 static struct weston_layer_entry *
2268 shell_surface_calculate_layer_link (struct shell_surface *shsurf)
2270 struct workspace *ws;
2271 struct weston_view *parent;
2273 switch (shsurf->type) {
2274 case SHELL_SURFACE_XWAYLAND:
2275 return &shsurf->shell->fullscreen_layer.view_list;
2277 case SHELL_SURFACE_NONE:
2280 case SHELL_SURFACE_POPUP:
2281 case SHELL_SURFACE_TOPLEVEL:
2282 if (shsurf->state.fullscreen && !shsurf->state.lowered) {
2283 return &shsurf->shell->fullscreen_layer.view_list;
2284 } else if (shsurf->parent) {
2285 /* Move the surface to its parent layer so
2286 * that surfaces which are transient for
2287 * fullscreen surfaces don't get hidden by the
2288 * fullscreen surfaces. */
2290 /* TODO: Handle a parent with multiple views */
2291 parent = get_default_view(shsurf->parent);
2293 return container_of(parent->layer_link.link.prev,
2294 struct weston_layer_entry, link);
2297 /* Move the surface to a normal workspace layer so that surfaces
2298 * which were previously fullscreen or transient are no longer
2299 * rendered on top. */
2300 ws = get_current_workspace(shsurf->shell);
2301 return &ws->layer.view_list;
2304 assert(0 && "Unknown shell surface type");
2308 shell_surface_update_child_surface_layers (struct shell_surface *shsurf)
2310 struct shell_surface *child;
2311 struct weston_layer_entry *prev;
2313 /* Move the child layers to the same workspace as shsurf. They will be
2314 * stacked above shsurf. */
2315 wl_list_for_each_reverse(child, &shsurf->children_list, children_link) {
2316 if (shsurf->view->layer_link.link.prev != &child->view->layer_link.link) {
2317 weston_view_damage_below(child->view);
2318 weston_view_geometry_dirty(child->view);
2319 prev = container_of(shsurf->view->layer_link.link.prev,
2320 struct weston_layer_entry, link);
2321 weston_layer_entry_remove(&child->view->layer_link);
2322 weston_layer_entry_insert(prev,
2323 &child->view->layer_link);
2324 weston_view_geometry_dirty(child->view);
2325 weston_surface_damage(child->surface);
2327 /* Recurse. We don’t expect this to recurse very far (if
2328 * at all) because that would imply we have transient
2329 * (or popup) children of transient surfaces, which
2330 * would be unusual. */
2331 shell_surface_update_child_surface_layers(child);
2336 /* Update the surface’s layer. Mark both the old and new views as having dirty
2337 * geometry to ensure the changes are redrawn.
2339 * If any child surfaces exist and are mapped, ensure they’re in the same layer
2340 * as this surface. */
2342 shell_surface_update_layer(struct shell_surface *shsurf)
2344 struct weston_layer_entry *new_layer_link;
2346 new_layer_link = shell_surface_calculate_layer_link(shsurf);
2348 if (new_layer_link == NULL)
2350 if (new_layer_link == &shsurf->view->layer_link)
2353 weston_view_geometry_dirty(shsurf->view);
2354 weston_layer_entry_remove(&shsurf->view->layer_link);
2355 weston_layer_entry_insert(new_layer_link, &shsurf->view->layer_link);
2356 weston_view_geometry_dirty(shsurf->view);
2357 weston_surface_damage(shsurf->surface);
2359 shell_surface_update_child_surface_layers(shsurf);
2363 shell_surface_set_parent(struct shell_surface *shsurf,
2364 struct weston_surface *parent)
2366 shsurf->parent = parent;
2368 wl_list_remove(&shsurf->children_link);
2369 wl_list_init(&shsurf->children_link);
2371 /* Insert into the parent surface’s child list. */
2372 if (parent != NULL) {
2373 struct shell_surface *parent_shsurf = get_shell_surface(parent);
2374 if (parent_shsurf != NULL)
2375 wl_list_insert(&parent_shsurf->children_list,
2376 &shsurf->children_link);
2381 shell_surface_set_output(struct shell_surface *shsurf,
2382 struct weston_output *output)
2384 struct weston_surface *es = shsurf->surface;
2386 /* get the default output, if the client set it as NULL
2387 check whether the ouput is available */
2389 shsurf->output = output;
2390 else if (es->output)
2391 shsurf->output = es->output;
2393 shsurf->output = get_default_output(es->compositor);
2397 surface_clear_next_states(struct shell_surface *shsurf)
2399 shsurf->next_state.maximized = false;
2400 shsurf->next_state.fullscreen = false;
2402 if ((shsurf->next_state.maximized != shsurf->state.maximized) ||
2403 (shsurf->next_state.fullscreen != shsurf->state.fullscreen))
2404 shsurf->state_changed = true;
2408 set_toplevel(struct shell_surface *shsurf)
2410 shell_surface_set_parent(shsurf, NULL);
2411 surface_clear_next_states(shsurf);
2412 shsurf->type = SHELL_SURFACE_TOPLEVEL;
2414 /* The layer_link is updated in set_surface_type(),
2415 * called from configure. */
2419 shell_surface_set_toplevel(struct wl_client *client,
2420 struct wl_resource *resource)
2422 struct shell_surface *surface = wl_resource_get_user_data(resource);
2424 set_toplevel(surface);
2428 set_transient(struct shell_surface *shsurf,
2429 struct weston_surface *parent, int x, int y, uint32_t flags)
2431 assert(parent != NULL);
2433 shell_surface_set_parent(shsurf, parent);
2435 surface_clear_next_states(shsurf);
2437 shsurf->transient.x = x;
2438 shsurf->transient.y = y;
2439 shsurf->transient.flags = flags;
2441 shsurf->next_state.relative = true;
2442 shsurf->state_changed = true;
2443 shsurf->type = SHELL_SURFACE_TOPLEVEL;
2445 /* The layer_link is updated in set_surface_type(),
2446 * called from configure. */
2450 shell_surface_set_transient(struct wl_client *client,
2451 struct wl_resource *resource,
2452 struct wl_resource *parent_resource,
2453 int x, int y, uint32_t flags)
2455 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2456 struct weston_surface *parent =
2457 wl_resource_get_user_data(parent_resource);
2459 set_transient(shsurf, parent, x, y, flags);
2463 set_fullscreen(struct shell_surface *shsurf,
2466 struct weston_output *output)
2468 shell_surface_set_output(shsurf, output);
2469 shsurf->type = SHELL_SURFACE_TOPLEVEL;
2471 shsurf->fullscreen_output = shsurf->output;
2472 shsurf->fullscreen.type = method;
2473 shsurf->fullscreen.framerate = framerate;
2475 send_configure_for_surface(shsurf);
2479 weston_view_set_initial_position(struct weston_view *view,
2480 struct desktop_shell *shell);
2483 unset_fullscreen(struct shell_surface *shsurf)
2485 /* Unset the fullscreen output, driver configuration and transforms. */
2486 if (shsurf->fullscreen.type == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER &&
2487 shell_surface_is_top_fullscreen(shsurf)) {
2488 restore_output_mode(shsurf->fullscreen_output);
2491 shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
2492 shsurf->fullscreen.framerate = 0;
2494 wl_list_remove(&shsurf->fullscreen.transform.link);
2495 wl_list_init(&shsurf->fullscreen.transform.link);
2497 if (shsurf->fullscreen.black_view)
2498 weston_surface_destroy(shsurf->fullscreen.black_view->surface);
2499 shsurf->fullscreen.black_view = NULL;
2501 if (shsurf->saved_position_valid)
2502 weston_view_set_position(shsurf->view,
2503 shsurf->saved_x, shsurf->saved_y);
2505 weston_view_set_initial_position(shsurf->view, shsurf->shell);
2507 if (shsurf->saved_rotation_valid) {
2508 wl_list_insert(&shsurf->view->geometry.transformation_list,
2509 &shsurf->rotation.transform.link);
2510 shsurf->saved_rotation_valid = false;
2513 /* Layer is updated in set_surface_type(). */
2517 shell_surface_set_fullscreen(struct wl_client *client,
2518 struct wl_resource *resource,
2521 struct wl_resource *output_resource)
2523 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2524 struct weston_output *output;
2526 if (output_resource)
2527 output = wl_resource_get_user_data(output_resource);
2531 shell_surface_set_parent(shsurf, NULL);
2533 surface_clear_next_states(shsurf);
2534 shsurf->next_state.fullscreen = true;
2535 shsurf->state_changed = true;
2536 set_fullscreen(shsurf, method, framerate, output);
2540 set_popup(struct shell_surface *shsurf,
2541 struct weston_surface *parent,
2542 struct weston_seat *seat,
2547 assert(parent != NULL);
2549 shsurf->popup.shseat = get_shell_seat(seat);
2550 shsurf->popup.serial = serial;
2551 shsurf->popup.x = x;
2552 shsurf->popup.y = y;
2554 shsurf->type = SHELL_SURFACE_POPUP;
2558 shell_surface_set_popup(struct wl_client *client,
2559 struct wl_resource *resource,
2560 struct wl_resource *seat_resource,
2562 struct wl_resource *parent_resource,
2563 int32_t x, int32_t y, uint32_t flags)
2565 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2566 struct weston_surface *parent =
2567 wl_resource_get_user_data(parent_resource);
2569 shell_surface_set_parent(shsurf, parent);
2571 surface_clear_next_states(shsurf);
2574 wl_resource_get_user_data(seat_resource),
2579 unset_maximized(struct shell_surface *shsurf)
2581 /* undo all maximized things here */
2582 shsurf->output = get_default_output(shsurf->surface->compositor);
2584 if (shsurf->saved_position_valid)
2585 weston_view_set_position(shsurf->view,
2586 shsurf->saved_x, shsurf->saved_y);
2588 weston_view_set_initial_position(shsurf->view, shsurf->shell);
2590 if (shsurf->saved_rotation_valid) {
2591 wl_list_insert(&shsurf->view->geometry.transformation_list,
2592 &shsurf->rotation.transform.link);
2593 shsurf->saved_rotation_valid = false;
2596 /* Layer is updated in set_surface_type(). */
2600 set_minimized(struct weston_surface *surface, uint32_t is_true)
2602 struct shell_surface *shsurf;
2603 struct workspace *current_ws;
2604 struct weston_seat *seat;
2605 struct weston_surface *focus;
2606 struct weston_view *view;
2608 view = get_default_view(surface);
2612 assert(weston_surface_get_main_surface(view->surface) == view->surface);
2614 shsurf = get_shell_surface(surface);
2615 current_ws = get_current_workspace(shsurf->shell);
2617 weston_layer_entry_remove(&view->layer_link);
2618 /* hide or show, depending on the state */
2620 weston_layer_entry_insert(&shsurf->shell->minimized_layer.view_list, &view->layer_link);
2622 drop_focus_state(shsurf->shell, current_ws, view->surface);
2623 wl_list_for_each(seat, &shsurf->shell->compositor->seat_list, link) {
2624 if (!seat->keyboard)
2626 focus = weston_surface_get_main_surface(seat->keyboard->focus);
2627 if (focus == view->surface)
2628 weston_keyboard_set_focus(seat->keyboard, NULL);
2632 weston_layer_entry_insert(¤t_ws->layer.view_list, &view->layer_link);
2634 wl_list_for_each(seat, &shsurf->shell->compositor->seat_list, link) {
2635 if (!seat->keyboard)
2637 activate(shsurf->shell, view->surface, seat, true);
2641 shell_surface_update_child_surface_layers(shsurf);
2643 weston_view_damage_below(view);
2647 shell_surface_set_maximized(struct wl_client *client,
2648 struct wl_resource *resource,
2649 struct wl_resource *output_resource)
2651 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
2652 struct weston_output *output;
2654 surface_clear_next_states(shsurf);
2655 shsurf->next_state.maximized = true;
2656 shsurf->state_changed = true;
2658 shsurf->type = SHELL_SURFACE_TOPLEVEL;
2659 shell_surface_set_parent(shsurf, NULL);
2661 if (output_resource)
2662 output = wl_resource_get_user_data(output_resource);
2666 shell_surface_set_output(shsurf, output);
2668 send_configure_for_surface(shsurf);
2671 /* This is only ever called from set_surface_type(), so there’s no need to
2672 * update layer_links here, since they’ll be updated when we return. */
2674 reset_surface_type(struct shell_surface *surface)
2676 if (surface->state.fullscreen)
2677 unset_fullscreen(surface);
2678 if (surface->state.maximized)
2679 unset_maximized(surface);
2685 set_full_output(struct shell_surface *shsurf)
2687 shsurf->saved_x = shsurf->view->geometry.x;
2688 shsurf->saved_y = shsurf->view->geometry.y;
2689 shsurf->saved_width = shsurf->surface->width;
2690 shsurf->saved_height = shsurf->surface->height;
2691 shsurf->saved_size_valid = true;
2692 shsurf->saved_position_valid = true;
2694 if (!wl_list_empty(&shsurf->rotation.transform.link)) {
2695 wl_list_remove(&shsurf->rotation.transform.link);
2696 wl_list_init(&shsurf->rotation.transform.link);
2697 weston_view_geometry_dirty(shsurf->view);
2698 shsurf->saved_rotation_valid = true;
2703 set_surface_type(struct shell_surface *shsurf)
2705 struct weston_surface *pes = shsurf->parent;
2706 struct weston_view *pev = get_default_view(pes);
2708 reset_surface_type(shsurf);
2710 shsurf->state = shsurf->next_state;
2711 shsurf->state_changed = false;
2713 switch (shsurf->type) {
2714 case SHELL_SURFACE_TOPLEVEL:
2715 if (shsurf->state.maximized || shsurf->state.fullscreen) {
2716 set_full_output(shsurf);
2717 } else if (shsurf->state.relative && pev) {
2718 weston_view_set_position(shsurf->view,
2719 pev->geometry.x + shsurf->transient.x,
2720 pev->geometry.y + shsurf->transient.y);
2724 case SHELL_SURFACE_XWAYLAND:
2725 weston_view_set_position(shsurf->view, shsurf->transient.x,
2726 shsurf->transient.y);
2729 case SHELL_SURFACE_POPUP:
2730 case SHELL_SURFACE_NONE:
2735 /* Update the surface’s layer. */
2736 shell_surface_update_layer(shsurf);
2739 static struct desktop_shell *
2740 shell_surface_get_shell(struct shell_surface *shsurf)
2742 return shsurf->shell;
2746 black_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy);
2748 static struct weston_view *
2749 create_black_surface(struct weston_compositor *ec,
2750 struct weston_surface *fs_surface,
2751 float x, float y, int w, int h)
2753 struct weston_surface *surface = NULL;
2754 struct weston_view *view;
2756 surface = weston_surface_create(ec);
2757 if (surface == NULL) {
2758 weston_log("no memory\n");
2761 view = weston_view_create(surface);
2762 if (surface == NULL) {
2763 weston_log("no memory\n");
2764 weston_surface_destroy(surface);
2768 surface->configure = black_surface_configure;
2769 surface->configure_private = fs_surface;
2770 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1);
2771 pixman_region32_fini(&surface->opaque);
2772 pixman_region32_init_rect(&surface->opaque, 0, 0, w, h);
2773 pixman_region32_fini(&surface->input);
2774 pixman_region32_init_rect(&surface->input, 0, 0, w, h);
2776 weston_surface_set_size(surface, w, h);
2777 weston_view_set_position(view, x, y);
2783 shell_ensure_fullscreen_black_view(struct shell_surface *shsurf)
2785 struct weston_output *output = shsurf->fullscreen_output;
2787 assert(shsurf->state.fullscreen);
2789 if (!shsurf->fullscreen.black_view)
2790 shsurf->fullscreen.black_view =
2791 create_black_surface(shsurf->surface->compositor,
2793 output->x, output->y,
2797 weston_view_geometry_dirty(shsurf->fullscreen.black_view);
2798 weston_layer_entry_remove(&shsurf->fullscreen.black_view->layer_link);
2799 weston_layer_entry_insert(&shsurf->view->layer_link,
2800 &shsurf->fullscreen.black_view->layer_link);
2801 weston_view_geometry_dirty(shsurf->fullscreen.black_view);
2802 weston_surface_damage(shsurf->surface);
2804 shsurf->state.lowered = false;
2807 /* Create black surface and append it to the associated fullscreen surface.
2808 * Handle size dismatch and positioning according to the method. */
2810 shell_configure_fullscreen(struct shell_surface *shsurf)
2812 struct weston_output *output = shsurf->fullscreen_output;
2813 struct weston_surface *surface = shsurf->surface;
2814 struct weston_matrix *matrix;
2815 float scale, output_aspect, surface_aspect, x, y;
2816 int32_t surf_x, surf_y, surf_width, surf_height;
2818 if (shsurf->fullscreen.type != WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER)
2819 restore_output_mode(output);
2821 /* Reverse the effect of lower_fullscreen_layer() */
2822 weston_layer_entry_remove(&shsurf->view->layer_link);
2823 weston_layer_entry_insert(&shsurf->shell->fullscreen_layer.view_list, &shsurf->view->layer_link);
2825 shell_ensure_fullscreen_black_view(shsurf);
2827 surface_subsurfaces_boundingbox(shsurf->surface, &surf_x, &surf_y,
2828 &surf_width, &surf_height);
2830 switch (shsurf->fullscreen.type) {
2831 case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT:
2832 if (surface->buffer_ref.buffer)
2833 center_on_output(shsurf->view, shsurf->fullscreen_output);
2835 case WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE:
2836 /* 1:1 mapping between surface and output dimensions */
2837 if (output->width == surf_width &&
2838 output->height == surf_height) {
2839 weston_view_set_position(shsurf->view,
2841 output->y - surf_y);
2845 matrix = &shsurf->fullscreen.transform.matrix;
2846 weston_matrix_init(matrix);
2848 output_aspect = (float) output->width /
2849 (float) output->height;
2850 /* XXX: Use surf_width and surf_height here? */
2851 surface_aspect = (float) surface->width /
2852 (float) surface->height;
2853 if (output_aspect < surface_aspect)
2854 scale = (float) output->width /
2857 scale = (float) output->height /
2858 (float) surf_height;
2860 weston_matrix_scale(matrix, scale, scale, 1);
2861 wl_list_remove(&shsurf->fullscreen.transform.link);
2862 wl_list_insert(&shsurf->view->geometry.transformation_list,
2863 &shsurf->fullscreen.transform.link);
2864 x = output->x + (output->width - surf_width * scale) / 2 - surf_x;
2865 y = output->y + (output->height - surf_height * scale) / 2 - surf_y;
2866 weston_view_set_position(shsurf->view, x, y);
2869 case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER:
2870 if (shell_surface_is_top_fullscreen(shsurf)) {
2871 struct weston_mode mode = {0,
2872 surf_width * surface->buffer_viewport.buffer.scale,
2873 surf_height * surface->buffer_viewport.buffer.scale,
2874 shsurf->fullscreen.framerate};
2876 if (weston_output_switch_mode(output, &mode, surface->buffer_viewport.buffer.scale,
2877 WESTON_MODE_SWITCH_SET_TEMPORARY) == 0) {
2878 weston_view_set_position(shsurf->view,
2880 output->y - surf_y);
2881 shsurf->fullscreen.black_view->surface->width = output->width;
2882 shsurf->fullscreen.black_view->surface->height = output->height;
2883 weston_view_set_position(shsurf->fullscreen.black_view,
2885 output->y - surf_y);
2888 restore_output_mode(output);
2889 center_on_output(shsurf->view, output);
2893 case WL_SHELL_SURFACE_FULLSCREEN_METHOD_FILL:
2894 center_on_output(shsurf->view, output);
2902 shell_map_fullscreen(struct shell_surface *shsurf)
2904 shell_configure_fullscreen(shsurf);
2908 set_xwayland(struct shell_surface *shsurf, int x, int y, uint32_t flags)
2910 /* XXX: using the same fields for transient type */
2911 surface_clear_next_states(shsurf);
2912 shsurf->transient.x = x;
2913 shsurf->transient.y = y;
2914 shsurf->transient.flags = flags;
2916 shell_surface_set_parent(shsurf, NULL);
2918 shsurf->type = SHELL_SURFACE_XWAYLAND;
2919 shsurf->state_changed = true;
2923 shell_interface_set_fullscreen(struct shell_surface *shsurf,
2926 struct weston_output *output)
2928 surface_clear_next_states(shsurf);
2929 set_fullscreen(shsurf, method, framerate, output);
2931 shsurf->next_state.fullscreen = true;
2932 shsurf->state_changed = true;
2936 shell_interface_move(struct shell_surface *shsurf, struct weston_seat *ws)
2938 return surface_move(shsurf, ws, 1);
2941 static const struct weston_pointer_grab_interface popup_grab_interface;
2944 destroy_shell_seat(struct wl_listener *listener, void *data)
2946 struct shell_seat *shseat =
2947 container_of(listener,
2948 struct shell_seat, seat_destroy_listener);
2949 struct shell_surface *shsurf, *prev = NULL;
2951 if (shseat->popup_grab.grab.interface == &popup_grab_interface) {
2952 weston_pointer_end_grab(shseat->popup_grab.grab.pointer);
2953 shseat->popup_grab.client = NULL;
2955 wl_list_for_each(shsurf, &shseat->popup_grab.surfaces_list, popup.grab_link) {
2956 shsurf->popup.shseat = NULL;
2958 wl_list_init(&prev->popup.grab_link);
2962 wl_list_init(&prev->popup.grab_link);
2965 wl_list_remove(&shseat->seat_destroy_listener.link);
2970 shell_seat_caps_changed(struct wl_listener *listener, void *data)
2972 struct shell_seat *seat;
2974 seat = container_of(listener, struct shell_seat, caps_changed_listener);
2976 if (seat->seat->keyboard &&
2977 wl_list_empty(&seat->keyboard_focus_listener.link)) {
2978 wl_signal_add(&seat->seat->keyboard->focus_signal,
2979 &seat->keyboard_focus_listener);
2980 } else if (!seat->seat->keyboard) {
2981 wl_list_init(&seat->keyboard_focus_listener.link);
2984 if (seat->seat->pointer &&
2985 wl_list_empty(&seat->pointer_focus_listener.link)) {
2986 wl_signal_add(&seat->seat->pointer->focus_signal,
2987 &seat->pointer_focus_listener);
2988 } else if (!seat->seat->pointer) {
2989 wl_list_init(&seat->pointer_focus_listener.link);
2993 static struct shell_seat *
2994 create_shell_seat(struct weston_seat *seat)
2996 struct shell_seat *shseat;
2998 shseat = calloc(1, sizeof *shseat);
3000 weston_log("no memory to allocate shell seat\n");
3004 shseat->seat = seat;
3005 wl_list_init(&shseat->popup_grab.surfaces_list);
3007 shseat->seat_destroy_listener.notify = destroy_shell_seat;
3008 wl_signal_add(&seat->destroy_signal,
3009 &shseat->seat_destroy_listener);
3011 shseat->keyboard_focus_listener.notify = handle_keyboard_focus;
3012 wl_list_init(&shseat->keyboard_focus_listener.link);
3014 shseat->pointer_focus_listener.notify = handle_pointer_focus;
3015 wl_list_init(&shseat->pointer_focus_listener.link);
3017 shseat->caps_changed_listener.notify = shell_seat_caps_changed;
3018 wl_signal_add(&seat->updated_caps_signal,
3019 &shseat->caps_changed_listener);
3020 shell_seat_caps_changed(&shseat->caps_changed_listener, NULL);
3025 static struct shell_seat *
3026 get_shell_seat(struct weston_seat *seat)
3028 struct wl_listener *listener;
3030 listener = wl_signal_get(&seat->destroy_signal, destroy_shell_seat);
3031 assert(listener != NULL);
3033 return container_of(listener,
3034 struct shell_seat, seat_destroy_listener);
3038 popup_grab_focus(struct weston_pointer_grab *grab)
3040 struct weston_pointer *pointer = grab->pointer;
3041 struct weston_view *view;
3042 struct shell_seat *shseat =
3043 container_of(grab, struct shell_seat, popup_grab.grab);
3044 struct wl_client *client = shseat->popup_grab.client;
3047 view = weston_compositor_pick_view(pointer->seat->compositor,
3048 pointer->x, pointer->y,
3051 if (view && view->surface->resource &&
3052 wl_resource_get_client(view->surface->resource) == client) {
3053 weston_pointer_set_focus(pointer, view, sx, sy);
3055 weston_pointer_set_focus(pointer, NULL,
3056 wl_fixed_from_int(0),
3057 wl_fixed_from_int(0));
3062 popup_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
3063 wl_fixed_t x, wl_fixed_t y)
3065 struct weston_pointer *pointer = grab->pointer;
3066 struct wl_resource *resource;
3069 if (pointer->focus) {
3070 weston_view_from_global_fixed(pointer->focus, x, y,
3071 &pointer->sx, &pointer->sy);
3074 weston_pointer_move(pointer, x, y);
3076 wl_resource_for_each(resource, &pointer->focus_resource_list) {
3077 weston_view_from_global_fixed(pointer->focus,
3078 pointer->x, pointer->y,
3080 wl_pointer_send_motion(resource, time, sx, sy);
3085 popup_grab_button(struct weston_pointer_grab *grab,
3086 uint32_t time, uint32_t button, uint32_t state_w)
3088 struct wl_resource *resource;
3089 struct shell_seat *shseat =
3090 container_of(grab, struct shell_seat, popup_grab.grab);
3091 struct wl_display *display = shseat->seat->compositor->wl_display;
3092 enum wl_pointer_button_state state = state_w;
3094 struct wl_list *resource_list;
3096 resource_list = &grab->pointer->focus_resource_list;
3097 if (!wl_list_empty(resource_list)) {
3098 serial = wl_display_get_serial(display);
3099 wl_resource_for_each(resource, resource_list) {
3100 wl_pointer_send_button(resource, serial,
3101 time, button, state);
3103 } else if (state == WL_POINTER_BUTTON_STATE_RELEASED &&
3104 (shseat->popup_grab.initial_up ||
3105 time - shseat->seat->pointer->grab_time > 500)) {
3106 popup_grab_end(grab->pointer);
3109 if (state == WL_POINTER_BUTTON_STATE_RELEASED)
3110 shseat->popup_grab.initial_up = 1;
3114 popup_grab_cancel(struct weston_pointer_grab *grab)
3116 popup_grab_end(grab->pointer);
3119 static const struct weston_pointer_grab_interface popup_grab_interface = {
3127 touch_popup_grab_down(struct weston_touch_grab *grab, uint32_t time,
3128 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
3130 struct wl_resource *resource;
3131 struct shell_seat *shseat =
3132 container_of(grab, struct shell_seat, popup_grab.touch_grab);
3133 struct wl_display *display = shseat->seat->compositor->wl_display;
3135 struct wl_list *resource_list;
3137 resource_list = &grab->touch->focus_resource_list;
3138 if (!wl_list_empty(resource_list)) {
3139 serial = wl_display_get_serial(display);
3140 wl_resource_for_each(resource, resource_list) {
3141 wl_touch_send_down(resource, serial, time,
3142 grab->touch->focus->surface->resource,
3149 touch_popup_grab_up(struct weston_touch_grab *grab, uint32_t time, int touch_id)
3151 struct wl_resource *resource;
3152 struct shell_seat *shseat =
3153 container_of(grab, struct shell_seat, popup_grab.touch_grab);
3154 struct wl_display *display = shseat->seat->compositor->wl_display;
3156 struct wl_list *resource_list;
3158 resource_list = &grab->touch->focus_resource_list;
3159 if (!wl_list_empty(resource_list)) {
3160 serial = wl_display_get_serial(display);
3161 wl_resource_for_each(resource, resource_list) {
3162 wl_touch_send_up(resource, serial, time, touch_id);
3168 touch_popup_grab_motion(struct weston_touch_grab *grab, uint32_t time,
3169 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
3171 struct wl_resource *resource;
3172 struct wl_list *resource_list;
3174 resource_list = &grab->touch->focus_resource_list;
3175 if (!wl_list_empty(resource_list)) {
3176 wl_resource_for_each(resource, resource_list) {
3177 wl_touch_send_motion(resource, time, touch_id, sx, sy);
3183 touch_popup_grab_frame(struct weston_touch_grab *grab)
3188 touch_popup_grab_cancel(struct weston_touch_grab *grab)
3190 touch_popup_grab_end(grab->touch);
3193 static const struct weston_touch_grab_interface touch_popup_grab_interface = {
3194 touch_popup_grab_down,
3195 touch_popup_grab_up,
3196 touch_popup_grab_motion,
3197 touch_popup_grab_frame,
3198 touch_popup_grab_cancel,
3202 shell_surface_send_popup_done(struct shell_surface *shsurf)
3204 if (shell_surface_is_wl_shell_surface(shsurf))
3205 wl_shell_surface_send_popup_done(shsurf->resource);
3206 else if (shell_surface_is_xdg_popup(shsurf))
3207 xdg_popup_send_popup_done(shsurf->resource,
3208 shsurf->popup.serial);
3212 popup_grab_end(struct weston_pointer *pointer)
3214 struct weston_pointer_grab *grab = pointer->grab;
3215 struct shell_seat *shseat =
3216 container_of(grab, struct shell_seat, popup_grab.grab);
3217 struct shell_surface *shsurf;
3218 struct shell_surface *prev = NULL;
3220 if (pointer->grab->interface == &popup_grab_interface) {
3221 weston_pointer_end_grab(grab->pointer);
3222 shseat->popup_grab.client = NULL;
3223 shseat->popup_grab.grab.interface = NULL;
3224 assert(!wl_list_empty(&shseat->popup_grab.surfaces_list));
3225 /* Send the popup_done event to all the popups open */
3226 wl_list_for_each(shsurf, &shseat->popup_grab.surfaces_list, popup.grab_link) {
3227 shell_surface_send_popup_done(shsurf);
3228 shsurf->popup.shseat = NULL;
3230 wl_list_init(&prev->popup.grab_link);
3234 wl_list_init(&prev->popup.grab_link);
3235 wl_list_init(&shseat->popup_grab.surfaces_list);
3240 touch_popup_grab_end(struct weston_touch *touch)
3242 struct weston_touch_grab *grab = touch->grab;
3243 struct shell_seat *shseat =
3244 container_of(grab, struct shell_seat, popup_grab.touch_grab);
3245 struct shell_surface *shsurf;
3246 struct shell_surface *prev = NULL;
3248 if (touch->grab->interface == &touch_popup_grab_interface) {
3249 weston_touch_end_grab(grab->touch);
3250 shseat->popup_grab.client = NULL;
3251 shseat->popup_grab.touch_grab.interface = NULL;
3252 assert(!wl_list_empty(&shseat->popup_grab.surfaces_list));
3253 /* Send the popup_done event to all the popups open */
3254 wl_list_for_each(shsurf, &shseat->popup_grab.surfaces_list, popup.grab_link) {
3255 shell_surface_send_popup_done(shsurf);
3256 shsurf->popup.shseat = NULL;
3258 wl_list_init(&prev->popup.grab_link);
3262 wl_list_init(&prev->popup.grab_link);
3263 wl_list_init(&shseat->popup_grab.surfaces_list);
3268 add_popup_grab(struct shell_surface *shsurf, struct shell_seat *shseat, int32_t type)
3270 struct weston_seat *seat = shseat->seat;
3272 if (wl_list_empty(&shseat->popup_grab.surfaces_list)) {
3273 shseat->popup_grab.type = type;
3274 shseat->popup_grab.client = wl_resource_get_client(shsurf->resource);
3276 if (type == POINTER) {
3277 shseat->popup_grab.grab.interface = &popup_grab_interface;
3278 /* We must make sure here that this popup was opened after
3279 * a mouse press, and not just by moving around with other
3280 * popups already open. */
3281 if (shseat->seat->pointer->button_count > 0)
3282 shseat->popup_grab.initial_up = 0;
3283 } else if (type == TOUCH) {
3284 shseat->popup_grab.touch_grab.interface = &touch_popup_grab_interface;
3287 wl_list_insert(&shseat->popup_grab.surfaces_list, &shsurf->popup.grab_link);
3289 if (type == POINTER)
3290 weston_pointer_start_grab(seat->pointer, &shseat->popup_grab.grab);
3291 else if (type == TOUCH)
3292 weston_touch_start_grab(seat->touch, &shseat->popup_grab.touch_grab);
3294 wl_list_insert(&shseat->popup_grab.surfaces_list, &shsurf->popup.grab_link);
3299 remove_popup_grab(struct shell_surface *shsurf)
3301 struct shell_seat *shseat = shsurf->popup.shseat;
3303 wl_list_remove(&shsurf->popup.grab_link);
3304 wl_list_init(&shsurf->popup.grab_link);
3305 if (wl_list_empty(&shseat->popup_grab.surfaces_list)) {
3306 if (shseat->popup_grab.type == POINTER) {
3307 weston_pointer_end_grab(shseat->popup_grab.grab.pointer);
3308 shseat->popup_grab.grab.interface = NULL;
3309 } else if (shseat->popup_grab.type == TOUCH) {
3310 weston_touch_end_grab(shseat->popup_grab.touch_grab.touch);
3311 shseat->popup_grab.touch_grab.interface = NULL;
3317 shell_map_popup(struct shell_surface *shsurf)
3319 struct shell_seat *shseat = shsurf->popup.shseat;
3320 struct weston_view *parent_view = get_default_view(shsurf->parent);
3322 shsurf->surface->output = parent_view->output;
3323 shsurf->view->output = parent_view->output;
3325 weston_view_set_transform_parent(shsurf->view, parent_view);
3326 weston_view_set_position(shsurf->view, shsurf->popup.x, shsurf->popup.y);
3327 weston_view_update_transform(shsurf->view);
3329 if (shseat->seat->pointer &&
3330 shseat->seat->pointer->grab_serial == shsurf->popup.serial) {
3331 add_popup_grab(shsurf, shseat, POINTER);
3332 } else if (shseat->seat->touch &&
3333 shseat->seat->touch->grab_serial == shsurf->popup.serial) {
3334 add_popup_grab(shsurf, shseat, TOUCH);
3336 shell_surface_send_popup_done(shsurf);
3337 shseat->popup_grab.client = NULL;
3341 static const struct wl_shell_surface_interface shell_surface_implementation = {
3344 shell_surface_resize,
3345 shell_surface_set_toplevel,
3346 shell_surface_set_transient,
3347 shell_surface_set_fullscreen,
3348 shell_surface_set_popup,
3349 shell_surface_set_maximized,
3350 shell_surface_set_title,
3351 shell_surface_set_class
3355 destroy_shell_surface(struct shell_surface *shsurf)
3357 struct shell_surface *child, *next;
3359 wl_signal_emit(&shsurf->destroy_signal, shsurf);
3361 if (!wl_list_empty(&shsurf->popup.grab_link)) {
3362 remove_popup_grab(shsurf);
3365 if (shsurf->fullscreen.type == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER &&
3366 shell_surface_is_top_fullscreen(shsurf))
3367 restore_output_mode (shsurf->fullscreen_output);
3369 if (shsurf->fullscreen.black_view)
3370 weston_surface_destroy(shsurf->fullscreen.black_view->surface);
3372 /* As destroy_resource() use wl_list_for_each_safe(),
3373 * we can always remove the listener.
3375 wl_list_remove(&shsurf->surface_destroy_listener.link);
3376 shsurf->surface->configure = NULL;
3377 free(shsurf->title);
3379 weston_view_destroy(shsurf->view);
3381 wl_list_remove(&shsurf->children_link);
3382 wl_list_for_each_safe(child, next, &shsurf->children_list, children_link)
3383 shell_surface_set_parent(child, NULL);
3385 wl_list_remove(&shsurf->link);
3390 shell_destroy_shell_surface(struct wl_resource *resource)
3392 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3394 if (!wl_list_empty(&shsurf->popup.grab_link))
3395 remove_popup_grab(shsurf);
3396 shsurf->resource = NULL;
3400 shell_handle_surface_destroy(struct wl_listener *listener, void *data)
3402 struct shell_surface *shsurf = container_of(listener,
3403 struct shell_surface,
3404 surface_destroy_listener);
3406 if (shsurf->resource)
3407 wl_resource_destroy(shsurf->resource);
3409 destroy_shell_surface(shsurf);
3413 fade_out_done(struct weston_view_animation *animation, void *data)
3415 struct shell_surface *shsurf = data;
3417 weston_surface_destroy(shsurf->surface);
3421 handle_resource_destroy(struct wl_listener *listener, void *data)
3423 struct shell_surface *shsurf =
3424 container_of(listener, struct shell_surface,
3425 resource_destroy_listener);
3427 if (!weston_surface_is_mapped(shsurf->surface))
3430 shsurf->surface->ref_count++;
3432 pixman_region32_fini(&shsurf->surface->pending.input);
3433 pixman_region32_init(&shsurf->surface->pending.input);
3434 pixman_region32_fini(&shsurf->surface->input);
3435 pixman_region32_init(&shsurf->surface->input);
3436 if (shsurf->shell->win_close_animation_type == ANIMATION_FADE) {
3437 weston_fade_run(shsurf->view, 1.0, 0.0, 300.0,
3438 fade_out_done, shsurf);
3440 weston_surface_destroy(shsurf->surface);
3445 shell_surface_configure(struct weston_surface *, int32_t, int32_t);
3447 struct shell_surface *
3448 get_shell_surface(struct weston_surface *surface)
3450 if (surface->configure == shell_surface_configure)
3451 return surface->configure_private;
3456 static struct shell_surface *
3457 create_common_surface(struct shell_client *owner, void *shell,
3458 struct weston_surface *surface,
3459 const struct weston_shell_client *client)
3461 struct shell_surface *shsurf;
3463 if (surface->configure) {
3464 weston_log("surface->configure already set\n");
3468 shsurf = calloc(1, sizeof *shsurf);
3470 weston_log("no memory to allocate shell surface\n");
3474 shsurf->view = weston_view_create(surface);
3475 if (!shsurf->view) {
3476 weston_log("no memory to allocate shell surface\n");
3481 surface->configure = shell_surface_configure;
3482 surface->configure_private = shsurf;
3484 shsurf->resource_destroy_listener.notify = handle_resource_destroy;
3485 wl_resource_add_destroy_listener(surface->resource,
3486 &shsurf->resource_destroy_listener);
3487 shsurf->owner = owner;
3489 shsurf->shell = (struct desktop_shell *) shell;
3490 shsurf->unresponsive = 0;
3491 shsurf->saved_position_valid = false;
3492 shsurf->saved_size_valid = false;
3493 shsurf->saved_rotation_valid = false;
3494 shsurf->surface = surface;
3495 shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
3496 shsurf->fullscreen.framerate = 0;
3497 shsurf->fullscreen.black_view = NULL;
3498 wl_list_init(&shsurf->fullscreen.transform.link);
3500 shsurf->output = get_default_output(shsurf->shell->compositor);
3502 wl_signal_init(&shsurf->destroy_signal);
3503 shsurf->surface_destroy_listener.notify = shell_handle_surface_destroy;
3504 wl_signal_add(&surface->destroy_signal,
3505 &shsurf->surface_destroy_listener);
3507 /* init link so its safe to always remove it in destroy_shell_surface */
3508 wl_list_init(&shsurf->link);
3509 wl_list_init(&shsurf->popup.grab_link);
3511 /* empty when not in use */
3512 wl_list_init(&shsurf->rotation.transform.link);
3513 weston_matrix_init(&shsurf->rotation.rotation);
3515 wl_list_init(&shsurf->workspace_transform.link);
3517 wl_list_init(&shsurf->children_link);
3518 wl_list_init(&shsurf->children_list);
3519 shsurf->parent = NULL;
3521 shsurf->type = SHELL_SURFACE_NONE;
3523 shsurf->client = client;
3528 static struct shell_surface *
3529 create_shell_surface(void *shell, struct weston_surface *surface,
3530 const struct weston_shell_client *client)
3532 return create_common_surface(NULL, shell, surface, client);
3535 static struct weston_view *
3536 get_primary_view(void *shell, struct shell_surface *shsurf)
3538 return shsurf->view;
3542 shell_get_shell_surface(struct wl_client *client,
3543 struct wl_resource *resource,
3545 struct wl_resource *surface_resource)
3547 struct weston_surface *surface =
3548 wl_resource_get_user_data(surface_resource);
3549 struct shell_client *sc = wl_resource_get_user_data(resource);
3550 struct desktop_shell *shell = sc->shell;
3551 struct shell_surface *shsurf;
3553 if (get_shell_surface(surface)) {
3554 wl_resource_post_error(surface_resource,
3555 WL_DISPLAY_ERROR_INVALID_OBJECT,
3556 "desktop_shell::get_shell_surface already requested");
3560 shsurf = create_common_surface(sc, shell, surface, &shell_client);
3562 wl_resource_post_error(surface_resource,
3563 WL_DISPLAY_ERROR_INVALID_OBJECT,
3564 "surface->configure already set");
3569 wl_resource_create(client,
3570 &wl_shell_surface_interface, 1, id);
3571 wl_resource_set_implementation(shsurf->resource,
3572 &shell_surface_implementation,
3573 shsurf, shell_destroy_shell_surface);
3577 shell_surface_is_wl_shell_surface(struct shell_surface *shsurf)
3579 /* A shell surface without a resource is created from xwayland
3580 * and is considered a wl_shell surface for now. */
3582 return shsurf->resource == NULL ||
3583 wl_resource_instance_of(shsurf->resource,
3584 &wl_shell_surface_interface,
3585 &shell_surface_implementation);
3588 static const struct wl_shell_interface shell_implementation = {
3589 shell_get_shell_surface
3592 /****************************
3593 * xdg-shell implementation */
3596 xdg_surface_destroy(struct wl_client *client,
3597 struct wl_resource *resource)
3599 wl_resource_destroy(resource);
3603 xdg_surface_set_parent(struct wl_client *client,
3604 struct wl_resource *resource,
3605 struct wl_resource *parent_resource)
3607 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3608 struct weston_surface *parent;
3610 if (parent_resource)
3611 parent = wl_resource_get_user_data(parent_resource);
3615 shell_surface_set_parent(shsurf, parent);
3619 xdg_surface_set_app_id(struct wl_client *client,
3620 struct wl_resource *resource,
3623 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3625 free(shsurf->class);
3626 shsurf->class = strdup(app_id);
3630 xdg_surface_show_window_menu(struct wl_client *client,
3631 struct wl_resource *surface_resource,
3632 struct wl_resource *seat_resource,
3641 xdg_surface_set_title(struct wl_client *client,
3642 struct wl_resource *resource, const char *title)
3644 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3646 set_title(shsurf, title);
3650 xdg_surface_move(struct wl_client *client, struct wl_resource *resource,
3651 struct wl_resource *seat_resource, uint32_t serial)
3653 common_surface_move(resource, seat_resource, serial);
3657 xdg_surface_resize(struct wl_client *client, struct wl_resource *resource,
3658 struct wl_resource *seat_resource, uint32_t serial,
3661 common_surface_resize(resource, seat_resource, serial, edges);
3665 xdg_surface_ack_configure(struct wl_client *client,
3666 struct wl_resource *resource,
3669 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3671 if (shsurf->state_requested) {
3672 shsurf->next_state = shsurf->requested_state;
3673 shsurf->state_changed = true;
3674 shsurf->state_requested = false;
3679 xdg_surface_set_window_geometry(struct wl_client *client,
3680 struct wl_resource *resource,
3686 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3688 set_window_geometry(shsurf, x, y, width, height);
3692 xdg_surface_set_maximized(struct wl_client *client,
3693 struct wl_resource *resource)
3695 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3697 shsurf->state_requested = true;
3698 shsurf->requested_state.maximized = true;
3699 send_configure_for_surface(shsurf);
3703 xdg_surface_unset_maximized(struct wl_client *client,
3704 struct wl_resource *resource)
3706 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3708 shsurf->state_requested = true;
3709 shsurf->requested_state.maximized = false;
3710 send_configure_for_surface(shsurf);
3714 xdg_surface_set_fullscreen(struct wl_client *client,
3715 struct wl_resource *resource,
3716 struct wl_resource *output_resource)
3718 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3719 struct weston_output *output;
3721 shsurf->state_requested = true;
3722 shsurf->requested_state.fullscreen = true;
3724 if (output_resource)
3725 output = wl_resource_get_user_data(output_resource);
3729 shell_surface_set_output(shsurf, output);
3730 shsurf->fullscreen_output = shsurf->output;
3732 send_configure_for_surface(shsurf);
3736 xdg_surface_unset_fullscreen(struct wl_client *client,
3737 struct wl_resource *resource)
3739 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3741 shsurf->state_requested = true;
3742 shsurf->requested_state.fullscreen = false;
3743 send_configure_for_surface(shsurf);
3747 xdg_surface_set_minimized(struct wl_client *client,
3748 struct wl_resource *resource)
3750 struct shell_surface *shsurf = wl_resource_get_user_data(resource);
3752 if (shsurf->type != SHELL_SURFACE_TOPLEVEL)
3755 /* apply compositor's own minimization logic (hide) */
3756 set_minimized(shsurf->surface, 1);
3759 static const struct xdg_surface_interface xdg_surface_implementation = {
3760 xdg_surface_destroy,
3761 xdg_surface_set_parent,
3762 xdg_surface_set_title,
3763 xdg_surface_set_app_id,
3764 xdg_surface_show_window_menu,
3767 xdg_surface_ack_configure,
3768 xdg_surface_set_window_geometry,
3769 xdg_surface_set_maximized,
3770 xdg_surface_unset_maximized,
3771 xdg_surface_set_fullscreen,
3772 xdg_surface_unset_fullscreen,
3773 xdg_surface_set_minimized,
3777 xdg_send_configure(struct weston_surface *surface,
3778 int32_t width, int32_t height)
3780 struct shell_surface *shsurf = get_shell_surface(surface);
3782 struct wl_array states;
3787 if (!shsurf->resource)
3790 wl_array_init(&states);
3791 if (shsurf->requested_state.fullscreen) {
3792 s = wl_array_add(&states, sizeof *s);
3793 *s = XDG_SURFACE_STATE_FULLSCREEN;
3794 } else if (shsurf->requested_state.maximized) {
3795 s = wl_array_add(&states, sizeof *s);
3796 *s = XDG_SURFACE_STATE_MAXIMIZED;
3798 if (shsurf->resize_edges != 0) {
3799 s = wl_array_add(&states, sizeof *s);
3800 *s = XDG_SURFACE_STATE_RESIZING;
3802 if (shsurf->focus_count > 0) {
3803 s = wl_array_add(&states, sizeof *s);
3804 *s = XDG_SURFACE_STATE_ACTIVATED;
3807 serial = wl_display_next_serial(shsurf->surface->compositor->wl_display);
3808 xdg_surface_send_configure(shsurf->resource, width, height, &states, serial);
3810 wl_array_release(&states);
3813 static const struct weston_shell_client xdg_client = {
3818 xdg_use_unstable_version(struct wl_client *client,
3819 struct wl_resource *resource,
3823 wl_resource_post_error(resource,
3825 "xdg-shell:: version not implemented yet.");
3830 static struct shell_surface *
3831 create_xdg_surface(struct shell_client *owner, void *shell,
3832 struct weston_surface *surface,
3833 const struct weston_shell_client *client)
3835 struct shell_surface *shsurf;
3837 shsurf = create_common_surface(owner, shell, surface, client);
3838 shsurf->type = SHELL_SURFACE_TOPLEVEL;
3844 xdg_get_xdg_surface(struct wl_client *client,
3845 struct wl_resource *resource,
3847 struct wl_resource *surface_resource)
3849 struct weston_surface *surface =
3850 wl_resource_get_user_data(surface_resource);
3851 struct shell_client *sc = wl_resource_get_user_data(resource);
3852 struct desktop_shell *shell = sc->shell;
3853 struct shell_surface *shsurf;
3855 if (get_shell_surface(surface)) {
3856 wl_resource_post_error(surface_resource,
3857 WL_DISPLAY_ERROR_INVALID_OBJECT,
3858 "xdg_shell::get_xdg_surface already requested");
3862 shsurf = create_xdg_surface(sc, shell, surface, &xdg_client);
3864 wl_resource_post_error(surface_resource,
3865 WL_DISPLAY_ERROR_INVALID_OBJECT,
3866 "surface->configure already set");
3871 wl_resource_create(client,
3872 &xdg_surface_interface, 1, id);
3873 wl_resource_set_implementation(shsurf->resource,
3874 &xdg_surface_implementation,
3875 shsurf, shell_destroy_shell_surface);
3879 shell_surface_is_xdg_surface(struct shell_surface *shsurf)
3881 return shsurf->resource &&
3882 wl_resource_instance_of(shsurf->resource,
3883 &xdg_surface_interface,
3884 &xdg_surface_implementation);
3887 /* xdg-popup implementation */
3890 xdg_popup_destroy(struct wl_client *client,
3891 struct wl_resource *resource)
3893 wl_resource_destroy(resource);
3896 static const struct xdg_popup_interface xdg_popup_implementation = {
3901 xdg_popup_send_configure(struct weston_surface *surface,
3902 int32_t width, int32_t height)
3906 static const struct weston_shell_client xdg_popup_client = {
3907 xdg_popup_send_configure
3910 static struct shell_surface *
3911 create_xdg_popup(struct shell_client *owner, void *shell,
3912 struct weston_surface *surface,
3913 const struct weston_shell_client *client,
3914 struct weston_surface *parent,
3915 struct shell_seat *seat,
3917 int32_t x, int32_t y)
3919 struct shell_surface *shsurf;
3921 shsurf = create_common_surface(owner, shell, surface, client);
3922 shsurf->type = SHELL_SURFACE_POPUP;
3923 shsurf->popup.shseat = seat;
3924 shsurf->popup.serial = serial;
3925 shsurf->popup.x = x;
3926 shsurf->popup.y = y;
3927 shell_surface_set_parent(shsurf, parent);
3933 xdg_get_xdg_popup(struct wl_client *client,
3934 struct wl_resource *resource,
3936 struct wl_resource *surface_resource,
3937 struct wl_resource *parent_resource,
3938 struct wl_resource *seat_resource,
3940 int32_t x, int32_t y, uint32_t flags)
3942 struct weston_surface *surface =
3943 wl_resource_get_user_data(surface_resource);
3944 struct shell_client *sc = wl_resource_get_user_data(resource);
3945 struct desktop_shell *shell = sc->shell;
3946 struct shell_surface *shsurf;
3947 struct weston_surface *parent;
3948 struct shell_seat *seat;
3950 if (get_shell_surface(surface)) {
3951 wl_resource_post_error(surface_resource,
3952 WL_DISPLAY_ERROR_INVALID_OBJECT,
3953 "xdg_shell::get_xdg_popup already requested");
3957 if (!parent_resource) {
3958 wl_resource_post_error(surface_resource,
3959 WL_DISPLAY_ERROR_INVALID_OBJECT,
3960 "xdg_shell::get_xdg_popup requires a parent shell surface");
3964 parent = wl_resource_get_user_data(parent_resource);
3965 seat = get_shell_seat(wl_resource_get_user_data(seat_resource));;
3967 shsurf = create_xdg_popup(sc, shell, surface, &xdg_popup_client,
3968 parent, seat, serial, x, y);
3970 wl_resource_post_error(surface_resource,
3971 WL_DISPLAY_ERROR_INVALID_OBJECT,
3972 "surface->configure already set");
3977 wl_resource_create(client,
3978 &xdg_popup_interface, 1, id);
3979 wl_resource_set_implementation(shsurf->resource,
3980 &xdg_popup_implementation,
3981 shsurf, shell_destroy_shell_surface);
3985 xdg_pong(struct wl_client *client,
3986 struct wl_resource *resource, uint32_t serial)
3988 struct shell_client *sc = wl_resource_get_user_data(resource);
3990 shell_client_pong(sc, serial);
3994 shell_surface_is_xdg_popup(struct shell_surface *shsurf)
3996 return wl_resource_instance_of(shsurf->resource,
3997 &xdg_popup_interface,
3998 &xdg_popup_implementation);
4001 static const struct xdg_shell_interface xdg_implementation = {
4002 xdg_use_unstable_version,
4003 xdg_get_xdg_surface,
4009 xdg_shell_unversioned_dispatch(const void *implementation,
4010 void *_target, uint32_t opcode,
4011 const struct wl_message *message,
4012 union wl_argument *args)
4014 struct wl_resource *resource = _target;
4015 struct shell_client *sc = wl_resource_get_user_data(resource);
4018 wl_resource_post_error(resource,
4019 WL_DISPLAY_ERROR_INVALID_OBJECT,
4020 "must call use_unstable_version first");
4024 #define XDG_SERVER_VERSION 4
4026 static_assert(XDG_SERVER_VERSION == XDG_SHELL_VERSION_CURRENT,
4027 "shell implementation doesn't match protocol version");
4029 if (args[0].i != XDG_SERVER_VERSION) {
4030 wl_resource_post_error(resource,
4031 WL_DISPLAY_ERROR_INVALID_OBJECT,
4032 "incompatible version, server is %d "
4034 XDG_SERVER_VERSION, args[0].i);
4038 wl_resource_set_implementation(resource, &xdg_implementation,
4044 /* end of xdg-shell implementation */
4045 /***********************************/
4048 shell_fade(struct desktop_shell *shell, enum fade_type type);
4051 screensaver_timeout(void *data)
4053 struct desktop_shell *shell = data;
4055 shell_fade(shell, FADE_OUT);
4061 handle_screensaver_sigchld(struct weston_process *proc, int status)
4063 struct desktop_shell *shell =
4064 container_of(proc, struct desktop_shell, screensaver.process);
4069 weston_compositor_sleep(shell->compositor);
4073 launch_screensaver(struct desktop_shell *shell)
4075 if (shell->screensaver.binding)
4078 if (!shell->screensaver.path) {
4079 weston_compositor_sleep(shell->compositor);
4083 if (shell->screensaver.process.pid != 0) {
4084 weston_log("old screensaver still running\n");
4088 weston_client_launch(shell->compositor,
4089 &shell->screensaver.process,
4090 shell->screensaver.path,
4091 handle_screensaver_sigchld);
4095 terminate_screensaver(struct desktop_shell *shell)
4097 if (shell->screensaver.process.pid == 0)
4100 /* Disarm the screensaver timer, otherwise it may fire when the
4101 * compositor is not in the idle state. In that case, the screen will
4102 * be locked, but the wake_signal won't fire on user input, making the
4103 * system unresponsive. */
4104 wl_event_source_timer_update(shell->screensaver.timer, 0);
4106 kill(shell->screensaver.process.pid, SIGTERM);
4110 configure_static_view(struct weston_view *ev, struct weston_layer *layer)
4112 struct weston_view *v, *next;
4114 wl_list_for_each_safe(v, next, &layer->view_list.link, layer_link.link) {
4115 if (v->output == ev->output && v != ev) {
4116 weston_view_unmap(v);
4117 v->surface->configure = NULL;
4121 weston_view_set_position(ev, ev->output->x, ev->output->y);
4123 if (wl_list_empty(&ev->layer_link.link)) {
4124 weston_layer_entry_insert(&layer->view_list, &ev->layer_link);
4125 weston_compositor_schedule_repaint(ev->surface->compositor);
4130 background_configure(struct weston_surface *es, int32_t sx, int32_t sy)
4132 struct desktop_shell *shell = es->configure_private;
4133 struct weston_view *view;
4135 view = container_of(es->views.next, struct weston_view, surface_link);
4137 configure_static_view(view, &shell->background_layer);
4141 desktop_shell_set_background(struct wl_client *client,
4142 struct wl_resource *resource,
4143 struct wl_resource *output_resource,
4144 struct wl_resource *surface_resource)
4146 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4147 struct weston_surface *surface =
4148 wl_resource_get_user_data(surface_resource);
4149 struct weston_view *view, *next;
4151 if (surface->configure) {
4152 wl_resource_post_error(surface_resource,
4153 WL_DISPLAY_ERROR_INVALID_OBJECT,
4154 "surface role already assigned");
4158 wl_list_for_each_safe(view, next, &surface->views, surface_link)
4159 weston_view_destroy(view);
4160 view = weston_view_create(surface);
4162 surface->configure = background_configure;
4163 surface->configure_private = shell;
4164 surface->output = wl_resource_get_user_data(output_resource);
4165 view->output = surface->output;
4166 desktop_shell_send_configure(resource, 0,
4168 surface->output->width,
4169 surface->output->height);
4173 panel_configure(struct weston_surface *es, int32_t sx, int32_t sy)
4175 struct desktop_shell *shell = es->configure_private;
4176 struct weston_view *view;
4178 view = container_of(es->views.next, struct weston_view, surface_link);
4180 configure_static_view(view, &shell->panel_layer);
4184 desktop_shell_set_panel(struct wl_client *client,
4185 struct wl_resource *resource,
4186 struct wl_resource *output_resource,
4187 struct wl_resource *surface_resource)
4189 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4190 struct weston_surface *surface =
4191 wl_resource_get_user_data(surface_resource);
4192 struct weston_view *view, *next;
4194 if (surface->configure) {
4195 wl_resource_post_error(surface_resource,
4196 WL_DISPLAY_ERROR_INVALID_OBJECT,
4197 "surface role already assigned");
4201 wl_list_for_each_safe(view, next, &surface->views, surface_link)
4202 weston_view_destroy(view);
4203 view = weston_view_create(surface);
4205 surface->configure = panel_configure;
4206 surface->configure_private = shell;
4207 surface->output = wl_resource_get_user_data(output_resource);
4208 view->output = surface->output;
4209 desktop_shell_send_configure(resource, 0,
4211 surface->output->width,
4212 surface->output->height);
4216 lock_surface_configure(struct weston_surface *surface, int32_t sx, int32_t sy)
4218 struct desktop_shell *shell = surface->configure_private;
4219 struct weston_view *view;
4221 view = container_of(surface->views.next, struct weston_view, surface_link);
4223 if (surface->width == 0)
4226 center_on_output(view, get_default_output(shell->compositor));
4228 if (!weston_surface_is_mapped(surface)) {
4229 weston_layer_entry_insert(&shell->lock_layer.view_list,
4231 weston_view_update_transform(view);
4232 shell_fade(shell, FADE_IN);
4237 handle_lock_surface_destroy(struct wl_listener *listener, void *data)
4239 struct desktop_shell *shell =
4240 container_of(listener, struct desktop_shell, lock_surface_listener);
4242 weston_log("lock surface gone\n");
4243 shell->lock_surface = NULL;
4247 desktop_shell_set_lock_surface(struct wl_client *client,
4248 struct wl_resource *resource,
4249 struct wl_resource *surface_resource)
4251 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4252 struct weston_surface *surface =
4253 wl_resource_get_user_data(surface_resource);
4255 shell->prepare_event_sent = false;
4260 shell->lock_surface = surface;
4262 shell->lock_surface_listener.notify = handle_lock_surface_destroy;
4263 wl_signal_add(&surface->destroy_signal,
4264 &shell->lock_surface_listener);
4266 weston_view_create(surface);
4267 surface->configure = lock_surface_configure;
4268 surface->configure_private = shell;
4272 resume_desktop(struct desktop_shell *shell)
4274 struct workspace *ws = get_current_workspace(shell);
4276 terminate_screensaver(shell);
4278 wl_list_remove(&shell->lock_layer.link);
4279 if (shell->showing_input_panels) {
4280 wl_list_insert(&shell->compositor->cursor_layer.link,
4281 &shell->input_panel_layer.link);
4282 wl_list_insert(&shell->input_panel_layer.link,
4283 &shell->fullscreen_layer.link);
4285 wl_list_insert(&shell->compositor->cursor_layer.link,
4286 &shell->fullscreen_layer.link);
4288 wl_list_insert(&shell->fullscreen_layer.link,
4289 &shell->panel_layer.link);
4290 wl_list_insert(&shell->panel_layer.link,
4293 restore_focus_state(shell, get_current_workspace(shell));
4295 shell->locked = false;
4296 shell_fade(shell, FADE_IN);
4297 weston_compositor_damage_all(shell->compositor);
4301 desktop_shell_unlock(struct wl_client *client,
4302 struct wl_resource *resource)
4304 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4306 shell->prepare_event_sent = false;
4309 resume_desktop(shell);
4313 desktop_shell_set_grab_surface(struct wl_client *client,
4314 struct wl_resource *resource,
4315 struct wl_resource *surface_resource)
4317 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4319 shell->grab_surface = wl_resource_get_user_data(surface_resource);
4320 weston_view_create(shell->grab_surface);
4324 desktop_shell_desktop_ready(struct wl_client *client,
4325 struct wl_resource *resource)
4327 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4329 shell_fade_startup(shell);
4333 desktop_shell_set_panel_position(struct wl_client *client,
4334 struct wl_resource *resource,
4337 struct desktop_shell *shell = wl_resource_get_user_data(resource);
4339 if (position != DESKTOP_SHELL_PANEL_POSITION_TOP &&
4340 position != DESKTOP_SHELL_PANEL_POSITION_BOTTOM &&
4341 position != DESKTOP_SHELL_PANEL_POSITION_LEFT &&
4342 position != DESKTOP_SHELL_PANEL_POSITION_RIGHT) {
4343 wl_resource_post_error(resource,
4344 DESKTOP_SHELL_ERROR_INVALID_ARGUMENT,
4345 "bad position argument");
4349 shell->panel_position = position;
4352 static const struct desktop_shell_interface desktop_shell_implementation = {
4353 desktop_shell_set_background,
4354 desktop_shell_set_panel,
4355 desktop_shell_set_lock_surface,
4356 desktop_shell_unlock,
4357 desktop_shell_set_grab_surface,
4358 desktop_shell_desktop_ready,
4359 desktop_shell_set_panel_position
4362 static enum shell_surface_type
4363 get_shell_surface_type(struct weston_surface *surface)
4365 struct shell_surface *shsurf;
4367 shsurf = get_shell_surface(surface);
4369 return SHELL_SURFACE_NONE;
4370 return shsurf->type;
4374 move_binding(struct weston_seat *seat, uint32_t time, uint32_t button, void *data)
4376 struct weston_surface *focus;
4377 struct weston_surface *surface;
4378 struct shell_surface *shsurf;
4380 if (seat->pointer->focus == NULL)
4383 focus = seat->pointer->focus->surface;
4385 surface = weston_surface_get_main_surface(focus);
4386 if (surface == NULL)
4389 shsurf = get_shell_surface(surface);
4390 if (shsurf == NULL || shsurf->state.fullscreen ||
4391 shsurf->state.maximized)
4394 surface_move(shsurf, (struct weston_seat *) seat, 0);
4398 maximize_binding(struct weston_seat *seat, uint32_t time, uint32_t button, void *data)
4400 struct weston_surface *focus = seat->keyboard->focus;
4401 struct weston_surface *surface;
4402 struct shell_surface *shsurf;
4404 surface = weston_surface_get_main_surface(focus);
4405 if (surface == NULL)
4408 shsurf = get_shell_surface(surface);
4412 if (!shell_surface_is_xdg_surface(shsurf))
4415 shsurf->state_requested = true;
4416 shsurf->requested_state.maximized = !shsurf->state.maximized;
4417 send_configure_for_surface(shsurf);
4421 fullscreen_binding(struct weston_seat *seat, uint32_t time, uint32_t button, void *data)
4423 struct weston_surface *focus = seat->keyboard->focus;
4424 struct weston_surface *surface;
4425 struct shell_surface *shsurf;
4427 surface = weston_surface_get_main_surface(focus);
4428 if (surface == NULL)
4431 shsurf = get_shell_surface(surface);
4435 if (!shell_surface_is_xdg_surface(shsurf))
4438 shsurf->state_requested = true;
4439 shsurf->requested_state.fullscreen = !shsurf->state.fullscreen;
4440 shsurf->fullscreen_output = shsurf->output;
4441 send_configure_for_surface(shsurf);
4445 touch_move_binding(struct weston_seat *seat, uint32_t time, void *data)
4447 struct weston_surface *focus;
4448 struct weston_surface *surface;
4449 struct shell_surface *shsurf;
4451 if (seat->touch->focus == NULL)
4454 focus = seat->touch->focus->surface;
4455 surface = weston_surface_get_main_surface(focus);
4456 if (surface == NULL)
4459 shsurf = get_shell_surface(surface);
4460 if (shsurf == NULL || shsurf->state.fullscreen ||
4461 shsurf->state.maximized)
4464 surface_touch_move(shsurf, (struct weston_seat *) seat);
4468 resize_binding(struct weston_seat *seat, uint32_t time, uint32_t button, void *data)
4470 struct weston_surface *focus;
4471 struct weston_surface *surface;
4474 struct shell_surface *shsurf;
4476 if (seat->pointer->focus == NULL)
4479 focus = seat->pointer->focus->surface;
4481 surface = weston_surface_get_main_surface(focus);
4482 if (surface == NULL)
4485 shsurf = get_shell_surface(surface);
4486 if (shsurf == NULL || shsurf->state.fullscreen ||
4487 shsurf->state.maximized)
4490 weston_view_from_global(shsurf->view,
4491 wl_fixed_to_int(seat->pointer->grab_x),
4492 wl_fixed_to_int(seat->pointer->grab_y),
4495 if (x < shsurf->surface->width / 3)
4496 edges |= WL_SHELL_SURFACE_RESIZE_LEFT;
4497 else if (x < 2 * shsurf->surface->width / 3)
4500 edges |= WL_SHELL_SURFACE_RESIZE_RIGHT;
4502 if (y < shsurf->surface->height / 3)
4503 edges |= WL_SHELL_SURFACE_RESIZE_TOP;
4504 else if (y < 2 * shsurf->surface->height / 3)
4507 edges |= WL_SHELL_SURFACE_RESIZE_BOTTOM;
4509 surface_resize(shsurf, (struct weston_seat *) seat, edges);
4513 surface_opacity_binding(struct weston_seat *seat, uint32_t time, uint32_t axis,
4514 wl_fixed_t value, void *data)
4517 struct shell_surface *shsurf;
4518 struct weston_surface *focus = seat->pointer->focus->surface;
4519 struct weston_surface *surface;
4521 /* XXX: broken for windows containing sub-surfaces */
4522 surface = weston_surface_get_main_surface(focus);
4523 if (surface == NULL)
4526 shsurf = get_shell_surface(surface);
4530 shsurf->view->alpha -= wl_fixed_to_double(value) * step;
4532 if (shsurf->view->alpha > 1.0)
4533 shsurf->view->alpha = 1.0;
4534 if (shsurf->view->alpha < step)
4535 shsurf->view->alpha = step;
4537 weston_view_geometry_dirty(shsurf->view);
4538 weston_surface_damage(surface);
4542 do_zoom(struct weston_seat *seat, uint32_t time, uint32_t key, uint32_t axis,
4545 struct weston_seat *ws = (struct weston_seat *) seat;
4546 struct weston_compositor *compositor = ws->compositor;
4547 struct weston_output *output;
4550 wl_list_for_each(output, &compositor->output_list, link) {
4551 if (pixman_region32_contains_point(&output->region,
4552 wl_fixed_to_double(seat->pointer->x),
4553 wl_fixed_to_double(seat->pointer->y),
4555 if (key == KEY_PAGEUP)
4556 increment = output->zoom.increment;
4557 else if (key == KEY_PAGEDOWN)
4558 increment = -output->zoom.increment;
4559 else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
4560 /* For every pixel zoom 20th of a step */
4561 increment = output->zoom.increment *
4562 -wl_fixed_to_double(value) / 20.0;
4566 output->zoom.level += increment;
4568 if (output->zoom.level < 0.0)
4569 output->zoom.level = 0.0;
4570 else if (output->zoom.level > output->zoom.max_level)
4571 output->zoom.level = output->zoom.max_level;
4572 else if (!output->zoom.active) {
4573 weston_output_activate_zoom(output);
4576 output->zoom.spring_z.target = output->zoom.level;
4578 weston_output_update_zoom(output);
4584 zoom_axis_binding(struct weston_seat *seat, uint32_t time, uint32_t axis,
4585 wl_fixed_t value, void *data)
4587 do_zoom(seat, time, 0, axis, value);
4591 zoom_key_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
4594 do_zoom(seat, time, key, 0, 0);
4598 terminate_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
4601 struct weston_compositor *compositor = data;
4603 wl_display_terminate(compositor->wl_display);
4607 rotate_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
4608 wl_fixed_t x, wl_fixed_t y)
4610 struct rotate_grab *rotate =
4611 container_of(grab, struct rotate_grab, base.grab);
4612 struct weston_pointer *pointer = grab->pointer;
4613 struct shell_surface *shsurf = rotate->base.shsurf;
4614 float cx, cy, dx, dy, cposx, cposy, dposx, dposy, r;
4616 weston_pointer_move(pointer, x, y);
4621 cx = 0.5f * shsurf->surface->width;
4622 cy = 0.5f * shsurf->surface->height;
4624 dx = wl_fixed_to_double(pointer->x) - rotate->center.x;
4625 dy = wl_fixed_to_double(pointer->y) - rotate->center.y;
4626 r = sqrtf(dx * dx + dy * dy);
4628 wl_list_remove(&shsurf->rotation.transform.link);
4629 weston_view_geometry_dirty(shsurf->view);
4632 struct weston_matrix *matrix =
4633 &shsurf->rotation.transform.matrix;
4635 weston_matrix_init(&rotate->rotation);
4636 weston_matrix_rotate_xy(&rotate->rotation, dx / r, dy / r);
4638 weston_matrix_init(matrix);
4639 weston_matrix_translate(matrix, -cx, -cy, 0.0f);
4640 weston_matrix_multiply(matrix, &shsurf->rotation.rotation);
4641 weston_matrix_multiply(matrix, &rotate->rotation);
4642 weston_matrix_translate(matrix, cx, cy, 0.0f);
4645 &shsurf->view->geometry.transformation_list,
4646 &shsurf->rotation.transform.link);
4648 wl_list_init(&shsurf->rotation.transform.link);
4649 weston_matrix_init(&shsurf->rotation.rotation);
4650 weston_matrix_init(&rotate->rotation);
4653 /* We need to adjust the position of the surface
4654 * in case it was resized in a rotated state before */
4655 cposx = shsurf->view->geometry.x + cx;
4656 cposy = shsurf->view->geometry.y + cy;
4657 dposx = rotate->center.x - cposx;
4658 dposy = rotate->center.y - cposy;
4659 if (dposx != 0.0f || dposy != 0.0f) {
4660 weston_view_set_position(shsurf->view,
4661 shsurf->view->geometry.x + dposx,
4662 shsurf->view->geometry.y + dposy);
4665 /* Repaint implies weston_surface_update_transform(), which
4666 * lazily applies the damage due to rotation update.
4668 weston_compositor_schedule_repaint(shsurf->surface->compositor);
4672 rotate_grab_button(struct weston_pointer_grab *grab,
4673 uint32_t time, uint32_t button, uint32_t state_w)
4675 struct rotate_grab *rotate =
4676 container_of(grab, struct rotate_grab, base.grab);
4677 struct weston_pointer *pointer = grab->pointer;
4678 struct shell_surface *shsurf = rotate->base.shsurf;
4679 enum wl_pointer_button_state state = state_w;
4681 if (pointer->button_count == 0 &&
4682 state == WL_POINTER_BUTTON_STATE_RELEASED) {
4684 weston_matrix_multiply(&shsurf->rotation.rotation,
4686 shell_grab_end(&rotate->base);
4692 rotate_grab_cancel(struct weston_pointer_grab *grab)
4694 struct rotate_grab *rotate =
4695 container_of(grab, struct rotate_grab, base.grab);
4697 shell_grab_end(&rotate->base);
4701 static const struct weston_pointer_grab_interface rotate_grab_interface = {
4709 surface_rotate(struct shell_surface *surface, struct weston_seat *seat)
4711 struct rotate_grab *rotate;
4715 rotate = malloc(sizeof *rotate);
4719 weston_view_to_global_float(surface->view,
4720 surface->surface->width * 0.5f,
4721 surface->surface->height * 0.5f,
4722 &rotate->center.x, &rotate->center.y);
4724 dx = wl_fixed_to_double(seat->pointer->x) - rotate->center.x;
4725 dy = wl_fixed_to_double(seat->pointer->y) - rotate->center.y;
4726 r = sqrtf(dx * dx + dy * dy);
4728 struct weston_matrix inverse;
4730 weston_matrix_init(&inverse);
4731 weston_matrix_rotate_xy(&inverse, dx / r, -dy / r);
4732 weston_matrix_multiply(&surface->rotation.rotation, &inverse);
4734 weston_matrix_init(&rotate->rotation);
4735 weston_matrix_rotate_xy(&rotate->rotation, dx / r, dy / r);
4737 weston_matrix_init(&surface->rotation.rotation);
4738 weston_matrix_init(&rotate->rotation);
4741 shell_grab_start(&rotate->base, &rotate_grab_interface, surface,
4742 seat->pointer, DESKTOP_SHELL_CURSOR_ARROW);
4746 rotate_binding(struct weston_seat *seat, uint32_t time, uint32_t button,
4749 struct weston_surface *focus;
4750 struct weston_surface *base_surface;
4751 struct shell_surface *surface;
4753 if (seat->pointer->focus == NULL)
4756 focus = seat->pointer->focus->surface;
4758 base_surface = weston_surface_get_main_surface(focus);
4759 if (base_surface == NULL)
4762 surface = get_shell_surface(base_surface);
4763 if (surface == NULL || surface->state.fullscreen ||
4764 surface->state.maximized)
4767 surface_rotate(surface, seat);
4770 /* Move all fullscreen layers down to the current workspace and hide their
4771 * black views. The surfaces' state is set to both fullscreen and lowered,
4772 * and this is reversed when such a surface is re-configured, see
4773 * shell_configure_fullscreen() and shell_ensure_fullscreen_black_view().
4775 * This should be used when implementing shell-wide overlays, such as
4776 * the alt-tab switcher, which need to de-promote fullscreen layers. */
4778 lower_fullscreen_layer(struct desktop_shell *shell)
4780 struct workspace *ws;
4781 struct weston_view *view, *prev;
4783 ws = get_current_workspace(shell);
4784 wl_list_for_each_reverse_safe(view, prev,
4785 &shell->fullscreen_layer.view_list.link,
4787 struct shell_surface *shsurf = get_shell_surface(view->surface);
4792 /* We can have a non-fullscreen popup for a fullscreen surface
4793 * in the fullscreen layer. */
4794 if (shsurf->state.fullscreen) {
4795 /* Hide the black view */
4796 weston_layer_entry_remove(&shsurf->fullscreen.black_view->layer_link);
4797 wl_list_init(&shsurf->fullscreen.black_view->layer_link.link);
4798 weston_view_damage_below(shsurf->fullscreen.black_view);
4802 /* Lower the view to the workspace layer */
4803 weston_layer_entry_remove(&view->layer_link);
4804 weston_layer_entry_insert(&ws->layer.view_list, &view->layer_link);
4805 weston_view_damage_below(view);
4806 weston_surface_damage(view->surface);
4808 shsurf->state.lowered = true;
4813 activate(struct desktop_shell *shell, struct weston_surface *es,
4814 struct weston_seat *seat, bool configure)
4816 struct weston_surface *main_surface;
4817 struct focus_state *state;
4818 struct workspace *ws;
4819 struct weston_surface *old_es;
4820 struct shell_surface *shsurf;
4822 lower_fullscreen_layer(shell);
4824 main_surface = weston_surface_get_main_surface(es);
4826 weston_surface_activate(es, seat);
4828 state = ensure_focus_state(shell, seat);
4832 old_es = state->keyboard_focus;
4833 focus_state_set_focus(state, es);
4835 shsurf = get_shell_surface(main_surface);
4838 if (shsurf->state.fullscreen && configure)
4839 shell_configure_fullscreen(shsurf);
4841 restore_all_output_modes(shell->compositor);
4843 /* Update the surface’s layer. This brings it to the top of the stacking
4844 * order as appropriate. */
4845 shell_surface_update_layer(shsurf);
4847 if (shell->focus_animation_type != ANIMATION_NONE) {
4848 ws = get_current_workspace(shell);
4849 animate_focus_change(shell, ws, get_default_view(old_es), get_default_view(es));
4853 /* no-op func for checking black surface */
4855 black_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
4860 is_black_surface (struct weston_surface *es, struct weston_surface **fs_surface)
4862 if (es->configure == black_surface_configure) {
4864 *fs_surface = (struct weston_surface *)es->configure_private;
4871 activate_binding(struct weston_seat *seat,
4872 struct desktop_shell *shell,
4873 struct weston_surface *focus)
4875 struct weston_surface *main_surface;
4880 if (is_black_surface(focus, &main_surface))
4881 focus = main_surface;
4883 main_surface = weston_surface_get_main_surface(focus);
4884 if (get_shell_surface_type(main_surface) == SHELL_SURFACE_NONE)
4887 activate(shell, focus, seat, true);
4891 click_to_activate_binding(struct weston_seat *seat, uint32_t time, uint32_t button,
4894 if (seat->pointer->grab != &seat->pointer->default_grab)
4896 if (seat->pointer->focus == NULL)
4899 activate_binding(seat, data, seat->pointer->focus->surface);
4903 touch_to_activate_binding(struct weston_seat *seat, uint32_t time, void *data)
4905 if (seat->touch->grab != &seat->touch->default_grab)
4907 if (seat->touch->focus == NULL)
4910 activate_binding(seat, data, seat->touch->focus->surface);
4914 unfocus_all_seats(struct desktop_shell *shell)
4916 struct weston_seat *seat, *next;
4918 wl_list_for_each_safe(seat, next, &shell->compositor->seat_list, link) {
4919 if (seat->keyboard == NULL)
4922 weston_keyboard_set_focus(seat->keyboard, NULL);
4927 lock(struct desktop_shell *shell)
4929 struct workspace *ws = get_current_workspace(shell);
4931 if (shell->locked) {
4932 weston_compositor_sleep(shell->compositor);
4936 shell->locked = true;
4938 /* Hide all surfaces by removing the fullscreen, panel and
4939 * toplevel layers. This way nothing else can show or receive
4940 * input events while we are locked. */
4942 wl_list_remove(&shell->panel_layer.link);
4943 wl_list_remove(&shell->fullscreen_layer.link);
4944 if (shell->showing_input_panels)
4945 wl_list_remove(&shell->input_panel_layer.link);
4946 wl_list_remove(&ws->layer.link);
4947 wl_list_insert(&shell->compositor->cursor_layer.link,
4948 &shell->lock_layer.link);
4950 launch_screensaver(shell);
4952 /* Remove the keyboard focus on all seats. This will be
4953 * restored to the workspace's saved state via
4954 * restore_focus_state when the compositor is unlocked */
4955 unfocus_all_seats(shell);
4957 /* TODO: disable bindings that should not work while locked. */
4959 /* All this must be undone in resume_desktop(). */
4963 unlock(struct desktop_shell *shell)
4965 if (!shell->locked || shell->lock_surface) {
4966 shell_fade(shell, FADE_IN);
4970 /* If desktop-shell client has gone away, unlock immediately. */
4971 if (!shell->child.desktop_shell) {
4972 resume_desktop(shell);
4976 if (shell->prepare_event_sent)
4979 desktop_shell_send_prepare_lock_surface(shell->child.desktop_shell);
4980 shell->prepare_event_sent = true;
4984 shell_fade_done(struct weston_view_animation *animation, void *data)
4986 struct desktop_shell *shell = data;
4988 shell->fade.animation = NULL;
4990 switch (shell->fade.type) {
4992 weston_surface_destroy(shell->fade.view->surface);
4993 shell->fade.view = NULL;
5003 static struct weston_view *
5004 shell_fade_create_surface(struct desktop_shell *shell)
5006 struct weston_compositor *compositor = shell->compositor;
5007 struct weston_surface *surface;
5008 struct weston_view *view;
5010 surface = weston_surface_create(compositor);
5014 view = weston_view_create(surface);
5016 weston_surface_destroy(surface);
5020 weston_surface_set_size(surface, 8192, 8192);
5021 weston_view_set_position(view, 0, 0);
5022 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1.0);
5023 weston_layer_entry_insert(&compositor->fade_layer.view_list,
5025 pixman_region32_init(&surface->input);
5031 shell_fade(struct desktop_shell *shell, enum fade_type type)
5043 weston_log("shell: invalid fade type\n");
5047 shell->fade.type = type;
5049 if (shell->fade.view == NULL) {
5050 shell->fade.view = shell_fade_create_surface(shell);
5051 if (!shell->fade.view)
5054 shell->fade.view->alpha = 1.0 - tint;
5055 weston_view_update_transform(shell->fade.view);
5058 if (shell->fade.view->output == NULL) {
5059 /* If the black view gets a NULL output, we lost the
5060 * last output and we'll just cancel the fade. This
5061 * happens when you close the last window under the
5062 * X11 or Wayland backends. */
5063 shell->locked = false;
5064 weston_surface_destroy(shell->fade.view->surface);
5065 shell->fade.view = NULL;
5066 } else if (shell->fade.animation) {
5067 weston_fade_update(shell->fade.animation, tint);
5069 shell->fade.animation =
5070 weston_fade_run(shell->fade.view,
5071 1.0 - tint, tint, 300.0,
5072 shell_fade_done, shell);
5077 do_shell_fade_startup(void *data)
5079 struct desktop_shell *shell = data;
5081 if (shell->startup_animation_type == ANIMATION_FADE)
5082 shell_fade(shell, FADE_IN);
5083 else if (shell->startup_animation_type == ANIMATION_NONE) {
5084 weston_surface_destroy(shell->fade.view->surface);
5085 shell->fade.view = NULL;
5090 shell_fade_startup(struct desktop_shell *shell)
5092 struct wl_event_loop *loop;
5094 if (!shell->fade.startup_timer)
5097 wl_event_source_remove(shell->fade.startup_timer);
5098 shell->fade.startup_timer = NULL;
5100 loop = wl_display_get_event_loop(shell->compositor->wl_display);
5101 wl_event_loop_add_idle(loop, do_shell_fade_startup, shell);
5105 fade_startup_timeout(void *data)
5107 struct desktop_shell *shell = data;
5109 shell_fade_startup(shell);
5114 shell_fade_init(struct desktop_shell *shell)
5116 /* Make compositor output all black, and wait for the desktop-shell
5117 * client to signal it is ready, then fade in. The timer triggers a
5118 * fade-in, in case the desktop-shell client takes too long.
5121 struct wl_event_loop *loop;
5123 if (shell->fade.view != NULL) {
5124 weston_log("%s: warning: fade surface already exists\n",
5129 shell->fade.view = shell_fade_create_surface(shell);
5130 if (!shell->fade.view)
5133 weston_view_update_transform(shell->fade.view);
5134 weston_surface_damage(shell->fade.view->surface);
5136 loop = wl_display_get_event_loop(shell->compositor->wl_display);
5137 shell->fade.startup_timer =
5138 wl_event_loop_add_timer(loop, fade_startup_timeout, shell);
5139 wl_event_source_timer_update(shell->fade.startup_timer, 15000);
5143 idle_handler(struct wl_listener *listener, void *data)
5145 struct desktop_shell *shell =
5146 container_of(listener, struct desktop_shell, idle_listener);
5147 struct weston_seat *seat;
5149 wl_list_for_each(seat, &shell->compositor->seat_list, link) {
5151 popup_grab_end(seat->pointer);
5153 touch_popup_grab_end(seat->touch);
5156 shell_fade(shell, FADE_OUT);
5157 /* lock() is called from shell_fade_done() */
5161 wake_handler(struct wl_listener *listener, void *data)
5163 struct desktop_shell *shell =
5164 container_of(listener, struct desktop_shell, wake_listener);
5170 center_on_output(struct weston_view *view, struct weston_output *output)
5172 int32_t surf_x, surf_y, width, height;
5175 surface_subsurfaces_boundingbox(view->surface, &surf_x, &surf_y, &width, &height);
5177 x = output->x + (output->width - width) / 2 - surf_x / 2;
5178 y = output->y + (output->height - height) / 2 - surf_y / 2;
5180 weston_view_set_position(view, x, y);
5184 weston_view_set_initial_position(struct weston_view *view,
5185 struct desktop_shell *shell)
5187 struct weston_compositor *compositor = shell->compositor;
5189 int32_t range_x, range_y;
5190 int32_t dx, dy, x, y;
5191 struct weston_output *output, *target_output = NULL;
5192 struct weston_seat *seat;
5193 pixman_rectangle32_t area;
5195 /* As a heuristic place the new window on the same output as the
5196 * pointer. Falling back to the output containing 0, 0.
5198 * TODO: Do something clever for touch too?
5200 wl_list_for_each(seat, &compositor->seat_list, link) {
5201 if (seat->pointer) {
5202 ix = wl_fixed_to_int(seat->pointer->x);
5203 iy = wl_fixed_to_int(seat->pointer->y);
5208 wl_list_for_each(output, &compositor->output_list, link) {
5209 if (pixman_region32_contains_point(&output->region, ix, iy, NULL)) {
5210 target_output = output;
5215 if (!target_output) {
5216 weston_view_set_position(view, 10 + random() % 400,
5217 10 + random() % 400);
5221 /* Valid range within output where the surface will still be onscreen.
5222 * If this is negative it means that the surface is bigger than
5225 get_output_work_area(shell, target_output, &area);
5229 range_x = area.width - view->surface->width;
5230 range_y = area.height - view->surface->height;
5233 dx += random() % range_x;
5236 dy += random() % range_y;
5238 x = target_output->x + dx;
5239 y = target_output->y + dy;
5241 weston_view_set_position(view, x, y);
5245 set_maximized_position(struct desktop_shell *shell,
5246 struct shell_surface *shsurf)
5248 int32_t surf_x, surf_y;
5249 pixman_rectangle32_t area;
5251 /* use surface configure to set the geometry */
5252 get_output_work_area(shell, shsurf->output, &area);
5253 surface_subsurfaces_boundingbox(shsurf->surface,
5254 &surf_x, &surf_y, NULL, NULL);
5256 weston_view_set_position(shsurf->view,
5262 map(struct desktop_shell *shell, struct shell_surface *shsurf,
5263 int32_t sx, int32_t sy)
5265 struct weston_compositor *compositor = shell->compositor;
5266 struct weston_seat *seat;
5268 /* initial positioning, see also configure() */
5269 switch (shsurf->type) {
5270 case SHELL_SURFACE_TOPLEVEL:
5271 if (shsurf->state.fullscreen) {
5272 center_on_output(shsurf->view, shsurf->fullscreen_output);
5273 shell_map_fullscreen(shsurf);
5274 } else if (shsurf->state.maximized) {
5275 set_maximized_position(shell, shsurf);
5276 } else if (!shsurf->state.relative) {
5277 weston_view_set_initial_position(shsurf->view, shell);
5280 case SHELL_SURFACE_POPUP:
5281 shell_map_popup(shsurf);
5283 case SHELL_SURFACE_NONE:
5284 weston_view_set_position(shsurf->view,
5285 shsurf->view->geometry.x + sx,
5286 shsurf->view->geometry.y + sy);
5288 case SHELL_SURFACE_XWAYLAND:
5293 /* Surface stacking order, see also activate(). */
5294 shell_surface_update_layer(shsurf);
5296 if (shsurf->type != SHELL_SURFACE_NONE) {
5297 weston_view_update_transform(shsurf->view);
5298 if (shsurf->state.maximized) {
5299 shsurf->surface->output = shsurf->output;
5300 shsurf->view->output = shsurf->output;
5304 switch (shsurf->type) {
5305 /* XXX: xwayland's using the same fields for transient type */
5306 case SHELL_SURFACE_XWAYLAND:
5307 if (shsurf->transient.flags ==
5308 WL_SHELL_SURFACE_TRANSIENT_INACTIVE)
5310 case SHELL_SURFACE_TOPLEVEL:
5311 if (shsurf->state.relative &&
5312 shsurf->transient.flags == WL_SHELL_SURFACE_TRANSIENT_INACTIVE)
5316 wl_list_for_each(seat, &compositor->seat_list, link)
5317 activate(shell, shsurf->surface, seat, true);
5319 case SHELL_SURFACE_POPUP:
5320 case SHELL_SURFACE_NONE:
5325 if (shsurf->type == SHELL_SURFACE_TOPLEVEL &&
5326 !shsurf->state.maximized && !shsurf->state.fullscreen)
5328 switch (shell->win_animation_type) {
5329 case ANIMATION_FADE:
5330 weston_fade_run(shsurf->view, 0.0, 1.0, 300.0, NULL, NULL);
5332 case ANIMATION_ZOOM:
5333 weston_zoom_run(shsurf->view, 0.5, 1.0, NULL, NULL);
5335 case ANIMATION_NONE:
5343 configure(struct desktop_shell *shell, struct weston_surface *surface,
5346 struct shell_surface *shsurf;
5347 struct weston_view *view;
5349 shsurf = get_shell_surface(surface);
5353 if (shsurf->state.fullscreen)
5354 shell_configure_fullscreen(shsurf);
5355 else if (shsurf->state.maximized) {
5356 set_maximized_position(shell, shsurf);
5358 weston_view_set_position(shsurf->view, x, y);
5361 /* XXX: would a fullscreen surface need the same handling? */
5362 if (surface->output) {
5363 wl_list_for_each(view, &surface->views, surface_link)
5364 weston_view_update_transform(view);
5366 if (shsurf->state.maximized)
5367 surface->output = shsurf->output;
5372 shell_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
5374 struct shell_surface *shsurf = get_shell_surface(es);
5375 struct desktop_shell *shell;
5376 int type_changed = 0;
5380 shell = shsurf->shell;
5382 if (!weston_surface_is_mapped(es) &&
5383 !wl_list_empty(&shsurf->popup.grab_link)) {
5384 remove_popup_grab(shsurf);
5390 if (shsurf->has_next_geometry) {
5391 shsurf->geometry = shsurf->next_geometry;
5392 shsurf->has_next_geometry = false;
5393 shsurf->has_set_geometry = true;
5394 } else if (!shsurf->has_set_geometry) {
5395 surface_subsurfaces_boundingbox(shsurf->surface,
5396 &shsurf->geometry.x,
5397 &shsurf->geometry.y,
5398 &shsurf->geometry.width,
5399 &shsurf->geometry.height);
5402 if (shsurf->state_changed) {
5403 set_surface_type(shsurf);
5407 if (!weston_surface_is_mapped(es)) {
5408 map(shell, shsurf, sx, sy);
5409 } else if (type_changed || sx != 0 || sy != 0 ||
5410 shsurf->last_width != es->width ||
5411 shsurf->last_height != es->height) {
5412 float from_x, from_y;
5415 if (shsurf->resize_edges) {
5420 if (shsurf->resize_edges & WL_SHELL_SURFACE_RESIZE_LEFT)
5421 sx = shsurf->last_width - es->width;
5422 if (shsurf->resize_edges & WL_SHELL_SURFACE_RESIZE_TOP)
5423 sy = shsurf->last_height - es->height;
5425 shsurf->last_width = es->width;
5426 shsurf->last_height = es->height;
5428 weston_view_to_global_float(shsurf->view, 0, 0, &from_x, &from_y);
5429 weston_view_to_global_float(shsurf->view, sx, sy, &to_x, &to_y);
5430 configure(shell, es,
5431 shsurf->view->geometry.x + to_x - from_x,
5432 shsurf->view->geometry.y + to_y - from_y);
5437 check_desktop_shell_crash_too_early(struct desktop_shell *shell)
5439 struct timespec now;
5441 if (clock_gettime(CLOCK_MONOTONIC, &now) < 0)
5445 * If the shell helper client dies before the session has been
5446 * up for roughly 30 seconds, better just make Weston shut down,
5447 * because the user likely has no way to interact with the desktop
5450 if (now.tv_sec - shell->startup_time.tv_sec < 30) {
5451 weston_log("Error: %s apparently cannot run at all.\n",
5453 weston_log_continue(STAMP_SPACE "Quitting...");
5454 wl_display_terminate(shell->compositor->wl_display);
5462 static void launch_desktop_shell_process(void *data);
5465 respawn_desktop_shell_process(struct desktop_shell *shell)
5469 /* if desktop-shell dies more than 5 times in 30 seconds, give up */
5470 time = weston_compositor_get_time();
5471 if (time - shell->child.deathstamp > 30000) {
5472 shell->child.deathstamp = time;
5473 shell->child.deathcount = 0;
5476 shell->child.deathcount++;
5477 if (shell->child.deathcount > 5) {
5478 weston_log("%s disconnected, giving up.\n", shell->client);
5482 weston_log("%s disconnected, respawning...\n", shell->client);
5483 launch_desktop_shell_process(shell);
5487 desktop_shell_client_destroy(struct wl_listener *listener, void *data)
5489 struct desktop_shell *shell;
5491 shell = container_of(listener, struct desktop_shell,
5492 child.client_destroy_listener);
5494 wl_list_remove(&shell->child.client_destroy_listener.link);
5495 shell->child.client = NULL;
5497 * unbind_desktop_shell() will reset shell->child.desktop_shell
5498 * before the respawned process has a chance to create a new
5499 * desktop_shell object, because we are being called from the
5500 * wl_client destructor which destroys all wl_resources before
5504 if (!check_desktop_shell_crash_too_early(shell))
5505 respawn_desktop_shell_process(shell);
5507 shell_fade_startup(shell);
5511 launch_desktop_shell_process(void *data)
5513 struct desktop_shell *shell = data;
5515 shell->child.client = weston_client_start(shell->compositor,
5518 if (!shell->child.client) {
5519 weston_log("not able to start %s\n", shell->client);
5523 shell->child.client_destroy_listener.notify =
5524 desktop_shell_client_destroy;
5525 wl_client_add_destroy_listener(shell->child.client,
5526 &shell->child.client_destroy_listener);
5530 handle_shell_client_destroy(struct wl_listener *listener, void *data)
5532 struct shell_client *sc =
5533 container_of(listener, struct shell_client, destroy_listener);
5536 wl_event_source_remove(sc->ping_timer);
5540 static struct shell_client *
5541 shell_client_create(struct wl_client *client, struct desktop_shell *shell,
5542 const struct wl_interface *interface, uint32_t id)
5544 struct shell_client *sc;
5546 sc = zalloc(sizeof *sc);
5548 wl_client_post_no_memory(client);
5552 sc->resource = wl_resource_create(client, interface, 1, id);
5553 if (sc->resource == NULL) {
5555 wl_client_post_no_memory(client);
5559 sc->client = client;
5561 sc->destroy_listener.notify = handle_shell_client_destroy;
5562 wl_client_add_destroy_listener(client, &sc->destroy_listener);
5568 bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
5570 struct desktop_shell *shell = data;
5571 struct shell_client *sc;
5573 sc = shell_client_create(client, shell, &wl_shell_interface, id);
5575 wl_resource_set_implementation(sc->resource,
5576 &shell_implementation,
5581 bind_xdg_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
5583 struct desktop_shell *shell = data;
5584 struct shell_client *sc;
5586 sc = shell_client_create(client, shell, &xdg_shell_interface, id);
5588 wl_resource_set_dispatcher(sc->resource,
5589 xdg_shell_unversioned_dispatch,
5594 unbind_desktop_shell(struct wl_resource *resource)
5596 struct desktop_shell *shell = wl_resource_get_user_data(resource);
5599 resume_desktop(shell);
5601 shell->child.desktop_shell = NULL;
5602 shell->prepare_event_sent = false;
5606 bind_desktop_shell(struct wl_client *client,
5607 void *data, uint32_t version, uint32_t id)
5609 struct desktop_shell *shell = data;
5610 struct wl_resource *resource;
5612 resource = wl_resource_create(client, &desktop_shell_interface,
5613 MIN(version, 3), id);
5615 if (client == shell->child.client) {
5616 wl_resource_set_implementation(resource,
5617 &desktop_shell_implementation,
5618 shell, unbind_desktop_shell);
5619 shell->child.desktop_shell = resource;
5622 shell_fade_startup(shell);
5627 wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
5628 "permission to bind desktop_shell denied");
5632 screensaver_configure(struct weston_surface *surface, int32_t sx, int32_t sy)
5634 struct desktop_shell *shell = surface->configure_private;
5635 struct weston_view *view;
5636 struct weston_layer_entry *prev;
5638 if (surface->width == 0)
5641 /* XXX: starting weston-screensaver beforehand does not work */
5645 view = container_of(surface->views.next, struct weston_view, surface_link);
5646 center_on_output(view, surface->output);
5648 if (wl_list_empty(&view->layer_link.link)) {
5649 prev = container_of(shell->lock_layer.view_list.link.prev,
5650 struct weston_layer_entry, link);
5651 weston_layer_entry_insert(prev, &view->layer_link);
5652 weston_view_update_transform(view);
5653 wl_event_source_timer_update(shell->screensaver.timer,
5654 shell->screensaver.duration);
5655 shell_fade(shell, FADE_IN);
5660 screensaver_set_surface(struct wl_client *client,
5661 struct wl_resource *resource,
5662 struct wl_resource *surface_resource,
5663 struct wl_resource *output_resource)
5665 struct desktop_shell *shell = wl_resource_get_user_data(resource);
5666 struct weston_surface *surface =
5667 wl_resource_get_user_data(surface_resource);
5668 struct weston_output *output = wl_resource_get_user_data(output_resource);
5669 struct weston_view *view, *next;
5671 /* Make sure we only have one view */
5672 wl_list_for_each_safe(view, next, &surface->views, surface_link)
5673 weston_view_destroy(view);
5674 weston_view_create(surface);
5676 surface->configure = screensaver_configure;
5677 surface->configure_private = shell;
5678 surface->output = output;
5681 static const struct screensaver_interface screensaver_implementation = {
5682 screensaver_set_surface
5686 unbind_screensaver(struct wl_resource *resource)
5688 struct desktop_shell *shell = wl_resource_get_user_data(resource);
5690 shell->screensaver.binding = NULL;
5694 bind_screensaver(struct wl_client *client,
5695 void *data, uint32_t version, uint32_t id)
5697 struct desktop_shell *shell = data;
5698 struct wl_resource *resource;
5700 resource = wl_resource_create(client, &screensaver_interface, 1, id);
5702 if (shell->screensaver.binding == NULL) {
5703 wl_resource_set_implementation(resource,
5704 &screensaver_implementation,
5705 shell, unbind_screensaver);
5706 shell->screensaver.binding = resource;
5710 wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
5711 "interface object already bound");
5715 struct desktop_shell *shell;
5716 struct weston_surface *current;
5717 struct wl_listener listener;
5718 struct weston_keyboard_grab grab;
5719 struct wl_array minimized_array;
5723 switcher_next(struct switcher *switcher)
5725 struct weston_view *view;
5726 struct weston_surface *first = NULL, *prev = NULL, *next = NULL;
5727 struct shell_surface *shsurf;
5728 struct workspace *ws = get_current_workspace(switcher->shell);
5730 /* temporary re-display minimized surfaces */
5731 struct weston_view *tmp;
5732 struct weston_view **minimized;
5733 wl_list_for_each_safe(view, tmp, &switcher->shell->minimized_layer.view_list.link, layer_link.link) {
5734 weston_layer_entry_remove(&view->layer_link);
5735 weston_layer_entry_insert(&ws->layer.view_list, &view->layer_link);
5736 minimized = wl_array_add(&switcher->minimized_array, sizeof *minimized);
5740 wl_list_for_each(view, &ws->layer.view_list.link, layer_link.link) {
5741 shsurf = get_shell_surface(view->surface);
5743 shsurf->type == SHELL_SURFACE_TOPLEVEL &&
5744 shsurf->parent == NULL) {
5746 first = view->surface;
5747 if (prev == switcher->current)
5748 next = view->surface;
5749 prev = view->surface;
5751 weston_view_geometry_dirty(view);
5752 weston_surface_damage(view->surface);
5755 if (is_black_surface(view->surface, NULL)) {
5757 weston_view_geometry_dirty(view);
5758 weston_surface_damage(view->surface);
5768 wl_list_remove(&switcher->listener.link);
5769 wl_signal_add(&next->destroy_signal, &switcher->listener);
5771 switcher->current = next;
5772 wl_list_for_each(view, &next->views, surface_link)
5775 shsurf = get_shell_surface(switcher->current);
5776 if (shsurf && shsurf->state.fullscreen)
5777 shsurf->fullscreen.black_view->alpha = 1.0;
5781 switcher_handle_surface_destroy(struct wl_listener *listener, void *data)
5783 struct switcher *switcher =
5784 container_of(listener, struct switcher, listener);
5786 switcher_next(switcher);
5790 switcher_destroy(struct switcher *switcher)
5792 struct weston_view *view;
5793 struct weston_keyboard *keyboard = switcher->grab.keyboard;
5794 struct workspace *ws = get_current_workspace(switcher->shell);
5796 wl_list_for_each(view, &ws->layer.view_list.link, layer_link.link) {
5797 if (is_focus_view(view))
5801 weston_surface_damage(view->surface);
5804 if (switcher->current)
5805 activate(switcher->shell, switcher->current,
5806 (struct weston_seat *) keyboard->seat, true);
5807 wl_list_remove(&switcher->listener.link);
5808 weston_keyboard_end_grab(keyboard);
5809 if (keyboard->input_method_resource)
5810 keyboard->grab = &keyboard->input_method_grab;
5812 /* re-hide surfaces that were temporary shown during the switch */
5813 struct weston_view **minimized;
5814 wl_array_for_each(minimized, &switcher->minimized_array) {
5815 /* with the exception of the current selected */
5816 if ((*minimized)->surface != switcher->current) {
5817 weston_layer_entry_remove(&(*minimized)->layer_link);
5818 weston_layer_entry_insert(&switcher->shell->minimized_layer.view_list, &(*minimized)->layer_link);
5819 weston_view_damage_below(*minimized);
5822 wl_array_release(&switcher->minimized_array);
5828 switcher_key(struct weston_keyboard_grab *grab,
5829 uint32_t time, uint32_t key, uint32_t state_w)
5831 struct switcher *switcher = container_of(grab, struct switcher, grab);
5832 enum wl_keyboard_key_state state = state_w;
5834 if (key == KEY_TAB && state == WL_KEYBOARD_KEY_STATE_PRESSED)
5835 switcher_next(switcher);
5839 switcher_modifier(struct weston_keyboard_grab *grab, uint32_t serial,
5840 uint32_t mods_depressed, uint32_t mods_latched,
5841 uint32_t mods_locked, uint32_t group)
5843 struct switcher *switcher = container_of(grab, struct switcher, grab);
5844 struct weston_seat *seat = (struct weston_seat *) grab->keyboard->seat;
5846 if ((seat->modifier_state & switcher->shell->binding_modifier) == 0)
5847 switcher_destroy(switcher);
5851 switcher_cancel(struct weston_keyboard_grab *grab)
5853 struct switcher *switcher = container_of(grab, struct switcher, grab);
5855 switcher_destroy(switcher);
5858 static const struct weston_keyboard_grab_interface switcher_grab = {
5865 switcher_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
5868 struct desktop_shell *shell = data;
5869 struct switcher *switcher;
5871 switcher = malloc(sizeof *switcher);
5872 switcher->shell = shell;
5873 switcher->current = NULL;
5874 switcher->listener.notify = switcher_handle_surface_destroy;
5875 wl_list_init(&switcher->listener.link);
5876 wl_array_init(&switcher->minimized_array);
5878 restore_all_output_modes(shell->compositor);
5879 lower_fullscreen_layer(switcher->shell);
5880 switcher->grab.interface = &switcher_grab;
5881 weston_keyboard_start_grab(seat->keyboard, &switcher->grab);
5882 weston_keyboard_set_focus(seat->keyboard, NULL);
5883 switcher_next(switcher);
5887 backlight_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
5890 struct weston_compositor *compositor = data;
5891 struct weston_output *output;
5892 long backlight_new = 0;
5894 /* TODO: we're limiting to simple use cases, where we assume just
5895 * control on the primary display. We'd have to extend later if we
5896 * ever get support for setting backlights on random desktop LCD
5898 output = get_default_output(compositor);
5902 if (!output->set_backlight)
5905 if (key == KEY_F9 || key == KEY_BRIGHTNESSDOWN)
5906 backlight_new = output->backlight_current - 25;
5907 else if (key == KEY_F10 || key == KEY_BRIGHTNESSUP)
5908 backlight_new = output->backlight_current + 25;
5910 if (backlight_new < 5)
5912 if (backlight_new > 255)
5913 backlight_new = 255;
5915 output->backlight_current = backlight_new;
5916 output->set_backlight(output, output->backlight_current);
5919 struct debug_binding_grab {
5920 struct weston_keyboard_grab grab;
5921 struct weston_seat *seat;
5923 int key_released[2];
5927 debug_binding_key(struct weston_keyboard_grab *grab, uint32_t time,
5928 uint32_t key, uint32_t state)
5930 struct debug_binding_grab *db = (struct debug_binding_grab *) grab;
5931 struct weston_compositor *ec = db->seat->compositor;
5932 struct wl_display *display = ec->wl_display;
5933 struct wl_resource *resource;
5935 int send = 0, terminate = 0;
5936 int check_binding = 1;
5938 struct wl_list *resource_list;
5940 if (state == WL_KEYBOARD_KEY_STATE_RELEASED) {
5941 /* Do not run bindings on key releases */
5944 for (i = 0; i < 2; i++)
5945 if (key == db->key[i])
5946 db->key_released[i] = 1;
5948 if (db->key_released[0] && db->key_released[1]) {
5949 /* All key releases been swalled so end the grab */
5951 } else if (key != db->key[0] && key != db->key[1]) {
5952 /* Should not swallow release of other keys */
5955 } else if (key == db->key[0] && !db->key_released[0]) {
5956 /* Do not check bindings for the first press of the binding
5957 * key. This allows it to be used as a debug shortcut.
5958 * We still need to swallow this event. */
5960 } else if (db->key[1]) {
5961 /* If we already ran a binding don't process another one since
5962 * we can't keep track of all the binding keys that were
5963 * pressed in order to swallow the release events. */
5968 if (check_binding) {
5969 if (weston_compositor_run_debug_binding(ec, db->seat, time,
5971 /* We ran a binding so swallow the press and keep the
5972 * grab to swallow the released too. */
5977 /* Terminate the grab since the key pressed is not a
5978 * debug binding key. */
5985 serial = wl_display_next_serial(display);
5986 resource_list = &grab->keyboard->focus_resource_list;
5987 wl_resource_for_each(resource, resource_list) {
5988 wl_keyboard_send_key(resource, serial, time, key, state);
5993 weston_keyboard_end_grab(grab->keyboard);
5994 if (grab->keyboard->input_method_resource)
5995 grab->keyboard->grab = &grab->keyboard->input_method_grab;
6001 debug_binding_modifiers(struct weston_keyboard_grab *grab, uint32_t serial,
6002 uint32_t mods_depressed, uint32_t mods_latched,
6003 uint32_t mods_locked, uint32_t group)
6005 struct wl_resource *resource;
6006 struct wl_list *resource_list;
6008 resource_list = &grab->keyboard->focus_resource_list;
6010 wl_resource_for_each(resource, resource_list) {
6011 wl_keyboard_send_modifiers(resource, serial, mods_depressed,
6012 mods_latched, mods_locked, group);
6017 debug_binding_cancel(struct weston_keyboard_grab *grab)
6019 struct debug_binding_grab *db = (struct debug_binding_grab *) grab;
6021 weston_keyboard_end_grab(grab->keyboard);
6025 struct weston_keyboard_grab_interface debug_binding_keyboard_grab = {
6027 debug_binding_modifiers,
6028 debug_binding_cancel,
6032 debug_binding(struct weston_seat *seat, uint32_t time, uint32_t key, void *data)
6034 struct debug_binding_grab *grab;
6036 grab = calloc(1, sizeof *grab);
6040 grab->seat = (struct weston_seat *) seat;
6042 grab->grab.interface = &debug_binding_keyboard_grab;
6043 weston_keyboard_start_grab(seat->keyboard, &grab->grab);
6047 force_kill_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
6050 struct weston_surface *focus_surface;
6051 struct wl_client *client;
6052 struct desktop_shell *shell = data;
6053 struct weston_compositor *compositor = shell->compositor;
6056 focus_surface = seat->keyboard->focus;
6060 wl_signal_emit(&compositor->kill_signal, focus_surface);
6062 client = wl_resource_get_client(focus_surface->resource);
6063 wl_client_get_credentials(client, &pid, NULL, NULL);
6065 /* Skip clients that we launched ourselves (the credentials of
6066 * the socketpair is ours) */
6067 if (pid == getpid())
6074 workspace_up_binding(struct weston_seat *seat, uint32_t time,
6075 uint32_t key, void *data)
6077 struct desktop_shell *shell = data;
6078 unsigned int new_index = shell->workspaces.current;
6085 change_workspace(shell, new_index);
6089 workspace_down_binding(struct weston_seat *seat, uint32_t time,
6090 uint32_t key, void *data)
6092 struct desktop_shell *shell = data;
6093 unsigned int new_index = shell->workspaces.current;
6097 if (new_index < shell->workspaces.num - 1)
6100 change_workspace(shell, new_index);
6104 workspace_f_binding(struct weston_seat *seat, uint32_t time,
6105 uint32_t key, void *data)
6107 struct desktop_shell *shell = data;
6108 unsigned int new_index;
6112 new_index = key - KEY_F1;
6113 if (new_index >= shell->workspaces.num)
6114 new_index = shell->workspaces.num - 1;
6116 change_workspace(shell, new_index);
6120 workspace_move_surface_up_binding(struct weston_seat *seat, uint32_t time,
6121 uint32_t key, void *data)
6123 struct desktop_shell *shell = data;
6124 unsigned int new_index = shell->workspaces.current;
6132 take_surface_to_workspace_by_seat(shell, seat, new_index);
6136 workspace_move_surface_down_binding(struct weston_seat *seat, uint32_t time,
6137 uint32_t key, void *data)
6139 struct desktop_shell *shell = data;
6140 unsigned int new_index = shell->workspaces.current;
6145 if (new_index < shell->workspaces.num - 1)
6148 take_surface_to_workspace_by_seat(shell, seat, new_index);
6152 shell_reposition_view_on_output_destroy(struct weston_view *view)
6154 struct weston_output *output, *first_output;
6155 struct weston_compositor *ec = view->surface->compositor;
6156 struct shell_surface *shsurf;
6160 x = view->geometry.x;
6161 y = view->geometry.y;
6163 /* At this point the destroyed output is not in the list anymore.
6164 * If the view is still visible somewhere, we leave where it is,
6165 * otherwise, move it to the first output. */
6167 wl_list_for_each(output, &ec->output_list, link) {
6168 if (pixman_region32_contains_point(&output->region,
6176 first_output = container_of(ec->output_list.next,
6177 struct weston_output, link);
6179 x = first_output->x + first_output->width / 4;
6180 y = first_output->y + first_output->height / 4;
6182 weston_view_set_position(view, x, y);
6184 weston_view_geometry_dirty(view);
6188 shsurf = get_shell_surface(view->surface);
6191 shsurf->saved_position_valid = false;
6192 shsurf->next_state.maximized = false;
6193 shsurf->next_state.fullscreen = false;
6194 shsurf->state_changed = true;
6199 shell_for_each_layer(struct desktop_shell *shell,
6200 shell_for_each_layer_func_t func, void *data)
6202 struct workspace **ws;
6204 func(shell, &shell->fullscreen_layer, data);
6205 func(shell, &shell->panel_layer, data);
6206 func(shell, &shell->background_layer, data);
6207 func(shell, &shell->lock_layer, data);
6208 func(shell, &shell->input_panel_layer, data);
6210 wl_array_for_each(ws, &shell->workspaces.array)
6211 func(shell, &(*ws)->layer, data);
6215 shell_output_destroy_move_layer(struct desktop_shell *shell,
6216 struct weston_layer *layer,
6219 struct weston_output *output = data;
6220 struct weston_view *view;
6222 wl_list_for_each(view, &layer->view_list.link, layer_link.link) {
6223 if (view->output != output)
6226 shell_reposition_view_on_output_destroy(view);
6231 handle_output_destroy(struct wl_listener *listener, void *data)
6233 struct shell_output *output_listener =
6234 container_of(listener, struct shell_output, destroy_listener);
6235 struct weston_output *output = output_listener->output;
6236 struct desktop_shell *shell = output_listener->shell;
6238 shell_for_each_layer(shell, shell_output_destroy_move_layer, output);
6240 wl_list_remove(&output_listener->destroy_listener.link);
6241 wl_list_remove(&output_listener->link);
6242 free(output_listener);
6246 create_shell_output(struct desktop_shell *shell,
6247 struct weston_output *output)
6249 struct shell_output *shell_output;
6251 shell_output = zalloc(sizeof *shell_output);
6252 if (shell_output == NULL)
6255 shell_output->output = output;
6256 shell_output->shell = shell;
6257 shell_output->destroy_listener.notify = handle_output_destroy;
6258 wl_signal_add(&output->destroy_signal,
6259 &shell_output->destroy_listener);
6260 wl_list_insert(shell->output_list.prev, &shell_output->link);
6264 handle_output_create(struct wl_listener *listener, void *data)
6266 struct desktop_shell *shell =
6267 container_of(listener, struct desktop_shell, output_create_listener);
6268 struct weston_output *output = (struct weston_output *)data;
6270 create_shell_output(shell, output);
6274 handle_output_move_layer(struct desktop_shell *shell,
6275 struct weston_layer *layer, void *data)
6277 struct weston_output *output = data;
6278 struct weston_view *view;
6281 wl_list_for_each(view, &layer->view_list.link, layer_link.link) {
6282 if (view->output != output)
6285 x = view->geometry.x + output->move_x;
6286 y = view->geometry.y + output->move_y;
6287 weston_view_set_position(view, x, y);
6292 handle_output_move(struct wl_listener *listener, void *data)
6294 struct desktop_shell *shell;
6296 shell = container_of(listener, struct desktop_shell,
6297 output_move_listener);
6299 shell_for_each_layer(shell, handle_output_move_layer, data);
6303 setup_output_destroy_handler(struct weston_compositor *ec,
6304 struct desktop_shell *shell)
6306 struct weston_output *output;
6308 wl_list_init(&shell->output_list);
6309 wl_list_for_each(output, &ec->output_list, link)
6310 create_shell_output(shell, output);
6312 shell->output_create_listener.notify = handle_output_create;
6313 wl_signal_add(&ec->output_created_signal,
6314 &shell->output_create_listener);
6316 shell->output_move_listener.notify = handle_output_move;
6317 wl_signal_add(&ec->output_moved_signal, &shell->output_move_listener);
6321 shell_destroy(struct wl_listener *listener, void *data)
6323 struct desktop_shell *shell =
6324 container_of(listener, struct desktop_shell, destroy_listener);
6325 struct workspace **ws;
6326 struct shell_output *shell_output, *tmp;
6328 /* Force state to unlocked so we don't try to fade */
6329 shell->locked = false;
6331 if (shell->child.client) {
6332 /* disable respawn */
6333 wl_list_remove(&shell->child.client_destroy_listener.link);
6334 wl_client_destroy(shell->child.client);
6337 wl_list_remove(&shell->idle_listener.link);
6338 wl_list_remove(&shell->wake_listener.link);
6340 input_panel_destroy(shell);
6342 wl_list_for_each_safe(shell_output, tmp, &shell->output_list, link) {
6343 wl_list_remove(&shell_output->destroy_listener.link);
6344 wl_list_remove(&shell_output->link);
6348 wl_list_remove(&shell->output_create_listener.link);
6349 wl_list_remove(&shell->output_move_listener.link);
6351 wl_array_for_each(ws, &shell->workspaces.array)
6352 workspace_destroy(*ws);
6353 wl_array_release(&shell->workspaces.array);
6355 free(shell->screensaver.path);
6356 free(shell->client);
6361 shell_add_bindings(struct weston_compositor *ec, struct desktop_shell *shell)
6364 int i, num_workspace_bindings;
6366 /* fixed bindings */
6367 weston_compositor_add_key_binding(ec, KEY_BACKSPACE,
6368 MODIFIER_CTRL | MODIFIER_ALT,
6369 terminate_binding, ec);
6370 weston_compositor_add_button_binding(ec, BTN_LEFT, 0,
6371 click_to_activate_binding,
6373 weston_compositor_add_button_binding(ec, BTN_RIGHT, 0,
6374 click_to_activate_binding,
6376 weston_compositor_add_touch_binding(ec, 0,
6377 touch_to_activate_binding,
6379 weston_compositor_add_axis_binding(ec, WL_POINTER_AXIS_VERTICAL_SCROLL,
6380 MODIFIER_SUPER | MODIFIER_ALT,
6381 surface_opacity_binding, NULL);
6382 weston_compositor_add_axis_binding(ec, WL_POINTER_AXIS_VERTICAL_SCROLL,
6383 MODIFIER_SUPER, zoom_axis_binding,
6386 /* configurable bindings */
6387 mod = shell->binding_modifier;
6388 weston_compositor_add_key_binding(ec, KEY_PAGEUP, mod,
6389 zoom_key_binding, NULL);
6390 weston_compositor_add_key_binding(ec, KEY_PAGEDOWN, mod,
6391 zoom_key_binding, NULL);
6392 weston_compositor_add_key_binding(ec, KEY_M, mod | MODIFIER_SHIFT,
6393 maximize_binding, NULL);
6394 weston_compositor_add_key_binding(ec, KEY_F, mod | MODIFIER_SHIFT,
6395 fullscreen_binding, NULL);
6396 weston_compositor_add_button_binding(ec, BTN_LEFT, mod, move_binding,
6398 weston_compositor_add_touch_binding(ec, mod, touch_move_binding, shell);
6399 weston_compositor_add_button_binding(ec, BTN_MIDDLE, mod,
6400 resize_binding, shell);
6401 weston_compositor_add_button_binding(ec, BTN_LEFT,
6402 mod | MODIFIER_SHIFT,
6403 resize_binding, shell);
6405 if (ec->capabilities & WESTON_CAP_ROTATION_ANY)
6406 weston_compositor_add_button_binding(ec, BTN_RIGHT, mod,
6407 rotate_binding, NULL);
6409 weston_compositor_add_key_binding(ec, KEY_TAB, mod, switcher_binding,
6411 weston_compositor_add_key_binding(ec, KEY_F9, mod, backlight_binding,
6413 weston_compositor_add_key_binding(ec, KEY_BRIGHTNESSDOWN, 0,
6414 backlight_binding, ec);
6415 weston_compositor_add_key_binding(ec, KEY_F10, mod, backlight_binding,
6417 weston_compositor_add_key_binding(ec, KEY_BRIGHTNESSUP, 0,
6418 backlight_binding, ec);
6419 weston_compositor_add_key_binding(ec, KEY_K, mod,
6420 force_kill_binding, shell);
6421 weston_compositor_add_key_binding(ec, KEY_UP, mod,
6422 workspace_up_binding, shell);
6423 weston_compositor_add_key_binding(ec, KEY_DOWN, mod,
6424 workspace_down_binding, shell);
6425 weston_compositor_add_key_binding(ec, KEY_UP, mod | MODIFIER_SHIFT,
6426 workspace_move_surface_up_binding,
6428 weston_compositor_add_key_binding(ec, KEY_DOWN, mod | MODIFIER_SHIFT,
6429 workspace_move_surface_down_binding,
6432 if (shell->exposay_modifier)
6433 weston_compositor_add_modifier_binding(ec, shell->exposay_modifier,
6434 exposay_binding, shell);
6436 /* Add bindings for mod+F[1-6] for workspace 1 to 6. */
6437 if (shell->workspaces.num > 1) {
6438 num_workspace_bindings = shell->workspaces.num;
6439 if (num_workspace_bindings > 6)
6440 num_workspace_bindings = 6;
6441 for (i = 0; i < num_workspace_bindings; i++)
6442 weston_compositor_add_key_binding(ec, KEY_F1 + i, mod,
6443 workspace_f_binding,
6447 /* Debug bindings */
6448 weston_compositor_add_key_binding(ec, KEY_SPACE, mod | MODIFIER_SHIFT,
6449 debug_binding, shell);
6453 handle_seat_created(struct wl_listener *listener, void *data)
6455 struct weston_seat *seat = data;
6457 create_shell_seat(seat);
6461 module_init(struct weston_compositor *ec,
6462 int *argc, char *argv[])
6464 struct weston_seat *seat;
6465 struct desktop_shell *shell;
6466 struct workspace **pws;
6468 struct wl_event_loop *loop;
6470 shell = zalloc(sizeof *shell);
6474 shell->compositor = ec;
6476 shell->destroy_listener.notify = shell_destroy;
6477 wl_signal_add(&ec->destroy_signal, &shell->destroy_listener);
6478 shell->idle_listener.notify = idle_handler;
6479 wl_signal_add(&ec->idle_signal, &shell->idle_listener);
6480 shell->wake_listener.notify = wake_handler;
6481 wl_signal_add(&ec->wake_signal, &shell->wake_listener);
6483 ec->shell_interface.shell = shell;
6484 ec->shell_interface.create_shell_surface = create_shell_surface;
6485 ec->shell_interface.get_primary_view = get_primary_view;
6486 ec->shell_interface.set_toplevel = set_toplevel;
6487 ec->shell_interface.set_transient = set_transient;
6488 ec->shell_interface.set_fullscreen = shell_interface_set_fullscreen;
6489 ec->shell_interface.set_xwayland = set_xwayland;
6490 ec->shell_interface.move = shell_interface_move;
6491 ec->shell_interface.resize = surface_resize;
6492 ec->shell_interface.set_title = set_title;
6493 ec->shell_interface.set_window_geometry = set_window_geometry;
6495 weston_layer_init(&shell->fullscreen_layer, &ec->cursor_layer.link);
6496 weston_layer_init(&shell->panel_layer, &shell->fullscreen_layer.link);
6497 weston_layer_init(&shell->background_layer, &shell->panel_layer.link);
6498 weston_layer_init(&shell->lock_layer, NULL);
6499 weston_layer_init(&shell->input_panel_layer, NULL);
6501 wl_array_init(&shell->workspaces.array);
6502 wl_list_init(&shell->workspaces.client_list);
6504 if (input_panel_setup(shell) < 0)
6507 shell_configuration(shell);
6509 shell->exposay.state_cur = EXPOSAY_LAYOUT_INACTIVE;
6510 shell->exposay.state_target = EXPOSAY_TARGET_CANCEL;
6512 for (i = 0; i < shell->workspaces.num; i++) {
6513 pws = wl_array_add(&shell->workspaces.array, sizeof *pws);
6517 *pws = workspace_create();
6521 activate_workspace(shell, 0);
6523 weston_layer_init(&shell->minimized_layer, NULL);
6525 wl_list_init(&shell->workspaces.anim_sticky_list);
6526 wl_list_init(&shell->workspaces.animation.link);
6527 shell->workspaces.animation.frame = animate_workspace_change_frame;
6529 if (wl_global_create(ec->wl_display, &wl_shell_interface, 1,
6530 shell, bind_shell) == NULL)
6533 if (wl_global_create(ec->wl_display, &xdg_shell_interface, 1,
6534 shell, bind_xdg_shell) == NULL)
6537 if (wl_global_create(ec->wl_display,
6538 &desktop_shell_interface, 3,
6539 shell, bind_desktop_shell) == NULL)
6542 if (wl_global_create(ec->wl_display, &screensaver_interface, 1,
6543 shell, bind_screensaver) == NULL)
6546 if (wl_global_create(ec->wl_display, &workspace_manager_interface, 1,
6547 shell, bind_workspace_manager) == NULL)
6550 shell->child.deathstamp = weston_compositor_get_time();
6552 shell->panel_position = DESKTOP_SHELL_PANEL_POSITION_TOP;
6554 setup_output_destroy_handler(ec, shell);
6556 loop = wl_display_get_event_loop(ec->wl_display);
6557 wl_event_loop_add_idle(loop, launch_desktop_shell_process, shell);
6559 shell->screensaver.timer =
6560 wl_event_loop_add_timer(loop, screensaver_timeout, shell);
6562 wl_list_for_each(seat, &ec->seat_list, link)
6563 handle_seat_created(NULL, seat);
6564 shell->seat_create_listener.notify = handle_seat_created;
6565 wl_signal_add(&ec->seat_created_signal, &shell->seat_create_listener);
6567 screenshooter_create(ec);
6569 shell_add_bindings(ec, shell);
6571 shell_fade_init(shell);
6573 clock_gettime(CLOCK_MONOTONIC, &shell->startup_time);