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
  34 #include <wayland-server.h>
  35 #include "compositor.h"
  36 #include "desktop-shell-server-protocol.h"
  37 #include "../shared/config-parser.h"
  38
  39 struct shell_surface;
  40
  41 struct wl_shell {
  42         struct weston_compositor *compositor;
  43         struct weston_shell shell;
  44
  45         struct weston_layer fullscreen_layer;
  46         struct weston_layer panel_layer;
  47         struct weston_layer toplevel_layer;
  48         struct weston_layer background_layer;
  49         struct weston_layer lock_layer;
  50
  51         struct {
  52                 struct weston_process process;
  53                 struct wl_client *client;
  54                 struct wl_resource *desktop_shell;
  55
  56                 unsigned deathcount;
  57                 uint32_t deathstamp;
  58         } child;
  59
  60         bool locked;
  61         bool prepare_event_sent;
  62
  63         struct shell_surface *lock_surface;
  64         struct wl_listener lock_surface_listener;
  65
  66         struct wl_list backgrounds;
  67         struct wl_list panels;
  68
  69         struct {
  70                 char *path;
  71                 int duration;
  72                 struct wl_resource *binding;
  73                 struct wl_list surfaces;
  74                 struct weston_process process;
  75         } screensaver;
  76
  77         struct weston_surface *debug_repaint_surface;
  78 };
  79
  80 enum shell_surface_type {
  81         SHELL_SURFACE_NONE,
  82
  83         SHELL_SURFACE_PANEL,
  84         SHELL_SURFACE_BACKGROUND,
  85         SHELL_SURFACE_LOCK,
  86         SHELL_SURFACE_SCREENSAVER,
  87
  88         SHELL_SURFACE_TOPLEVEL,
  89         SHELL_SURFACE_TRANSIENT,
  90         SHELL_SURFACE_FULLSCREEN,
  91         SHELL_SURFACE_MAXIMIZED,
  92         SHELL_SURFACE_POPUP
  93 };
  94
  95 struct shell_surface {
  96         struct wl_resource resource;
  97
  98         struct weston_surface *surface;
  99         struct wl_listener surface_destroy_listener;
 100         struct shell_surface *parent;
 101
 102         enum shell_surface_type type;
 103         int32_t saved_x, saved_y;
 104         bool saved_position_valid;
 105
 106         struct {
 107                 struct weston_transform transform;
 108                 struct weston_matrix rotation;
 109         } rotation;
 110
 111         struct {
 112                 struct wl_pointer_grab grab;
 113                 uint32_t time;
 114                 int32_t x, y;
 115                 struct weston_transform parent_transform;
 116                 int32_t initial_up;
 117         } popup;
 118
 119         struct {
 120                 enum wl_shell_surface_fullscreen_method type;
 121                 struct weston_transform transform; /* matrix from x, y */
 122                 uint32_t framerate;
 123                 struct weston_surface *black_surface;
 124         } fullscreen;
 125
 126         struct weston_output *fullscreen_output;
 127         struct weston_output *output;
 128         struct wl_list link;
 129 };
 130
 131 struct weston_move_grab {
 132         struct wl_pointer_grab grab;
 133         struct weston_surface *surface;
 134         int32_t dx, dy;
 135 };
 136
 137 struct rotate_grab {
 138         struct wl_pointer_grab grab;
 139         struct shell_surface *surface;
 140         struct weston_matrix rotation;
 141         struct {
 142                 int32_t x;
 143                 int32_t y;
 144         } center;
 145 };
 146
 147 static void
 148 center_on_output(struct weston_surface *surface,
 149                  struct weston_output *output);
 150
 151 static void
 152 shell_configuration(struct wl_shell *shell)
 153 {
 154         char *config_file;
 155         char *path = NULL;
 156         int duration = 60;
 157
 158         struct config_key saver_keys[] = {
 159                 { "path",       CONFIG_KEY_STRING,  &path },
 160                 { "duration",   CONFIG_KEY_INTEGER, &duration },
 161         };
 162
 163         struct config_section cs[] = {
 164                 { "screensaver", saver_keys, ARRAY_LENGTH(saver_keys), NULL },
 165         };
 166
 167         config_file = config_file_path("weston-desktop-shell.ini");
 168         parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
 169         free(config_file);
 170
 171         shell->screensaver.path = path;
 172         shell->screensaver.duration = duration;
 173 }
 174
 175 static void
 176 noop_grab_focus(struct wl_pointer_grab *grab, uint32_t time,
 177                 struct wl_surface *surface, int32_t x, int32_t y)
 178 {
 179         grab->focus = NULL;
 180 }
 181
 182 static void
 183 move_grab_motion(struct wl_pointer_grab *grab,
 184                  uint32_t time, int32_t x, int32_t y)
 185 {
 186         struct weston_move_grab *move = (struct weston_move_grab *) grab;
 187         struct wl_input_device *device = grab->input_device;
 188         struct weston_surface *es = move->surface;
 189
 190         weston_surface_configure(es,
 191                                  device->x + move->dx,
 192                                  device->y + move->dy,
 193                                  es->geometry.width, es->geometry.height);
 194 }
 195
 196 static void
 197 move_grab_button(struct wl_pointer_grab *grab,
 198                  uint32_t time, int32_t button, int32_t state)
 199 {
 200         struct wl_input_device *device = grab->input_device;
 201
 202         if (device->button_count == 0 && state == 0) {
 203                 wl_input_device_end_pointer_grab(device, time);
 204                 free(grab);
 205         }
 206 }
 207
 208 static const struct wl_pointer_grab_interface move_grab_interface = {
 209         noop_grab_focus,
 210         move_grab_motion,
 211         move_grab_button,
 212 };
 213
 214 static int
 215 weston_surface_move(struct weston_surface *es,
 216                     struct weston_input_device *wd, uint32_t time)
 217 {
 218         struct weston_move_grab *move;
 219
 220         move = malloc(sizeof *move);
 221         if (!move)
 222                 return -1;
 223
 224         move->grab.interface = &move_grab_interface;
 225         move->dx = es->geometry.x - wd->input_device.grab_x;
 226         move->dy = es->geometry.y - wd->input_device.grab_y;
 227         move->surface = es;
 228
 229         wl_input_device_start_pointer_grab(&wd->input_device, &move->grab, time);
 230
 231         wl_input_device_set_pointer_focus(&wd->input_device, NULL, time, 0, 0);
 232
 233         return 0;
 234 }
 235
 236 static void
 237 shell_surface_move(struct wl_client *client, struct wl_resource *resource,
 238                    struct wl_resource *input_resource, uint32_t time)
 239 {
 240         struct weston_input_device *wd = input_resource->data;
 241         struct shell_surface *shsurf = resource->data;
 242
 243         if (wd->input_device.button_count == 0 ||
 244             wd->input_device.grab_time != time ||
 245             wd->input_device.pointer_focus != &shsurf->surface->surface)
 246                 return;
 247
 248         if (weston_surface_move(shsurf->surface, wd, time) < 0)
 249                 wl_resource_post_no_memory(resource);
 250 }
 251
 252 struct weston_resize_grab {
 253         struct wl_pointer_grab grab;
 254         uint32_t edges;
 255         int32_t width, height;
 256         struct shell_surface *shsurf;
 257 };
 258
 259 static void
 260 resize_grab_motion(struct wl_pointer_grab *grab,
 261                    uint32_t time, int32_t x, int32_t y)
 262 {
 263         struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
 264         struct wl_input_device *device = grab->input_device;
 265         int32_t width, height;
 266         int32_t from_x, from_y;
 267         int32_t to_x, to_y;
 268
 269         weston_surface_from_global(resize->shsurf->surface,
 270                                    device->grab_x, device->grab_y,
 271                                    &from_x, &from_y);
 272         weston_surface_from_global(resize->shsurf->surface,
 273                                    device->x, device->y, &to_x, &to_y);
 274
 275         if (resize->edges & WL_SHELL_SURFACE_RESIZE_LEFT) {
 276                 width = resize->width + from_x - to_x;
 277         } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_RIGHT) {
 278                 width = resize->width + to_x - from_x;
 279         } else {
 280                 width = resize->width;
 281         }
 282
 283         if (resize->edges & WL_SHELL_SURFACE_RESIZE_TOP) {
 284                 height = resize->height + from_y - to_y;
 285         } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_BOTTOM) {
 286                 height = resize->height + to_y - from_y;
 287         } else {
 288                 height = resize->height;
 289         }
 290
 291         wl_shell_surface_send_configure(&resize->shsurf->resource,
 292                                         time, resize->edges, width, height);
 293 }
 294
 295 static void
 296 resize_grab_button(struct wl_pointer_grab *grab,
 297                    uint32_t time, int32_t button, int32_t state)
 298 {
 299         struct wl_input_device *device = grab->input_device;
 300
 301         if (device->button_count == 0 && state == 0) {
 302                 wl_input_device_end_pointer_grab(device, time);
 303                 free(grab);
 304         }
 305 }
 306
 307 static const struct wl_pointer_grab_interface resize_grab_interface = {
 308         noop_grab_focus,
 309         resize_grab_motion,
 310         resize_grab_button,
 311 };
 312
 313 static int
 314 weston_surface_resize(struct shell_surface *shsurf,
 315                     struct weston_input_device *wd,
 316                     uint32_t time, uint32_t edges)
 317 {
 318         struct weston_resize_grab *resize;
 319
 320         if (shsurf->type == SHELL_SURFACE_FULLSCREEN)
 321                 return 0;
 322
 323         if (edges == 0 || edges > 15 ||
 324             (edges & 3) == 3 || (edges & 12) == 12)
 325                 return 0;
 326
 327         resize = malloc(sizeof *resize);
 328         if (!resize)
 329                 return -1;
 330
 331         resize->grab.interface = &resize_grab_interface;
 332         resize->edges = edges;
 333         resize->width = shsurf->surface->geometry.width;
 334         resize->height = shsurf->surface->geometry.height;
 335         resize->shsurf = shsurf;
 336
 337         wl_input_device_start_pointer_grab(&wd->input_device, &resize->grab, time);
 338
 339         wl_input_device_set_pointer_focus(&wd->input_device, NULL, time, 0, 0);
 340
 341         return 0;
 342 }
 343
 344 static void
 345 shell_surface_resize(struct wl_client *client, struct wl_resource *resource,
 346                      struct wl_resource *input_resource, uint32_t time,
 347                      uint32_t edges)
 348 {
 349         struct weston_input_device *wd = input_resource->data;
 350         struct shell_surface *shsurf = resource->data;
 351
 352         if (shsurf->type == SHELL_SURFACE_FULLSCREEN)
 353                 return;
 354
 355         if (wd->input_device.button_count == 0 ||
 356             wd->input_device.grab_time != time ||
 357             wd->input_device.pointer_focus != &shsurf->surface->surface)
 358                 return;
 359
 360         if (weston_surface_resize(shsurf, wd, time, edges) < 0)
 361                 wl_resource_post_no_memory(resource);
 362 }
 363
 364 static struct weston_output *
 365 get_default_output(struct weston_compositor *compositor)
 366 {
 367         return container_of(compositor->output_list.next,
 368                             struct weston_output, link);
 369 }
 370
 371 static void
 372 shell_unset_fullscreen(struct shell_surface *shsurf)
 373 {
 374         /* undo all fullscreen things here */
 375         shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
 376         shsurf->fullscreen.framerate = 0;
 377         wl_list_remove(&shsurf->fullscreen.transform.link);
 378         wl_list_init(&shsurf->fullscreen.transform.link);
 379         weston_surface_destroy(shsurf->fullscreen.black_surface);
 380         shsurf->fullscreen.black_surface = NULL;
 381         shsurf->fullscreen_output = NULL;
 382         shsurf->surface->force_configure = 1;
 383         weston_surface_set_position(shsurf->surface,
 384                                     shsurf->saved_x, shsurf->saved_y);
 385 }
 386
 387 static int
 388 reset_shell_surface_type(struct shell_surface *surface)
 389 {
 390         switch (surface->type) {
 391         case SHELL_SURFACE_FULLSCREEN:
 392                 shell_unset_fullscreen(surface);
 393                 break;
 394         case SHELL_SURFACE_MAXIMIZED:
 395                 surface->output = get_default_output(surface->surface->compositor);
 396                 weston_surface_set_position(surface->surface,
 397                                             surface->saved_x,
 398                                             surface->saved_y);
 399                 break;
 400         case SHELL_SURFACE_PANEL:
 401         case SHELL_SURFACE_BACKGROUND:
 402                 wl_list_remove(&surface->link);
 403                 wl_list_init(&surface->link);
 404                 break;
 405         case SHELL_SURFACE_SCREENSAVER:
 406         case SHELL_SURFACE_LOCK:
 407                 wl_resource_post_error(&surface->resource,
 408                                        WL_DISPLAY_ERROR_INVALID_METHOD,
 409                                        "cannot reassign surface type");
 410                 return -1;
 411         case SHELL_SURFACE_NONE:
 412         case SHELL_SURFACE_TOPLEVEL:
 413         case SHELL_SURFACE_TRANSIENT:
 414         case SHELL_SURFACE_POPUP:
 415                 break;
 416         }
 417
 418         surface->type = SHELL_SURFACE_NONE;
 419         return 0;
 420 }
 421
 422 static void
 423 shell_surface_set_toplevel(struct wl_client *client,
 424                            struct wl_resource *resource)
 425
 426 {
 427         struct shell_surface *surface = resource->data;
 428
 429         if (reset_shell_surface_type(surface))
 430                 return;
 431
 432         surface->type = SHELL_SURFACE_TOPLEVEL;
 433 }
 434
 435 static void
 436 shell_surface_set_transient(struct wl_client *client,
 437                             struct wl_resource *resource,
 438                             struct wl_resource *parent_resource,
 439                             int x, int y, uint32_t flags)
 440 {
 441         struct shell_surface *shsurf = resource->data;
 442         struct weston_surface *es = shsurf->surface;
 443         struct shell_surface *pshsurf = parent_resource->data;
 444         struct weston_surface *pes = pshsurf->surface;
 445
 446         if (reset_shell_surface_type(shsurf))
 447                 return;
 448
 449         /* assign to parents output */
 450         shsurf->output = pes->output;
 451         weston_surface_set_position(es, pes->geometry.x + x,
 452                                         pes->geometry.y + y);
 453
 454         shsurf->type = SHELL_SURFACE_TRANSIENT;
 455 }
 456
 457 static struct wl_shell *
 458 shell_surface_get_shell(struct shell_surface *shsurf)
 459 {
 460         struct weston_surface *es = shsurf->surface;
 461         struct weston_shell *shell = es->compositor->shell;
 462
 463         return (struct wl_shell *)container_of(shell, struct wl_shell, shell);
 464 }
 465
 466 static int
 467 get_output_panel_height(struct wl_shell *wlshell,struct weston_output *output)
 468 {
 469         struct shell_surface *priv;
 470         int panel_height = 0;
 471
 472         if (!output)
 473                 return 0;
 474
 475         wl_list_for_each(priv, &wlshell->panels, link) {
 476                 if (priv->output == output) {
 477                         panel_height = priv->surface->geometry.height;
 478                         break;
 479                 }
 480         }
 481         return panel_height;
 482 }
 483
 484 static void
 485 shell_surface_set_maximized(struct wl_client *client,
 486                             struct wl_resource *resource,
 487                             struct wl_resource *output_resource )
 488 {
 489         struct shell_surface *shsurf = resource->data;
 490         struct weston_surface *es = shsurf->surface;
 491         struct wl_shell *wlshell = NULL;
 492         uint32_t edges = 0, panel_height = 0;
 493
 494         /* get the default output, if the client set it as NULL
 495            check whether the ouput is available */
 496         if (output_resource)
 497                 shsurf->output = output_resource->data;
 498         else
 499                 shsurf->output = get_default_output(es->compositor);
 500
 501         if (reset_shell_surface_type(shsurf))
 502                 return;
 503
 504         shsurf->saved_x = es->geometry.x;
 505         shsurf->saved_y = es->geometry.y;
 506         shsurf->saved_position_valid = true;
 507
 508         wlshell = shell_surface_get_shell(shsurf);
 509         panel_height = get_output_panel_height(wlshell, es->output);
 510         edges = WL_SHELL_SURFACE_RESIZE_TOP|WL_SHELL_SURFACE_RESIZE_LEFT;
 511
 512         wl_shell_surface_send_configure(&shsurf->resource,
 513                                         weston_compositor_get_time(), edges,
 514                                         es->output->current->width,
 515                                         es->output->current->height - panel_height);
 516
 517         shsurf->type = SHELL_SURFACE_MAXIMIZED;
 518 }
 519
 520 static struct weston_surface *
 521 create_black_surface(struct weston_compositor *ec,
 522                      GLfloat x, GLfloat y, int w, int h)
 523 {
 524         struct weston_surface *surface = NULL;
 525
 526         surface = weston_surface_create(ec);
 527         if (surface == NULL) {
 528                 fprintf(stderr, "no memory\n");
 529                 return NULL;
 530         }
 531
 532         weston_surface_configure(surface, x, y, w, h);
 533         weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1);
 534         return surface;
 535 }
 536
 537 /* Create black surface and append it to the associated fullscreen surface.
 538  * Handle size dismatch and positioning according to the method. */
 539 static void
 540 shell_configure_fullscreen(struct shell_surface *shsurf)
 541 {
 542         struct weston_output *output = shsurf->fullscreen_output;
 543         struct weston_surface *surface = shsurf->surface;
 544         struct weston_matrix *matrix;
 545         float scale;
 546
 547         center_on_output(surface, output);
 548
 549         if (!shsurf->fullscreen.black_surface)
 550                 shsurf->fullscreen.black_surface =
 551                         create_black_surface(surface->compositor,
 552                                              output->x, output->y,
 553                                              output->current->width,
 554                                              output->current->height);
 555
 556         wl_list_remove(&shsurf->fullscreen.black_surface->layer_link);
 557         wl_list_insert(&surface->layer_link,
 558                        &shsurf->fullscreen.black_surface->layer_link);
 559         shsurf->fullscreen.black_surface->output = output;
 560
 561         switch (shsurf->fullscreen.type) {
 562         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT:
 563                 break;
 564         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE:
 565                 matrix = &shsurf->fullscreen.transform.matrix;
 566                 weston_matrix_init(matrix);
 567                 scale = (float)output->current->width/(float)surface->geometry.width;
 568                 weston_matrix_scale(matrix, scale, scale, 1);
 569                 wl_list_remove(&shsurf->fullscreen.transform.link);
 570                 wl_list_insert(surface->geometry.transformation_list.prev,
 571                                &shsurf->fullscreen.transform.link);
 572                 weston_surface_set_position(surface, output->x, output->y);
 573                 break;
 574         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER:
 575                 break;
 576         case WL_SHELL_SURFACE_FULLSCREEN_METHOD_FILL:
 577                 break;
 578         default:
 579                 break;
 580         }
 581 }
 582
 583 /* make the fullscreen and black surface at the top */
 584 static void
 585 shell_stack_fullscreen(struct shell_surface *shsurf)
 586 {
 587         struct weston_surface *surface = shsurf->surface;
 588         struct wl_shell *shell = shell_surface_get_shell(shsurf);
 589
 590         wl_list_remove(&surface->layer_link);
 591         wl_list_remove(&shsurf->fullscreen.black_surface->layer_link);
 592
 593         wl_list_insert(&shell->fullscreen_layer.surface_list,
 594                        &surface->layer_link);
 595         wl_list_insert(&surface->layer_link,
 596                        &shsurf->fullscreen.black_surface->layer_link);
 597
 598         weston_surface_damage(surface);
 599         weston_surface_damage(shsurf->fullscreen.black_surface);
 600 }
 601
 602 static void
 603 shell_map_fullscreen(struct shell_surface *shsurf)
 604 {
 605         shell_configure_fullscreen(shsurf);
 606         shell_stack_fullscreen(shsurf);
 607 }
 608
 609 static void
 610 shell_surface_set_fullscreen(struct wl_client *client,
 611                              struct wl_resource *resource,
 612                              uint32_t method,
 613                              uint32_t framerate,
 614                              struct wl_resource *output_resource)
 615 {
 616         struct shell_surface *shsurf = resource->data;
 617         struct weston_surface *es = shsurf->surface;
 618
 619         if (output_resource)
 620                 shsurf->output = output_resource->data;
 621         else
 622                 shsurf->output = get_default_output(es->compositor);
 623
 624         if (reset_shell_surface_type(shsurf))
 625                 return;
 626
 627         shsurf->fullscreen_output = shsurf->output;
 628         shsurf->fullscreen.type = method;
 629         shsurf->fullscreen.framerate = framerate;
 630         shsurf->type = SHELL_SURFACE_FULLSCREEN;
 631
 632         shsurf->saved_x = es->geometry.x;
 633         shsurf->saved_y = es->geometry.y;
 634         shsurf->saved_position_valid = true;
 635
 636         if (es->output)
 637                 shsurf->surface->force_configure = 1;
 638
 639         wl_shell_surface_send_configure(&shsurf->resource,
 640                                         weston_compositor_get_time(), 0,
 641                                         shsurf->output->current->width,
 642                                         shsurf->output->current->height);
 643 }
 644
 645 static void
 646 popup_grab_focus(struct wl_pointer_grab *grab, uint32_t time,
 647                  struct wl_surface *surface, int32_t x, int32_t y)
 648 {
 649         struct wl_input_device *device = grab->input_device;
 650         struct shell_surface *priv =
 651                 container_of(grab, struct shell_surface, popup.grab);
 652         struct wl_client *client = priv->surface->surface.resource.client;
 653
 654         if (surface && surface->resource.client == client) {
 655                 wl_input_device_set_pointer_focus(device, surface, time, x, y);
 656                 grab->focus = surface;
 657         } else {
 658                 wl_input_device_set_pointer_focus(device, NULL, time, 0, 0);
 659                 grab->focus = NULL;
 660         }
 661 }
 662
 663 static void
 664 popup_grab_motion(struct wl_pointer_grab *grab,
 665                   uint32_t time, int32_t sx, int32_t sy)
 666 {
 667         struct wl_resource *resource;
 668
 669         resource = grab->input_device->pointer_focus_resource;
 670         if (resource)
 671                 wl_input_device_send_motion(resource, time, sx, sy);
 672 }
 673
 674 static void
 675 popup_grab_button(struct wl_pointer_grab *grab,
 676                   uint32_t time, int32_t button, int32_t state)
 677 {
 678         struct wl_resource *resource;
 679         struct shell_surface *shsurf =
 680                 container_of(grab, struct shell_surface, popup.grab);
 681
 682         resource = grab->input_device->pointer_focus_resource;
 683         if (resource) {
 684                 wl_input_device_send_button(resource, time, button, state);
 685         } else if (state == 0 &&
 686                    (shsurf->popup.initial_up ||
 687                     time - shsurf->popup.time > 500)) {
 688                 wl_shell_surface_send_popup_done(&shsurf->resource);
 689                 wl_input_device_end_pointer_grab(grab->input_device, time);
 690                 shsurf->popup.grab.input_device = NULL;
 691         }
 692
 693         if (state == 0)
 694                 shsurf->popup.initial_up = 1;
 695 }
 696
 697 static const struct wl_pointer_grab_interface popup_grab_interface = {
 698         popup_grab_focus,
 699         popup_grab_motion,
 700         popup_grab_button,
 701 };
 702
 703 static void
 704 shell_map_popup(struct shell_surface *shsurf, uint32_t time)
 705 {
 706         struct wl_input_device *device;
 707         struct weston_surface *es = shsurf->surface;
 708         struct weston_surface *parent = shsurf->parent->surface;
 709
 710         es->output = parent->output;
 711
 712         shsurf->popup.grab.interface = &popup_grab_interface;
 713         device = es->compositor->input_device;
 714
 715         weston_surface_update_transform(parent);
 716         if (parent->transform.enabled) {
 717                 shsurf->popup.parent_transform.matrix =
 718                         parent->transform.matrix;
 719         } else {
 720                 /* construct x, y translation matrix */
 721                 weston_matrix_init(&shsurf->popup.parent_transform.matrix);
 722                 shsurf->popup.parent_transform.matrix.d[12] =
 723                         parent->geometry.x;
 724                 shsurf->popup.parent_transform.matrix.d[13] =
 725                         parent->geometry.y;
 726         }
 727         wl_list_insert(es->geometry.transformation_list.prev,
 728                        &shsurf->popup.parent_transform.link);
 729         weston_surface_set_position(es, shsurf->popup.x, shsurf->popup.y);
 730
 731         shsurf->popup.grab.input_device = device;
 732         shsurf->popup.time = device->grab_time;
 733         shsurf->popup.initial_up = 0;
 734
 735         wl_input_device_start_pointer_grab(shsurf->popup.grab.input_device,
 736                                    &shsurf->popup.grab, shsurf->popup.time);
 737 }
 738
 739 static void
 740 shell_surface_set_popup(struct wl_client *client,
 741                         struct wl_resource *resource,
 742                         struct wl_resource *input_device_resource,
 743                         uint32_t time,
 744                         struct wl_resource *parent_resource,
 745                         int32_t x, int32_t y, uint32_t flags)
 746 {
 747         struct shell_surface *shsurf = resource->data;
 748
 749         shsurf->type = SHELL_SURFACE_POPUP;
 750         shsurf->parent = parent_resource->data;
 751         shsurf->popup.x = x;
 752         shsurf->popup.y = y;
 753 }
 754
 755 static const struct wl_shell_surface_interface shell_surface_implementation = {
 756         shell_surface_move,
 757         shell_surface_resize,
 758         shell_surface_set_toplevel,
 759         shell_surface_set_transient,
 760         shell_surface_set_fullscreen,
 761         shell_surface_set_popup,
 762         shell_surface_set_maximized
 763 };
 764
 765 static void
 766 destroy_shell_surface(struct wl_resource *resource)
 767 {
 768         struct shell_surface *shsurf = resource->data;
 769
 770         if (shsurf->popup.grab.input_device)
 771                 wl_input_device_end_pointer_grab(shsurf->popup.grab.input_device, 0);
 772
 773         /* in case cleaning up a dead client destroys shell_surface first */
 774         if (shsurf->surface)
 775                 wl_list_remove(&shsurf->surface_destroy_listener.link);
 776
 777         if (shsurf->fullscreen.black_surface)
 778                 weston_surface_destroy(shsurf->fullscreen.black_surface);
 779
 780         wl_list_remove(&shsurf->link);
 781         free(shsurf);
 782 }
 783
 784 static void
 785 shell_handle_surface_destroy(struct wl_listener *listener,
 786                              struct wl_resource *resource, uint32_t time)
 787 {
 788         struct shell_surface *shsurf = container_of(listener,
 789                                                     struct shell_surface,
 790                                                     surface_destroy_listener);
 791
 792         shsurf->surface = NULL;
 793         wl_resource_destroy(&shsurf->resource, time);
 794 }
 795
 796 static struct shell_surface *
 797 get_shell_surface(struct weston_surface *surface)
 798 {
 799         struct wl_list *lst = &surface->surface.resource.destroy_listener_list;
 800         struct wl_listener *listener;
 801
 802         /* search the destroy listener list for our callback */
 803         wl_list_for_each(listener, lst, link) {
 804                 if (listener->func == shell_handle_surface_destroy) {
 805                         return container_of(listener, struct shell_surface,
 806                                             surface_destroy_listener);
 807                 }
 808         }
 809
 810         return NULL;
 811 }
 812
 813 static void
 814 shell_get_shell_surface(struct wl_client *client,
 815                         struct wl_resource *resource,
 816                         uint32_t id,
 817                         struct wl_resource *surface_resource)
 818 {
 819         struct weston_surface *surface = surface_resource->data;
 820         struct shell_surface *shsurf;
 821
 822         if (get_shell_surface(surface)) {
 823                 wl_resource_post_error(surface_resource,
 824                         WL_DISPLAY_ERROR_INVALID_OBJECT,
 825                         "wl_shell::get_shell_surface already requested");
 826                 return;
 827         }
 828
 829         shsurf = calloc(1, sizeof *shsurf);
 830         if (!shsurf) {
 831                 wl_resource_post_no_memory(resource);
 832                 return;
 833         }
 834
 835         shsurf->resource.destroy = destroy_shell_surface;
 836         shsurf->resource.object.id = id;
 837         shsurf->resource.object.interface = &wl_shell_surface_interface;
 838         shsurf->resource.object.implementation =
 839                 (void (**)(void)) &shell_surface_implementation;
 840         shsurf->resource.data = shsurf;
 841
 842         shsurf->saved_position_valid = false;
 843         shsurf->surface = surface;
 844         shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
 845         shsurf->fullscreen.framerate = 0;
 846         shsurf->fullscreen.black_surface = NULL;
 847         wl_list_init(&shsurf->fullscreen.transform.link);
 848
 849         shsurf->surface_destroy_listener.func = shell_handle_surface_destroy;
 850         wl_list_insert(surface->surface.resource.destroy_listener_list.prev,
 851                        &shsurf->surface_destroy_listener.link);
 852
 853         /* init link so its safe to always remove it in destroy_shell_surface */
 854         wl_list_init(&shsurf->link);
 855
 856         /* empty when not in use */
 857         wl_list_init(&shsurf->rotation.transform.link);
 858         weston_matrix_init(&shsurf->rotation.rotation);
 859
 860         shsurf->type = SHELL_SURFACE_NONE;
 861
 862         wl_client_add_resource(client, &shsurf->resource);
 863 }
 864
 865 static const struct wl_shell_interface shell_implementation = {
 866         shell_get_shell_surface
 867 };
 868
 869 static void
 870 handle_screensaver_sigchld(struct weston_process *proc, int status)
 871 {
 872         proc->pid = 0;
 873 }
 874
 875 static void
 876 launch_screensaver(struct wl_shell *shell)
 877 {
 878         if (shell->screensaver.binding)
 879                 return;
 880
 881         if (!shell->screensaver.path)
 882                 return;
 883
 884         if (shell->screensaver.process.pid != 0) {
 885                 fprintf(stderr, "old screensaver still running\n");
 886                 return;
 887         }
 888
 889         weston_client_launch(shell->compositor,
 890                            &shell->screensaver.process,
 891                            shell->screensaver.path,
 892                            handle_screensaver_sigchld);
 893 }
 894
 895 static void
 896 terminate_screensaver(struct wl_shell *shell)
 897 {
 898         if (shell->screensaver.process.pid == 0)
 899                 return;
 900
 901         kill(shell->screensaver.process.pid, SIGTERM);
 902 }
 903
 904 static void
 905 show_screensaver(struct wl_shell *shell, struct shell_surface *surface)
 906 {
 907         struct wl_list *list;
 908
 909         if (shell->lock_surface)
 910                 list = &shell->lock_surface->surface->layer_link;
 911         else
 912                 list = &shell->lock_layer.surface_list;
 913
 914         wl_list_remove(&surface->surface->layer_link);
 915         wl_list_insert(list, &surface->surface->layer_link);
 916         surface->surface->output = surface->output;
 917         weston_surface_damage(surface->surface);
 918 }
 919
 920 static void
 921 hide_screensaver(struct wl_shell *shell, struct shell_surface *surface)
 922 {
 923         wl_list_remove(&surface->surface->layer_link);
 924         wl_list_init(&surface->surface->layer_link);
 925         surface->surface->output = NULL;
 926 }
 927
 928 static void
 929 desktop_shell_set_background(struct wl_client *client,
 930                              struct wl_resource *resource,
 931                              struct wl_resource *output_resource,
 932                              struct wl_resource *surface_resource)
 933 {
 934         struct wl_shell *shell = resource->data;
 935         struct shell_surface *shsurf = surface_resource->data;
 936         struct weston_surface *surface = shsurf->surface;
 937         struct shell_surface *priv;
 938
 939         if (reset_shell_surface_type(shsurf))
 940                 return;
 941
 942         wl_list_for_each(priv, &shell->backgrounds, link) {
 943                 if (priv->output == output_resource->data) {
 944                         priv->surface->output = NULL;
 945                         wl_list_remove(&priv->surface->layer_link);
 946                         wl_list_remove(&priv->link);
 947                         break;
 948                 }
 949         }
 950
 951         shsurf->type = SHELL_SURFACE_BACKGROUND;
 952         shsurf->output = output_resource->data;
 953
 954         wl_list_insert(&shell->backgrounds, &shsurf->link);
 955
 956         weston_surface_set_position(surface, shsurf->output->x,
 957                                     shsurf->output->y);
 958
 959         desktop_shell_send_configure(resource,
 960                                      weston_compositor_get_time(), 0,
 961                                      surface_resource,
 962                                      shsurf->output->current->width,
 963                                      shsurf->output->current->height);
 964 }
 965
 966 static void
 967 desktop_shell_set_panel(struct wl_client *client,
 968                         struct wl_resource *resource,
 969                         struct wl_resource *output_resource,
 970                         struct wl_resource *surface_resource)
 971 {
 972         struct wl_shell *shell = resource->data;
 973         struct shell_surface *shsurf = surface_resource->data;
 974         struct weston_surface *surface = shsurf->surface;
 975         struct shell_surface *priv;
 976
 977         if (reset_shell_surface_type(shsurf))
 978                 return;
 979
 980         wl_list_for_each(priv, &shell->panels, link) {
 981                 if (priv->output == output_resource->data) {
 982                         priv->surface->output = NULL;
 983                         wl_list_remove(&priv->surface->layer_link);
 984                         wl_list_remove(&priv->link);
 985                         break;
 986                 }
 987         }
 988
 989         shsurf->type = SHELL_SURFACE_PANEL;
 990         shsurf->output = output_resource->data;
 991
 992         wl_list_insert(&shell->panels, &shsurf->link);
 993
 994         weston_surface_set_position(surface, shsurf->output->x,
 995                                     shsurf->output->y);
 996
 997         desktop_shell_send_configure(resource,
 998                                      weston_compositor_get_time(), 0,
 999                                      surface_resource,
1000                                      shsurf->output->current->width,
1001                                      shsurf->output->current->height);
1002 }
1003
1004 static void
1005 handle_lock_surface_destroy(struct wl_listener *listener,
1006                             struct wl_resource *resource, uint32_t time)
1007 {
1008         struct wl_shell *shell =
1009                 container_of(listener, struct wl_shell, lock_surface_listener);
1010
1011         fprintf(stderr, "lock surface gone\n");
1012         shell->lock_surface = NULL;
1013 }
1014
1015 static void
1016 desktop_shell_set_lock_surface(struct wl_client *client,
1017                                struct wl_resource *resource,
1018                                struct wl_resource *surface_resource)
1019 {
1020         struct wl_shell *shell = resource->data;
1021         struct shell_surface *surface = surface_resource->data;
1022
1023         if (reset_shell_surface_type(surface))
1024                 return;
1025
1026         shell->prepare_event_sent = false;
1027
1028         if (!shell->locked)
1029                 return;
1030
1031         shell->lock_surface = surface;
1032
1033         shell->lock_surface_listener.func = handle_lock_surface_destroy;
1034         wl_list_insert(&surface_resource->destroy_listener_list,
1035                        &shell->lock_surface_listener.link);
1036
1037         shell->lock_surface->type = SHELL_SURFACE_LOCK;
1038 }
1039
1040 static void
1041 resume_desktop(struct wl_shell *shell)
1042 {
1043         struct shell_surface *tmp;
1044
1045         wl_list_for_each(tmp, &shell->screensaver.surfaces, link)
1046                 hide_screensaver(shell, tmp);
1047
1048         terminate_screensaver(shell);
1049
1050         wl_list_remove(&shell->lock_layer.link);
1051         wl_list_insert(&shell->compositor->cursor_layer.link,
1052                        &shell->fullscreen_layer.link);
1053         wl_list_insert(&shell->fullscreen_layer.link,
1054                        &shell->panel_layer.link);
1055         wl_list_insert(&shell->panel_layer.link, &shell->toplevel_layer.link);
1056
1057         shell->locked = false;
1058         shell->compositor->idle_time = shell->compositor->option_idle_time;
1059         weston_compositor_wake(shell->compositor);
1060         weston_compositor_damage_all(shell->compositor);
1061 }
1062
1063 static void
1064 desktop_shell_unlock(struct wl_client *client,
1065                      struct wl_resource *resource)
1066 {
1067         struct wl_shell *shell = resource->data;
1068
1069         shell->prepare_event_sent = false;
1070
1071         if (shell->locked)
1072                 resume_desktop(shell);
1073 }
1074
1075 static const struct desktop_shell_interface desktop_shell_implementation = {
1076         desktop_shell_set_background,
1077         desktop_shell_set_panel,
1078         desktop_shell_set_lock_surface,
1079         desktop_shell_unlock
1080 };
1081
1082 static enum shell_surface_type
1083 get_shell_surface_type(struct weston_surface *surface)
1084 {
1085         struct shell_surface *shsurf;
1086
1087         shsurf = get_shell_surface(surface);
1088         if (!shsurf)
1089                 return SHELL_SURFACE_NONE;
1090         return shsurf->type;
1091 }
1092
1093 static void
1094 move_binding(struct wl_input_device *device, uint32_t time,
1095              uint32_t key, uint32_t button, uint32_t state, void *data)
1096 {
1097         struct weston_surface *surface =
1098                 (struct weston_surface *) device->pointer_focus;
1099
1100         if (surface == NULL)
1101                 return;
1102
1103         switch (get_shell_surface_type(surface)) {
1104                 case SHELL_SURFACE_PANEL:
1105                 case SHELL_SURFACE_BACKGROUND:
1106                 case SHELL_SURFACE_FULLSCREEN:
1107                 case SHELL_SURFACE_SCREENSAVER:
1108                         return;
1109                 default:
1110                         break;
1111         }
1112
1113         weston_surface_move(surface, (struct weston_input_device *) device, time);
1114 }
1115
1116 static void
1117 resize_binding(struct wl_input_device *device, uint32_t time,
1118                uint32_t key, uint32_t button, uint32_t state, void *data)
1119 {
1120         struct weston_surface *surface =
1121                 (struct weston_surface *) device->pointer_focus;
1122         uint32_t edges = 0;
1123         int32_t x, y;
1124         struct shell_surface *shsurf;
1125
1126         if (surface == NULL)
1127                 return;
1128
1129         shsurf = get_shell_surface(surface);
1130         if (!shsurf)
1131                 return;
1132
1133         switch (shsurf->type) {
1134                 case SHELL_SURFACE_PANEL:
1135                 case SHELL_SURFACE_BACKGROUND:
1136                 case SHELL_SURFACE_FULLSCREEN:
1137                 case SHELL_SURFACE_SCREENSAVER:
1138                         return;
1139                 default:
1140                         break;
1141         }
1142
1143         weston_surface_from_global(surface,
1144                                    device->grab_x, device->grab_y, &x, &y);
1145
1146         if (x < surface->geometry.width / 3)
1147                 edges |= WL_SHELL_SURFACE_RESIZE_LEFT;
1148         else if (x < 2 * surface->geometry.width / 3)
1149                 edges |= 0;
1150         else
1151                 edges |= WL_SHELL_SURFACE_RESIZE_RIGHT;
1152
1153         if (y < surface->geometry.height / 3)
1154                 edges |= WL_SHELL_SURFACE_RESIZE_TOP;
1155         else if (y < 2 * surface->geometry.height / 3)
1156                 edges |= 0;
1157         else
1158                 edges |= WL_SHELL_SURFACE_RESIZE_BOTTOM;
1159
1160         weston_surface_resize(shsurf, (struct weston_input_device *) device,
1161                             time, edges);
1162 }
1163
1164 static void
1165 zoom_binding(struct wl_input_device *device, uint32_t time,
1166                uint32_t key, uint32_t button, uint32_t state, void *data)
1167 {
1168         struct weston_input_device *wd = (struct weston_input_device *) device;
1169         struct weston_compositor *compositor = wd->compositor;
1170         struct weston_output *output;
1171
1172         wl_list_for_each(output, &compositor->output_list, link) {
1173                 if (pixman_region32_contains_point(&output->region,
1174                                                 device->x, device->y, NULL)) {
1175                         if (state && key == KEY_UP) {
1176                                 output->zoom.active = 1;
1177                                 output->zoom.level -= output->zoom.increment;
1178                         }
1179                         if (state && key == KEY_DOWN)
1180                                 output->zoom.level += output->zoom.increment;
1181
1182                         if (output->zoom.level >= 1.0) {
1183                                 output->zoom.active = 0;
1184                                 output->zoom.level = 1.0;
1185                         }
1186
1187                         if (output->zoom.level < output->zoom.increment)
1188                                 output->zoom.level = output->zoom.increment;
1189
1190                         weston_output_update_zoom(output, device->x, device->y);
1191                 }
1192         }
1193 }
1194
1195 static void
1196 terminate_binding(struct wl_input_device *device, uint32_t time,
1197                   uint32_t key, uint32_t button, uint32_t state, void *data)
1198 {
1199         struct weston_compositor *compositor = data;
1200
1201         if (state)
1202                 wl_display_terminate(compositor->wl_display);
1203 }
1204
1205 static void
1206 rotate_grab_motion(struct wl_pointer_grab *grab,
1207                  uint32_t time, int32_t x, int32_t y)
1208 {
1209         struct rotate_grab *rotate =
1210                 container_of(grab, struct rotate_grab, grab);
1211         struct wl_input_device *device = grab->input_device;
1212         struct shell_surface *surface = rotate->surface;
1213         GLfloat cx = 0.5f * surface->surface->geometry.width;
1214         GLfloat cy = 0.5f * surface->surface->geometry.height;
1215         GLfloat dx, dy;
1216         GLfloat r;
1217
1218         dx = device->x - rotate->center.x;
1219         dy = device->y - rotate->center.y;
1220         r = sqrtf(dx * dx + dy * dy);
1221
1222         wl_list_remove(&surface->rotation.transform.link);
1223         surface->surface->geometry.dirty = 1;
1224
1225         if (r > 20.0f) {
1226                 struct weston_matrix *matrix =
1227                         &surface->rotation.transform.matrix;
1228
1229                 weston_matrix_init(&rotate->rotation);
1230                 rotate->rotation.d[0] = dx / r;
1231                 rotate->rotation.d[4] = -dy / r;
1232                 rotate->rotation.d[1] = -rotate->rotation.d[4];
1233                 rotate->rotation.d[5] = rotate->rotation.d[0];
1234
1235                 weston_matrix_init(matrix);
1236                 weston_matrix_translate(matrix, -cx, -cy, 0.0f);
1237                 weston_matrix_multiply(matrix, &surface->rotation.rotation);
1238                 weston_matrix_multiply(matrix, &rotate->rotation);
1239                 weston_matrix_translate(matrix, cx, cy, 0.0f);
1240
1241                 wl_list_insert(
1242                         &surface->surface->geometry.transformation_list,
1243                         &surface->rotation.transform.link);
1244         } else {
1245                 wl_list_init(&surface->rotation.transform.link);
1246                 weston_matrix_init(&surface->rotation.rotation);
1247                 weston_matrix_init(&rotate->rotation);
1248         }
1249
1250         /* Repaint implies weston_surface_update_transform(), which
1251          * lazily applies the damage due to rotation update.
1252          */
1253         weston_compositor_schedule_repaint(surface->surface->compositor);
1254 }
1255
1256 static void
1257 rotate_grab_button(struct wl_pointer_grab *grab,
1258                  uint32_t time, int32_t button, int32_t state)
1259 {
1260         struct rotate_grab *rotate =
1261                 container_of(grab, struct rotate_grab, grab);
1262         struct wl_input_device *device = grab->input_device;
1263         struct shell_surface *surface = rotate->surface;
1264
1265         if (device->button_count == 0 && state == 0) {
1266                 weston_matrix_multiply(&surface->rotation.rotation,
1267                                        &rotate->rotation);
1268                 wl_input_device_end_pointer_grab(device, time);
1269                 free(rotate);
1270         }
1271 }
1272
1273 static const struct wl_pointer_grab_interface rotate_grab_interface = {
1274         noop_grab_focus,
1275         rotate_grab_motion,
1276         rotate_grab_button,
1277 };
1278
1279 static void
1280 rotate_binding(struct wl_input_device *device, uint32_t time,
1281                uint32_t key, uint32_t button, uint32_t state, void *data)
1282 {
1283         struct weston_surface *base_surface =
1284                 (struct weston_surface *) device->pointer_focus;
1285         struct shell_surface *surface;
1286         struct rotate_grab *rotate;
1287         GLfloat dx, dy, cx, cy, cposx, cposy, dposx, dposy;
1288         GLfloat r;
1289
1290         if (base_surface == NULL)
1291                 return;
1292
1293         surface = get_shell_surface(base_surface);
1294         if (!surface)
1295                 return;
1296
1297         switch (surface->type) {
1298                 case SHELL_SURFACE_PANEL:
1299                 case SHELL_SURFACE_BACKGROUND:
1300                 case SHELL_SURFACE_FULLSCREEN:
1301                 case SHELL_SURFACE_SCREENSAVER:
1302                         return;
1303                 default:
1304                         break;
1305         }
1306
1307         rotate = malloc(sizeof *rotate);
1308         if (!rotate)
1309                 return;
1310
1311         rotate->grab.interface = &rotate_grab_interface;
1312         rotate->surface = surface;
1313
1314         weston_surface_to_global(surface->surface,
1315                                  surface->surface->geometry.width / 2,
1316                                  surface->surface->geometry.height / 2,
1317                                  &rotate->center.x, &rotate->center.y);
1318
1319         wl_input_device_start_pointer_grab(device, &rotate->grab, time);
1320
1321         dx = device->x - rotate->center.x;
1322         dy = device->y - rotate->center.y;
1323         r = sqrtf(dx * dx + dy * dy);
1324         if (r > 20.0f) {
1325                 struct weston_matrix inverse;
1326
1327                 weston_matrix_init(&inverse);
1328                 inverse.d[0] = dx / r;
1329                 inverse.d[4] = dy / r;
1330                 inverse.d[1] = -inverse.d[4];
1331                 inverse.d[5] = inverse.d[0];
1332                 weston_matrix_multiply(&surface->rotation.rotation, &inverse);
1333         } else {
1334                 weston_matrix_init(&surface->rotation.rotation);
1335                 weston_matrix_init(&rotate->rotation);
1336         }
1337
1338         /* We need to adjust the position of the surface
1339          * in case it was resized in a rotated state before */
1340         cx = 0.5f * surface->surface->geometry.width;
1341         cy = 0.5f * surface->surface->geometry.height;
1342         cposx = surface->surface->geometry.x + cx;
1343         cposy = surface->surface->geometry.y + cy;
1344         dposx = rotate->center.x - cposx;
1345         dposy = rotate->center.y - cposy;
1346         if (dposx != 0 || dposy != 0) {
1347                 weston_surface_set_position(base_surface,
1348                                 base_surface->geometry.x + dposx,
1349                                 base_surface->geometry.y + dposy);
1350         }
1351
1352         wl_input_device_set_pointer_focus(device, NULL, time, 0, 0);
1353 }
1354
1355 static void
1356 activate(struct weston_shell *base, struct weston_surface *es,
1357          struct weston_input_device *device, uint32_t time)
1358 {
1359         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1360         struct weston_compositor *compositor = shell->compositor;
1361
1362         weston_surface_activate(es, device, time);
1363
1364         if (compositor->wxs)
1365                 weston_xserver_surface_activate(es);
1366
1367         switch (get_shell_surface_type(es)) {
1368         case SHELL_SURFACE_BACKGROUND:
1369         case SHELL_SURFACE_PANEL:
1370         case SHELL_SURFACE_LOCK:
1371                 break;
1372
1373         case SHELL_SURFACE_SCREENSAVER:
1374                 /* always below lock surface */
1375                 if (shell->lock_surface)
1376                         weston_surface_restack(es,
1377                                                &shell->lock_surface->surface->layer_link);
1378                 break;
1379         case SHELL_SURFACE_FULLSCREEN:
1380                 /* should on top of panels */
1381                 break;
1382         default:
1383                 weston_surface_restack(es,
1384                                        &shell->toplevel_layer.surface_list);
1385                 break;
1386         }
1387 }
1388
1389 static void
1390 click_to_activate_binding(struct wl_input_device *device,
1391                           uint32_t time, uint32_t key,
1392                           uint32_t button, uint32_t state, void *data)
1393 {
1394         struct weston_input_device *wd = (struct weston_input_device *) device;
1395         struct weston_compositor *compositor = data;
1396         struct weston_surface *focus;
1397         struct weston_surface *upper;
1398
1399         focus = (struct weston_surface *) device->pointer_focus;
1400         if (!focus)
1401                 return;
1402
1403         upper = container_of(focus->link.prev, struct weston_surface, link);
1404         if (focus->link.prev != &compositor->surface_list &&
1405             get_shell_surface_type(upper) == SHELL_SURFACE_FULLSCREEN) {
1406                 printf("%s: focus is black surface, raise its fullscreen surface\n", __func__);
1407                 shell_stack_fullscreen(get_shell_surface(upper));
1408                 focus = upper;
1409         }
1410
1411         if (state && device->pointer_grab == &device->default_pointer_grab)
1412                 activate(compositor->shell, focus, wd, time);
1413 }
1414
1415 static void
1416 lock(struct weston_shell *base)
1417 {
1418         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1419         struct weston_input_device *device;
1420         struct shell_surface *shsurf;
1421         struct weston_output *output;
1422         uint32_t time;
1423
1424         if (shell->locked) {
1425                 wl_list_for_each(output, &shell->compositor->output_list, link)
1426                         /* TODO: find a way to jump to other DPMS levels */
1427                         if (output->set_dpms)
1428                                 output->set_dpms(output, WESTON_DPMS_STANDBY);
1429                 return;
1430         }
1431
1432         shell->locked = true;
1433
1434         /* Hide all surfaces by removing the fullscreen, panel and
1435          * toplevel layers.  This way nothing else can show or receive
1436          * input events while we are locked. */
1437
1438         wl_list_remove(&shell->panel_layer.link);
1439         wl_list_remove(&shell->toplevel_layer.link);
1440         wl_list_remove(&shell->fullscreen_layer.link);
1441         wl_list_insert(&shell->compositor->cursor_layer.link,
1442                        &shell->lock_layer.link);
1443
1444         launch_screensaver(shell);
1445
1446         wl_list_for_each(shsurf, &shell->screensaver.surfaces, link)
1447                 show_screensaver(shell, shsurf);
1448
1449         if (!wl_list_empty(&shell->screensaver.surfaces)) {
1450                 shell->compositor->idle_time = shell->screensaver.duration;
1451                 weston_compositor_wake(shell->compositor);
1452                 shell->compositor->state = WESTON_COMPOSITOR_IDLE;
1453         }
1454
1455         /* reset pointer foci */
1456         weston_compositor_schedule_repaint(shell->compositor);
1457
1458         /* reset keyboard foci */
1459         time = weston_compositor_get_time();
1460         wl_list_for_each(device, &shell->compositor->input_device_list, link) {
1461                 wl_input_device_set_keyboard_focus(&device->input_device,
1462                                                    NULL, time);
1463         }
1464
1465         /* TODO: disable bindings that should not work while locked. */
1466
1467         /* All this must be undone in resume_desktop(). */
1468 }
1469
1470 static void
1471 unlock(struct weston_shell *base)
1472 {
1473         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1474
1475         if (!shell->locked || shell->lock_surface) {
1476                 weston_compositor_wake(shell->compositor);
1477                 return;
1478         }
1479
1480         /* If desktop-shell client has gone away, unlock immediately. */
1481         if (!shell->child.desktop_shell) {
1482                 resume_desktop(shell);
1483                 return;
1484         }
1485
1486         if (shell->prepare_event_sent)
1487                 return;
1488
1489         desktop_shell_send_prepare_lock_surface(shell->child.desktop_shell);
1490         shell->prepare_event_sent = true;
1491 }
1492
1493 static void
1494 center_on_output(struct weston_surface *surface, struct weston_output *output)
1495 {
1496         struct weston_mode *mode = output->current;
1497         GLfloat x = (mode->width - surface->geometry.width) / 2;
1498         GLfloat y = (mode->height - surface->geometry.height) / 2;
1499
1500         weston_surface_set_position(surface, output->x + x, output->y + y);
1501 }
1502
1503 static void
1504 map(struct weston_shell *base, struct weston_surface *surface,
1505     int32_t width, int32_t height, int32_t sx, int32_t sy)
1506 {
1507         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1508         struct weston_compositor *compositor = shell->compositor;
1509         struct shell_surface *shsurf;
1510         enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
1511         struct weston_surface *parent;
1512         int panel_height = 0;
1513
1514         shsurf = get_shell_surface(surface);
1515         if (shsurf)
1516                 surface_type = shsurf->type;
1517
1518         surface->geometry.width = width;
1519         surface->geometry.height = height;
1520         surface->geometry.dirty = 1;
1521
1522         weston_compositor_update_drag_surfaces(compositor);
1523
1524         /* initial positioning, see also configure() */
1525         switch (surface_type) {
1526         case SHELL_SURFACE_TOPLEVEL:
1527                 weston_surface_set_position(surface, 10 + random() % 400,
1528                                             10 + random() % 400);
1529                 break;
1530         case SHELL_SURFACE_SCREENSAVER:
1531                 center_on_output(surface, shsurf->fullscreen_output);
1532                 break;
1533         case SHELL_SURFACE_FULLSCREEN:
1534                 shell_map_fullscreen(shsurf);
1535                 break;
1536         case SHELL_SURFACE_MAXIMIZED:
1537                 /* use surface configure to set the geometry */
1538                 panel_height = get_output_panel_height(shell,surface->output);
1539                 weston_surface_set_position(surface, surface->output->x,
1540                                             surface->output->y + panel_height);
1541                 break;
1542         case SHELL_SURFACE_LOCK:
1543                 center_on_output(surface, get_default_output(compositor));
1544                 break;
1545         case SHELL_SURFACE_POPUP:
1546                 shell_map_popup(shsurf, shsurf->popup.time);
1547         case SHELL_SURFACE_NONE:
1548                 weston_surface_set_position(surface,
1549                                             surface->geometry.x + sx,
1550                                             surface->geometry.y + sy);
1551                 break;
1552         default:
1553                 ;
1554         }
1555
1556         /* surface stacking order, see also activate() */
1557         switch (surface_type) {
1558         case SHELL_SURFACE_BACKGROUND:
1559                 /* background always visible, at the bottom */
1560                 wl_list_insert(&shell->background_layer.surface_list,
1561                                &surface->layer_link);
1562                 break;
1563         case SHELL_SURFACE_PANEL:
1564                 /* panel always on top, hidden while locked */
1565                 wl_list_insert(&shell->panel_layer.surface_list,
1566                                &surface->layer_link);
1567                 break;
1568         case SHELL_SURFACE_LOCK:
1569                 /* lock surface always visible, on top */
1570                 wl_list_insert(&shell->lock_layer.surface_list,
1571                                &surface->layer_link);
1572                 weston_compositor_wake(compositor);
1573                 break;
1574         case SHELL_SURFACE_SCREENSAVER:
1575                 /* If locked, show it. */
1576                 if (shell->locked) {
1577                         show_screensaver(shell, shsurf);
1578                         compositor->idle_time = shell->screensaver.duration;
1579                         weston_compositor_wake(compositor);
1580                         if (!shell->lock_surface)
1581                                 compositor->state = WESTON_COMPOSITOR_IDLE;
1582                 }
1583                 break;
1584         case SHELL_SURFACE_POPUP:
1585         case SHELL_SURFACE_TRANSIENT:
1586                 parent = shsurf->parent->surface;
1587                 wl_list_insert(parent->layer_link.prev, &surface->layer_link);
1588                 break;
1589         case SHELL_SURFACE_FULLSCREEN:
1590         case SHELL_SURFACE_NONE:
1591                 break;
1592         default:
1593                 wl_list_insert(&shell->toplevel_layer.surface_list,
1594                                &surface->layer_link);
1595                 break;
1596         }
1597
1598         if (surface_type != SHELL_SURFACE_NONE) {
1599                 weston_surface_assign_output(surface);
1600                 if (surface_type == SHELL_SURFACE_MAXIMIZED)
1601                         surface->output = shsurf->output;
1602         }
1603
1604         switch (surface_type) {
1605         case SHELL_SURFACE_TOPLEVEL:
1606         case SHELL_SURFACE_TRANSIENT:
1607         case SHELL_SURFACE_FULLSCREEN:
1608         case SHELL_SURFACE_MAXIMIZED:
1609                 if (!shell->locked)
1610                         activate(base, surface,
1611                                  (struct weston_input_device *)
1612                                  compositor->input_device,
1613                                  weston_compositor_get_time());
1614                 break;
1615         default:
1616                 break;
1617         }
1618
1619         if (surface_type == SHELL_SURFACE_TOPLEVEL)
1620                 weston_zoom_run(surface, 0.8, 1.0, NULL, NULL);
1621 }
1622
1623 static void
1624 configure(struct weston_shell *base, struct weston_surface *surface,
1625           GLfloat x, GLfloat y, int32_t width, int32_t height)
1626 {
1627         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1628         enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
1629         enum shell_surface_type prev_surface_type = SHELL_SURFACE_NONE;
1630         struct shell_surface *shsurf;
1631
1632         shsurf = get_shell_surface(surface);
1633         if (shsurf)
1634                 surface_type = shsurf->type;
1635
1636         surface->geometry.x = x;
1637         surface->geometry.y = y;
1638         surface->geometry.width = width;
1639         surface->geometry.height = height;
1640         surface->geometry.dirty = 1;
1641
1642         switch (surface_type) {
1643         case SHELL_SURFACE_SCREENSAVER:
1644                 center_on_output(surface, shsurf->fullscreen_output);
1645                 break;
1646         case SHELL_SURFACE_FULLSCREEN:
1647                 shell_configure_fullscreen(shsurf);
1648                 if (prev_surface_type != SHELL_SURFACE_FULLSCREEN)
1649                         shell_stack_fullscreen(shsurf);
1650                 break;
1651         case SHELL_SURFACE_MAXIMIZED:
1652                 /* setting x, y and using configure to change that geometry */
1653                 surface->geometry.x = surface->output->x;
1654                 surface->geometry.y = surface->output->y +
1655                         get_output_panel_height(shell,surface->output);
1656                 break;
1657         case SHELL_SURFACE_TOPLEVEL:
1658                 break;
1659         default:
1660                 break;
1661         }
1662
1663         /* XXX: would a fullscreen surface need the same handling? */
1664         if (surface->output) {
1665                 weston_surface_assign_output(surface);
1666
1667                 if (surface_type == SHELL_SURFACE_SCREENSAVER)
1668                         surface->output = shsurf->output;
1669                 else if (surface_type == SHELL_SURFACE_MAXIMIZED)
1670                         surface->output = shsurf->output;
1671         }
1672 }
1673
1674 static int launch_desktop_shell_process(struct wl_shell *shell);
1675
1676 static void
1677 desktop_shell_sigchld(struct weston_process *process, int status)
1678 {
1679         uint32_t time;
1680         struct wl_shell *shell =
1681                 container_of(process, struct wl_shell, child.process);
1682
1683         shell->child.process.pid = 0;
1684         shell->child.client = NULL; /* already destroyed by wayland */
1685
1686         /* if desktop-shell dies more than 5 times in 30 seconds, give up */
1687         time = weston_compositor_get_time();
1688         if (time - shell->child.deathstamp > 30000) {
1689                 shell->child.deathstamp = time;
1690                 shell->child.deathcount = 0;
1691         }
1692
1693         shell->child.deathcount++;
1694         if (shell->child.deathcount > 5) {
1695                 fprintf(stderr, "weston-desktop-shell died, giving up.\n");
1696                 return;
1697         }
1698
1699         fprintf(stderr, "weston-desktop-shell died, respawning...\n");
1700         launch_desktop_shell_process(shell);
1701 }
1702
1703 static int
1704 launch_desktop_shell_process(struct wl_shell *shell)
1705 {
1706         const char *shell_exe = LIBEXECDIR "/weston-desktop-shell";
1707
1708         shell->child.client = weston_client_launch(shell->compositor,
1709                                                  &shell->child.process,
1710                                                  shell_exe,
1711                                                  desktop_shell_sigchld);
1712
1713         if (!shell->child.client)
1714                 return -1;
1715         return 0;
1716 }
1717
1718 static void
1719 bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
1720 {
1721         struct wl_shell *shell = data;
1722
1723         wl_client_add_object(client, &wl_shell_interface,
1724                              &shell_implementation, id, shell);
1725 }
1726
1727 static void
1728 unbind_desktop_shell(struct wl_resource *resource)
1729 {
1730         struct wl_shell *shell = resource->data;
1731
1732         if (shell->locked)
1733                 resume_desktop(shell);
1734
1735         shell->child.desktop_shell = NULL;
1736         shell->prepare_event_sent = false;
1737         free(resource);
1738 }
1739
1740 static void
1741 bind_desktop_shell(struct wl_client *client,
1742                    void *data, uint32_t version, uint32_t id)
1743 {
1744         struct wl_shell *shell = data;
1745         struct wl_resource *resource;
1746
1747         resource = wl_client_add_object(client, &desktop_shell_interface,
1748                                         &desktop_shell_implementation,
1749                                         id, shell);
1750
1751         if (client == shell->child.client) {
1752                 resource->destroy = unbind_desktop_shell;
1753                 shell->child.desktop_shell = resource;
1754                 return;
1755         }
1756
1757         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
1758                                "permission to bind desktop_shell denied");
1759         wl_resource_destroy(resource, 0);
1760 }
1761
1762 static void
1763 screensaver_set_surface(struct wl_client *client,
1764                         struct wl_resource *resource,
1765                         struct wl_resource *shell_surface_resource,
1766                         struct wl_resource *output_resource)
1767 {
1768         struct wl_shell *shell = resource->data;
1769         struct shell_surface *surface = shell_surface_resource->data;
1770         struct weston_output *output = output_resource->data;
1771
1772         if (reset_shell_surface_type(surface))
1773                 return;
1774
1775         surface->type = SHELL_SURFACE_SCREENSAVER;
1776
1777         surface->fullscreen_output = output;
1778         surface->output = output;
1779         wl_list_insert(shell->screensaver.surfaces.prev, &surface->link);
1780 }
1781
1782 static const struct screensaver_interface screensaver_implementation = {
1783         screensaver_set_surface
1784 };
1785
1786 static void
1787 unbind_screensaver(struct wl_resource *resource)
1788 {
1789         struct wl_shell *shell = resource->data;
1790
1791         shell->screensaver.binding = NULL;
1792         free(resource);
1793 }
1794
1795 static void
1796 bind_screensaver(struct wl_client *client,
1797                  void *data, uint32_t version, uint32_t id)
1798 {
1799         struct wl_shell *shell = data;
1800         struct wl_resource *resource;
1801
1802         resource = wl_client_add_object(client, &screensaver_interface,
1803                                         &screensaver_implementation,
1804                                         id, shell);
1805
1806         if (shell->screensaver.binding == NULL) {
1807                 resource->destroy = unbind_screensaver;
1808                 shell->screensaver.binding = resource;
1809                 return;
1810         }
1811
1812         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
1813                                "interface object already bound");
1814         wl_resource_destroy(resource, 0);
1815 }
1816
1817 struct switcher {
1818         struct weston_compositor *compositor;
1819         struct weston_surface *current;
1820         struct wl_listener listener;
1821         struct wl_keyboard_grab grab;
1822 };
1823
1824 static void
1825 switcher_next(struct switcher *switcher)
1826 {
1827         struct weston_compositor *compositor = switcher->compositor;
1828         struct weston_surface *surface;
1829         struct weston_surface *first = NULL, *prev = NULL, *next = NULL;
1830
1831         wl_list_for_each(surface, &compositor->surface_list, link) {
1832                 /* Workaround for cursor surfaces. */
1833                 if (surface->surface.resource.destroy_listener_list.next == NULL)
1834                         continue;
1835
1836                 switch (get_shell_surface_type(surface)) {
1837                 case SHELL_SURFACE_TOPLEVEL:
1838                 case SHELL_SURFACE_FULLSCREEN:
1839                 case SHELL_SURFACE_MAXIMIZED:
1840                         if (first == NULL)
1841                                 first = surface;
1842                         if (prev == switcher->current)
1843                                 next = surface;
1844                         prev = surface;
1845                         surface->alpha = 64;
1846                         surface->geometry.dirty = 1;
1847                         weston_surface_damage(surface);
1848                         break;
1849                 default:
1850                         break;
1851                 }
1852         }
1853
1854         if (next == NULL)
1855                 next = first;
1856
1857         if (next == NULL)
1858                 return;
1859
1860         wl_list_remove(&switcher->listener.link);
1861         wl_list_insert(next->surface.resource.destroy_listener_list.prev,
1862                        &switcher->listener.link);
1863
1864         switcher->current = next;
1865         next->alpha = 255;
1866 }
1867
1868 static void
1869 switcher_handle_surface_destroy(struct wl_listener *listener,
1870                                 struct wl_resource *resource, uint32_t time)
1871 {
1872         struct switcher *switcher =
1873                 container_of(listener, struct switcher, listener);
1874
1875         switcher_next(switcher);
1876 }
1877
1878 static void
1879 switcher_destroy(struct switcher *switcher, uint32_t time)
1880 {
1881         struct weston_compositor *compositor = switcher->compositor;
1882         struct weston_surface *surface;
1883         struct weston_input_device *device =
1884                 (struct weston_input_device *) switcher->grab.input_device;
1885
1886         wl_list_for_each(surface, &compositor->surface_list, link) {
1887                 surface->alpha = 255;
1888                 weston_surface_damage(surface);
1889         }
1890
1891         if (switcher->current)
1892                 activate(compositor->shell, switcher->current, device, time);
1893         wl_list_remove(&switcher->listener.link);
1894         wl_input_device_end_keyboard_grab(&device->input_device, time);
1895         free(switcher);
1896 }
1897
1898 static void
1899 switcher_key(struct wl_keyboard_grab *grab,
1900              uint32_t time, uint32_t key, int32_t state)
1901 {
1902         struct switcher *switcher = container_of(grab, struct switcher, grab);
1903         struct weston_input_device *device =
1904                 (struct weston_input_device *) grab->input_device;
1905
1906         if ((device->modifier_state & MODIFIER_SUPER) == 0) {
1907                 switcher_destroy(switcher, time);
1908         } else if (key == KEY_TAB && state) {
1909                 switcher_next(switcher);
1910         }
1911 };
1912
1913 static const struct wl_keyboard_grab_interface switcher_grab = {
1914         switcher_key
1915 };
1916
1917 static void
1918 switcher_binding(struct wl_input_device *device, uint32_t time,
1919                  uint32_t key, uint32_t button,
1920                  uint32_t state, void *data)
1921 {
1922         struct weston_compositor *compositor = data;
1923         struct switcher *switcher;
1924
1925         switcher = malloc(sizeof *switcher);
1926         switcher->compositor = compositor;
1927         switcher->current = NULL;
1928         switcher->listener.func = switcher_handle_surface_destroy;
1929         wl_list_init(&switcher->listener.link);
1930
1931         switcher->grab.interface = &switcher_grab;
1932         wl_input_device_start_keyboard_grab(device, &switcher->grab, time);
1933         wl_input_device_set_keyboard_focus(device, NULL,
1934                                            weston_compositor_get_time());
1935         switcher_next(switcher);
1936 }
1937
1938 static void
1939 backlight_binding(struct wl_input_device *device, uint32_t time,
1940                   uint32_t key, uint32_t button, uint32_t state, void *data)
1941 {
1942         struct weston_compositor *compositor = data;
1943         struct weston_output *output;
1944         long backlight_new = 0;
1945
1946         /* TODO: we're limiting to simple use cases, where we assume just
1947          * control on the primary display. We'd have to extend later if we
1948          * ever get support for setting backlights on random desktop LCD
1949          * panels though */
1950         output = get_default_output(compositor);
1951         if (!output)
1952                 return;
1953
1954         if (!output->set_backlight)
1955                 return;
1956
1957         if (key == KEY_F9 || key == KEY_BRIGHTNESSDOWN)
1958                 backlight_new = output->backlight_current - 25;
1959         else if (key == KEY_F10 || key == KEY_BRIGHTNESSUP)
1960                 backlight_new = output->backlight_current + 25;
1961
1962         if (backlight_new < 5)
1963                 backlight_new = 5;
1964         if (backlight_new > 255)
1965                 backlight_new = 255;
1966
1967         output->backlight_current = backlight_new;
1968         output->set_backlight(output, output->backlight_current);
1969 }
1970
1971 static void
1972 debug_repaint_binding(struct wl_input_device *device, uint32_t time,
1973                       uint32_t key, uint32_t button, uint32_t state, void *data)
1974 {
1975         struct weston_compositor *compositor = data;
1976         struct wl_shell *shell =
1977                 container_of(compositor->shell, struct wl_shell, shell);
1978         struct weston_surface *surface;
1979
1980         if (shell->debug_repaint_surface) {
1981                 weston_surface_destroy(shell->debug_repaint_surface);
1982                 shell->debug_repaint_surface = NULL;
1983         } else {
1984                 surface = weston_surface_create(compositor);
1985                 weston_surface_set_color(surface, 1.0, 0.0, 0.0, 0.2);
1986                 weston_surface_configure(surface, 0, 0, 8192, 8192);
1987                 wl_list_insert(&compositor->fade_layer.surface_list,
1988                                &surface->layer_link);
1989                 weston_surface_assign_output(surface);
1990                 pixman_region32_init(&surface->input);
1991
1992                 /* Here's the dirty little trick that makes the
1993                  * repaint debugging work: we force an
1994                  * update_transform first to update dependent state
1995                  * and clear the geometry.dirty bit.  Then we clear
1996                  * the surface damage so it only gets repainted
1997                  * piecewise as we repaint other things.  */
1998
1999                 weston_surface_update_transform(surface);
2000                 pixman_region32_fini(&surface->damage);
2001                 pixman_region32_init(&surface->damage);
2002                 shell->debug_repaint_surface = surface;
2003         }
2004 }
2005
2006 static void
2007 shell_destroy(struct weston_shell *base)
2008 {
2009         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
2010
2011         if (shell->child.client)
2012                 wl_client_destroy(shell->child.client);
2013
2014         free(shell->screensaver.path);
2015         free(shell);
2016 }
2017
2018 int
2019 shell_init(struct weston_compositor *ec);
2020
2021 WL_EXPORT int
2022 shell_init(struct weston_compositor *ec)
2023 {
2024         struct wl_shell *shell;
2025
2026         shell = malloc(sizeof *shell);
2027         if (shell == NULL)
2028                 return -1;
2029
2030         memset(shell, 0, sizeof *shell);
2031         shell->compositor = ec;
2032         shell->shell.lock = lock;
2033         shell->shell.unlock = unlock;
2034         shell->shell.map = map;
2035         shell->shell.configure = configure;
2036         shell->shell.destroy = shell_destroy;
2037
2038         wl_list_init(&shell->backgrounds);
2039         wl_list_init(&shell->panels);
2040         wl_list_init(&shell->screensaver.surfaces);
2041
2042         weston_layer_init(&shell->fullscreen_layer, &ec->cursor_layer.link);
2043         weston_layer_init(&shell->panel_layer, &shell->fullscreen_layer.link);
2044         weston_layer_init(&shell->toplevel_layer, &shell->panel_layer.link);
2045         weston_layer_init(&shell->background_layer,
2046                           &shell->toplevel_layer.link);
2047         wl_list_init(&shell->lock_layer.surface_list);
2048
2049         shell_configuration(shell);
2050
2051         if (wl_display_add_global(ec->wl_display, &wl_shell_interface,
2052                                   shell, bind_shell) == NULL)
2053                 return -1;
2054
2055         if (wl_display_add_global(ec->wl_display,
2056                                   &desktop_shell_interface,
2057                                   shell, bind_desktop_shell) == NULL)
2058                 return -1;
2059
2060         if (wl_display_add_global(ec->wl_display, &screensaver_interface,
2061                                   shell, bind_screensaver) == NULL)
2062                 return -1;
2063
2064         shell->child.deathstamp = weston_compositor_get_time();
2065         if (launch_desktop_shell_process(shell) != 0)
2066                 return -1;
2067
2068         weston_compositor_add_binding(ec, 0, BTN_LEFT, MODIFIER_SUPER,
2069                                     move_binding, shell);
2070         weston_compositor_add_binding(ec, 0, BTN_MIDDLE, MODIFIER_SUPER,
2071                                     resize_binding, shell);
2072         weston_compositor_add_binding(ec, KEY_BACKSPACE, 0,
2073                                     MODIFIER_CTRL | MODIFIER_ALT,
2074                                     terminate_binding, ec);
2075         weston_compositor_add_binding(ec, 0, BTN_LEFT, 0,
2076                                     click_to_activate_binding, ec);
2077         weston_compositor_add_binding(ec, KEY_UP, 0, MODIFIER_SUPER,
2078                                     zoom_binding, shell);
2079         weston_compositor_add_binding(ec, KEY_DOWN, 0, MODIFIER_SUPER,
2080                                     zoom_binding, shell);
2081         weston_compositor_add_binding(ec, 0, BTN_LEFT,
2082                                       MODIFIER_SUPER | MODIFIER_ALT,
2083                                       rotate_binding, NULL);
2084         weston_compositor_add_binding(ec, KEY_TAB, 0, MODIFIER_SUPER,
2085                                       switcher_binding, ec);
2086
2087         /* brightness */
2088         weston_compositor_add_binding(ec, KEY_F9, 0, MODIFIER_CTRL,
2089                                       backlight_binding, ec);
2090         weston_compositor_add_binding(ec, KEY_BRIGHTNESSDOWN, 0, 0,
2091                                       backlight_binding, ec);
2092         weston_compositor_add_binding(ec, KEY_F10, 0, MODIFIER_CTRL,
2093                                       backlight_binding, ec);
2094         weston_compositor_add_binding(ec, KEY_BRIGHTNESSUP, 0, 0,
2095                                       backlight_binding, ec);
2096
2097         weston_compositor_add_binding(ec, KEY_SPACE, 0, MODIFIER_SUPER,
2098                                     debug_repaint_binding, ec);
2099
2100         ec->shell = &shell->shell;
2101
2102         return 0;
2103 }