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         weston_compositor_repick(shell->compositor);
1059         shell->compositor->idle_time = shell->compositor->option_idle_time;
1060         weston_compositor_wake(shell->compositor);
1061         weston_compositor_damage_all(shell->compositor);
1062 }
1063
1064 static void
1065 desktop_shell_unlock(struct wl_client *client,
1066                      struct wl_resource *resource)
1067 {
1068         struct wl_shell *shell = resource->data;
1069
1070         shell->prepare_event_sent = false;
1071
1072         if (shell->locked)
1073                 resume_desktop(shell);
1074 }
1075
1076 static const struct desktop_shell_interface desktop_shell_implementation = {
1077         desktop_shell_set_background,
1078         desktop_shell_set_panel,
1079         desktop_shell_set_lock_surface,
1080         desktop_shell_unlock
1081 };
1082
1083 static enum shell_surface_type
1084 get_shell_surface_type(struct weston_surface *surface)
1085 {
1086         struct shell_surface *shsurf;
1087
1088         shsurf = get_shell_surface(surface);
1089         if (!shsurf)
1090                 return SHELL_SURFACE_NONE;
1091         return shsurf->type;
1092 }
1093
1094 static void
1095 move_binding(struct wl_input_device *device, uint32_t time,
1096              uint32_t key, uint32_t button, uint32_t state, void *data)
1097 {
1098         struct weston_surface *surface =
1099                 (struct weston_surface *) device->pointer_focus;
1100
1101         if (surface == NULL)
1102                 return;
1103
1104         switch (get_shell_surface_type(surface)) {
1105                 case SHELL_SURFACE_PANEL:
1106                 case SHELL_SURFACE_BACKGROUND:
1107                 case SHELL_SURFACE_FULLSCREEN:
1108                 case SHELL_SURFACE_SCREENSAVER:
1109                         return;
1110                 default:
1111                         break;
1112         }
1113
1114         weston_surface_move(surface, (struct weston_input_device *) device, time);
1115 }
1116
1117 static void
1118 resize_binding(struct wl_input_device *device, uint32_t time,
1119                uint32_t key, uint32_t button, uint32_t state, void *data)
1120 {
1121         struct weston_surface *surface =
1122                 (struct weston_surface *) device->pointer_focus;
1123         uint32_t edges = 0;
1124         int32_t x, y;
1125         struct shell_surface *shsurf;
1126
1127         if (surface == NULL)
1128                 return;
1129
1130         shsurf = get_shell_surface(surface);
1131         if (!shsurf)
1132                 return;
1133
1134         switch (shsurf->type) {
1135                 case SHELL_SURFACE_PANEL:
1136                 case SHELL_SURFACE_BACKGROUND:
1137                 case SHELL_SURFACE_FULLSCREEN:
1138                 case SHELL_SURFACE_SCREENSAVER:
1139                         return;
1140                 default:
1141                         break;
1142         }
1143
1144         weston_surface_from_global(surface,
1145                                    device->grab_x, device->grab_y, &x, &y);
1146
1147         if (x < surface->geometry.width / 3)
1148                 edges |= WL_SHELL_SURFACE_RESIZE_LEFT;
1149         else if (x < 2 * surface->geometry.width / 3)
1150                 edges |= 0;
1151         else
1152                 edges |= WL_SHELL_SURFACE_RESIZE_RIGHT;
1153
1154         if (y < surface->geometry.height / 3)
1155                 edges |= WL_SHELL_SURFACE_RESIZE_TOP;
1156         else if (y < 2 * surface->geometry.height / 3)
1157                 edges |= 0;
1158         else
1159                 edges |= WL_SHELL_SURFACE_RESIZE_BOTTOM;
1160
1161         weston_surface_resize(shsurf, (struct weston_input_device *) device,
1162                             time, edges);
1163 }
1164
1165 static void
1166 zoom_binding(struct wl_input_device *device, uint32_t time,
1167                uint32_t key, uint32_t button, uint32_t state, void *data)
1168 {
1169         struct weston_input_device *wd = (struct weston_input_device *) device;
1170         struct weston_compositor *compositor = wd->compositor;
1171         struct weston_output *output;
1172
1173         wl_list_for_each(output, &compositor->output_list, link) {
1174                 if (pixman_region32_contains_point(&output->region,
1175                                                 device->x, device->y, NULL)) {
1176                         if (state && key == KEY_UP) {
1177                                 output->zoom.active = 1;
1178                                 output->zoom.level -= output->zoom.increment;
1179                         }
1180                         if (state && key == KEY_DOWN)
1181                                 output->zoom.level += output->zoom.increment;
1182
1183                         if (output->zoom.level >= 1.0) {
1184                                 output->zoom.active = 0;
1185                                 output->zoom.level = 1.0;
1186                         }
1187
1188                         if (output->zoom.level < output->zoom.increment)
1189                                 output->zoom.level = output->zoom.increment;
1190
1191                         weston_output_update_zoom(output, device->x, device->y);
1192                 }
1193         }
1194 }
1195
1196 static void
1197 terminate_binding(struct wl_input_device *device, uint32_t time,
1198                   uint32_t key, uint32_t button, uint32_t state, void *data)
1199 {
1200         struct weston_compositor *compositor = data;
1201
1202         if (state)
1203                 wl_display_terminate(compositor->wl_display);
1204 }
1205
1206 static void
1207 rotate_grab_motion(struct wl_pointer_grab *grab,
1208                  uint32_t time, int32_t x, int32_t y)
1209 {
1210         struct rotate_grab *rotate =
1211                 container_of(grab, struct rotate_grab, grab);
1212         struct wl_input_device *device = grab->input_device;
1213         struct shell_surface *surface = rotate->surface;
1214         GLfloat cx = 0.5f * surface->surface->geometry.width;
1215         GLfloat cy = 0.5f * surface->surface->geometry.height;
1216         GLfloat dx, dy;
1217         GLfloat r;
1218
1219         dx = device->x - rotate->center.x;
1220         dy = device->y - rotate->center.y;
1221         r = sqrtf(dx * dx + dy * dy);
1222
1223         wl_list_remove(&surface->rotation.transform.link);
1224         surface->surface->geometry.dirty = 1;
1225
1226         if (r > 20.0f) {
1227                 struct weston_matrix *matrix =
1228                         &surface->rotation.transform.matrix;
1229
1230                 weston_matrix_init(&rotate->rotation);
1231                 rotate->rotation.d[0] = dx / r;
1232                 rotate->rotation.d[4] = -dy / r;
1233                 rotate->rotation.d[1] = -rotate->rotation.d[4];
1234                 rotate->rotation.d[5] = rotate->rotation.d[0];
1235
1236                 weston_matrix_init(matrix);
1237                 weston_matrix_translate(matrix, -cx, -cy, 0.0f);
1238                 weston_matrix_multiply(matrix, &surface->rotation.rotation);
1239                 weston_matrix_multiply(matrix, &rotate->rotation);
1240                 weston_matrix_translate(matrix, cx, cy, 0.0f);
1241
1242                 wl_list_insert(
1243                         &surface->surface->geometry.transformation_list,
1244                         &surface->rotation.transform.link);
1245         } else {
1246                 wl_list_init(&surface->rotation.transform.link);
1247                 weston_matrix_init(&surface->rotation.rotation);
1248                 weston_matrix_init(&rotate->rotation);
1249         }
1250
1251         /* Repaint implies weston_surface_update_transform(), which
1252          * lazily applies the damage due to rotation update.
1253          */
1254         weston_compositor_schedule_repaint(surface->surface->compositor);
1255 }
1256
1257 static void
1258 rotate_grab_button(struct wl_pointer_grab *grab,
1259                  uint32_t time, int32_t button, int32_t state)
1260 {
1261         struct rotate_grab *rotate =
1262                 container_of(grab, struct rotate_grab, grab);
1263         struct wl_input_device *device = grab->input_device;
1264         struct shell_surface *surface = rotate->surface;
1265
1266         if (device->button_count == 0 && state == 0) {
1267                 weston_matrix_multiply(&surface->rotation.rotation,
1268                                        &rotate->rotation);
1269                 wl_input_device_end_pointer_grab(device, time);
1270                 free(rotate);
1271         }
1272 }
1273
1274 static const struct wl_pointer_grab_interface rotate_grab_interface = {
1275         noop_grab_focus,
1276         rotate_grab_motion,
1277         rotate_grab_button,
1278 };
1279
1280 static void
1281 rotate_binding(struct wl_input_device *device, uint32_t time,
1282                uint32_t key, uint32_t button, uint32_t state, void *data)
1283 {
1284         struct weston_surface *base_surface =
1285                 (struct weston_surface *) device->pointer_focus;
1286         struct shell_surface *surface;
1287         struct rotate_grab *rotate;
1288         GLfloat dx, dy;
1289         GLfloat r;
1290
1291         if (base_surface == NULL)
1292                 return;
1293
1294         surface = get_shell_surface(base_surface);
1295         if (!surface)
1296                 return;
1297
1298         switch (surface->type) {
1299                 case SHELL_SURFACE_PANEL:
1300                 case SHELL_SURFACE_BACKGROUND:
1301                 case SHELL_SURFACE_FULLSCREEN:
1302                 case SHELL_SURFACE_SCREENSAVER:
1303                         return;
1304                 default:
1305                         break;
1306         }
1307
1308         rotate = malloc(sizeof *rotate);
1309         if (!rotate)
1310                 return;
1311
1312         rotate->grab.interface = &rotate_grab_interface;
1313         rotate->surface = surface;
1314
1315         weston_surface_to_global(surface->surface,
1316                                  surface->surface->geometry.width / 2,
1317                                  surface->surface->geometry.height / 2,
1318                                  &rotate->center.x, &rotate->center.y);
1319
1320         wl_input_device_start_pointer_grab(device, &rotate->grab, time);
1321
1322         dx = device->x - rotate->center.x;
1323         dy = device->y - rotate->center.y;
1324         r = sqrtf(dx * dx + dy * dy);
1325         if (r > 20.0f) {
1326                 struct weston_matrix inverse;
1327
1328                 weston_matrix_init(&inverse);
1329                 inverse.d[0] = dx / r;
1330                 inverse.d[4] = dy / r;
1331                 inverse.d[1] = -inverse.d[4];
1332                 inverse.d[5] = inverse.d[0];
1333                 weston_matrix_multiply(&surface->rotation.rotation, &inverse);
1334         } else {
1335                 weston_matrix_init(&surface->rotation.rotation);
1336                 weston_matrix_init(&rotate->rotation);
1337         }
1338
1339         wl_input_device_set_pointer_focus(device, NULL, time, 0, 0);
1340 }
1341
1342 static void
1343 activate(struct weston_shell *base, struct weston_surface *es,
1344          struct weston_input_device *device, uint32_t time)
1345 {
1346         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1347         struct weston_compositor *compositor = shell->compositor;
1348
1349         weston_surface_activate(es, device, time);
1350
1351         if (compositor->wxs)
1352                 weston_xserver_surface_activate(es);
1353
1354         switch (get_shell_surface_type(es)) {
1355         case SHELL_SURFACE_BACKGROUND:
1356         case SHELL_SURFACE_PANEL:
1357         case SHELL_SURFACE_LOCK:
1358                 break;
1359
1360         case SHELL_SURFACE_SCREENSAVER:
1361                 /* always below lock surface */
1362                 if (shell->lock_surface)
1363                         weston_surface_restack(es,
1364                                                &shell->lock_surface->surface->layer_link);
1365                 break;
1366         case SHELL_SURFACE_FULLSCREEN:
1367                 /* should on top of panels */
1368                 break;
1369         default:
1370                 weston_surface_restack(es,
1371                                        &shell->toplevel_layer.surface_list);
1372                 break;
1373         }
1374 }
1375
1376 static void
1377 click_to_activate_binding(struct wl_input_device *device,
1378                           uint32_t time, uint32_t key,
1379                           uint32_t button, uint32_t state, void *data)
1380 {
1381         struct weston_input_device *wd = (struct weston_input_device *) device;
1382         struct weston_compositor *compositor = data;
1383         struct weston_surface *focus;
1384         struct weston_surface *upper;
1385
1386         focus = (struct weston_surface *) device->pointer_focus;
1387         if (!focus)
1388                 return;
1389
1390         upper = container_of(focus->link.prev, struct weston_surface, link);
1391         if (focus->link.prev != &compositor->surface_list &&
1392             get_shell_surface_type(upper) == SHELL_SURFACE_FULLSCREEN) {
1393                 printf("%s: focus is black surface, raise its fullscreen surface\n", __func__);
1394                 shell_stack_fullscreen(get_shell_surface(upper));
1395                 focus = upper;
1396         }
1397
1398         if (state && device->pointer_grab == &device->default_pointer_grab)
1399                 activate(compositor->shell, focus, wd, time);
1400 }
1401
1402 static void
1403 lock(struct weston_shell *base)
1404 {
1405         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1406         struct weston_input_device *device;
1407         struct shell_surface *shsurf;
1408         struct weston_output *output;
1409         uint32_t time;
1410
1411         if (shell->locked) {
1412                 wl_list_for_each(output, &shell->compositor->output_list, link)
1413                         /* TODO: find a way to jump to other DPMS levels */
1414                         if (output->set_dpms)
1415                                 output->set_dpms(output, WESTON_DPMS_STANDBY);
1416                 return;
1417         }
1418
1419         shell->locked = true;
1420
1421         /* Hide all surfaces by removing the fullscreen, panel and
1422          * toplevel layers.  This way nothing else can show or receive
1423          * input events while we are locked. */
1424
1425         wl_list_remove(&shell->panel_layer.link);
1426         wl_list_remove(&shell->toplevel_layer.link);
1427         wl_list_remove(&shell->fullscreen_layer.link);
1428         wl_list_insert(&shell->compositor->cursor_layer.link,
1429                        &shell->lock_layer.link);
1430
1431         launch_screensaver(shell);
1432
1433         wl_list_for_each(shsurf, &shell->screensaver.surfaces, link)
1434                 show_screensaver(shell, shsurf);
1435
1436         if (!wl_list_empty(&shell->screensaver.surfaces)) {
1437                 shell->compositor->idle_time = shell->screensaver.duration;
1438                 weston_compositor_wake(shell->compositor);
1439                 shell->compositor->state = WESTON_COMPOSITOR_IDLE;
1440         }
1441
1442         /* reset pointer foci */
1443         weston_compositor_repick(shell->compositor);
1444
1445         /* reset keyboard foci */
1446         time = weston_compositor_get_time();
1447         wl_list_for_each(device, &shell->compositor->input_device_list, link) {
1448                 wl_input_device_set_keyboard_focus(&device->input_device,
1449                                                    NULL, time);
1450         }
1451
1452         /* TODO: disable bindings that should not work while locked. */
1453
1454         /* All this must be undone in resume_desktop(). */
1455 }
1456
1457 static void
1458 unlock(struct weston_shell *base)
1459 {
1460         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1461
1462         if (!shell->locked || shell->lock_surface) {
1463                 weston_compositor_wake(shell->compositor);
1464                 return;
1465         }
1466
1467         /* If desktop-shell client has gone away, unlock immediately. */
1468         if (!shell->child.desktop_shell) {
1469                 resume_desktop(shell);
1470                 return;
1471         }
1472
1473         if (shell->prepare_event_sent)
1474                 return;
1475
1476         desktop_shell_send_prepare_lock_surface(shell->child.desktop_shell);
1477         shell->prepare_event_sent = true;
1478 }
1479
1480 static void
1481 center_on_output(struct weston_surface *surface, struct weston_output *output)
1482 {
1483         struct weston_mode *mode = output->current;
1484         GLfloat x = (mode->width - surface->geometry.width) / 2;
1485         GLfloat y = (mode->height - surface->geometry.height) / 2;
1486
1487         weston_surface_set_position(surface, output->x + x, output->y + y);
1488 }
1489
1490 static void
1491 map(struct weston_shell *base, struct weston_surface *surface,
1492     int32_t width, int32_t height, int32_t sx, int32_t sy)
1493 {
1494         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1495         struct weston_compositor *compositor = shell->compositor;
1496         struct shell_surface *shsurf;
1497         enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
1498         struct weston_surface *parent;
1499         int panel_height = 0;
1500
1501         shsurf = get_shell_surface(surface);
1502         if (shsurf)
1503                 surface_type = shsurf->type;
1504
1505         surface->geometry.width = width;
1506         surface->geometry.height = height;
1507         surface->geometry.dirty = 1;
1508
1509         weston_compositor_update_drag_surfaces(compositor);
1510
1511         /* initial positioning, see also configure() */
1512         switch (surface_type) {
1513         case SHELL_SURFACE_TOPLEVEL:
1514                 weston_surface_set_position(surface, 10 + random() % 400,
1515                                             10 + random() % 400);
1516                 break;
1517         case SHELL_SURFACE_SCREENSAVER:
1518                 center_on_output(surface, shsurf->fullscreen_output);
1519                 break;
1520         case SHELL_SURFACE_FULLSCREEN:
1521                 shell_map_fullscreen(shsurf);
1522                 break;
1523         case SHELL_SURFACE_MAXIMIZED:
1524                 /* use surface configure to set the geometry */
1525                 panel_height = get_output_panel_height(shell,surface->output);
1526                 weston_surface_set_position(surface, surface->output->x,
1527                                             surface->output->y + panel_height);
1528                 break;
1529         case SHELL_SURFACE_LOCK:
1530                 center_on_output(surface, get_default_output(compositor));
1531                 break;
1532         case SHELL_SURFACE_POPUP:
1533                 shell_map_popup(shsurf, shsurf->popup.time);
1534         case SHELL_SURFACE_NONE:
1535                 weston_surface_set_position(surface,
1536                                             surface->geometry.x + sx,
1537                                             surface->geometry.y + sy);
1538                 break;
1539         default:
1540                 ;
1541         }
1542
1543         /* surface stacking order, see also activate() */
1544         switch (surface_type) {
1545         case SHELL_SURFACE_BACKGROUND:
1546                 /* background always visible, at the bottom */
1547                 wl_list_insert(&shell->background_layer.surface_list,
1548                                &surface->layer_link);
1549                 break;
1550         case SHELL_SURFACE_PANEL:
1551                 /* panel always on top, hidden while locked */
1552                 wl_list_insert(&shell->panel_layer.surface_list,
1553                                &surface->layer_link);
1554                 break;
1555         case SHELL_SURFACE_LOCK:
1556                 /* lock surface always visible, on top */
1557                 wl_list_insert(&shell->lock_layer.surface_list,
1558                                &surface->layer_link);
1559                 weston_compositor_wake(compositor);
1560                 break;
1561         case SHELL_SURFACE_SCREENSAVER:
1562                 /* If locked, show it. */
1563                 if (shell->locked) {
1564                         show_screensaver(shell, shsurf);
1565                         compositor->idle_time = shell->screensaver.duration;
1566                         weston_compositor_wake(compositor);
1567                         if (!shell->lock_surface)
1568                                 compositor->state = WESTON_COMPOSITOR_IDLE;
1569                 }
1570                 break;
1571         case SHELL_SURFACE_POPUP:
1572         case SHELL_SURFACE_TRANSIENT:
1573                 parent = shsurf->parent->surface;
1574                 wl_list_insert(parent->layer_link.prev, &surface->layer_link);
1575                 break;
1576         case SHELL_SURFACE_FULLSCREEN:
1577         case SHELL_SURFACE_NONE:
1578                 break;
1579         default:
1580                 wl_list_insert(&shell->toplevel_layer.surface_list,
1581                                &surface->layer_link);
1582                 break;
1583         }
1584
1585         weston_surface_assign_output(surface);
1586         weston_compositor_repick(compositor);
1587         if (surface_type == SHELL_SURFACE_MAXIMIZED)
1588                 surface->output = shsurf->output;
1589
1590         switch (surface_type) {
1591         case SHELL_SURFACE_TOPLEVEL:
1592         case SHELL_SURFACE_TRANSIENT:
1593         case SHELL_SURFACE_FULLSCREEN:
1594         case SHELL_SURFACE_MAXIMIZED:
1595                 if (!shell->locked)
1596                         activate(base, surface,
1597                                  (struct weston_input_device *)
1598                                  compositor->input_device,
1599                                  weston_compositor_get_time());
1600                 break;
1601         default:
1602                 break;
1603         }
1604
1605         if (surface_type == SHELL_SURFACE_TOPLEVEL)
1606                 weston_zoom_run(surface, 0.8, 1.0, NULL, NULL);
1607 }
1608
1609 static void
1610 configure(struct weston_shell *base, struct weston_surface *surface,
1611           GLfloat x, GLfloat y, int32_t width, int32_t height)
1612 {
1613         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1614         enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
1615         enum shell_surface_type prev_surface_type = SHELL_SURFACE_NONE;
1616         struct shell_surface *shsurf;
1617
1618         shsurf = get_shell_surface(surface);
1619         if (shsurf)
1620                 surface_type = shsurf->type;
1621
1622         surface->geometry.x = x;
1623         surface->geometry.y = y;
1624         surface->geometry.width = width;
1625         surface->geometry.height = height;
1626         surface->geometry.dirty = 1;
1627
1628         switch (surface_type) {
1629         case SHELL_SURFACE_SCREENSAVER:
1630                 center_on_output(surface, shsurf->fullscreen_output);
1631                 break;
1632         case SHELL_SURFACE_FULLSCREEN:
1633                 shell_configure_fullscreen(shsurf);
1634                 if (prev_surface_type != SHELL_SURFACE_FULLSCREEN)
1635                         shell_stack_fullscreen(shsurf);
1636                 break;
1637         case SHELL_SURFACE_MAXIMIZED:
1638                 /* setting x, y and using configure to change that geometry */
1639                 surface->geometry.x = surface->output->x;
1640                 surface->geometry.y = surface->output->y +
1641                         get_output_panel_height(shell,surface->output);
1642                 break;
1643         case SHELL_SURFACE_TOPLEVEL:
1644                 break;
1645         default:
1646                 break;
1647         }
1648
1649         /* XXX: would a fullscreen surface need the same handling? */
1650         if (surface->output) {
1651                 weston_surface_assign_output(surface);
1652                 weston_compositor_repick(surface->compositor);
1653
1654                 if (surface_type == SHELL_SURFACE_SCREENSAVER)
1655                         surface->output = shsurf->output;
1656                 else if (surface_type == SHELL_SURFACE_MAXIMIZED)
1657                         surface->output = shsurf->output;
1658         }
1659 }
1660
1661 static int launch_desktop_shell_process(struct wl_shell *shell);
1662
1663 static void
1664 desktop_shell_sigchld(struct weston_process *process, int status)
1665 {
1666         uint32_t time;
1667         struct wl_shell *shell =
1668                 container_of(process, struct wl_shell, child.process);
1669
1670         shell->child.process.pid = 0;
1671         shell->child.client = NULL; /* already destroyed by wayland */
1672
1673         /* if desktop-shell dies more than 5 times in 30 seconds, give up */
1674         time = weston_compositor_get_time();
1675         if (time - shell->child.deathstamp > 30000) {
1676                 shell->child.deathstamp = time;
1677                 shell->child.deathcount = 0;
1678         }
1679
1680         shell->child.deathcount++;
1681         if (shell->child.deathcount > 5) {
1682                 fprintf(stderr, "weston-desktop-shell died, giving up.\n");
1683                 return;
1684         }
1685
1686         fprintf(stderr, "weston-desktop-shell died, respawning...\n");
1687         launch_desktop_shell_process(shell);
1688 }
1689
1690 static int
1691 launch_desktop_shell_process(struct wl_shell *shell)
1692 {
1693         const char *shell_exe = LIBEXECDIR "/weston-desktop-shell";
1694
1695         shell->child.client = weston_client_launch(shell->compositor,
1696                                                  &shell->child.process,
1697                                                  shell_exe,
1698                                                  desktop_shell_sigchld);
1699
1700         if (!shell->child.client)
1701                 return -1;
1702         return 0;
1703 }
1704
1705 static void
1706 bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id)
1707 {
1708         struct wl_shell *shell = data;
1709
1710         wl_client_add_object(client, &wl_shell_interface,
1711                              &shell_implementation, id, shell);
1712 }
1713
1714 static void
1715 unbind_desktop_shell(struct wl_resource *resource)
1716 {
1717         struct wl_shell *shell = resource->data;
1718
1719         if (shell->locked)
1720                 resume_desktop(shell);
1721
1722         shell->child.desktop_shell = NULL;
1723         shell->prepare_event_sent = false;
1724         free(resource);
1725 }
1726
1727 static void
1728 bind_desktop_shell(struct wl_client *client,
1729                    void *data, uint32_t version, uint32_t id)
1730 {
1731         struct wl_shell *shell = data;
1732         struct wl_resource *resource;
1733
1734         resource = wl_client_add_object(client, &desktop_shell_interface,
1735                                         &desktop_shell_implementation,
1736                                         id, shell);
1737
1738         if (client == shell->child.client) {
1739                 resource->destroy = unbind_desktop_shell;
1740                 shell->child.desktop_shell = resource;
1741                 return;
1742         }
1743
1744         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
1745                                "permission to bind desktop_shell denied");
1746         wl_resource_destroy(resource, 0);
1747 }
1748
1749 static void
1750 screensaver_set_surface(struct wl_client *client,
1751                         struct wl_resource *resource,
1752                         struct wl_resource *shell_surface_resource,
1753                         struct wl_resource *output_resource)
1754 {
1755         struct wl_shell *shell = resource->data;
1756         struct shell_surface *surface = shell_surface_resource->data;
1757         struct weston_output *output = output_resource->data;
1758
1759         if (reset_shell_surface_type(surface))
1760                 return;
1761
1762         surface->type = SHELL_SURFACE_SCREENSAVER;
1763
1764         surface->fullscreen_output = output;
1765         surface->output = output;
1766         wl_list_insert(shell->screensaver.surfaces.prev, &surface->link);
1767 }
1768
1769 static const struct screensaver_interface screensaver_implementation = {
1770         screensaver_set_surface
1771 };
1772
1773 static void
1774 unbind_screensaver(struct wl_resource *resource)
1775 {
1776         struct wl_shell *shell = resource->data;
1777
1778         shell->screensaver.binding = NULL;
1779         free(resource);
1780 }
1781
1782 static void
1783 bind_screensaver(struct wl_client *client,
1784                  void *data, uint32_t version, uint32_t id)
1785 {
1786         struct wl_shell *shell = data;
1787         struct wl_resource *resource;
1788
1789         resource = wl_client_add_object(client, &screensaver_interface,
1790                                         &screensaver_implementation,
1791                                         id, shell);
1792
1793         if (shell->screensaver.binding == NULL) {
1794                 resource->destroy = unbind_screensaver;
1795                 shell->screensaver.binding = resource;
1796                 return;
1797         }
1798
1799         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
1800                                "interface object already bound");
1801         wl_resource_destroy(resource, 0);
1802 }
1803
1804 struct switcher {
1805         struct weston_compositor *compositor;
1806         struct weston_surface *current;
1807         struct wl_listener listener;
1808         struct wl_keyboard_grab grab;
1809 };
1810
1811 static void
1812 switcher_next(struct switcher *switcher)
1813 {
1814         struct weston_compositor *compositor = switcher->compositor;
1815         struct weston_surface *surface;
1816         struct weston_surface *first = NULL, *prev = NULL, *next = NULL;
1817
1818         wl_list_for_each(surface, &compositor->surface_list, link) {
1819                 /* Workaround for cursor surfaces. */
1820                 if (surface->surface.resource.destroy_listener_list.next == NULL)
1821                         continue;
1822
1823                 switch (get_shell_surface_type(surface)) {
1824                 case SHELL_SURFACE_TOPLEVEL:
1825                 case SHELL_SURFACE_FULLSCREEN:
1826                 case SHELL_SURFACE_MAXIMIZED:
1827                         if (first == NULL)
1828                                 first = surface;
1829                         if (prev == switcher->current)
1830                                 next = surface;
1831                         prev = surface;
1832                         surface->alpha = 64;
1833                         surface->geometry.dirty = 1;
1834                         weston_surface_damage(surface);
1835                         break;
1836                 default:
1837                         break;
1838                 }
1839         }
1840
1841         if (next == NULL)
1842                 next = first;
1843
1844         wl_list_remove(&switcher->listener.link);
1845         wl_list_insert(next->surface.resource.destroy_listener_list.prev,
1846                        &switcher->listener.link);
1847
1848         switcher->current = next;
1849         next->alpha = 255;
1850 }
1851
1852 static void
1853 switcher_handle_surface_destroy(struct wl_listener *listener,
1854                                 struct wl_resource *resource, uint32_t time)
1855 {
1856         struct switcher *switcher =
1857                 container_of(listener, struct switcher, listener);
1858
1859         switcher_next(switcher);
1860 }
1861
1862 static void
1863 switcher_destroy(struct switcher *switcher, uint32_t time)
1864 {
1865         struct weston_compositor *compositor = switcher->compositor;
1866         struct weston_surface *surface;
1867         struct weston_input_device *device =
1868                 (struct weston_input_device *) switcher->grab.input_device;
1869
1870         wl_list_for_each(surface, &compositor->surface_list, link) {
1871                 surface->alpha = 255;
1872                 weston_surface_damage(surface);
1873         }
1874
1875         activate(compositor->shell, switcher->current, device, time);
1876         wl_list_remove(&switcher->listener.link);
1877         wl_input_device_end_keyboard_grab(&device->input_device, time);
1878         free(switcher);
1879 }
1880
1881 static void
1882 switcher_key(struct wl_keyboard_grab *grab,
1883              uint32_t time, uint32_t key, int32_t state)
1884 {
1885         struct switcher *switcher = container_of(grab, struct switcher, grab);
1886         struct weston_input_device *device =
1887                 (struct weston_input_device *) grab->input_device;
1888
1889         if ((device->modifier_state & MODIFIER_SUPER) == 0) {
1890                 switcher_destroy(switcher, time);
1891         } else if (key == KEY_TAB && state) {
1892                 switcher_next(switcher);
1893         }
1894 };
1895
1896 static const struct wl_keyboard_grab_interface switcher_grab = {
1897         switcher_key
1898 };
1899
1900 static void
1901 switcher_binding(struct wl_input_device *device, uint32_t time,
1902                  uint32_t key, uint32_t button,
1903                  uint32_t state, void *data)
1904 {
1905         struct weston_compositor *compositor = data;
1906         struct switcher *switcher;
1907
1908         switcher = malloc(sizeof *switcher);
1909         switcher->compositor = compositor;
1910         switcher->current = NULL;
1911         switcher->listener.func = switcher_handle_surface_destroy;
1912         wl_list_init(&switcher->listener.link);
1913
1914         switcher->grab.interface = &switcher_grab;
1915         wl_input_device_start_keyboard_grab(device, &switcher->grab, time);
1916         wl_input_device_set_keyboard_focus(device, NULL,
1917                                            weston_compositor_get_time());
1918         switcher_next(switcher);
1919 }
1920
1921 static void
1922 backlight_binding(struct wl_input_device *device, uint32_t time,
1923                   uint32_t key, uint32_t button, uint32_t state, void *data)
1924 {
1925         struct weston_compositor *compositor = data;
1926         struct weston_output *output;
1927
1928         /* TODO: we're limiting to simple use cases, where we assume just
1929          * control on the primary display. We'd have to extend later if we
1930          * ever get support for setting backlights on random desktop LCD
1931          * panels though */
1932         output = get_default_output(compositor);
1933         if (!output)
1934                 return;
1935
1936         if (!output->set_backlight)
1937                 return;
1938
1939         if ((key == KEY_F9 || key == KEY_BRIGHTNESSDOWN) &&
1940             output->backlight_current > 1)
1941                 output->backlight_current--;
1942         else if ((key == KEY_F10 || key == KEY_BRIGHTNESSUP) &&
1943             output->backlight_current < 10)
1944                 output->backlight_current++;
1945
1946         output->set_backlight(output, output->backlight_current);
1947 }
1948
1949 static void
1950 debug_repaint_binding(struct wl_input_device *device, uint32_t time,
1951                       uint32_t key, uint32_t button, uint32_t state, void *data)
1952 {
1953         struct weston_compositor *compositor = data;
1954         struct wl_shell *shell =
1955                 container_of(compositor->shell, struct wl_shell, shell);
1956         struct weston_surface *surface;
1957
1958         if (shell->debug_repaint_surface) {
1959                 weston_surface_destroy(shell->debug_repaint_surface);
1960                 shell->debug_repaint_surface = NULL;
1961         } else {
1962                 surface = weston_surface_create(compositor);
1963                 weston_surface_set_color(surface, 1.0, 0.0, 0.0, 0.2);
1964                 weston_surface_configure(surface, 0, 0, 8192, 8192);
1965                 wl_list_insert(&compositor->fade_layer.surface_list,
1966                                &surface->layer_link);
1967                 weston_surface_assign_output(surface);
1968                 pixman_region32_init(&surface->input);
1969
1970                 /* Here's the dirty little trick that makes the
1971                  * repaint debugging work: we force an
1972                  * update_transform first to update dependent state
1973                  * and clear the geometry.dirty bit.  Then we clear
1974                  * the surface damage so it only gets repainted
1975                  * piecewise as we repaint other things.  */
1976
1977                 weston_surface_update_transform(surface);
1978                 pixman_region32_fini(&surface->damage);
1979                 pixman_region32_init(&surface->damage);
1980                 shell->debug_repaint_surface = surface;
1981         }
1982 }
1983
1984 static void
1985 shell_destroy(struct weston_shell *base)
1986 {
1987         struct wl_shell *shell = container_of(base, struct wl_shell, shell);
1988
1989         if (shell->child.client)
1990                 wl_client_destroy(shell->child.client);
1991
1992         free(shell->screensaver.path);
1993         free(shell);
1994 }
1995
1996 int
1997 shell_init(struct weston_compositor *ec);
1998
1999 WL_EXPORT int
2000 shell_init(struct weston_compositor *ec)
2001 {
2002         struct wl_shell *shell;
2003
2004         shell = malloc(sizeof *shell);
2005         if (shell == NULL)
2006                 return -1;
2007
2008         memset(shell, 0, sizeof *shell);
2009         shell->compositor = ec;
2010         shell->shell.lock = lock;
2011         shell->shell.unlock = unlock;
2012         shell->shell.map = map;
2013         shell->shell.configure = configure;
2014         shell->shell.destroy = shell_destroy;
2015
2016         wl_list_init(&shell->backgrounds);
2017         wl_list_init(&shell->panels);
2018         wl_list_init(&shell->screensaver.surfaces);
2019
2020         weston_layer_init(&shell->fullscreen_layer, &ec->cursor_layer.link);
2021         weston_layer_init(&shell->panel_layer, &shell->fullscreen_layer.link);
2022         weston_layer_init(&shell->toplevel_layer, &shell->panel_layer.link);
2023         weston_layer_init(&shell->background_layer,
2024                           &shell->toplevel_layer.link);
2025         wl_list_init(&shell->lock_layer.surface_list);
2026
2027         shell_configuration(shell);
2028
2029         if (wl_display_add_global(ec->wl_display, &wl_shell_interface,
2030                                   shell, bind_shell) == NULL)
2031                 return -1;
2032
2033         if (wl_display_add_global(ec->wl_display,
2034                                   &desktop_shell_interface,
2035                                   shell, bind_desktop_shell) == NULL)
2036                 return -1;
2037
2038         if (wl_display_add_global(ec->wl_display, &screensaver_interface,
2039                                   shell, bind_screensaver) == NULL)
2040                 return -1;
2041
2042         shell->child.deathstamp = weston_compositor_get_time();
2043         if (launch_desktop_shell_process(shell) != 0)
2044                 return -1;
2045
2046         weston_compositor_add_binding(ec, 0, BTN_LEFT, MODIFIER_SUPER,
2047                                     move_binding, shell);
2048         weston_compositor_add_binding(ec, 0, BTN_MIDDLE, MODIFIER_SUPER,
2049                                     resize_binding, shell);
2050         weston_compositor_add_binding(ec, KEY_BACKSPACE, 0,
2051                                     MODIFIER_CTRL | MODIFIER_ALT,
2052                                     terminate_binding, ec);
2053         weston_compositor_add_binding(ec, 0, BTN_LEFT, 0,
2054                                     click_to_activate_binding, ec);
2055         weston_compositor_add_binding(ec, KEY_UP, 0, MODIFIER_SUPER,
2056                                     zoom_binding, shell);
2057         weston_compositor_add_binding(ec, KEY_DOWN, 0, MODIFIER_SUPER,
2058                                     zoom_binding, shell);
2059         weston_compositor_add_binding(ec, 0, BTN_LEFT,
2060                                       MODIFIER_SUPER | MODIFIER_ALT,
2061                                       rotate_binding, NULL);
2062         weston_compositor_add_binding(ec, KEY_TAB, 0, MODIFIER_SUPER,
2063                                       switcher_binding, ec);
2064
2065         /* brightness */
2066         weston_compositor_add_binding(ec, KEY_F9, 0, MODIFIER_CTRL,
2067                                       backlight_binding, ec);
2068         weston_compositor_add_binding(ec, KEY_BRIGHTNESSDOWN, 0, 0,
2069                                       backlight_binding, ec);
2070         weston_compositor_add_binding(ec, KEY_F10, 0, MODIFIER_CTRL,
2071                                       backlight_binding, ec);
2072         weston_compositor_add_binding(ec, KEY_BRIGHTNESSUP, 0, 0,
2073                                       backlight_binding, ec);
2074
2075         weston_compositor_add_binding(ec, KEY_SPACE, 0, MODIFIER_SUPER,
2076                                     debug_repaint_binding, ec);
2077
2078         ec->shell = &shell->shell;
2079
2080         return 0;
2081 }