src/shell.c

   1 /*
   2  * Copyright © 2010-2012 Intel Corporation
   3  * Copyright © 2011-2012 Collabora, Ltd.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and
   6  * its documentation for any purpose is hereby granted without fee, provided
   7  * that the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of the copyright holders not be used in
  10  * advertising or publicity pertaining to distribution of the software
  11  * without specific, written prior permission.  The copyright holders make
  12  * no representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  18  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  20  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <stdbool.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <linux/input.h>
  30 #include <assert.h>
  31 #include <signal.h>
  32 #include <math.h>
  33 #include <sys/types.h>
  34
  35 #include <wayland-server.h>
  36 #include "compositor.h"
  37 #include "desktop-shell-server-protocol.h"
  38 #include "../shared/config-parser.h"
  39
  40 #define DEFAULT_NUM_WORKSPACES 1
  41 #define DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH 200
  42
  43 enum animation_type {
  44         ANIMATION_NONE,
  45
  46         ANIMATION_ZOOM,
  47         ANIMATION_FADE
  48 };
  49
  50 struct focus_state {
  51         struct weston_seat *seat;
  52         struct workspace *ws;
  53         struct weston_surface *keyboard_focus;
  54         struct wl_list link;
  55         struct wl_listener seat_destroy_listener;
  56         struct wl_listener surface_destroy_listener;
  57 };
  58
  59 struct workspace {
  60         struct weston_layer layer;
  61
  62         struct wl_list focus_list;
  63         struct wl_listener seat_destroyed_listener;
  64 };
  65
  66 struct input_panel_surface {
  67         struct wl_list link;
  68         struct weston_surface *surface;
  69         struct wl_listener listener;
  70 };
  71
  72 struct desktop_shell {
  73         struct weston_compositor *compositor;
  74
  75         struct wl_listener lock_listener;
  76         struct wl_listener unlock_listener;
  77         struct wl_listener destroy_listener;
  78         struct wl_listener show_input_panel_listener;
  79         struct wl_listener hide_input_panel_listener;
  80
  81         struct weston_layer fullscreen_layer;
  82         struct weston_layer panel_layer;
  83         struct weston_layer background_layer;
  84         struct weston_layer lock_layer;
  85         struct weston_layer input_panel_layer;
  86
  87         struct wl_listener pointer_focus_listener;
  88         struct weston_surface *grab_surface;
  89
  90         struct {
  91                 struct weston_process process;
  92                 struct wl_client *client;
  93                 struct wl_resource *desktop_shell;
  94
  95                 unsigned deathcount;
  96                 uint32_t deathstamp;
  97         } child;
  98
  99         bool locked;
 100         bool showing_input_panels;
 101         bool prepare_event_sent;
 102
 103         struct weston_surface *lock_surface;
 104         struct wl_listener lock_surface_listener;
 105
 106         struct {
 107                 struct wl_array array;
 108                 unsigned int current;
 109                 unsigned int num;
 110
 111                 struct weston_animation animation;
 112                 int anim_dir;
 113                 uint32_t anim_timestamp;
 114                 double anim_current;
 115                 struct workspace *anim_from;
 116                 struct workspace *anim_to;
 117         } workspaces;
 118
 119         struct {
 120                 char *path;
 121                 int duration;
 122                 struct wl_resource *binding;
 123                 struct wl_list surfaces;
 124                 struct weston_process process;
 125         } screensaver;
 126
 127         struct {
 128                 struct wl_resource *binding;
 129                 struct wl_list surfaces;
 130         } input_panel;
 131
 132         uint32_t binding_modifier;
 133         enum animation_type win_animation_type;
 134         struct weston_surface *debug_repaint_surface;
 135 };
 136
 137 enum shell_surface_type {
 138         SHELL_SURFACE_NONE,
 139         SHELL_SURFACE_TOPLEVEL,
 140         SHELL_SURFACE_TRANSIENT,
 141         SHELL_SURFACE_FULLSCREEN,
 142         SHELL_SURFACE_MAXIMIZED,
 143         SHELL_SURFACE_POPUP
 144 };
 145
 146 struct ping_timer {
 147         struct wl_event_source *source;
 148         uint32_t serial;
 149 };
 150
 151 struct shell_surface {
 152         struct wl_resource resource;
 153
 154         struct weston_surface *surface;
 155         struct wl_listener surface_destroy_listener;
 156         struct weston_surface *parent;
 157         struct desktop_shell *shell;
 158
 159         enum shell_surface_type type, next_type;
 160         char *title, *class;
 161         int32_t saved_x, saved_y;
 162         bool saved_position_valid;
 163         bool saved_rotation_valid;
 164         int unresponsive;
 165
 166         struct {
 167                 struct weston_transform transform;
 168                 struct weston_matrix rotation;
 169         } rotation;
 170
 171         struct {
 172                 struct wl_pointer_grab grab;
 173                 int32_t x, y;
 174                 struct weston_transform parent_transform;
 175                 int32_t initial_up;
 176                 struct wl_seat *seat;
 177                 uint32_t serial;
 178         } popup;
 179
 180         struct {
 181                 int32_t x, y;
 182                 uint32_t flags;
 183         } transient;
 184
 185         struct {
 186                 enum wl_shell_surface_fullscreen_method type;
 187                 struct weston_transform transform; /* matrix from x, y */
 188                 uint32_t framerate;
 189                 struct weston_surface *black_surface;
 190         } fullscreen;
 191
 192         struct ping_timer *ping_timer;
 193
 194         struct weston_transform workspace_transform;
 195
 196         struct weston_output *fullscreen_output;
 197         struct weston_output *output;
 198         struct wl_list link;
 199
 200         const struct weston_shell_client *client;
 201 };
 202
 203 struct shell_grab {
 204         struct wl_pointer_grab grab;
 205         struct shell_surface *shsurf;
 206         struct wl_listener shsurf_destroy_listener;
 207         struct wl_pointer *pointer;
 208 };
 209
 210 struct weston_move_grab {
 211         struct shell_grab base;
 212         wl_fixed_t dx, dy;
 213 };
 214
 215 struct rotate_grab {
 216         struct shell_grab base;
 217         struct weston_matrix rotation;
 218         struct {
 219                 GLfloat x;
 220                 GLfloat y;
 221         } center;
 222 };
 223
 224 static void
 225 activate(struct desktop_shell *shell, struct weston_surface *es,
 226          struct weston_seat *seat);
 227
 228 static struct workspace *
 229 get_current_workspace(struct desktop_shell *shell);
 230
 231 static struct shell_surface *
 232 get_shell_surface(struct weston_surface *surface);
 233
 234 static struct desktop_shell *
 235 shell_surface_get_shell(struct shell_surface *shsurf);
 236
 237 static bool
 238 shell_surface_is_top_fullscreen(struct shell_surface *shsurf)
 239 {
 240         struct desktop_shell *shell;
 241         struct weston_surface *top_fs_es;
 242
 243         shell = shell_surface_get_shell(shsurf);
 244
 245         if (wl_list_empty(&shell->fullscreen_layer.surface_list))
 246                 return false;
 247
 248         top_fs_es = container_of(shell->fullscreen_layer.surface_list.next,
 249                                  struct weston_surface,
 250                                  layer_link);
 251         return (shsurf == get_shell_surface(top_fs_es));
 252 }
 253
 254 static void
 255 destroy_shell_grab_shsurf(struct wl_listener *listener, void *data)
 256 {
 257         struct shell_grab *grab;
 258
 259         grab = container_of(listener, struct shell_grab,
 260                             shsurf_destroy_listener);
 261
 262         grab->shsurf = NULL;
 263 }
 264
 265 static void
 266 shell_grab_start(struct shell_grab *grab,
 267                  const struct wl_pointer_grab_interface *interface,
 268                  struct shell_surface *shsurf,
 269                  struct wl_pointer *pointer,
 270                  enum desktop_shell_cursor cursor)
 271 {
 272         struct desktop_shell *shell = shsurf->shell;
 273
 274         grab->grab.interface = interface;
 275         grab->shsurf = shsurf;
 276         grab->shsurf_destroy_listener.notify = destroy_shell_grab_shsurf;
 277         wl_signal_add(&shsurf->resource.destroy_signal,
 278                       &grab->shsurf_destroy_listener);
 279
 280         grab->pointer = pointer;
 281         grab->grab.focus = &shsurf->surface->surface;
 282
 283         wl_pointer_start_grab(pointer, &grab->grab);
 284         desktop_shell_send_grab_cursor(shell->child.desktop_shell, cursor);
 285         wl_pointer_set_focus(pointer, &shell->grab_surface->surface,
 286                              wl_fixed_from_int(0), wl_fixed_from_int(0));
 287 }
 288
 289 static void
 290 shell_grab_end(struct shell_grab *grab)
 291 {
 292         if (grab->shsurf)
 293                 wl_list_remove(&grab->shsurf_destroy_listener.link);
 294
 295         wl_pointer_end_grab(grab->pointer);
 296 }
 297
 298 static void
 299 center_on_output(struct weston_surface *surface,
 300                  struct weston_output *output);
 301
 302 static enum weston_keyboard_modifier
 303 get_modifier(char *modifier)
 304 {
 305         if (!modifier)
 306                 return MODIFIER_SUPER;
 307
 308         if (!strcmp("ctrl", modifier))
 309                 return MODIFIER_CTRL;
 310         else if (!strcmp("alt", modifier))
 311                 return MODIFIER_ALT;
 312         else if (!strcmp("super", modifier))
 313                 return MODIFIER_SUPER;
 314         else
 315                 return MODIFIER_SUPER;
 316 }
 317
 318 static enum animation_type
 319 get_animation_type(char *animation)
 320 {
 321         if (!animation)
 322                 return ANIMATION_NONE;
 323
 324         if (!strcmp("zoom", animation))
 325                 return ANIMATION_ZOOM;
 326         else if (!strcmp("fade", animation))
 327                 return ANIMATION_FADE;
 328         else
 329                 return ANIMATION_NONE;
 330 }
 331
 332 static void
 333 shell_configuration(struct desktop_shell *shell)
 334 {
 335         char *config_file;
 336         char *path = NULL;
 337         int duration = 60;
 338         unsigned int num_workspaces = DEFAULT_NUM_WORKSPACES;
 339         char *modifier = NULL;
 340         char *win_animation = NULL;
 341
 342         struct config_key shell_keys[] = {
 343                 { "binding-modifier",   CONFIG_KEY_STRING, &modifier },
 344                 { "animation",          CONFIG_KEY_STRING, &win_animation},
 345                 { "num-workspaces",
 346                         CONFIG_KEY_UNSIGNED_INTEGER, &num_workspaces },
 347         };
 348
 349         struct config_key saver_keys[] = {
 350                 { "path",       CONFIG_KEY_STRING,  &path },
 351                 { "duration",   CONFIG_KEY_INTEGER, &duration },
 352         };
 353
 354         struct config_section cs[] = {
 355                 { "shell", shell_keys, ARRAY_LENGTH(shell_keys), NULL },
 356                 { "screensaver", saver_keys, ARRAY_LENGTH(saver_keys), NULL },
 357         };
 358
 359         config_file = config_file_path("weston.ini");
 360         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
 361         free(config_file);
 362
 363         shell->screensaver.path = path;
 364         shell->screensaver.duration = duration;
 365         shell->binding_modifier = get_modifier(modifier);
 366         shell->win_animation_type = get_animation_type(win_animation);
 367         shell->workspaces.num = num_workspaces > 0 ? num_workspaces : 1;
 368 }
 369
 370 static void
 371 focus_state_destroy(struct focus_state *state)
 372 {
 373         wl_list_remove(&state->seat_destroy_listener.link);
 374         wl_list_remove(&state->surface_destroy_listener.link);
 375         free(state);
 376 }
 377
 378 static void
 379 focus_state_seat_destroy(struct wl_listener *listener, void *data)
 380 {
 381         struct focus_state *state = container_of(listener,
 382                                                  struct focus_state,
 383                                                  seat_destroy_listener);
 384
 385         wl_list_remove(&state->link);
 386         focus_state_destroy(state);
 387 }
 388
 389 static void
 390 focus_state_surface_destroy(struct wl_listener *listener, void *data)
 391 {
 392         struct focus_state *state = container_of(listener,
 393                                                  struct focus_state,
 394                                                  surface_destroy_listener);
 395         struct desktop_shell *shell;
 396         struct weston_surface *surface, *next;
 397
 398         next = NULL;
 399         wl_list_for_each(surface, &state->ws->layer.surface_list, layer_link) {
 400                 if (surface == state->keyboard_focus)
 401                         continue;
 402
 403                 next = surface;
 404                 break;
 405         }
 406
 407         if (next) {
 408                 shell = state->seat->compositor->shell_interface.shell;
 409                 activate(shell, next, state->seat);
 410         } else {
 411                 wl_list_remove(&state->link);
 412                 focus_state_destroy(state);
 413         }
 414 }
 415
 416 static struct focus_state *
 417 focus_state_create(struct weston_seat *seat, struct workspace *ws)
 418 {
 419         struct focus_state *state;
 420
 421         state = malloc(sizeof *state);
 422         if (state == NULL)
 423                 return NULL;
 424
 425         state->ws = ws;
 426         state->seat = seat;
 427         wl_list_insert(&ws->focus_list, &state->link);
 428
 429         state->seat_destroy_listener.notify = focus_state_seat_destroy;
 430         state->surface_destroy_listener.notify = focus_state_surface_destroy;
 431         wl_signal_add(&seat->seat.destroy_signal,
 432                       &state->seat_destroy_listener);
 433         wl_list_init(&state->surface_destroy_listener.link);
 434
 435         return state;
 436 }
 437
 438 static void
 439 restore_focus_state(struct desktop_shell *shell, struct workspace *ws)
 440 {
 441         struct focus_state *state, *next;
 442
 443         wl_list_for_each_safe(state, next, &ws->focus_list, link) {
 444                 if (state->keyboard_focus)
 445                         wl_keyboard_set_focus(state->seat->seat.keyboard,
 446                                               &state->keyboard_focus->surface);
 447         }
 448 }
 449
 450 static void
 451 workspace_destroy(struct workspace *ws)
 452 {
 453         struct focus_state *state, *next;
 454
 455         wl_list_for_each_safe(state, next, &ws->focus_list, link)
 456                 focus_state_destroy(state);
 457
 458         free(ws);
 459 }
 460
 461 static void
 462 seat_destroyed(struct wl_listener *listener, void *data)
 463 {
 464         struct weston_seat *seat = data;
 465         struct focus_state *state, *next;
 466         struct workspace *ws = container_of(listener,
 467                                             struct workspace,
 468                                             seat_destroyed_listener);
 469
 470         wl_list_for_each_safe(state, next, &ws->focus_list, link)
 471                 if (state->seat == seat)
 472                         wl_list_remove(&state->link);
 473 }
 474
 475 static struct workspace *
 476 workspace_create(void)
 477 {
 478         struct workspace *ws = malloc(sizeof *ws);
 479         if (ws == NULL)
 480                 return NULL;
 481
 482         weston_layer_init(&ws->layer, NULL);
 483
 484         wl_list_init(&ws->focus_list);
 485         wl_list_init(&ws->seat_destroyed_listener.link);
 486         ws->seat_destroyed_listener.notify = seat_destroyed;
 487
 488         return ws;
 489 }
 490
 491 static int
 492 workspace_is_empty(struct workspace *ws)
 493 {
 494         return wl_list_empty(&ws->layer.surface_list);
 495 }
 496
 497 static struct workspace *
 498 get_workspace(struct desktop_shell *shell, unsigned int index)
 499 {
 500         struct workspace **pws = shell->workspaces.array.data;
 501         pws += index;
 502         return *pws;
 503 }
 504
 505 static struct workspace *
 506 get_current_workspace(struct desktop_shell *shell)
 507 {
 508         return get_workspace(shell, shell->workspaces.current);
 509 }
 510
 511 static void
 512 activate_workspace(struct desktop_shell *shell, unsigned int index)
 513 {
 514         struct workspace *ws;
 515
 516         ws = get_workspace(shell, index);
 517         wl_list_insert(&shell->panel_layer.link, &ws->layer.link);
 518
 519         shell->workspaces.current = index;
 520 }
 521
 522 static unsigned int
 523 get_output_height(struct weston_output *output)
 524 {
 525         return abs(output->region.extents.y1 - output->region.extents.y2);
 526 }
 527
 528 static void
 529 surface_translate(struct weston_surface *surface, double d)
 530 {
 531         struct shell_surface *shsurf = get_shell_surface(surface);
 532         struct weston_transform *transform;
 533
 534         transform = &shsurf->workspace_transform;
 535         if (wl_list_empty(&transform->link))
 536                 wl_list_insert(surface->geometry.transformation_list.prev,
 537                                &shsurf->workspace_transform.link);
 538
 539         weston_matrix_init(&shsurf->workspace_transform.matrix);
 540         weston_matrix_translate(&shsurf->workspace_transform.matrix,
 541                                 0.0, d, 0.0);
 542         surface->geometry.dirty = 1;
 543 }
 544
 545 static void
 546 workspace_translate_out(struct workspace *ws, double fraction)
 547 {
 548         struct weston_surface *surface;
 549         unsigned int height;
 550         double d;
 551
 552         wl_list_for_each(surface, &ws->layer.surface_list, layer_link) {
 553                 height = get_output_height(surface->output);
 554                 d = height * fraction;
 555
 556                 surface_translate(surface, d);
 557         }
 558 }
 559
 560 static void
 561 workspace_translate_in(struct workspace *ws, double fraction)
 562 {
 563         struct weston_surface *surface;
 564         unsigned int height;
 565         double d;
 566
 567         wl_list_for_each(surface, &ws->layer.surface_list, layer_link) {
 568                 height = get_output_height(surface->output);
 569
 570                 if (fraction > 0)
 571                         d = -(height - height * fraction);
 572                 else
 573                         d = height + height * fraction;
 574
 575                 surface_translate(surface, d);
 576         }
 577 }
 578
 579 static void
 580 reverse_workspace_change_animation(struct desktop_shell *shell,
 581                                    unsigned int index,
 582                                    struct workspace *from,
 583                                    struct workspace *to)
 584 {
 585         shell->workspaces.current = index;
 586
 587         shell->workspaces.anim_to = to;
 588         shell->workspaces.anim_from = from;
 589         shell->workspaces.anim_dir = -1 * shell->workspaces.anim_dir;
 590         shell->workspaces.anim_timestamp = 0;
 591
 592         restore_focus_state(shell, to);
 593
 594         weston_compositor_schedule_repaint(shell->compositor);
 595 }
 596
 597 static void
 598 workspace_deactivate_transforms(struct workspace *ws)
 599 {
 600         struct weston_surface *surface;
 601         struct shell_surface *shsurf;
 602
 603         wl_list_for_each(surface, &ws->layer.surface_list, layer_link) {
 604                 shsurf = get_shell_surface(surface);
 605                 wl_list_remove(&shsurf->workspace_transform.link);
 606                 wl_list_init(&shsurf->workspace_transform.link);
 607                 shsurf->surface->geometry.dirty = 1;
 608         }
 609 }
 610
 611 static void
 612 finish_workspace_change_animation(struct desktop_shell *shell,
 613                                   struct workspace *from,
 614                                   struct workspace *to)
 615 {
 616         weston_compositor_schedule_repaint(shell->compositor);
 617
 618         wl_list_remove(&shell->workspaces.animation.link);
 619         workspace_deactivate_transforms(from);
 620         workspace_deactivate_transforms(to);
 621         shell->workspaces.anim_to = NULL;
 622
 623         wl_list_remove(&shell->workspaces.anim_from->layer.link);
 624 }
 625
 626 static void
 627 animate_workspace_change_frame(struct weston_animation *animation,
 628                                struct weston_output *output, uint32_t msecs)
 629 {
 630         struct desktop_shell *shell =
 631                 container_of(animation, struct desktop_shell,
 632                              workspaces.animation);
 633         struct workspace *from = shell->workspaces.anim_from;
 634         struct workspace *to = shell->workspaces.anim_to;
 635         uint32_t t;
 636         double x, y;
 637
 638         if (workspace_is_empty(from) && workspace_is_empty(to)) {
 639                 finish_workspace_change_animation(shell, from, to);
 640                 return;
 641         }
 642
 643         if (shell->workspaces.anim_timestamp == 0) {
 644                 if (shell->workspaces.anim_current == 0.0)
 645                         shell->workspaces.anim_timestamp = msecs;
 646                 else
 647                         shell->workspaces.anim_timestamp =
 648                                 msecs -
 649                                 /* Invers of movement function 'y' below. */
 650                                 (asin(1.0 - shell->workspaces.anim_current) *
 651                                  DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH *
 652                                  M_2_PI);
 653         }
 654
 655         t = msecs - shell->workspaces.anim_timestamp;
 656
 657         /*
 658          * x = [0, π/2]
 659          * y(x) = sin(x)
 660          */
 661         x = t * (1.0/DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH) * M_PI_2;
 662         y = sin(x);
 663
 664         if (t < DEFAULT_WORKSPACE_CHANGE_ANIMATION_LENGTH) {
 665                 weston_compositor_schedule_repaint(shell->compositor);
 666
 667                 workspace_translate_out(from, shell->workspaces.anim_dir * y);
 668                 workspace_translate_in(to, shell->workspaces.anim_dir * y);
 669                 shell->workspaces.anim_current = y;
 670
 671                 weston_compositor_schedule_repaint(shell->compositor);
 672         }
 673         else
 674                 finish_workspace_change_animation(shell, from, to);
 675 }
 676
 677 static void
 678 animate_workspace_change(struct desktop_shell *shell,
 679                          unsigned int index,
 680                          struct workspace *from,
 681                          struct workspace *to)
 682 {
 683         struct weston_output *output;
 684
 685         int dir;
 686
 687         if (index > shell->workspaces.current)
 688                 dir = -1;
 689         else
 690                 dir = 1;
 691
 692         shell->workspaces.current = index;
 693
 694         shell->workspaces.anim_dir = dir;
 695         shell->workspaces.anim_from = from;
 696         shell->workspaces.anim_to = to;
 697         shell->workspaces.anim_current = 0.0;
 698         shell->workspaces.anim_timestamp = 0;
 699
 700         output = container_of(shell->compositor->output_list.next,
 701                               struct weston_output, link);
 702         wl_list_insert(&output->animation_list,
 703                        &shell->workspaces.animation.link);
 704
 705         wl_list_insert(&from->layer.link, &to->layer.link);
 706
 707         workspace_translate_in(to, 0);
 708
 709         restore_focus_state(shell, to);
 710
 711         weston_compositor_schedule_repaint(shell->compositor);
 712 }
 713
 714 static void
 715 change_workspace(struct desktop_shell *shell, unsigned int index)
 716 {
 717         struct workspace *from;
 718         struct workspace *to;
 719
 720         if (index == shell->workspaces.current)
 721                 return;
 722
 723         /* Don't change workspace when there is any fullscreen surfaces. */
 724         if (!wl_list_empty(&shell->fullscreen_layer.surface_list))
 725                 return;
 726
 727         from = get_current_workspace(shell);
 728         to = get_workspace(shell, index);
 729
 730         if (shell->workspaces.anim_from == to &&
 731             shell->workspaces.anim_to == from) {
 732                 reverse_workspace_change_animation(shell, index, from, to);
 733                 return;
 734         }
 735
 736         if (shell->workspaces.anim_to != NULL)
 737                 finish_workspace_change_animation(shell,
 738                                                   shell->workspaces.anim_from,
 739                                                   shell->workspaces.anim_to);
 740
 741         if (workspace_is_empty(to) && workspace_is_empty(from)) {
 742                 shell->workspaces.current = index;
 743                 wl_list_insert(&from->layer.link, &to->layer.link);
 744                 wl_list_remove(&from->layer.link);
 745
 746                 restore_focus_state(shell, to);
 747         }
 748         else
 749                 animate_workspace_change(shell, index, from, to);
 750 }
 751
 752 static void
 753 noop_grab_focus(struct wl_pointer_grab *grab,
 754                 struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y)
 755 {
 756         grab->focus = NULL;
 757 }
 758
 759 static void
 760 move_grab_motion(struct wl_pointer_grab *grab,
 761                  uint32_t time, wl_fixed_t x, wl_fixed_t y)
 762 {
 763         struct weston_move_grab *move = (struct weston_move_grab *) grab;
 764         struct wl_pointer *pointer = grab->pointer;
 765         struct shell_surface *shsurf = move->base.shsurf;
 766         struct weston_surface *es;
 767         int dx = wl_fixed_to_int(pointer->x + move->dx);
 768         int dy = wl_fixed_to_int(pointer->y + move->dy);
 769
 770         if (!shsurf)
 771                 return;
 772
 773         es = shsurf->surface;
 774
 775         weston_surface_configure(es, dx, dy,
 776                                  es->geometry.width, es->geometry.height);
 777
 778         weston_compositor_schedule_repaint(es->compositor);
 779 }
 780
 781 static void
 782 move_grab_button(struct wl_pointer_grab *grab,
 783                  uint32_t time, uint32_t button, uint32_t state_w)
 784 {
 785         struct shell_grab *shell_grab = container_of(grab, struct shell_grab,
 786                                                     grab);
 787         struct wl_pointer *pointer = grab->pointer;
 788         enum wl_pointer_button_state state = state_w;
 789
 790         if (pointer->button_count == 0 &&
 791             state == WL_POINTER_BUTTON_STATE_RELEASED) {
 792                 shell_grab_end(shell_grab);
 793                 free(grab);
 794         }
 795 }
 796
 797 static const struct wl_pointer_grab_interface move_grab_interface = {
 798         noop_grab_focus,
 799         move_grab_motion,
 800         move_grab_button,
 801 };
 802
 803 static int
 804 surface_move(struct shell_surface *shsurf, struct weston_seat *ws)
 805 {
 806         struct weston_move_grab *move;
 807
 808         if (!shsurf)
 809                 return -1;
 810
 811         if (shsurf->type == SHELL_SURFACE_FULLSCREEN)
 812                 return 0;
 813
 814         move = malloc(sizeof *move);
 815         if (!move)
 816                 return -1;
 817
 818         move->dx = wl_fixed_from_double(shsurf->surface->geometry.x) -
 819                         ws->seat.pointer->grab_x;
 820         move->dy = wl_fixed_from_double(shsurf->surface->geometry.y) -
 821                         ws->seat.pointer->grab_y;
 822
 823         shell_grab_start(&move->base, &move_grab_interface, shsurf,
 824                          ws->seat.pointer, DESKTOP_SHELL_CURSOR_MOVE);
 825
 826         return 0;
 827 }
 828
 829 static void
 830 shell_surface_move(struct wl_client *client, struct wl_resource *resource,
 831                    struct wl_resource *seat_resource, uint32_t serial)
 832 {
 833         struct weston_seat *ws = seat_resource->data;
 834         struct shell_surface *shsurf = resource->data;
 835
 836         if (ws->seat.pointer->button_count == 0 ||
 837             ws->seat.pointer->grab_serial != serial ||
 838             ws->seat.pointer->focus != &shsurf->surface->surface)
 839                 return;
 840
 841         if (surface_move(shsurf, ws) < 0)
 842                 wl_resource_post_no_memory(resource);
 843 }
 844
 845 struct weston_resize_grab {
 846         struct shell_grab base;
 847         uint32_t edges;
 848         int32_t width, height;
 849 };
 850
 851 static void
 852 resize_grab_motion(struct wl_pointer_grab *grab,
 853                    uint32_t time, wl_fixed_t x, wl_fixed_t y)
 854 {
 855         struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
 856         struct wl_pointer *pointer = grab->pointer;
 857         struct shell_surface *shsurf = resize->base.shsurf;
 858         int32_t width, height;
 859         wl_fixed_t from_x, from_y;
 860         wl_fixed_t to_x, to_y;
 861
 862         if (!shsurf)
 863                 return;
 864
 865         weston_surface_from_global_fixed(shsurf->surface,
 866                                          pointer->grab_x, pointer->grab_y,
 867                                          &from_x, &from_y);
 868         weston_surface_from_global_fixed(shsurf->surface,
 869                                          pointer->x, pointer->y, &to_x, &to_y);
 870
 871         width = resize->width;
 872         if (resize->edges & WL_SHELL_SURFACE_RESIZE_LEFT) {
 873                 width += wl_fixed_to_int(from_x - to_x);
 874         } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_RIGHT) {
 875                 width += wl_fixed_to_int(to_x - from_x);
 876         }
 877
 878         height = resize->height;
 879         if (resize->edges & WL_SHELL_SURFACE_RESIZE_TOP) {
 880                 height += wl_fixed_to_int(from_y - to_y);
 881         } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_BOTTOM) {
 882                 height += wl_fixed_to_int(to_y - from_y);
 883         }
 884
 885         shsurf->client->send_configure(shsurf->surface,
 886                                        resize->edges, width, height);
 887 }
 888
 889 static void
 890 send_configure(struct weston_surface *surface,
 891                uint32_t edges, int32_t width, int32_t height)
 892 {
 893         struct shell_surface *shsurf = get_shell_surface(surface);
 894
 895         wl_shell_surface_send_configure(&shsurf->resource,
 896                                         edges, width, height);
 897 }
 898
 899 static const struct weston_shell_client shell_client = {
 900         send_configure
 901 };
 902
 903 static void
 904 resize_grab_button(struct wl_pointer_grab *grab,
 905                    uint32_t time, uint32_t button, uint32_t state_w)
 906 {
 907         struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
 908         struct wl_pointer *pointer = grab->pointer;
 909         enum wl_pointer_button_state state = state_w;
 910
 911         if (pointer->button_count == 0 &&
 912             state == WL_POINTER_BUTTON_STATE_RELEASED) {
 913                 shell_grab_end(&resize->base);
 914                 free(grab);
 915         }
 916 }
 917
 918 static const struct wl_pointer_grab_interface resize_grab_interface = {
 919         noop_grab_focus,
 920         resize_grab_motion,
 921         resize_grab_button,
 922 };
 923
 924 static int
 925 surface_resize(struct shell_surface *shsurf,
 926                struct weston_seat *ws, uint32_t edges)
 927 {
 928         struct weston_resize_grab *resize;
 929
 930         if (shsurf->type == SHELL_SURFACE_FULLSCREEN)
 931                 return 0;
 932
 933         if (edges == 0 || edges > 15 ||
 934             (edges & 3) == 3 || (edges & 12) == 12)
 935                 return 0;
 936
 937         resize = malloc(sizeof *resize);
 938         if (!resize)
 939                 return -1;
 940
 941         resize->edges = edges;
 942         resize->width = shsurf->surface->geometry.width;
 943         resize->height = shsurf->surface->geometry.height;
 944
 945         shell_grab_start(&resize->base, &resize_grab_interface, shsurf,
 946                          ws->seat.pointer, edges);
 947
 948         return 0;
 949 }
 950
 951 static void
 952 shell_surface_resize(struct wl_client *client, struct wl_resource *resource,
 953                      struct wl_resource *seat_resource, uint32_t serial,
 954                      uint32_t edges)
 955 {
 956         struct weston_seat *ws = seat_resource->data;
 957         struct shell_surface *shsurf = resource->data;
 958
 959         if (shsurf->type == SHELL_SURFACE_FULLSCREEN)
 960                 return;
 961
 962         if (ws->seat.pointer->button_count == 0 ||
 963             ws->seat.pointer->grab_serial != serial ||
 964             ws->seat.pointer->focus != &shsurf->surface->surface)
 965                 return;
 966
 967         if (surface_resize(shsurf, ws, edges) < 0)
 968                 wl_resource_post_no_memory(resource);
 969 }
 970
 971 static void
 972 busy_cursor_grab_focus(struct wl_pointer_grab *base,
 973                        struct wl_surface *surface, int32_t x, int32_t y)
 974 {
 975         struct shell_grab *grab = (struct shell_grab *) base;
 976
 977         if (grab->grab.focus != surface) {
 978                 shell_grab_end(grab);
 979                 free(grab);
 980         }
 981 }
 982
 983 static void
 984 busy_cursor_grab_motion(struct wl_pointer_grab *grab,
 985                         uint32_t time, int32_t x, int32_t y)
 986 {
 987 }
 988
 989 static void
 990 busy_cursor_grab_button(struct wl_pointer_grab *base,
 991                         uint32_t time, uint32_t button, uint32_t state)
 992 {
 993         struct shell_grab *grab = (struct shell_grab *) base;
 994         struct shell_surface *shsurf;
 995         struct weston_surface *surface =
 996                 (struct weston_surface *) grab->grab.pointer->current;
 997         struct weston_seat *seat =
 998                 (struct weston_seat *) grab->grab.pointer->seat;
 999
1000         shsurf = get_shell_surface(surface);
1001         if (shsurf && button == BTN_LEFT && state) {
1002                 activate(shsurf->shell, shsurf->surface, seat);
1003                 surface_move(shsurf, seat);
1004         }
1005 }
1006
1007 static const struct wl_pointer_grab_interface busy_cursor_grab_interface = {
1008         busy_cursor_grab_focus,
1009         busy_cursor_grab_motion,
1010         busy_cursor_grab_button,
1011 };
1012
1013 static void
1014 set_busy_cursor(struct shell_surface *shsurf, struct wl_pointer *pointer)
1015 {
1016         struct shell_grab *grab;
1017
1018         grab = malloc(sizeof *grab);
1019         if (!grab)
1020                 return;
1021
1022         shell_grab_start(grab, &busy_cursor_grab_interface, shsurf, pointer,
1023                          DESKTOP_SHELL_CURSOR_BUSY);
1024 }
1025
1026 static void
1027 end_busy_cursor(struct shell_surface *shsurf, struct wl_pointer *pointer)
1028 {
1029         struct shell_grab *grab = (struct shell_grab *) pointer->grab;
1030
1031         if (grab->grab.interface == &busy_cursor_grab_interface) {
1032                 shell_grab_end(grab);
1033                 free(grab);
1034         }
1035 }
1036
1037 static void
1038 ping_timer_destroy(struct shell_surface *shsurf)
1039 {
1040         if (!shsurf || !shsurf->ping_timer)
1041                 return;
1042
1043         if (shsurf->ping_timer->source)
1044                 wl_event_source_remove(shsurf->ping_timer->source);
1045
1046         free(shsurf->ping_timer);
1047         shsurf->ping_timer = NULL;
1048 }
1049
1050 static int
1051 ping_timeout_handler(void *data)
1052 {
1053         struct shell_surface *shsurf = data;
1054         struct weston_seat *seat;
1055
1056         /* Client is not responding */
1057         shsurf->unresponsive = 1;
1058
1059         wl_list_for_each(seat, &shsurf->surface->compositor->seat_list, link)
1060                 if (seat->seat.pointer->focus == &shsurf->surface->surface)
1061                         set_busy_cursor(shsurf, seat->seat.pointer);
1062
1063         return 1;
1064 }
1065
1066 static void
1067 ping_handler(struct weston_surface *surface, uint32_t serial)
1068 {
1069         struct shell_surface *shsurf = get_shell_surface(surface);
1070         struct wl_event_loop *loop;
1071         int ping_timeout = 200;
1072
1073         if (!shsurf)
1074                 return;
1075         if (!shsurf->resource.client)
1076                 return;
1077
1078         if (shsurf->surface == shsurf->shell->grab_surface)
1079                 return;
1080
1081         if (!shsurf->ping_timer) {
1082                 shsurf->ping_timer = malloc(sizeof *shsurf->ping_timer);
1083                 if (!shsurf->ping_timer)
1084                         return;
1085
1086                 shsurf->ping_timer->serial = serial;
1087                 loop = wl_display_get_event_loop(surface->compositor->wl_display);
1088                 shsurf->ping_timer->source =
1089                         wl_event_loop_add_timer(loop, ping_timeout_handler, shsurf);
1090                 wl_event_source_timer_update(shsurf->ping_timer->source, ping_timeout);
1091
1092                 wl_shell_surface_send_ping(&shsurf->resource, serial);
1093         }
1094 }
1095
1096 static void
1097 handle_pointer_focus(struct wl_listener *listener, void *data)
1098 {
1099         struct wl_pointer *pointer = data;
1100         struct weston_surface *surface =
1101                 (struct weston_surface *) pointer->focus;
1102         struct weston_compositor *compositor;
1103         struct shell_surface *shsurf;
1104         uint32_t serial;
1105
1106         if (!surface)
1107                 return;
1108
1109         compositor = surface->compositor;
1110         shsurf = get_shell_surface(surface);
1111
1112         if (shsurf && shsurf->unresponsive) {
1113                 set_busy_cursor(shsurf, pointer);
1114         } else {
1115                 serial = wl_display_next_serial(compositor->wl_display);
1116                 ping_handler(surface, serial);
1117         }
1118 }
1119
1120 static void
1121 create_pointer_focus_listener(struct weston_seat *seat)
1122 {
1123         struct wl_listener *listener;
1124
1125         if (!seat->seat.pointer)
1126                 return;
1127
1128         listener = malloc(sizeof *listener);
1129         listener->notify = handle_pointer_focus;
1130         wl_signal_add(&seat->seat.pointer->focus_signal, listener);
1131 }
1132
1133 static void
1134 shell_surface_pong(struct wl_client *client, struct wl_resource *resource,
1135                                                         uint32_t serial)
1136 {
1137         struct shell_surface *shsurf = resource->data;
1138         struct desktop_shell *shell = shsurf->shell;
1139         struct weston_seat *seat;
1140         struct weston_compositor *ec = shsurf->surface->compositor;
1141         struct wl_pointer *pointer;
1142         int was_unresponsive;
1143
1144         if (shsurf->ping_timer == NULL)
1145                 /* Just ignore unsolicited pong. */
1146                 return;
1147
1148         if (shsurf->ping_timer->serial == serial) {
1149                 was_unresponsive = shsurf->unresponsive;
1150                 shsurf->unresponsive = 0;
1151                 if (was_unresponsive) {
1152                         /* Received pong from previously unresponsive client */
1153                         wl_list_for_each(seat, &ec->seat_list, link) {
1154                                 pointer = seat->seat.pointer;
1155                                 if (pointer->focus ==
1156                                     &shell->grab_surface->surface &&
1157                                     pointer->current ==
1158                                     &shsurf->surface->surface)
1159                                         end_busy_cursor(shsurf, pointer);
1160                         }
1161                 }
1162                 ping_timer_destroy(shsurf);
1163         }
1164 }
1165
1166 static void
1167 shell_surface_set_title(struct wl_client *client,
1168                         struct wl_resource *resource, const char *title)
1169 {
1170         struct shell_surface *shsurf = resource->data;
1171
1172         free(shsurf->title);
1173         shsurf->title = strdup(title);
1174 }
1175
1176 static void
1177 shell_surface_set_class(struct wl_client *client,
1178                         struct wl_resource *resource, const char *class)
1179 {
1180         struct shell_surface *shsurf = resource->data;
1181
1182         free(shsurf->class);
1183         shsurf->class = strdup(class);
1184 }
1185
1186 static struct weston_output *
1187 get_default_output(struct weston_compositor *compositor)
1188 {
1189         return container_of(compositor->output_list.next,
1190                             struct weston_output, link);
1191 }
1192
1193 static void
1194 shell_unset_fullscreen(struct shell_surface *shsurf)
1195 {
1196         /* undo all fullscreen things here */
1197         if (shsurf->fullscreen.type == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER &&
1198             shell_surface_is_top_fullscreen(shsurf)) {
1199                 weston_output_switch_mode(shsurf->fullscreen_output,
1200                                           shsurf->fullscreen_output->origin);
1201         }
1202         shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
1203         shsurf->fullscreen.framerate = 0;
1204         wl_list_remove(&shsurf->fullscreen.transform.link);
1205         wl_list_init(&shsurf->fullscreen.transform.link);
1206         if (shsurf->fullscreen.black_surface)
1207                 weston_surface_destroy(shsurf->fullscreen.black_surface);
1208         shsurf->fullscreen.black_surface = NULL;
1209         shsurf->fullscreen_output = NULL;
1210         weston_surface_set_position(shsurf->surface,
1211                                     shsurf->saved_x, shsurf->saved_y);
1212         if (shsurf->saved_rotation_valid) {
1213                 wl_list_insert(&shsurf->surface->geometry.transformation_list,
1214                                &shsurf->rotation.transform.link);
1215                 shsurf->saved_rotation_valid = false;
1216         }
1217 }
1218
1219 static int
1220 reset_shell_surface_type(struct shell_surface *surface)
1221 {
1222         switch (surface->type) {
1223         case SHELL_SURFACE_FULLSCREEN:
1224                 shell_unset_fullscreen(surface);
1225                 break;
1226         case SHELL_SURFACE_MAXIMIZED:
1227                 surface->output = get_default_output(surface->surface->compositor);
1228                 weston_surface_set_position(surface->surface,
1229                                             surface->saved_x,
1230                                             surface->saved_y);
1231                 break;
1232         case SHELL_SURFACE_NONE:
1233         case SHELL_SURFACE_TOPLEVEL:
1234         case SHELL_SURFACE_TRANSIENT:
1235         case SHELL_SURFACE_POPUP:
1236                 break;
1237         }
1238
1239         surface->type = SHELL_SURFACE_NONE;
1240         return 0;
1241 }
1242
1243 static void
1244 set_surface_type(struct shell_surface *shsurf)
1245 {
1246         struct weston_surface *surface = shsurf->surface;
1247         struct weston_surface *pes = shsurf->parent;
1248
1249         reset_shell_surface_type(shsurf);
1250
1251         shsurf->type = shsurf->next_type;
1252         shsurf->next_type = SHELL_SURFACE_NONE;
1253
1254         switch (shsurf->type) {
1255         case SHELL_SURFACE_TOPLEVEL:
1256                 break;
1257         case SHELL_SURFACE_TRANSIENT:
1258                 weston_surface_set_position(surface,
1259                                 pes->geometry.x + shsurf->transient.x,
1260                                 pes->geometry.y + shsurf->transient.y);
1261                 break;
1262
1263         case SHELL_SURFACE_MAXIMIZED:
1264                 shsurf->saved_x = surface->geometry.x;
1265                 shsurf->saved_y = surface->geometry.y;
1266                 shsurf->saved_position_valid = true;
1267                 break;
1268
1269         case SHELL_SURFACE_FULLSCREEN:
1270                 shsurf->saved_x = surface->geometry.x;
1271                 shsurf->saved_y = surface->geometry.y;
1272                 shsurf->saved_position_valid = true;
1273
1274                 if (!wl_list_empty(&shsurf->rotation.transform.link)) {
1275                         wl_list_remove(&shsurf->rotation.transform.link);
1276                         wl_list_init(&shsurf->rotation.transform.link);
1277                         shsurf->surface->geometry.dirty = 1;
1278                         shsurf->saved_rotation_valid = true;
1279                 }
1280                 break;
1281
1282         default:
1283                 break;
1284         }
1285 }
1286
1287 static void
1288 set_toplevel(struct shell_surface *shsurf)
1289 {
1290        shsurf->next_type = SHELL_SURFACE_TOPLEVEL;
1291 }
1292
1293 static void
1294 shell_surface_set_toplevel(struct wl_client *client,
1295                            struct wl_resource *resource)
1296 {
1297         struct shell_surface *surface = resource->data;
1298
1299         set_toplevel(surface);
1300 }
1301
1302 static void
1303 set_transient(struct shell_surface *shsurf,
1304               struct weston_surface *parent, int x, int y, uint32_t flags)
1305 {
1306         /* assign to parents output */
1307         shsurf->parent = parent;
1308         shsurf->transient.x = x;
1309         shsurf->transient.y = y;
1310         shsurf->transient.flags = flags;
1311         shsurf->next_type = SHELL_SURFACE_TRANSIENT;
1312 }
1313
1314 static void
1315 shell_surface_set_transient(struct wl_client *client,
1316                             struct wl_resource *resource,
1317                             struct wl_resource *parent_resource,
1318                             int x, int y, uint32_t flags)
1319 {
1320         struct shell_surface *shsurf = resource->data;
1321         struct weston_surface *parent = parent_resource->data;
1322
1323         set_transient(shsurf, parent, x, y, flags);
1324 }
1325
1326 static struct desktop_shell *
1327 shell_surface_get_shell(struct shell_surface *shsurf)
1328 {
1329         return shsurf->shell;
1330 }
1331
1332 static int
1333 get_output_panel_height(struct desktop_shell *shell,
1334                         struct weston_output *output)
1335 {
1336         struct weston_surface *surface;
1337         int panel_height = 0;
1338
1339         if (!output)
1340                 return 0;
1341
1342         wl_list_for_each(surface, &shell->panel_layer.surface_list, layer_link) {
1343                 if (surface->output == output) {
1344                         panel_height = surface->geometry.height;
1345                         break;
1346                 }
1347         }
1348
1349         return panel_height;
1350 }
1351
1352 static void
1353 shell_surface_set_maximized(struct wl_client *client,
1354                             struct wl_resource *resource,
1355                             struct wl_resource *output_resource )
1356 {
1357         struct shell_surface *shsurf = resource->data;
1358         struct weston_surface *es = shsurf->surface;
1359         struct desktop_shell *shell = NULL;
1360         uint32_t edges = 0, panel_height = 0;
1361
1362         /* get the default output, if the client set it as NULL
1363            check whether the ouput is available */
1364         if (output_resource)
1365                 shsurf->output = output_resource->data;
1366         else if (es->output)
1367                 shsurf->output = es->output;
1368         else
1369                 shsurf->output = get_default_output(es->compositor);
1370
1371         shell = shell_surface_get_shell(shsurf);
1372         panel_height = get_output_panel_height(shell, shsurf->output);
1373         edges = WL_SHELL_SURFACE_RESIZE_TOP|WL_SHELL_SURFACE_RESIZE_LEFT;
1374
1375         shsurf->client->send_configure(shsurf->surface, edges,
1376                                        shsurf->output->current->width,
1377                                        shsurf->output->current->height - panel_height);
1378
1379         shsurf->next_type = SHELL_SURFACE_MAXIMIZED;
1380 }
1381
1382 static void
1383 black_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy);
1384
1385 static struct weston_surface *
1386 create_black_surface(struct weston_compositor *ec,
1387                      struct weston_surface *fs_surface,
1388                      GLfloat x, GLfloat y, int w, int h)
1389 {
1390         struct weston_surface *surface = NULL;
1391
1392         surface = weston_surface_create(ec);
1393         if (surface == NULL) {
1394                 weston_log("no memory\n");
1395                 return NULL;
1396         }
1397
1398         surface->configure = black_surface_configure;
1399         surface->private = fs_surface;
1400         weston_surface_configure(surface, x, y, w, h);
1401         weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1);
1402         pixman_region32_init_rect(&surface->opaque, 0, 0, w, h);
1403
1404         return surface;
1405 }
1406
1407 /* Create black surface and append it to the associated fullscreen surface.
1408  * Handle size dismatch and positioning according to the method. */
1409 static void
1410 shell_configure_fullscreen(struct shell_surface *shsurf)
1411 {
1412         struct weston_output *output = shsurf->fullscreen_output;
1413         struct weston_surface *surface = shsurf->surface;
1414         struct weston_matrix *matrix;
1415         float scale, output_aspect, surface_aspect, x, y;
1416
1417         if (!shsurf->fullscreen.black_surface)
1418                 shsurf->fullscreen.black_surface =
1419                         create_black_surface(surface->compositor,
1420                                              surface,
1421                                              output->x, output->y,
1422                                              output->current->width,
1423                                              output->current->height);
1424
1425         wl_list_remove(&shsurf->fullscreen.black_surface->layer_link);
1426         wl_list_insert(&surface->layer_link,
1427                        &shsurf->fullscreen.black_surface->layer_link);
1428         shsurf->fullscreen.black_surface->output = output;
1429
1430         switch (shsurf->fullscreen.type) {
1431         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT:
1432                 if (surface->buffer)
1433                         center_on_output(surface, shsurf->fullscreen_output);
1434                 break;
1435         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE:
1436                 matrix = &shsurf->fullscreen.transform.matrix;
1437                 weston_matrix_init(matrix);
1438
1439                 output_aspect = (float) output->current->width /
1440                         (float) output->current->height;
1441                 surface_aspect = (float) surface->geometry.width /
1442                         (float) surface->geometry.height;
1443                 if (output_aspect < surface_aspect)
1444                         scale = (float) output->current->width /
1445                                 (float) surface->geometry.width;
1446                 else
1447                         scale = (float) output->current->height /
1448                                 (float) surface->geometry.height;
1449
1450                 weston_matrix_scale(matrix, scale, scale, 1);
1451                 wl_list_remove(&shsurf->fullscreen.transform.link);
1452                 wl_list_insert(&surface->geometry.transformation_list,
1453                                &shsurf->fullscreen.transform.link);
1454                 x = output->x + (output->current->width - surface->geometry.width * scale) / 2;
1455                 y = output->y + (output->current->height - surface->geometry.height * scale) / 2;
1456                 weston_surface_set_position(surface, x, y);
1457
1458                 break;
1459         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER:
1460                 if (shell_surface_is_top_fullscreen(shsurf)) {
1461                         struct weston_mode mode = {0,
1462                                 surface->geometry.width,
1463                                 surface->geometry.height,
1464                                 shsurf->fullscreen.framerate};
1465
1466                         if (weston_output_switch_mode(output, &mode) == 0) {
1467                                 weston_surface_configure(shsurf->fullscreen.black_surface,
1468                                                          output->x, output->y,
1469                                                          output->current->width,
1470                                                          output->current->height);
1471                                 weston_surface_set_position(surface, output->x, output->y);
1472                                 break;
1473                         }
1474                 }
1475                 break;
1476         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_FILL:
1477                 break;
1478         default:
1479                 break;
1480         }
1481 }
1482
1483 /* make the fullscreen and black surface at the top */
1484 static void
1485 shell_stack_fullscreen(struct shell_surface *shsurf)
1486 {
1487         struct weston_output *output = shsurf->fullscreen_output;
1488         struct weston_surface *surface = shsurf->surface;
1489         struct desktop_shell *shell = shell_surface_get_shell(shsurf);
1490
1491         wl_list_remove(&surface->layer_link);
1492         wl_list_insert(&shell->fullscreen_layer.surface_list,
1493                        &surface->layer_link);
1494         weston_surface_damage(surface);
1495
1496         if (!shsurf->fullscreen.black_surface)
1497                 shsurf->fullscreen.black_surface =
1498                         create_black_surface(surface->compositor,
1499                                              surface,
1500                                              output->x, output->y,
1501                                              output->current->width,
1502                                              output->current->height);
1503
1504         wl_list_remove(&shsurf->fullscreen.black_surface->layer_link);
1505         wl_list_insert(&surface->layer_link,
1506                        &shsurf->fullscreen.black_surface->layer_link);
1507         weston_surface_damage(shsurf->fullscreen.black_surface);
1508 }
1509
1510 static void
1511 shell_map_fullscreen(struct shell_surface *shsurf)
1512 {
1513         shell_stack_fullscreen(shsurf);
1514         shell_configure_fullscreen(shsurf);
1515 }
1516
1517 static void
1518 shell_surface_set_fullscreen(struct wl_client *client,
1519                              struct wl_resource *resource,
1520                              uint32_t method,
1521                              uint32_t framerate,
1522                              struct wl_resource *output_resource)
1523 {
1524         struct shell_surface *shsurf = resource->data;
1525         struct weston_surface *es = shsurf->surface;
1526
1527         if (output_resource)
1528                 shsurf->output = output_resource->data;
1529         else if (es->output)
1530                 shsurf->output = es->output;
1531         else
1532                 shsurf->output = get_default_output(es->compositor);
1533
1534         shsurf->fullscreen_output = shsurf->output;
1535         shsurf->fullscreen.type = method;
1536         shsurf->fullscreen.framerate = framerate;
1537         shsurf->next_type = SHELL_SURFACE_FULLSCREEN;
1538
1539         shsurf->client->send_configure(shsurf->surface, 0,
1540                                        shsurf->output->current->width,
1541                                        shsurf->output->current->height);
1542 }
1543
1544 static void
1545 popup_grab_focus(struct wl_pointer_grab *grab,
1546                  struct wl_surface *surface,
1547                  wl_fixed_t x,
1548                  wl_fixed_t y)
1549 {
1550         struct wl_pointer *pointer = grab->pointer;
1551         struct shell_surface *priv =
1552                 container_of(grab, struct shell_surface, popup.grab);
1553         struct wl_client *client = priv->surface->surface.resource.client;
1554
1555         if (surface && surface->resource.client == client) {
1556                 wl_pointer_set_focus(pointer, surface, x, y);
1557                 grab->focus = surface;
1558         } else {
1559                 wl_pointer_set_focus(pointer, NULL,
1560                                      wl_fixed_from_int(0),
1561                                      wl_fixed_from_int(0));
1562                 grab->focus = NULL;
1563         }
1564 }
1565
1566 static void
1567 popup_grab_motion(struct wl_pointer_grab *grab,
1568                   uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
1569 {
1570         struct wl_resource *resource;
1571
1572         resource = grab->pointer->focus_resource;
1573         if (resource)
1574                 wl_pointer_send_motion(resource, time, sx, sy);
1575 }
1576
1577 static void
1578 popup_grab_button(struct wl_pointer_grab *grab,
1579                   uint32_t time, uint32_t button, uint32_t state_w)
1580 {
1581         struct wl_resource *resource;
1582         struct shell_surface *shsurf =
1583                 container_of(grab, struct shell_surface, popup.grab);
1584         struct wl_display *display;
1585         enum wl_pointer_button_state state = state_w;
1586         uint32_t serial;
1587
1588         resource = grab->pointer->focus_resource;
1589         if (resource) {
1590                 display = wl_client_get_display(resource->client);
1591                 serial = wl_display_get_serial(display);
1592                 wl_pointer_send_button(resource, serial, time, button, state);
1593         } else if (state == WL_POINTER_BUTTON_STATE_RELEASED &&
1594                    (shsurf->popup.initial_up ||
1595                     time - shsurf->popup.seat->pointer->grab_time > 500)) {
1596                 wl_shell_surface_send_popup_done(&shsurf->resource);
1597                 wl_pointer_end_grab(grab->pointer);
1598                 shsurf->popup.grab.pointer = NULL;
1599         }
1600
1601         if (state == WL_POINTER_BUTTON_STATE_RELEASED)
1602                 shsurf->popup.initial_up = 1;
1603 }
1604
1605 static const struct wl_pointer_grab_interface popup_grab_interface = {
1606         popup_grab_focus,
1607         popup_grab_motion,
1608         popup_grab_button,
1609 };
1610
1611 static void
1612 shell_map_popup(struct shell_surface *shsurf)
1613 {
1614         struct wl_seat *seat = shsurf->popup.seat;
1615         struct weston_surface *es = shsurf->surface;
1616         struct weston_surface *parent = shsurf->parent;
1617
1618         es->output = parent->output;
1619         shsurf->popup.grab.interface = &popup_grab_interface;
1620
1621         weston_surface_update_transform(parent);
1622         if (parent->transform.enabled) {
1623                 shsurf->popup.parent_transform.matrix =
1624                         parent->transform.matrix;
1625         } else {
1626                 /* construct x, y translation matrix */
1627                 weston_matrix_init(&shsurf->popup.parent_transform.matrix);
1628                 shsurf->popup.parent_transform.matrix.d[12] =
1629                         parent->geometry.x;
1630                 shsurf->popup.parent_transform.matrix.d[13] =
1631                         parent->geometry.y;
1632         }
1633         wl_list_insert(es->geometry.transformation_list.prev,
1634                        &shsurf->popup.parent_transform.link);
1635         weston_surface_set_position(es, shsurf->popup.x, shsurf->popup.y);
1636
1637         shsurf->popup.initial_up = 0;
1638
1639         /* We don't require the grab to still be active, but if another
1640          * grab has started in the meantime, we end the popup now. */
1641         if (seat->pointer->grab_serial == shsurf->popup.serial) {
1642                 wl_pointer_start_grab(seat->pointer, &shsurf->popup.grab);
1643         } else {
1644                 wl_shell_surface_send_popup_done(&shsurf->resource);
1645         }
1646 }
1647
1648 static void
1649 shell_surface_set_popup(struct wl_client *client,
1650                         struct wl_resource *resource,
1651                         struct wl_resource *seat_resource,
1652                         uint32_t serial,
1653                         struct wl_resource *parent_resource,
1654                         int32_t x, int32_t y, uint32_t flags)
1655 {
1656         struct shell_surface *shsurf = resource->data;
1657
1658         shsurf->type = SHELL_SURFACE_POPUP;
1659         shsurf->parent = parent_resource->data;
1660         shsurf->popup.seat = seat_resource->data;
1661         shsurf->popup.serial = serial;
1662         shsurf->popup.x = x;
1663         shsurf->popup.y = y;
1664 }
1665
1666 static const struct wl_shell_surface_interface shell_surface_implementation = {
1667         shell_surface_pong,
1668         shell_surface_move,
1669         shell_surface_resize,
1670         shell_surface_set_toplevel,
1671         shell_surface_set_transient,
1672         shell_surface_set_fullscreen,
1673         shell_surface_set_popup,
1674         shell_surface_set_maximized,
1675         shell_surface_set_title,
1676         shell_surface_set_class
1677 };
1678
1679 static void
1680 destroy_shell_surface(struct shell_surface *shsurf)
1681 {
1682         if (shsurf->popup.grab.pointer)
1683                 wl_pointer_end_grab(shsurf->popup.grab.pointer);
1684
1685         if (shsurf->fullscreen.type == WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER &&
1686             shell_surface_is_top_fullscreen(shsurf)) {
1687                 weston_output_switch_mode(shsurf->fullscreen_output,
1688                                           shsurf->fullscreen_output->origin);
1689         }
1690
1691         if (shsurf->fullscreen.black_surface)
1692                 weston_surface_destroy(shsurf->fullscreen.black_surface);
1693
1694         /* As destroy_resource() use wl_list_for_each_safe(),
1695          * we can always remove the listener.
1696          */
1697         wl_list_remove(&shsurf->surface_destroy_listener.link);
1698         shsurf->surface->configure = NULL;
1699         ping_timer_destroy(shsurf);
1700
1701         wl_list_remove(&shsurf->link);
1702         free(shsurf);
1703 }
1704
1705 static void
1706 shell_destroy_shell_surface(struct wl_resource *resource)
1707 {
1708         struct shell_surface *shsurf = resource->data;
1709
1710         destroy_shell_surface(shsurf);
1711 }
1712
1713 static void
1714 shell_handle_surface_destroy(struct wl_listener *listener, void *data)
1715 {
1716         struct shell_surface *shsurf = container_of(listener,
1717                                                     struct shell_surface,
1718                                                     surface_destroy_listener);
1719
1720         if (shsurf->resource.client) {
1721                 wl_resource_destroy(&shsurf->resource);
1722         } else {
1723                 wl_signal_emit(&shsurf->resource.destroy_signal,
1724                                &shsurf->resource);
1725                 destroy_shell_surface(shsurf);
1726         }
1727 }
1728
1729 static void
1730 shell_surface_configure(struct weston_surface *, int32_t, int32_t);
1731
1732 static struct shell_surface *
1733 get_shell_surface(struct weston_surface *surface)
1734 {
1735         if (surface->configure == shell_surface_configure)
1736                 return surface->private;
1737         else
1738                 return NULL;
1739 }
1740
1741 static  struct shell_surface *
1742 create_shell_surface(void *shell, struct weston_surface *surface,
1743                      const struct weston_shell_client *client)
1744 {
1745         struct shell_surface *shsurf;
1746
1747         if (surface->configure) {
1748                 weston_log("surface->configure already set\n");
1749                 return NULL;
1750         }
1751
1752         shsurf = calloc(1, sizeof *shsurf);
1753         if (!shsurf) {
1754                 weston_log("no memory to allocate shell surface\n");
1755                 return NULL;
1756         }
1757
1758         surface->configure = shell_surface_configure;
1759         surface->private = shsurf;
1760
1761         shsurf->shell = (struct desktop_shell *) shell;
1762         shsurf->unresponsive = 0;
1763         shsurf->saved_position_valid = false;
1764         shsurf->saved_rotation_valid = false;
1765         shsurf->surface = surface;
1766         shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
1767         shsurf->fullscreen.framerate = 0;
1768         shsurf->fullscreen.black_surface = NULL;
1769         shsurf->ping_timer = NULL;
1770         wl_list_init(&shsurf->fullscreen.transform.link);
1771
1772         wl_signal_init(&shsurf->resource.destroy_signal);
1773         shsurf->surface_destroy_listener.notify = shell_handle_surface_destroy;
1774         wl_signal_add(&surface->surface.resource.destroy_signal,
1775                       &shsurf->surface_destroy_listener);
1776
1777         /* init link so its safe to always remove it in destroy_shell_surface */
1778         wl_list_init(&shsurf->link);
1779
1780         /* empty when not in use */
1781         wl_list_init(&shsurf->rotation.transform.link);
1782         weston_matrix_init(&shsurf->rotation.rotation);
1783
1784         wl_list_init(&shsurf->workspace_transform.link);
1785
1786         shsurf->type = SHELL_SURFACE_NONE;
1787         shsurf->next_type = SHELL_SURFACE_NONE;
1788
1789         shsurf->client = client;
1790
1791         return shsurf;
1792 }
1793
1794 static void
1795 shell_get_shell_surface(struct wl_client *client,
1796                         struct wl_resource *resource,
1797                         uint32_t id,
1798                         struct wl_resource *surface_resource)
1799 {
1800         struct weston_surface *surface = surface_resource->data;
1801         struct desktop_shell *shell = resource->data;
1802         struct shell_surface *shsurf;
1803
1804         if (get_shell_surface(surface)) {
1805                 wl_resource_post_error(surface_resource,
1806                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1807                                        "desktop_shell::get_shell_surface already requested");
1808                 return;
1809         }
1810
1811         shsurf = create_shell_surface(shell, surface, &shell_client);
1812         if (!shsurf) {
1813                 wl_resource_post_error(surface_resource,
1814                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1815                                        "surface->configure already set");
1816                 return;
1817         }
1818
1819         shsurf->resource.destroy = shell_destroy_shell_surface;
1820         shsurf->resource.object.id = id;
1821         shsurf->resource.object.interface = &wl_shell_surface_interface;
1822         shsurf->resource.object.implementation =
1823                 (void (**)(void)) &shell_surface_implementation;
1824         shsurf->resource.data = shsurf;
1825
1826         wl_client_add_resource(client, &shsurf->resource);
1827 }
1828
1829 static const struct wl_shell_interface shell_implementation = {
1830         shell_get_shell_surface
1831 };
1832
1833 static void
1834 handle_screensaver_sigchld(struct weston_process *proc, int status)
1835 {
1836         proc->pid = 0;
1837 }
1838
1839 static void
1840 launch_screensaver(struct desktop_shell *shell)
1841 {
1842         if (shell->screensaver.binding)
1843                 return;
1844
1845         if (!shell->screensaver.path)
1846                 return;
1847
1848         if (shell->screensaver.process.pid != 0) {
1849                 weston_log("old screensaver still running\n");
1850                 return;
1851         }
1852
1853         weston_client_launch(shell->compositor,
1854                            &shell->screensaver.process,
1855                            shell->screensaver.path,
1856                            handle_screensaver_sigchld);
1857 }
1858
1859 static void
1860 terminate_screensaver(struct desktop_shell *shell)
1861 {
1862         if (shell->screensaver.process.pid == 0)
1863                 return;
1864
1865         kill(shell->screensaver.process.pid, SIGTERM);
1866 }
1867
1868 static void
1869 configure_static_surface(struct weston_surface *es, struct weston_layer *layer)
1870 {
1871         struct weston_surface *s, *next;
1872
1873         wl_list_for_each_safe(s, next, &layer->surface_list, layer_link) {
1874                 if (s->output == es->output && s != es) {
1875                         weston_surface_unmap(s);
1876                         s->configure = NULL;
1877                 }
1878         }
1879
1880         weston_surface_configure(es, es->output->x, es->output->y,
1881                                  es->buffer->width, es->buffer->height);
1882
1883         if (wl_list_empty(&es->layer_link)) {
1884                 wl_list_insert(&layer->surface_list, &es->layer_link);
1885                 weston_compositor_schedule_repaint(es->compositor);
1886         }
1887 }
1888
1889 static void
1890 background_configure(struct weston_surface *es, int32_t sx, int32_t sy)
1891 {
1892         struct desktop_shell *shell = es->private;
1893
1894         configure_static_surface(es, &shell->background_layer);
1895 }
1896
1897 static void
1898 desktop_shell_set_background(struct wl_client *client,
1899                              struct wl_resource *resource,
1900                              struct wl_resource *output_resource,
1901                              struct wl_resource *surface_resource)
1902 {
1903         struct desktop_shell *shell = resource->data;
1904         struct weston_surface *surface = surface_resource->data;
1905
1906         if (surface->configure) {
1907                 wl_resource_post_error(surface_resource,
1908                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1909                                        "surface role already assigned");
1910                 return;
1911         }
1912
1913         surface->configure = background_configure;
1914         surface->private = shell;
1915         surface->output = output_resource->data;
1916         desktop_shell_send_configure(resource, 0,
1917                                      surface_resource,
1918                                      surface->output->current->width,
1919                                      surface->output->current->height);
1920 }
1921
1922 static void
1923 panel_configure(struct weston_surface *es, int32_t sx, int32_t sy)
1924 {
1925         struct desktop_shell *shell = es->private;
1926
1927         configure_static_surface(es, &shell->panel_layer);
1928 }
1929
1930 static void
1931 desktop_shell_set_panel(struct wl_client *client,
1932                         struct wl_resource *resource,
1933                         struct wl_resource *output_resource,
1934                         struct wl_resource *surface_resource)
1935 {
1936         struct desktop_shell *shell = resource->data;
1937         struct weston_surface *surface = surface_resource->data;
1938
1939         if (surface->configure) {
1940                 wl_resource_post_error(surface_resource,
1941                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1942                                        "surface role already assigned");
1943                 return;
1944         }
1945
1946         surface->configure = panel_configure;
1947         surface->private = shell;
1948         surface->output = output_resource->data;
1949         desktop_shell_send_configure(resource, 0,
1950                                      surface_resource,
1951                                      surface->output->current->width,
1952                                      surface->output->current->height);
1953 }
1954
1955 static void
1956 lock_surface_configure(struct weston_surface *surface, int32_t sx, int32_t sy)
1957 {
1958         struct desktop_shell *shell = surface->private;
1959
1960         center_on_output(surface, get_default_output(shell->compositor));
1961
1962         if (!weston_surface_is_mapped(surface)) {
1963                 wl_list_insert(&shell->lock_layer.surface_list,
1964                                &surface->layer_link);
1965                 weston_surface_assign_output(surface);
1966                 weston_compositor_wake(shell->compositor);
1967         }
1968 }
1969
1970 static void
1971 handle_lock_surface_destroy(struct wl_listener *listener, void *data)
1972 {
1973         struct desktop_shell *shell =
1974             container_of(listener, struct desktop_shell, lock_surface_listener);
1975
1976         weston_log("lock surface gone\n");
1977         shell->lock_surface = NULL;
1978 }
1979
1980 static void
1981 desktop_shell_set_lock_surface(struct wl_client *client,
1982                                struct wl_resource *resource,
1983                                struct wl_resource *surface_resource)
1984 {
1985         struct desktop_shell *shell = resource->data;
1986         struct weston_surface *surface = surface_resource->data;
1987
1988         shell->prepare_event_sent = false;
1989
1990         if (!shell->locked)
1991                 return;
1992
1993         shell->lock_surface = surface;
1994
1995         shell->lock_surface_listener.notify = handle_lock_surface_destroy;
1996         wl_signal_add(&surface_resource->destroy_signal,
1997                       &shell->lock_surface_listener);
1998
1999         surface->configure = lock_surface_configure;
2000         surface->private = shell;
2001 }
2002
2003 static void
2004 resume_desktop(struct desktop_shell *shell)
2005 {
2006         struct weston_surface *surface;
2007         struct workspace *ws = get_current_workspace(shell);
2008
2009         wl_list_for_each(surface, &shell->screensaver.surfaces, link)
2010                 weston_surface_unmap(surface);
2011
2012         terminate_screensaver(shell);
2013
2014         wl_list_remove(&shell->lock_layer.link);
2015         wl_list_insert(&shell->compositor->cursor_layer.link,
2016                        &shell->fullscreen_layer.link);
2017         wl_list_insert(&shell->fullscreen_layer.link,
2018                        &shell->panel_layer.link);
2019         if (shell->showing_input_panels) {
2020                 wl_list_insert(&shell->panel_layer.link,
2021                                &shell->input_panel_layer.link);
2022                 wl_list_insert(&shell->input_panel_layer.link,
2023                                &ws->layer.link);
2024         } else {
2025                 wl_list_insert(&shell->panel_layer.link, &ws->layer.link);
2026         }
2027
2028         restore_focus_state(shell, get_current_workspace(shell));
2029
2030         shell->locked = false;
2031         shell->compositor->idle_time = shell->compositor->option_idle_time;
2032         weston_compositor_wake(shell->compositor);
2033         weston_compositor_damage_all(shell->compositor);
2034 }
2035
2036 static void
2037 desktop_shell_unlock(struct wl_client *client,
2038                      struct wl_resource *resource)
2039 {
2040         struct desktop_shell *shell = resource->data;
2041
2042         shell->prepare_event_sent = false;
2043
2044         if (shell->locked)
2045                 resume_desktop(shell);
2046 }
2047
2048 static void
2049 desktop_shell_set_grab_surface(struct wl_client *client,
2050                                struct wl_resource *resource,
2051                                struct wl_resource *surface_resource)
2052 {
2053         struct desktop_shell *shell = resource->data;
2054
2055         shell->grab_surface = surface_resource->data;
2056 }
2057
2058 static const struct desktop_shell_interface desktop_shell_implementation = {
2059         desktop_shell_set_background,
2060         desktop_shell_set_panel,
2061         desktop_shell_set_lock_surface,
2062         desktop_shell_unlock,
2063         desktop_shell_set_grab_surface
2064 };
2065
2066 static enum shell_surface_type
2067 get_shell_surface_type(struct weston_surface *surface)
2068 {
2069         struct shell_surface *shsurf;
2070
2071         shsurf = get_shell_surface(surface);
2072         if (!shsurf)
2073                 return SHELL_SURFACE_NONE;
2074         return shsurf->type;
2075 }
2076
2077 static void
2078 move_binding(struct wl_seat *seat, uint32_t time, uint32_t button, void *data)
2079 {
2080         struct weston_surface *surface =
2081                 (struct weston_surface *) seat->pointer->focus;
2082         struct shell_surface *shsurf;
2083
2084         if (surface == NULL)
2085                 return;
2086
2087         shsurf = get_shell_surface(surface);
2088         if (shsurf == NULL || shsurf->type == SHELL_SURFACE_FULLSCREEN)
2089                 return;
2090
2091         surface_move(shsurf, (struct weston_seat *) seat);
2092 }
2093
2094 static void
2095 resize_binding(struct wl_seat *seat, uint32_t time, uint32_t button, void *data)
2096 {
2097         struct weston_surface *surface =
2098                 (struct weston_surface *) seat->pointer->focus;
2099         uint32_t edges = 0;
2100         int32_t x, y;
2101         struct shell_surface *shsurf;
2102
2103         if (surface == NULL)
2104                 return;
2105
2106         shsurf = get_shell_surface(surface);
2107         if (!shsurf || shsurf->type == SHELL_SURFACE_FULLSCREEN)
2108                 return;
2109
2110         weston_surface_from_global(surface,
2111                                    wl_fixed_to_int(seat->pointer->grab_x),
2112                                    wl_fixed_to_int(seat->pointer->grab_y),
2113                                    &x, &y);
2114
2115         if (x < surface->geometry.width / 3)
2116                 edges |= WL_SHELL_SURFACE_RESIZE_LEFT;
2117         else if (x < 2 * surface->geometry.width / 3)
2118                 edges |= 0;
2119         else
2120                 edges |= WL_SHELL_SURFACE_RESIZE_RIGHT;
2121
2122         if (y < surface->geometry.height / 3)
2123                 edges |= WL_SHELL_SURFACE_RESIZE_TOP;
2124         else if (y < 2 * surface->geometry.height / 3)
2125                 edges |= 0;
2126         else
2127                 edges |= WL_SHELL_SURFACE_RESIZE_BOTTOM;
2128
2129         surface_resize(shsurf, (struct weston_seat *) seat, edges);
2130 }
2131
2132 static void
2133 surface_opacity_binding(struct wl_seat *seat, uint32_t time, uint32_t axis,
2134                         wl_fixed_t value, void *data)
2135 {
2136         float step = 0.05;
2137         struct shell_surface *shsurf;
2138         struct weston_surface *surface =
2139                 (struct weston_surface *) seat->pointer->focus;
2140
2141         if (surface == NULL)
2142                 return;
2143
2144         shsurf = get_shell_surface(surface);
2145         if (!shsurf)
2146                 return;
2147
2148         surface->alpha += wl_fixed_to_double(value) * step;
2149
2150         if (surface->alpha > 1.0)
2151                 surface->alpha = 1.0;
2152         if (surface->alpha < step)
2153                 surface->alpha = step;
2154
2155         surface->geometry.dirty = 1;
2156         weston_surface_damage(surface);
2157 }
2158
2159 static void
2160 do_zoom(struct wl_seat *seat, uint32_t time, uint32_t key, uint32_t axis,
2161         wl_fixed_t value)
2162 {
2163         struct weston_seat *ws = (struct weston_seat *) seat;
2164         struct weston_compositor *compositor = ws->compositor;
2165         struct weston_output *output;
2166         float increment;
2167
2168         wl_list_for_each(output, &compositor->output_list, link) {
2169                 if (pixman_region32_contains_point(&output->region,
2170                                                    wl_fixed_to_double(seat->pointer->x),
2171                                                    wl_fixed_to_double(seat->pointer->y),
2172                                                    NULL)) {
2173                         if (key == KEY_PAGEUP)
2174                                 increment = output->zoom.increment;
2175                         else if (key == KEY_PAGEDOWN)
2176                                 increment = -output->zoom.increment;
2177                         else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
2178                                 increment = output->zoom.increment *
2179                                             wl_fixed_to_double(value);
2180                         else
2181                                 increment = 0;
2182
2183                         output->zoom.level += increment;
2184
2185                         if (output->zoom.level < 0.0)
2186                                 output->zoom.level = 0.0;
2187                         else if (output->zoom.level > output->zoom.max_level)
2188                                 output->zoom.level = output->zoom.max_level;
2189                         else {
2190                                 output->zoom.active = 1;
2191                                 output->disable_planes++;
2192                         }
2193
2194                         output->zoom.spring_z.target = output->zoom.level;
2195
2196                         weston_output_update_zoom(output, output->zoom.type);
2197                 }
2198         }
2199 }
2200
2201 static void
2202 zoom_axis_binding(struct wl_seat *seat, uint32_t time, uint32_t axis,
2203                   wl_fixed_t value, void *data)
2204 {
2205         do_zoom(seat, time, 0, axis, value);
2206 }
2207
2208 static void
2209 zoom_key_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
2210                  void *data)
2211 {
2212         do_zoom(seat, time, key, 0, 0);
2213 }
2214
2215 static void
2216 terminate_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
2217                   void *data)
2218 {
2219         struct weston_compositor *compositor = data;
2220
2221         wl_display_terminate(compositor->wl_display);
2222 }
2223
2224 static void
2225 rotate_grab_motion(struct wl_pointer_grab *grab,
2226                    uint32_t time, wl_fixed_t x, wl_fixed_t y)
2227 {
2228         struct rotate_grab *rotate =
2229                 container_of(grab, struct rotate_grab, base.grab);
2230         struct wl_pointer *pointer = grab->pointer;
2231         struct shell_surface *shsurf = rotate->base.shsurf;
2232         struct weston_surface *surface;
2233         GLfloat cx, cy, dx, dy, cposx, cposy, dposx, dposy, r;
2234
2235         if (!shsurf)
2236                 return;
2237
2238         surface = shsurf->surface;
2239
2240         cx = 0.5f * surface->geometry.width;
2241         cy = 0.5f * surface->geometry.height;
2242
2243         dx = wl_fixed_to_double(pointer->x) - rotate->center.x;
2244         dy = wl_fixed_to_double(pointer->y) - rotate->center.y;
2245         r = sqrtf(dx * dx + dy * dy);
2246
2247         wl_list_remove(&shsurf->rotation.transform.link);
2248         shsurf->surface->geometry.dirty = 1;
2249
2250         if (r > 20.0f) {
2251                 struct weston_matrix *matrix =
2252                         &shsurf->rotation.transform.matrix;
2253
2254                 weston_matrix_init(&rotate->rotation);
2255                 rotate->rotation.d[0] = dx / r;
2256                 rotate->rotation.d[4] = -dy / r;
2257                 rotate->rotation.d[1] = -rotate->rotation.d[4];
2258                 rotate->rotation.d[5] = rotate->rotation.d[0];
2259
2260                 weston_matrix_init(matrix);
2261                 weston_matrix_translate(matrix, -cx, -cy, 0.0f);
2262                 weston_matrix_multiply(matrix, &shsurf->rotation.rotation);
2263                 weston_matrix_multiply(matrix, &rotate->rotation);
2264                 weston_matrix_translate(matrix, cx, cy, 0.0f);
2265
2266                 wl_list_insert(
2267                         &shsurf->surface->geometry.transformation_list,
2268                         &shsurf->rotation.transform.link);
2269         } else {
2270                 wl_list_init(&shsurf->rotation.transform.link);
2271                 weston_matrix_init(&shsurf->rotation.rotation);
2272                 weston_matrix_init(&rotate->rotation);
2273         }
2274
2275         /* We need to adjust the position of the surface
2276          * in case it was resized in a rotated state before */
2277         cposx = surface->geometry.x + cx;
2278         cposy = surface->geometry.y + cy;
2279         dposx = rotate->center.x - cposx;
2280         dposy = rotate->center.y - cposy;
2281         if (dposx != 0.0f || dposy != 0.0f) {
2282                 weston_surface_set_position(surface,
2283                                             surface->geometry.x + dposx,
2284                                             surface->geometry.y + dposy);
2285         }
2286
2287         /* Repaint implies weston_surface_update_transform(), which
2288          * lazily applies the damage due to rotation update.
2289          */
2290         weston_compositor_schedule_repaint(shsurf->surface->compositor);
2291 }
2292
2293 static void
2294 rotate_grab_button(struct wl_pointer_grab *grab,
2295                  uint32_t time, uint32_t button, uint32_t state_w)
2296 {
2297         struct rotate_grab *rotate =
2298                 container_of(grab, struct rotate_grab, base.grab);
2299         struct wl_pointer *pointer = grab->pointer;
2300         struct shell_surface *shsurf = rotate->base.shsurf;
2301         enum wl_pointer_button_state state = state_w;
2302
2303         if (pointer->button_count == 0 &&
2304             state == WL_POINTER_BUTTON_STATE_RELEASED) {
2305                 if (shsurf)
2306                         weston_matrix_multiply(&shsurf->rotation.rotation,
2307                                                &rotate->rotation);
2308                 shell_grab_end(&rotate->base);
2309                 free(rotate);
2310         }
2311 }
2312
2313 static const struct wl_pointer_grab_interface rotate_grab_interface = {
2314         noop_grab_focus,
2315         rotate_grab_motion,
2316         rotate_grab_button,
2317 };
2318
2319 static void
2320 rotate_binding(struct wl_seat *seat, uint32_t time, uint32_t button,
2321                void *data)
2322 {
2323         struct weston_surface *base_surface =
2324                 (struct weston_surface *) seat->pointer->focus;
2325         struct shell_surface *surface;
2326         struct rotate_grab *rotate;
2327         GLfloat dx, dy;
2328         GLfloat r;
2329
2330         if (base_surface == NULL)
2331                 return;
2332
2333         surface = get_shell_surface(base_surface);
2334         if (!surface || surface->type == SHELL_SURFACE_FULLSCREEN)
2335                 return;
2336
2337         rotate = malloc(sizeof *rotate);
2338         if (!rotate)
2339                 return;
2340
2341         weston_surface_to_global_float(surface->surface,
2342                                        surface->surface->geometry.width / 2,
2343                                        surface->surface->geometry.height / 2,
2344                                        &rotate->center.x, &rotate->center.y);
2345
2346         dx = wl_fixed_to_double(seat->pointer->x) - rotate->center.x;
2347         dy = wl_fixed_to_double(seat->pointer->y) - rotate->center.y;
2348         r = sqrtf(dx * dx + dy * dy);
2349         if (r > 20.0f) {
2350                 struct weston_matrix inverse;
2351
2352                 weston_matrix_init(&inverse);
2353                 inverse.d[0] = dx / r;
2354                 inverse.d[4] = dy / r;
2355                 inverse.d[1] = -inverse.d[4];
2356                 inverse.d[5] = inverse.d[0];
2357                 weston_matrix_multiply(&surface->rotation.rotation, &inverse);
2358
2359                 weston_matrix_init(&rotate->rotation);
2360                 rotate->rotation.d[0] = dx / r;
2361                 rotate->rotation.d[4] = -dy / r;
2362                 rotate->rotation.d[1] = -rotate->rotation.d[4];
2363                 rotate->rotation.d[5] = rotate->rotation.d[0];
2364         } else {
2365                 weston_matrix_init(&surface->rotation.rotation);
2366                 weston_matrix_init(&rotate->rotation);
2367         }
2368
2369         shell_grab_start(&rotate->base, &rotate_grab_interface, surface,
2370                          seat->pointer, DESKTOP_SHELL_CURSOR_ARROW);
2371 }
2372
2373 static void
2374 lower_fullscreen_layer(struct desktop_shell *shell)
2375 {
2376         struct workspace *ws;
2377         struct weston_surface *surface, *prev;
2378
2379         ws = get_current_workspace(shell);
2380         wl_list_for_each_reverse_safe(surface, prev,
2381                                       &shell->fullscreen_layer.surface_list,
2382                                       layer_link)
2383                 weston_surface_restack(surface, &ws->layer.surface_list);
2384 }
2385
2386 static void
2387 activate(struct desktop_shell *shell, struct weston_surface *es,
2388          struct weston_seat *seat)
2389 {
2390         struct workspace *ws = get_current_workspace(shell);
2391         struct focus_state *state;
2392
2393         weston_surface_activate(es, seat);
2394
2395         wl_list_for_each(state, &ws->focus_list, link)
2396                 if (state->seat == seat)
2397                         break;
2398
2399         if (&state->link == &ws->focus_list) {
2400                 state = focus_state_create(seat, ws);
2401                 if (state == NULL)
2402                         return;
2403         }
2404
2405         state->keyboard_focus = es;
2406         wl_list_remove(&state->surface_destroy_listener.link);
2407         wl_signal_add(&es->surface.resource.destroy_signal,
2408                       &state->surface_destroy_listener);
2409
2410         switch (get_shell_surface_type(es)) {
2411         case SHELL_SURFACE_FULLSCREEN:
2412                 /* should on top of panels */
2413                 shell_stack_fullscreen(get_shell_surface(es));
2414                 shell_configure_fullscreen(get_shell_surface(es));
2415                 break;
2416         default:
2417                 ws = get_current_workspace(shell);
2418                 lower_fullscreen_layer(shell);
2419                 weston_surface_restack(es, &ws->layer.surface_list);
2420                 break;
2421         }
2422 }
2423
2424 /* no-op func for checking black surface */
2425 static void
2426 black_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2427 {
2428 }
2429
2430 static bool
2431 is_black_surface (struct weston_surface *es, struct weston_surface **fs_surface)
2432 {
2433         if (es->configure == black_surface_configure) {
2434                 if (fs_surface)
2435                         *fs_surface = (struct weston_surface *)es->private;
2436                 return true;
2437         }
2438         return false;
2439 }
2440
2441 static void
2442 click_to_activate_binding(struct wl_seat *seat, uint32_t time, uint32_t button,
2443                           void *data)
2444 {
2445         struct weston_seat *ws = (struct weston_seat *) seat;
2446         struct desktop_shell *shell = data;
2447         struct weston_surface *focus;
2448         struct weston_surface *upper;
2449
2450         focus = (struct weston_surface *) seat->pointer->focus;
2451         if (!focus)
2452                 return;
2453
2454         if (is_black_surface(focus, &upper))
2455                 focus = upper;
2456
2457         if (get_shell_surface_type(focus) == SHELL_SURFACE_NONE)
2458                 return;
2459
2460         if (seat->pointer->grab == &seat->pointer->default_grab)
2461                 activate(shell, focus, ws);
2462 }
2463
2464 static void
2465 lock(struct wl_listener *listener, void *data)
2466 {
2467         struct desktop_shell *shell =
2468                 container_of(listener, struct desktop_shell, lock_listener);
2469         struct weston_output *output;
2470         struct workspace *ws = get_current_workspace(shell);
2471
2472         if (shell->locked) {
2473                 wl_list_for_each(output, &shell->compositor->output_list, link)
2474                         /* TODO: find a way to jump to other DPMS levels */
2475                         if (output->set_dpms)
2476                                 output->set_dpms(output, WESTON_DPMS_STANDBY);
2477                 return;
2478         }
2479
2480         shell->locked = true;
2481
2482         /* Hide all surfaces by removing the fullscreen, panel and
2483          * toplevel layers.  This way nothing else can show or receive
2484          * input events while we are locked. */
2485
2486         wl_list_remove(&shell->panel_layer.link);
2487         wl_list_remove(&shell->fullscreen_layer.link);
2488         if (shell->showing_input_panels)
2489                 wl_list_remove(&shell->input_panel_layer.link);
2490         wl_list_remove(&ws->layer.link);
2491         wl_list_insert(&shell->compositor->cursor_layer.link,
2492                        &shell->lock_layer.link);
2493
2494         launch_screensaver(shell);
2495
2496         /* TODO: disable bindings that should not work while locked. */
2497
2498         /* All this must be undone in resume_desktop(). */
2499 }
2500
2501 static void
2502 unlock(struct wl_listener *listener, void *data)
2503 {
2504         struct desktop_shell *shell =
2505                 container_of(listener, struct desktop_shell, unlock_listener);
2506
2507         if (!shell->locked || shell->lock_surface) {
2508                 weston_compositor_wake(shell->compositor);
2509                 return;
2510         }
2511
2512         /* If desktop-shell client has gone away, unlock immediately. */
2513         if (!shell->child.desktop_shell) {
2514                 resume_desktop(shell);
2515                 return;
2516         }
2517
2518         if (shell->prepare_event_sent)
2519                 return;
2520
2521         desktop_shell_send_prepare_lock_surface(shell->child.desktop_shell);
2522         shell->prepare_event_sent = true;
2523 }
2524
2525 static void
2526 show_input_panels(struct wl_listener *listener, void *data)
2527 {
2528         struct desktop_shell *shell =
2529                 container_of(listener, struct desktop_shell,
2530                              show_input_panel_listener);
2531         struct input_panel_surface *surface, *next;
2532         struct weston_surface *ws;
2533
2534         shell->showing_input_panels = true;
2535
2536         wl_list_insert(&shell->panel_layer.link,
2537                        &shell->input_panel_layer.link);
2538
2539         wl_list_for_each_safe(surface, next,
2540                               &shell->input_panel.surfaces, link) {
2541                 ws = surface->surface;
2542                 wl_list_insert(&shell->input_panel_layer.surface_list,
2543                                &ws->layer_link);
2544                 weston_surface_assign_output(ws);
2545                 weston_surface_damage(ws);
2546                 weston_slide_run(ws, ws->geometry.height, 0, NULL, NULL);
2547         }
2548 }
2549
2550 static void
2551 hide_input_panels(struct wl_listener *listener, void *data)
2552 {
2553         struct desktop_shell *shell =
2554                 container_of(listener, struct desktop_shell,
2555                              hide_input_panel_listener);
2556         struct weston_surface *surface, *next;
2557
2558         shell->showing_input_panels = false;
2559
2560         wl_list_remove(&shell->input_panel_layer.link);
2561
2562         wl_list_for_each_safe(surface, next,
2563                               &shell->input_panel_layer.surface_list, layer_link)
2564                 weston_surface_unmap(surface);
2565 }
2566
2567 static void
2568 center_on_output(struct weston_surface *surface, struct weston_output *output)
2569 {
2570         struct weston_mode *mode = output->current;
2571         GLfloat x = (mode->width - surface->buffer->width) / 2;
2572         GLfloat y = (mode->height - surface->buffer->height) / 2;
2573
2574         weston_surface_configure(surface, output->x + x, output->y + y,
2575                                  surface->buffer->width,
2576                                  surface->buffer->height);
2577 }
2578
2579 static void
2580 weston_surface_set_initial_position (struct weston_surface *surface,
2581                                      struct desktop_shell *shell)
2582 {
2583         struct weston_compositor *compositor = shell->compositor;
2584         int ix = 0, iy = 0;
2585         int range_x, range_y;
2586         int dx, dy, x, y, panel_height;
2587         struct weston_output *output, *target_output = NULL;
2588         struct weston_seat *seat;
2589
2590         /* As a heuristic place the new window on the same output as the
2591          * pointer. Falling back to the output containing 0, 0.
2592          *
2593          * TODO: Do something clever for touch too?
2594          */
2595         wl_list_for_each(seat, &compositor->seat_list, link) {
2596                 if (seat->has_pointer) {
2597                         ix = wl_fixed_to_int(seat->pointer.x);
2598                         iy = wl_fixed_to_int(seat->pointer.y);
2599                         break;
2600                 }
2601         }
2602
2603         wl_list_for_each(output, &compositor->output_list, link) {
2604                 if (pixman_region32_contains_point(&output->region, ix, iy, NULL)) {
2605                         target_output = output;
2606                         break;
2607                 }
2608         }
2609
2610         if (!target_output) {
2611                 weston_surface_set_position(surface, 10 + random() % 400,
2612                                            10 + random() % 400);
2613                 return;
2614         }
2615
2616         /* Valid range within output where the surface will still be onscreen.
2617          * If this is negative it means that the surface is bigger than
2618          * output.
2619          */
2620         panel_height = get_output_panel_height(shell, target_output);
2621         range_x = target_output->current->width - surface->geometry.width;
2622         range_y = (target_output->current->height - panel_height) -
2623                   surface->geometry.height;
2624
2625         if (range_x > 0)
2626                 dx = random() % range_x;
2627         else
2628                 dx = 0;
2629
2630         if (range_y > 0)
2631                 dy = panel_height + random() % range_y;
2632         else
2633                 dy = panel_height;
2634
2635         x = target_output->x + dx;
2636         y = target_output->y + dy;
2637
2638         weston_surface_set_position (surface, x, y);
2639 }
2640
2641 static void
2642 map(struct desktop_shell *shell, struct weston_surface *surface,
2643     int32_t width, int32_t height, int32_t sx, int32_t sy)
2644 {
2645         struct weston_compositor *compositor = shell->compositor;
2646         struct shell_surface *shsurf = get_shell_surface(surface);
2647         enum shell_surface_type surface_type = shsurf->type;
2648         struct weston_surface *parent;
2649         struct weston_seat *seat;
2650         struct workspace *ws;
2651         int panel_height = 0;
2652
2653         surface->geometry.width = width;
2654         surface->geometry.height = height;
2655         surface->geometry.dirty = 1;
2656
2657         /* initial positioning, see also configure() */
2658         switch (surface_type) {
2659         case SHELL_SURFACE_TOPLEVEL:
2660                 weston_surface_set_initial_position(surface, shell);
2661                 break;
2662         case SHELL_SURFACE_FULLSCREEN:
2663                 center_on_output(surface, shsurf->fullscreen_output);
2664                 shell_map_fullscreen(shsurf);
2665                 break;
2666         case SHELL_SURFACE_MAXIMIZED:
2667                 /* use surface configure to set the geometry */
2668                 panel_height = get_output_panel_height(shell,surface->output);
2669                 weston_surface_set_position(surface, shsurf->output->x,
2670                                             shsurf->output->y + panel_height);
2671                 break;
2672         case SHELL_SURFACE_POPUP:
2673                 shell_map_popup(shsurf);
2674         case SHELL_SURFACE_NONE:
2675                 weston_surface_set_position(surface,
2676                                             surface->geometry.x + sx,
2677                                             surface->geometry.y + sy);
2678                 break;
2679         default:
2680                 ;
2681         }
2682
2683         /* surface stacking order, see also activate() */
2684         switch (surface_type) {
2685         case SHELL_SURFACE_POPUP:
2686         case SHELL_SURFACE_TRANSIENT:
2687                 parent = shsurf->parent;
2688                 wl_list_insert(parent->layer_link.prev, &surface->layer_link);
2689                 break;
2690         case SHELL_SURFACE_FULLSCREEN:
2691         case SHELL_SURFACE_NONE:
2692                 break;
2693         default:
2694                 ws = get_current_workspace(shell);
2695                 wl_list_insert(&ws->layer.surface_list, &surface->layer_link);
2696                 break;
2697         }
2698
2699         if (surface_type != SHELL_SURFACE_NONE) {
2700                 weston_surface_assign_output(surface);
2701                 if (surface_type == SHELL_SURFACE_MAXIMIZED)
2702                         surface->output = shsurf->output;
2703         }
2704
2705         switch (surface_type) {
2706         case SHELL_SURFACE_TRANSIENT:
2707                 if (shsurf->transient.flags ==
2708                                 WL_SHELL_SURFACE_TRANSIENT_INACTIVE)
2709                         break;
2710         case SHELL_SURFACE_TOPLEVEL:
2711         case SHELL_SURFACE_FULLSCREEN:
2712         case SHELL_SURFACE_MAXIMIZED:
2713                 if (!shell->locked) {
2714                         wl_list_for_each(seat, &compositor->seat_list, link)
2715                                 activate(shell, surface, seat);
2716                 }
2717                 break;
2718         default:
2719                 break;
2720         }
2721
2722         if (surface_type == SHELL_SURFACE_TOPLEVEL)
2723         {
2724                 switch (shell->win_animation_type) {
2725                 case ANIMATION_FADE:
2726                         weston_fade_run(surface, NULL, NULL);
2727                         break;
2728                 case ANIMATION_ZOOM:
2729                         weston_zoom_run(surface, 0.8, 1.0, NULL, NULL);
2730                         break;
2731                 default:
2732                         break;
2733                 }
2734         }
2735 }
2736
2737 static void
2738 configure(struct desktop_shell *shell, struct weston_surface *surface,
2739           GLfloat x, GLfloat y, int32_t width, int32_t height)
2740 {
2741         enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
2742         struct shell_surface *shsurf;
2743
2744         shsurf = get_shell_surface(surface);
2745         if (shsurf)
2746                 surface_type = shsurf->type;
2747
2748         surface->geometry.x = x;
2749         surface->geometry.y = y;
2750         surface->geometry.width = width;
2751         surface->geometry.height = height;
2752         surface->geometry.dirty = 1;
2753
2754         switch (surface_type) {
2755         case SHELL_SURFACE_FULLSCREEN:
2756                 shell_stack_fullscreen(shsurf);
2757                 shell_configure_fullscreen(shsurf);
2758                 break;
2759         case SHELL_SURFACE_MAXIMIZED:
2760                 /* setting x, y and using configure to change that geometry */
2761                 surface->geometry.x = surface->output->x;
2762                 surface->geometry.y = surface->output->y +
2763                         get_output_panel_height(shell,surface->output);
2764                 break;
2765         case SHELL_SURFACE_TOPLEVEL:
2766                 break;
2767         default:
2768                 break;
2769         }
2770
2771         /* XXX: would a fullscreen surface need the same handling? */
2772         if (surface->output) {
2773                 weston_surface_assign_output(surface);
2774
2775                 if (surface_type == SHELL_SURFACE_MAXIMIZED)
2776                         surface->output = shsurf->output;
2777         }
2778 }
2779
2780 static void
2781 shell_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2782 {
2783         struct shell_surface *shsurf = get_shell_surface(es);
2784         struct desktop_shell *shell = shsurf->shell;
2785         int type_changed = 0;
2786
2787         if (shsurf->next_type != SHELL_SURFACE_NONE &&
2788             shsurf->type != shsurf->next_type) {
2789                 set_surface_type(shsurf);
2790                 type_changed = 1;
2791         }
2792
2793         if (!weston_surface_is_mapped(es)) {
2794                 map(shell, es, es->buffer->width, es->buffer->height, sx, sy);
2795         } else if (type_changed || sx != 0 || sy != 0 ||
2796                    es->geometry.width != es->buffer->width ||
2797                    es->geometry.height != es->buffer->height) {
2798                 GLfloat from_x, from_y;
2799                 GLfloat to_x, to_y;
2800
2801                 weston_surface_to_global_float(es, 0, 0, &from_x, &from_y);
2802                 weston_surface_to_global_float(es, sx, sy, &to_x, &to_y);
2803                 configure(shell, es,
2804                           es->geometry.x + to_x - from_x,
2805                           es->geometry.y + to_y - from_y,
2806                           es->buffer->width, es->buffer->height);
2807         }
2808 }
2809
2810 static int launch_desktop_shell_process(struct desktop_shell *shell);
2811
2812 static void
2813 desktop_shell_sigchld(struct weston_process *process, int status)
2814 {
2815         uint32_t time;
2816         struct desktop_shell *shell =
2817                 container_of(process, struct desktop_shell, child.process);
2818
2819         shell->child.process.pid = 0;
2820         shell->child.client = NULL; /* already destroyed by wayland */
2821
2822         /* if desktop-shell dies more than 5 times in 30 seconds, give up */
2823         time = weston_compositor_get_time();
2824         if (time - shell->child.deathstamp > 30000) {
2825                 shell->child.deathstamp = time;
2826                 shell->child.deathcount = 0;
2827         }
2828
2829         shell->child.deathcount++;
2830         if (shell->child.deathcount > 5) {
2831                 weston_log("weston-desktop-shell died, giving up.\n");
2832                 return;
2833         }
2834
2835         weston_log("weston-desktop-shell died, respawning...\n");
2836         launch_desktop_shell_process(shell);
2837 }
2838
2839 static int
2840 launch_desktop_shell_process(struct desktop_shell *shell)
2841 {
2842         const char *shell_exe = LIBEXECDIR "/weston-desktop-shell";
2843
2844         shell->child.client = weston_client_launch(shell->compositor,
2845                                                  &shell->child.process,
2846                                                  shell_exe,
2847                                                  desktop_shell_sigchld);
2848
2849         if (!shell->child.client)
2850                 return -1;
2851         return 0;
2852 }
2853
2854 static void
2855 bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2856 {
2857         struct desktop_shell *shell = data;
2858
2859         wl_client_add_object(client, &wl_shell_interface,
2860                              &shell_implementation, id, shell);
2861 }
2862
2863 static void
2864 unbind_desktop_shell(struct wl_resource *resource)
2865 {
2866         struct desktop_shell *shell = resource->data;
2867
2868         if (shell->locked)
2869                 resume_desktop(shell);
2870
2871         shell->child.desktop_shell = NULL;
2872         shell->prepare_event_sent = false;
2873         free(resource);
2874 }
2875
2876 static void
2877 bind_desktop_shell(struct wl_client *client,
2878                    void *data, uint32_t version, uint32_t id)
2879 {
2880         struct desktop_shell *shell = data;
2881         struct wl_resource *resource;
2882
2883         resource = wl_client_add_object(client, &desktop_shell_interface,
2884                                         &desktop_shell_implementation,
2885                                         id, shell);
2886
2887         if (client == shell->child.client) {
2888                 resource->destroy = unbind_desktop_shell;
2889                 shell->child.desktop_shell = resource;
2890                 return;
2891         }
2892
2893         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
2894                                "permission to bind desktop_shell denied");
2895         wl_resource_destroy(resource);
2896 }
2897
2898 static void
2899 screensaver_configure(struct weston_surface *surface, int32_t sx, int32_t sy)
2900 {
2901         struct desktop_shell *shell = surface->private;
2902
2903         if (!shell->locked)
2904                 return;
2905
2906         center_on_output(surface, surface->output);
2907
2908         if (wl_list_empty(&surface->layer_link)) {
2909                 wl_list_insert(shell->lock_layer.surface_list.prev,
2910                                &surface->layer_link);
2911                 weston_surface_assign_output(surface);
2912                 shell->compositor->idle_time = shell->screensaver.duration;
2913                 weston_compositor_wake(shell->compositor);
2914                 shell->compositor->state = WESTON_COMPOSITOR_IDLE;
2915         }
2916 }
2917
2918 static void
2919 screensaver_set_surface(struct wl_client *client,
2920                         struct wl_resource *resource,
2921                         struct wl_resource *surface_resource,
2922                         struct wl_resource *output_resource)
2923 {
2924         struct desktop_shell *shell = resource->data;
2925         struct weston_surface *surface = surface_resource->data;
2926         struct weston_output *output = output_resource->data;
2927
2928         surface->configure = screensaver_configure;
2929         surface->private = shell;
2930         surface->output = output;
2931 }
2932
2933 static const struct screensaver_interface screensaver_implementation = {
2934         screensaver_set_surface
2935 };
2936
2937 static void
2938 unbind_screensaver(struct wl_resource *resource)
2939 {
2940         struct desktop_shell *shell = resource->data;
2941
2942         shell->screensaver.binding = NULL;
2943         free(resource);
2944 }
2945
2946 static void
2947 bind_screensaver(struct wl_client *client,
2948                  void *data, uint32_t version, uint32_t id)
2949 {
2950         struct desktop_shell *shell = data;
2951         struct wl_resource *resource;
2952
2953         resource = wl_client_add_object(client, &screensaver_interface,
2954                                         &screensaver_implementation,
2955                                         id, shell);
2956
2957         if (shell->screensaver.binding == NULL) {
2958                 resource->destroy = unbind_screensaver;
2959                 shell->screensaver.binding = resource;
2960                 return;
2961         }
2962
2963         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
2964                                "interface object already bound");
2965         wl_resource_destroy(resource);
2966 }
2967
2968 static void
2969 input_panel_configure(struct weston_surface *surface, int32_t sx, int32_t sy)
2970 {
2971         struct weston_mode *mode = surface->output->current;
2972         GLfloat x = (mode->width - surface->buffer->width) / 2;
2973         GLfloat y = mode->height - surface->buffer->height;
2974
2975         /* Don't map the input panel here, wait for
2976          * show_input_panels signal. */
2977
2978         weston_surface_configure(surface,
2979                                  surface->output->x + x,
2980                                  surface->output->y + y,
2981                                  surface->buffer->width,
2982                                  surface->buffer->height);
2983 }
2984
2985 static void
2986 destroy_input_panel_surface(struct wl_listener *listener,
2987                             void *data)
2988 {
2989         struct input_panel_surface *input_panel_surface =
2990                 container_of(listener, struct input_panel_surface, listener);
2991
2992         wl_list_remove(&listener->link);
2993         wl_list_remove(&input_panel_surface->link);
2994
2995         free(input_panel_surface);
2996 }
2997
2998 static void
2999 input_panel_set_surface(struct wl_client *client,
3000                         struct wl_resource *resource,
3001                         struct wl_resource *surface_resource,
3002                         struct wl_resource *output_resource)
3003 {
3004         struct desktop_shell *shell = resource->data;
3005         struct weston_surface *surface = surface_resource->data;
3006         struct weston_output *output = output_resource->data;
3007         struct input_panel_surface *input_panel_surface;
3008
3009         surface->configure = input_panel_configure;
3010         surface->private = shell;
3011         surface->output = output;
3012
3013         input_panel_surface = malloc(sizeof *input_panel_surface);
3014         if (!input_panel_surface) {
3015                 wl_resource_post_no_memory(resource);
3016                 return;
3017         }
3018
3019         input_panel_surface->surface = surface;
3020         input_panel_surface->listener.notify = destroy_input_panel_surface;
3021
3022         wl_signal_add(&surface_resource->destroy_signal,
3023                       &input_panel_surface->listener);
3024
3025         wl_list_insert(&shell->input_panel.surfaces,
3026                        &input_panel_surface->link);
3027 }
3028
3029 static const struct input_panel_interface input_panel_implementation = {
3030         input_panel_set_surface
3031 };
3032
3033 static void
3034 unbind_input_panel(struct wl_resource *resource)
3035 {
3036         struct desktop_shell *shell = resource->data;
3037
3038         shell->input_panel.binding = NULL;
3039         free(resource);
3040 }
3041
3042 static void
3043 bind_input_panel(struct wl_client *client,
3044               void *data, uint32_t version, uint32_t id)
3045 {
3046         struct desktop_shell *shell = data;
3047         struct wl_resource *resource;
3048
3049         resource = wl_client_add_object(client, &input_panel_interface,
3050                                         &input_panel_implementation,
3051                                         id, shell);
3052
3053         if (shell->input_panel.binding == NULL) {
3054                 resource->destroy = unbind_input_panel;
3055                 shell->input_panel.binding = resource;
3056                 return;
3057         }
3058
3059         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
3060                                "interface object already bound");
3061         wl_resource_destroy(resource);
3062 }
3063
3064 struct switcher {
3065         struct desktop_shell *shell;
3066         struct weston_surface *current;
3067         struct wl_listener listener;
3068         struct wl_keyboard_grab grab;
3069 };
3070
3071 static void
3072 switcher_next(struct switcher *switcher)
3073 {
3074         struct weston_surface *surface;
3075         struct weston_surface *first = NULL, *prev = NULL, *next = NULL;
3076         struct shell_surface *shsurf;
3077         struct workspace *ws = get_current_workspace(switcher->shell);
3078
3079         wl_list_for_each(surface, &ws->layer.surface_list, layer_link) {
3080                 switch (get_shell_surface_type(surface)) {
3081                 case SHELL_SURFACE_TOPLEVEL:
3082                 case SHELL_SURFACE_FULLSCREEN:
3083                 case SHELL_SURFACE_MAXIMIZED:
3084                         if (first == NULL)
3085                                 first = surface;
3086                         if (prev == switcher->current)
3087                                 next = surface;
3088                         prev = surface;
3089                         surface->alpha = 0.25;
3090                         surface->geometry.dirty = 1;
3091                         weston_surface_damage(surface);
3092                         break;
3093                 default:
3094                         break;
3095                 }
3096
3097                 if (is_black_surface(surface, NULL)) {
3098                         surface->alpha = 0.25;
3099                         surface->geometry.dirty = 1;
3100                         weston_surface_damage(surface);
3101                 }
3102         }
3103
3104         if (next == NULL)
3105                 next = first;
3106
3107         if (next == NULL)
3108                 return;
3109
3110         wl_list_remove(&switcher->listener.link);
3111         wl_signal_add(&next->surface.resource.destroy_signal,
3112                       &switcher->listener);
3113
3114         switcher->current = next;
3115         next->alpha = 1.0;
3116
3117         shsurf = get_shell_surface(switcher->current);
3118         if (shsurf && shsurf->type ==SHELL_SURFACE_FULLSCREEN)
3119                 shsurf->fullscreen.black_surface->alpha = 1.0;
3120 }
3121
3122 static void
3123 switcher_handle_surface_destroy(struct wl_listener *listener, void *data)
3124 {
3125         struct switcher *switcher =
3126                 container_of(listener, struct switcher, listener);
3127
3128         switcher_next(switcher);
3129 }
3130
3131 static void
3132 switcher_destroy(struct switcher *switcher)
3133 {
3134         struct weston_surface *surface;
3135         struct wl_keyboard *keyboard = switcher->grab.keyboard;
3136         struct workspace *ws = get_current_workspace(switcher->shell);
3137
3138         wl_list_for_each(surface, &ws->layer.surface_list, layer_link) {
3139                 surface->alpha = 1.0;
3140                 weston_surface_damage(surface);
3141         }
3142
3143         if (switcher->current)
3144                 activate(switcher->shell, switcher->current,
3145                          (struct weston_seat *) keyboard->seat);
3146         wl_list_remove(&switcher->listener.link);
3147         wl_keyboard_end_grab(keyboard);
3148         free(switcher);
3149 }
3150
3151 static void
3152 switcher_key(struct wl_keyboard_grab *grab,
3153              uint32_t time, uint32_t key, uint32_t state_w)
3154 {
3155         struct switcher *switcher = container_of(grab, struct switcher, grab);
3156         enum wl_keyboard_key_state state = state_w;
3157
3158         if (key == KEY_TAB && state == WL_KEYBOARD_KEY_STATE_PRESSED)
3159                 switcher_next(switcher);
3160 }
3161
3162 static void
3163 switcher_modifier(struct wl_keyboard_grab *grab, uint32_t serial,
3164                   uint32_t mods_depressed, uint32_t mods_latched,
3165                   uint32_t mods_locked, uint32_t group)
3166 {
3167         struct switcher *switcher = container_of(grab, struct switcher, grab);
3168         struct weston_seat *seat = (struct weston_seat *) grab->keyboard->seat;
3169
3170         if ((seat->modifier_state & switcher->shell->binding_modifier) == 0)
3171                 switcher_destroy(switcher);
3172 }
3173
3174 static const struct wl_keyboard_grab_interface switcher_grab = {
3175         switcher_key,
3176         switcher_modifier,
3177 };
3178
3179 static void
3180 switcher_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
3181                  void *data)
3182 {
3183         struct desktop_shell *shell = data;
3184         struct switcher *switcher;
3185
3186         switcher = malloc(sizeof *switcher);
3187         switcher->shell = shell;
3188         switcher->current = NULL;
3189         switcher->listener.notify = switcher_handle_surface_destroy;
3190         wl_list_init(&switcher->listener.link);
3191
3192         lower_fullscreen_layer(switcher->shell);
3193         switcher->grab.interface = &switcher_grab;
3194         wl_keyboard_start_grab(seat->keyboard, &switcher->grab);
3195         wl_keyboard_set_focus(seat->keyboard, NULL);
3196         switcher_next(switcher);
3197 }
3198
3199 static void
3200 backlight_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
3201                   void *data)
3202 {
3203         struct weston_compositor *compositor = data;
3204         struct weston_output *output;
3205         long backlight_new = 0;
3206
3207         /* TODO: we're limiting to simple use cases, where we assume just
3208          * control on the primary display. We'd have to extend later if we
3209          * ever get support for setting backlights on random desktop LCD
3210          * panels though */
3211         output = get_default_output(compositor);
3212         if (!output)
3213                 return;
3214
3215         if (!output->set_backlight)
3216                 return;
3217
3218         if (key == KEY_F9 || key == KEY_BRIGHTNESSDOWN)
3219                 backlight_new = output->backlight_current - 25;
3220         else if (key == KEY_F10 || key == KEY_BRIGHTNESSUP)
3221                 backlight_new = output->backlight_current + 25;
3222
3223         if (backlight_new < 5)
3224                 backlight_new = 5;
3225         if (backlight_new > 255)
3226                 backlight_new = 255;
3227
3228         output->backlight_current = backlight_new;
3229         output->set_backlight(output, output->backlight_current);
3230 }
3231
3232 static void
3233 debug_repaint_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
3234                       void *data)
3235 {
3236         struct desktop_shell *shell = data;
3237         struct weston_compositor *compositor = shell->compositor;
3238         struct weston_surface *surface;
3239         struct weston_plane plane;
3240
3241         if (shell->debug_repaint_surface) {
3242                 weston_surface_destroy(shell->debug_repaint_surface);
3243                 shell->debug_repaint_surface = NULL;
3244         } else {
3245                 surface = weston_surface_create(compositor);
3246                 weston_surface_set_color(surface, 1.0, 0.0, 0.0, 0.2);
3247                 weston_surface_configure(surface, 0, 0, 8192, 8192);
3248                 wl_list_insert(&compositor->fade_layer.surface_list,
3249                                &surface->layer_link);
3250                 weston_surface_assign_output(surface);
3251                 pixman_region32_init(&surface->input);
3252
3253                 /* Here's the dirty little trick that makes the
3254                  * repaint debugging work: we move the surface to a
3255                  * different plane and force an update_transform to
3256                  * update dependent state and clear the
3257                  * geometry.dirty bit.  This way the call to
3258                  * damage_below() in update_transform() does not
3259                  * add damage to the primary plane.  */
3260
3261                 weston_plane_init(&plane, 0, 0);
3262                 surface->plane = &plane;
3263                 weston_surface_update_transform(surface);
3264                 shell->debug_repaint_surface = surface;
3265                 surface->plane = &compositor->primary_plane;
3266                 weston_plane_release(&plane);
3267         }
3268 }
3269
3270 static void
3271 force_kill_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
3272                    void *data)
3273 {
3274         struct wl_surface *focus_surface;
3275         struct wl_client *client;
3276         pid_t pid;
3277         uid_t uid;
3278         gid_t gid;
3279
3280         focus_surface = seat->keyboard->focus;
3281         if (!focus_surface)
3282                 return;
3283
3284         client = focus_surface->resource.client;
3285         wl_client_get_credentials(client, &pid, &uid, &gid);
3286
3287         kill(pid, SIGKILL);
3288 }
3289
3290 static void
3291 workspace_up_binding(struct wl_seat *seat, uint32_t time,
3292                      uint32_t key, void *data)
3293 {
3294         struct desktop_shell *shell = data;
3295         unsigned int new_index = shell->workspaces.current;
3296
3297         if (shell->locked)
3298                 return;
3299         if (new_index != 0)
3300                 new_index--;
3301
3302         change_workspace(shell, new_index);
3303 }
3304
3305 static void
3306 workspace_down_binding(struct wl_seat *seat, uint32_t time,
3307                        uint32_t key, void *data)
3308 {
3309         struct desktop_shell *shell = data;
3310         unsigned int new_index = shell->workspaces.current;
3311
3312         if (shell->locked)
3313                 return;
3314         if (new_index < shell->workspaces.num - 1)
3315                 new_index++;
3316
3317         change_workspace(shell, new_index);
3318 }
3319
3320 static void
3321 workspace_f_binding(struct wl_seat *seat, uint32_t time,
3322                     uint32_t key, void *data)
3323 {
3324         struct desktop_shell *shell = data;
3325         unsigned int new_index;
3326
3327         if (shell->locked)
3328                 return;
3329         new_index = key - KEY_F1;
3330         if (new_index >= shell->workspaces.num)
3331                 new_index = shell->workspaces.num - 1;
3332
3333         change_workspace(shell, new_index);
3334 }
3335
3336
3337 static void
3338 shell_destroy(struct wl_listener *listener, void *data)
3339 {
3340         struct desktop_shell *shell =
3341                 container_of(listener, struct desktop_shell, destroy_listener);
3342         struct workspace **ws;
3343
3344         if (shell->child.client)
3345                 wl_client_destroy(shell->child.client);
3346
3347         wl_list_remove(&shell->lock_listener.link);
3348         wl_list_remove(&shell->unlock_listener.link);
3349         wl_list_remove(&shell->show_input_panel_listener.link);
3350         wl_list_remove(&shell->hide_input_panel_listener.link);
3351
3352         wl_array_for_each(ws, &shell->workspaces.array)
3353                 workspace_destroy(*ws);
3354         wl_array_release(&shell->workspaces.array);
3355
3356         free(shell->screensaver.path);
3357         free(shell);
3358 }
3359
3360 static void
3361 shell_add_bindings(struct weston_compositor *ec, struct desktop_shell *shell)
3362 {
3363         uint32_t mod;
3364         int i, num_workspace_bindings;
3365
3366         /* fixed bindings */
3367         weston_compositor_add_key_binding(ec, KEY_BACKSPACE,
3368                                           MODIFIER_CTRL | MODIFIER_ALT,
3369                                           terminate_binding, ec);
3370         weston_compositor_add_button_binding(ec, BTN_LEFT, 0,
3371                                              click_to_activate_binding,
3372                                              shell);
3373         weston_compositor_add_axis_binding(ec, WL_POINTER_AXIS_VERTICAL_SCROLL,
3374                                            MODIFIER_SUPER | MODIFIER_ALT,
3375                                            surface_opacity_binding, NULL);
3376         weston_compositor_add_axis_binding(ec, WL_POINTER_AXIS_VERTICAL_SCROLL,
3377                                            MODIFIER_SUPER, zoom_axis_binding,
3378                                            NULL);
3379
3380         /* configurable bindings */
3381         mod = shell->binding_modifier;
3382         weston_compositor_add_key_binding(ec, KEY_PAGEUP, mod,
3383                                           zoom_key_binding, NULL);
3384         weston_compositor_add_key_binding(ec, KEY_PAGEDOWN, mod,
3385                                           zoom_key_binding, NULL);
3386         weston_compositor_add_button_binding(ec, BTN_LEFT, mod, move_binding,
3387                                              shell);
3388         weston_compositor_add_button_binding(ec, BTN_MIDDLE, mod,
3389                                              resize_binding, shell);
3390         weston_compositor_add_button_binding(ec, BTN_RIGHT, mod,
3391                                              rotate_binding, NULL);
3392         weston_compositor_add_key_binding(ec, KEY_TAB, mod, switcher_binding,
3393                                           shell);
3394         weston_compositor_add_key_binding(ec, KEY_F9, mod, backlight_binding,
3395                                           ec);
3396         weston_compositor_add_key_binding(ec, KEY_BRIGHTNESSDOWN, 0,
3397                                           backlight_binding, ec);
3398         weston_compositor_add_key_binding(ec, KEY_F10, mod, backlight_binding,
3399                                           ec);
3400         weston_compositor_add_key_binding(ec, KEY_BRIGHTNESSUP, 0,
3401                                           backlight_binding, ec);
3402         weston_compositor_add_key_binding(ec, KEY_SPACE, mod | MODIFIER_SHIFT,
3403                                           debug_repaint_binding, shell);
3404         weston_compositor_add_key_binding(ec, KEY_K, mod,
3405                                           force_kill_binding, shell);
3406         weston_compositor_add_key_binding(ec, KEY_UP, mod,
3407                                           workspace_up_binding, shell);
3408         weston_compositor_add_key_binding(ec, KEY_DOWN, mod,
3409                                           workspace_down_binding, shell);
3410
3411         /* Add bindings for mod+F[1-6] for workspace 1 to 6. */
3412         if (shell->workspaces.num > 1) {
3413                 num_workspace_bindings = shell->workspaces.num;
3414                 if (num_workspace_bindings > 6)
3415                         num_workspace_bindings = 6;
3416                 for (i = 0; i < num_workspace_bindings; i++)
3417                         weston_compositor_add_key_binding(ec, KEY_F1 + i, mod,
3418                                                           workspace_f_binding,
3419                                                           shell);
3420         }
3421 }
3422
3423 int
3424 shell_init(struct weston_compositor *ec);
3425
3426 WL_EXPORT int
3427 shell_init(struct weston_compositor *ec)
3428 {
3429         struct weston_seat *seat;
3430         struct desktop_shell *shell;
3431         struct workspace **pws;
3432         unsigned int i;
3433
3434         shell = malloc(sizeof *shell);
3435         if (shell == NULL)
3436                 return -1;
3437
3438         memset(shell, 0, sizeof *shell);
3439         shell->compositor = ec;
3440
3441         shell->destroy_listener.notify = shell_destroy;
3442         wl_signal_add(&ec->destroy_signal, &shell->destroy_listener);
3443         shell->lock_listener.notify = lock;
3444         wl_signal_add(&ec->lock_signal, &shell->lock_listener);
3445         shell->unlock_listener.notify = unlock;
3446         wl_signal_add(&ec->unlock_signal, &shell->unlock_listener);
3447         shell->show_input_panel_listener.notify = show_input_panels;
3448         wl_signal_add(&ec->show_input_panel_signal, &shell->show_input_panel_listener);
3449         shell->hide_input_panel_listener.notify = hide_input_panels;
3450         wl_signal_add(&ec->hide_input_panel_signal, &shell->hide_input_panel_listener);
3451         ec->ping_handler = ping_handler;
3452         ec->shell_interface.shell = shell;
3453         ec->shell_interface.create_shell_surface = create_shell_surface;
3454         ec->shell_interface.set_toplevel = set_toplevel;
3455         ec->shell_interface.set_transient = set_transient;
3456         ec->shell_interface.move = surface_move;
3457         ec->shell_interface.resize = surface_resize;
3458
3459         wl_list_init(&shell->screensaver.surfaces);
3460         wl_list_init(&shell->input_panel.surfaces);
3461
3462         weston_layer_init(&shell->fullscreen_layer, &ec->cursor_layer.link);
3463         weston_layer_init(&shell->panel_layer, &shell->fullscreen_layer.link);
3464         weston_layer_init(&shell->background_layer, &shell->panel_layer.link);
3465         weston_layer_init(&shell->lock_layer, NULL);
3466         weston_layer_init(&shell->input_panel_layer, NULL);
3467
3468         wl_array_init(&shell->workspaces.array);
3469
3470         shell_configuration(shell);
3471
3472         for (i = 0; i < shell->workspaces.num; i++) {
3473                 pws = wl_array_add(&shell->workspaces.array, sizeof *pws);
3474                 if (pws == NULL)
3475                         return -1;
3476
3477                 *pws = workspace_create();
3478                 if (*pws == NULL)
3479                         return -1;
3480         }
3481         activate_workspace(shell, 0);
3482
3483         wl_list_init(&shell->workspaces.animation.link);
3484         shell->workspaces.animation.frame = animate_workspace_change_frame;
3485
3486         if (wl_display_add_global(ec->wl_display, &wl_shell_interface,
3487                                   shell, bind_shell) == NULL)
3488                 return -1;
3489
3490         if (wl_display_add_global(ec->wl_display,
3491                                   &desktop_shell_interface,
3492                                   shell, bind_desktop_shell) == NULL)
3493                 return -1;
3494
3495         if (wl_display_add_global(ec->wl_display, &screensaver_interface,
3496                                   shell, bind_screensaver) == NULL)
3497                 return -1;
3498
3499         if (wl_display_add_global(ec->wl_display, &input_panel_interface,
3500                                   shell, bind_input_panel) == NULL)
3501                 return -1;
3502
3503         shell->child.deathstamp = weston_compositor_get_time();
3504         if (launch_desktop_shell_process(shell) != 0)
3505                 return -1;
3506
3507         wl_list_for_each(seat, &ec->seat_list, link)
3508                 create_pointer_focus_listener(seat);
3509
3510         shell_add_bindings(ec, shell);
3511
3512         return 0;
3513 }