src/input.c

   1 /*
   2  * Copyright © 2013 Intel Corporation
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <stdint.h>
  27 #include <string.h>
  28 #include <sys/mman.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <limits.h>
  33
  34 #include "../shared/os-compatibility.h"
  35 #include "compositor.h"
  36
  37 static void
  38 empty_region(pixman_region32_t *region)
  39 {
  40         pixman_region32_fini(region);
  41         pixman_region32_init(region);
  42 }
  43
  44 static void unbind_resource(struct wl_resource *resource)
  45 {
  46         wl_list_remove(wl_resource_get_link(resource));
  47 }
  48
  49 WL_EXPORT void
  50 weston_seat_repick(struct weston_seat *seat)
  51 {
  52         const struct weston_pointer *pointer = seat->pointer;
  53
  54         if (pointer == NULL)
  55                 return;
  56
  57         pointer->grab->interface->focus(seat->pointer->grab);
  58 }
  59
  60 static void
  61 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
  62 {
  63         weston_compositor_wake(compositor);
  64         compositor->idle_inhibit++;
  65 }
  66
  67 static void
  68 weston_compositor_idle_release(struct weston_compositor *compositor)
  69 {
  70         compositor->idle_inhibit--;
  71         weston_compositor_wake(compositor);
  72 }
  73
  74 static void
  75 pointer_focus_view_destroyed(struct wl_listener *listener, void *data)
  76 {
  77         struct weston_pointer *pointer =
  78                 container_of(listener, struct weston_pointer,
  79                              focus_view_listener);
  80
  81         weston_pointer_set_focus(pointer, NULL, 0, 0);
  82 }
  83
  84 static void
  85 pointer_focus_resource_destroyed(struct wl_listener *listener, void *data)
  86 {
  87         struct weston_pointer *pointer =
  88                 container_of(listener, struct weston_pointer,
  89                              focus_resource_listener);
  90
  91         weston_pointer_set_focus(pointer, NULL, 0, 0);
  92 }
  93
  94 static void
  95 keyboard_focus_resource_destroyed(struct wl_listener *listener, void *data)
  96 {
  97         struct weston_keyboard *keyboard =
  98                 container_of(listener, struct weston_keyboard,
  99                              focus_resource_listener);
 100
 101         weston_keyboard_set_focus(keyboard, NULL);
 102 }
 103
 104 static void
 105 touch_focus_view_destroyed(struct wl_listener *listener, void *data)
 106 {
 107         struct weston_touch *touch =
 108                 container_of(listener, struct weston_touch,
 109                              focus_view_listener);
 110
 111         weston_touch_set_focus(touch->seat, NULL);
 112 }
 113
 114 static void
 115 touch_focus_resource_destroyed(struct wl_listener *listener, void *data)
 116 {
 117         struct weston_touch *touch =
 118                 container_of(listener, struct weston_touch,
 119                              focus_resource_listener);
 120
 121         weston_touch_set_focus(touch->seat, NULL);
 122 }
 123
 124 static void
 125 move_resources(struct wl_list *destination, struct wl_list *source)
 126 {
 127         wl_list_insert_list(destination, source);
 128         wl_list_init(source);
 129 }
 130
 131 static void
 132 move_resources_for_client(struct wl_list *destination,
 133                           struct wl_list *source,
 134                           struct wl_client *client)
 135 {
 136         struct wl_resource *resource, *tmp;
 137         wl_resource_for_each_safe(resource, tmp, source) {
 138                 if (wl_resource_get_client(resource) == client) {
 139                         wl_list_remove(wl_resource_get_link(resource));
 140                         wl_list_insert(destination,
 141                                        wl_resource_get_link(resource));
 142                 }
 143         }
 144 }
 145
 146 static void
 147 default_grab_pointer_focus(struct weston_pointer_grab *grab)
 148 {
 149         struct weston_pointer *pointer = grab->pointer;
 150         struct weston_view *view;
 151         wl_fixed_t sx, sy;
 152
 153         if (pointer->button_count > 0)
 154                 return;
 155
 156         view = weston_compositor_pick_view(pointer->seat->compositor,
 157                                            pointer->x, pointer->y,
 158                                            &sx, &sy);
 159
 160         if (pointer->focus != view || pointer->sx != sx || pointer->sy != sy)
 161                 weston_pointer_set_focus(pointer, view, sx, sy);
 162 }
 163
 164 static void
 165 default_grab_pointer_motion(struct weston_pointer_grab *grab, uint32_t time,
 166                             wl_fixed_t x, wl_fixed_t y)
 167 {
 168         struct weston_pointer *pointer = grab->pointer;
 169         struct wl_list *resource_list;
 170         struct wl_resource *resource;
 171
 172         if (pointer->focus)
 173                 weston_view_from_global_fixed(pointer->focus, x, y,
 174                                               &pointer->sx, &pointer->sy);
 175
 176         weston_pointer_move(pointer, x, y);
 177
 178         resource_list = &pointer->focus_resource_list;
 179         wl_resource_for_each(resource, resource_list) {
 180                 wl_pointer_send_motion(resource, time,
 181                                        pointer->sx, pointer->sy);
 182         }
 183 }
 184
 185 static void
 186 default_grab_pointer_button(struct weston_pointer_grab *grab,
 187                             uint32_t time, uint32_t button, uint32_t state_w)
 188 {
 189         struct weston_pointer *pointer = grab->pointer;
 190         struct weston_compositor *compositor = pointer->seat->compositor;
 191         struct weston_view *view;
 192         struct wl_resource *resource;
 193         uint32_t serial;
 194         enum wl_pointer_button_state state = state_w;
 195         struct wl_display *display = compositor->wl_display;
 196         wl_fixed_t sx, sy;
 197         struct wl_list *resource_list;
 198
 199         resource_list = &pointer->focus_resource_list;
 200         if (!wl_list_empty(resource_list)) {
 201                 serial = wl_display_next_serial(display);
 202                 wl_resource_for_each(resource, resource_list)
 203                         wl_pointer_send_button(resource,
 204                                                serial,
 205                                                time,
 206                                                button,
 207                                                state_w);
 208         }
 209
 210         if (pointer->button_count == 0 &&
 211             state == WL_POINTER_BUTTON_STATE_RELEASED) {
 212                 view = weston_compositor_pick_view(compositor,
 213                                                    pointer->x, pointer->y,
 214                                                    &sx, &sy);
 215
 216                 weston_pointer_set_focus(pointer, view, sx, sy);
 217         }
 218 }
 219
 220 static void
 221 default_grab_pointer_cancel(struct weston_pointer_grab *grab)
 222 {
 223 }
 224
 225 static const struct weston_pointer_grab_interface
 226                                 default_pointer_grab_interface = {
 227         default_grab_pointer_focus,
 228         default_grab_pointer_motion,
 229         default_grab_pointer_button,
 230         default_grab_pointer_cancel,
 231 };
 232
 233 static void
 234 default_grab_touch_down(struct weston_touch_grab *grab, uint32_t time,
 235                         int touch_id, wl_fixed_t sx, wl_fixed_t sy)
 236 {
 237         struct weston_touch *touch = grab->touch;
 238         struct wl_display *display = touch->seat->compositor->wl_display;
 239         uint32_t serial;
 240         struct wl_resource *resource;
 241         struct wl_list *resource_list;
 242
 243         resource_list = &touch->focus_resource_list;
 244
 245         if (!wl_list_empty(resource_list) && touch->focus) {
 246                 serial = wl_display_next_serial(display);
 247                 wl_resource_for_each(resource, resource_list)
 248                                 wl_touch_send_down(resource, serial, time,
 249                                                    touch->focus->surface->resource,
 250                                                    touch_id, sx, sy);
 251         }
 252 }
 253
 254 static void
 255 default_grab_touch_up(struct weston_touch_grab *grab,
 256                       uint32_t time, int touch_id)
 257 {
 258         struct weston_touch *touch = grab->touch;
 259         struct wl_display *display = touch->seat->compositor->wl_display;
 260         uint32_t serial;
 261         struct wl_resource *resource;
 262         struct wl_list *resource_list;
 263
 264         resource_list = &touch->focus_resource_list;
 265
 266         if (!wl_list_empty(resource_list)) {
 267                 serial = wl_display_next_serial(display);
 268                 wl_resource_for_each(resource, resource_list)
 269                         wl_touch_send_up(resource, serial, time, touch_id);
 270         }
 271 }
 272
 273 static void
 274 default_grab_touch_motion(struct weston_touch_grab *grab, uint32_t time,
 275                           int touch_id, wl_fixed_t sx, wl_fixed_t sy)
 276 {
 277         struct weston_touch *touch = grab->touch;
 278         struct wl_resource *resource;
 279         struct wl_list *resource_list;
 280
 281         resource_list = &touch->focus_resource_list;
 282
 283         wl_resource_for_each(resource, resource_list) {
 284                 wl_touch_send_motion(resource, time,
 285                                      touch_id, sx, sy);
 286         }
 287 }
 288
 289 static void
 290 default_grab_touch_frame(struct weston_touch_grab *grab)
 291 {
 292         struct wl_resource *resource;
 293
 294         wl_resource_for_each(resource, &grab->touch->focus_resource_list)
 295                 wl_touch_send_frame(resource);
 296 }
 297
 298 static void
 299 default_grab_touch_cancel(struct weston_touch_grab *grab)
 300 {
 301 }
 302
 303 static const struct weston_touch_grab_interface default_touch_grab_interface = {
 304         default_grab_touch_down,
 305         default_grab_touch_up,
 306         default_grab_touch_motion,
 307         default_grab_touch_frame,
 308         default_grab_touch_cancel,
 309 };
 310
 311 static void
 312 default_grab_keyboard_key(struct weston_keyboard_grab *grab,
 313                           uint32_t time, uint32_t key, uint32_t state)
 314 {
 315         struct weston_keyboard *keyboard = grab->keyboard;
 316         struct wl_resource *resource;
 317         struct wl_display *display = keyboard->seat->compositor->wl_display;
 318         uint32_t serial;
 319         struct wl_list *resource_list;
 320
 321         resource_list = &keyboard->focus_resource_list;
 322         if (!wl_list_empty(resource_list)) {
 323                 serial = wl_display_next_serial(display);
 324                 wl_resource_for_each(resource, resource_list)
 325                         wl_keyboard_send_key(resource,
 326                                              serial,
 327                                              time,
 328                                              key,
 329                                              state);
 330         }
 331 }
 332
 333 static void
 334 send_modifiers_to_resource(struct weston_keyboard *keyboard,
 335                            struct wl_resource *resource,
 336                            uint32_t serial)
 337 {
 338         wl_keyboard_send_modifiers(resource,
 339                                    serial,
 340                                    keyboard->modifiers.mods_depressed,
 341                                    keyboard->modifiers.mods_latched,
 342                                    keyboard->modifiers.mods_locked,
 343                                    keyboard->modifiers.group);
 344 }
 345
 346 static void
 347 send_modifiers_to_client_in_list(struct wl_client *client,
 348                                  struct wl_list *list,
 349                                  uint32_t serial,
 350                                  struct weston_keyboard *keyboard)
 351 {
 352         struct wl_resource *resource;
 353
 354         wl_resource_for_each(resource, list) {
 355                 if (wl_resource_get_client(resource) == client)
 356                         send_modifiers_to_resource(keyboard,
 357                                                    resource,
 358                                                    serial);
 359         }
 360 }
 361
 362 static struct wl_resource *
 363 find_resource_for_surface(struct wl_list *list, struct weston_surface *surface)
 364 {
 365         if (!surface)
 366                 return NULL;
 367
 368         if (!surface->resource)
 369                 return NULL;
 370
 371         return wl_resource_find_for_client(list, wl_resource_get_client(surface->resource));
 372 }
 373
 374 static struct wl_resource *
 375 find_resource_for_view(struct wl_list *list, struct weston_view *view)
 376 {
 377         if (!view)
 378                 return NULL;
 379
 380         return find_resource_for_surface(list, view->surface);
 381 }
 382
 383 static void
 384 default_grab_keyboard_modifiers(struct weston_keyboard_grab *grab,
 385                                 uint32_t serial, uint32_t mods_depressed,
 386                                 uint32_t mods_latched,
 387                                 uint32_t mods_locked, uint32_t group)
 388 {
 389         struct weston_keyboard *keyboard = grab->keyboard;
 390         struct weston_pointer *pointer = grab->keyboard->seat->pointer;
 391         struct wl_resource *resource;
 392         struct wl_list *resource_list;
 393
 394         resource_list = &keyboard->focus_resource_list;
 395
 396         wl_resource_for_each(resource, resource_list) {
 397                 wl_keyboard_send_modifiers(resource, serial, mods_depressed,
 398                                            mods_latched, mods_locked, group);
 399         }
 400         if (pointer && pointer->focus && pointer->focus->surface->resource &&
 401             pointer->focus->surface != keyboard->focus) {
 402                 struct wl_client *pointer_client =
 403                         wl_resource_get_client(pointer->focus->surface->resource);
 404                 send_modifiers_to_client_in_list(pointer_client,
 405                                                  &keyboard->resource_list,
 406                                                  serial,
 407                                                  keyboard);
 408         }
 409 }
 410
 411 static void
 412 default_grab_keyboard_cancel(struct weston_keyboard_grab *grab)
 413 {
 414 }
 415
 416 static const struct weston_keyboard_grab_interface
 417                                 default_keyboard_grab_interface = {
 418         default_grab_keyboard_key,
 419         default_grab_keyboard_modifiers,
 420         default_grab_keyboard_cancel,
 421 };
 422
 423 static void
 424 pointer_unmap_sprite(struct weston_pointer *pointer)
 425 {
 426         if (weston_surface_is_mapped(pointer->sprite->surface))
 427                 weston_surface_unmap(pointer->sprite->surface);
 428
 429         wl_list_remove(&pointer->sprite_destroy_listener.link);
 430         pointer->sprite->surface->configure = NULL;
 431         pointer->sprite->surface->configure_private = NULL;
 432         weston_view_destroy(pointer->sprite);
 433         pointer->sprite = NULL;
 434 }
 435
 436 static void
 437 pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
 438 {
 439         struct weston_pointer *pointer =
 440                 container_of(listener, struct weston_pointer,
 441                              sprite_destroy_listener);
 442
 443         pointer->sprite = NULL;
 444 }
 445
 446 static void
 447 weston_pointer_reset_state(struct weston_pointer *pointer)
 448 {
 449         pointer->button_count = 0;
 450 }
 451
 452 static void
 453 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data);
 454
 455 WL_EXPORT struct weston_pointer *
 456 weston_pointer_create(struct weston_seat *seat)
 457 {
 458         struct weston_pointer *pointer;
 459
 460         pointer = zalloc(sizeof *pointer);
 461         if (pointer == NULL)
 462                 return NULL;
 463
 464         wl_list_init(&pointer->resource_list);
 465         wl_list_init(&pointer->focus_resource_list);
 466         weston_pointer_set_default_grab(pointer,
 467                                         seat->compositor->default_pointer_grab);
 468         wl_list_init(&pointer->focus_resource_listener.link);
 469         pointer->focus_resource_listener.notify = pointer_focus_resource_destroyed;
 470         pointer->default_grab.pointer = pointer;
 471         pointer->grab = &pointer->default_grab;
 472         wl_signal_init(&pointer->motion_signal);
 473         wl_signal_init(&pointer->focus_signal);
 474         wl_list_init(&pointer->focus_view_listener.link);
 475
 476         pointer->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
 477
 478         /* FIXME: Pick better co-ords. */
 479         pointer->x = wl_fixed_from_int(100);
 480         pointer->y = wl_fixed_from_int(100);
 481
 482         pointer->output_destroy_listener.notify =
 483                 weston_pointer_handle_output_destroy;
 484         wl_signal_add(&seat->compositor->output_destroyed_signal,
 485                       &pointer->output_destroy_listener);
 486
 487         return pointer;
 488 }
 489
 490 WL_EXPORT void
 491 weston_pointer_destroy(struct weston_pointer *pointer)
 492 {
 493         if (pointer->sprite)
 494                 pointer_unmap_sprite(pointer);
 495
 496         /* XXX: What about pointer->resource_list? */
 497
 498         wl_list_remove(&pointer->focus_resource_listener.link);
 499         wl_list_remove(&pointer->focus_view_listener.link);
 500         wl_list_remove(&pointer->output_destroy_listener.link);
 501         free(pointer);
 502 }
 503
 504 void
 505 weston_pointer_set_default_grab(struct weston_pointer *pointer,
 506                 const struct weston_pointer_grab_interface *interface)
 507 {
 508         if (interface)
 509                 pointer->default_grab.interface = interface;
 510         else
 511                 pointer->default_grab.interface =
 512                         &default_pointer_grab_interface;
 513 }
 514
 515 WL_EXPORT struct weston_keyboard *
 516 weston_keyboard_create(void)
 517 {
 518         struct weston_keyboard *keyboard;
 519
 520         keyboard = zalloc(sizeof *keyboard);
 521         if (keyboard == NULL)
 522             return NULL;
 523
 524         wl_list_init(&keyboard->resource_list);
 525         wl_list_init(&keyboard->focus_resource_list);
 526         wl_list_init(&keyboard->focus_resource_listener.link);
 527         keyboard->focus_resource_listener.notify = keyboard_focus_resource_destroyed;
 528         wl_array_init(&keyboard->keys);
 529         keyboard->default_grab.interface = &default_keyboard_grab_interface;
 530         keyboard->default_grab.keyboard = keyboard;
 531         keyboard->grab = &keyboard->default_grab;
 532         wl_signal_init(&keyboard->focus_signal);
 533
 534         return keyboard;
 535 }
 536
 537 static void
 538 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info);
 539
 540 WL_EXPORT void
 541 weston_keyboard_destroy(struct weston_keyboard *keyboard)
 542 {
 543         /* XXX: What about keyboard->resource_list? */
 544
 545 #ifdef ENABLE_XKBCOMMON
 546         if (keyboard->seat->compositor->use_xkbcommon) {
 547                 if (keyboard->xkb_state.state != NULL)
 548                         xkb_state_unref(keyboard->xkb_state.state);
 549                 if (keyboard->xkb_info)
 550                         weston_xkb_info_destroy(keyboard->xkb_info);
 551                 if (keyboard->pending_keymap)
 552                         xkb_keymap_unref(keyboard->pending_keymap);
 553         }
 554 #endif
 555
 556         wl_array_release(&keyboard->keys);
 557         wl_list_remove(&keyboard->focus_resource_listener.link);
 558         free(keyboard);
 559 }
 560
 561 static void
 562 weston_touch_reset_state(struct weston_touch *touch)
 563 {
 564         touch->num_tp = 0;
 565 }
 566
 567 WL_EXPORT struct weston_touch *
 568 weston_touch_create(void)
 569 {
 570         struct weston_touch *touch;
 571
 572         touch = zalloc(sizeof *touch);
 573         if (touch == NULL)
 574                 return NULL;
 575
 576         wl_list_init(&touch->resource_list);
 577         wl_list_init(&touch->focus_resource_list);
 578         wl_list_init(&touch->focus_view_listener.link);
 579         touch->focus_view_listener.notify = touch_focus_view_destroyed;
 580         wl_list_init(&touch->focus_resource_listener.link);
 581         touch->focus_resource_listener.notify = touch_focus_resource_destroyed;
 582         touch->default_grab.interface = &default_touch_grab_interface;
 583         touch->default_grab.touch = touch;
 584         touch->grab = &touch->default_grab;
 585         wl_signal_init(&touch->focus_signal);
 586
 587         return touch;
 588 }
 589
 590 WL_EXPORT void
 591 weston_touch_destroy(struct weston_touch *touch)
 592 {
 593         /* XXX: What about touch->resource_list? */
 594
 595         wl_list_remove(&touch->focus_view_listener.link);
 596         wl_list_remove(&touch->focus_resource_listener.link);
 597         free(touch);
 598 }
 599
 600 static void
 601 seat_send_updated_caps(struct weston_seat *seat)
 602 {
 603         enum wl_seat_capability caps = 0;
 604         struct wl_resource *resource;
 605
 606         if (seat->pointer_device_count > 0)
 607                 caps |= WL_SEAT_CAPABILITY_POINTER;
 608         if (seat->keyboard_device_count > 0)
 609                 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
 610         if (seat->touch_device_count > 0)
 611                 caps |= WL_SEAT_CAPABILITY_TOUCH;
 612
 613         wl_resource_for_each(resource, &seat->base_resource_list) {
 614                 wl_seat_send_capabilities(resource, caps);
 615         }
 616         wl_signal_emit(&seat->updated_caps_signal, seat);
 617 }
 618
 619 WL_EXPORT void
 620 weston_pointer_set_focus(struct weston_pointer *pointer,
 621                          struct weston_view *view,
 622                          wl_fixed_t sx, wl_fixed_t sy)
 623 {
 624         struct weston_keyboard *kbd = pointer->seat->keyboard;
 625         struct wl_resource *resource;
 626         struct wl_display *display = pointer->seat->compositor->wl_display;
 627         uint32_t serial;
 628         struct wl_list *focus_resource_list;
 629         int refocus = 0;
 630
 631         if ((!pointer->focus && view) ||
 632             (pointer->focus && !view) ||
 633             (pointer->focus && pointer->focus->surface != view->surface) ||
 634             pointer->sx != sx || pointer->sy != sy)
 635                 refocus = 1;
 636
 637         focus_resource_list = &pointer->focus_resource_list;
 638
 639         if (!wl_list_empty(focus_resource_list) && refocus) {
 640                 serial = wl_display_next_serial(display);
 641                 wl_resource_for_each(resource, focus_resource_list) {
 642                         wl_pointer_send_leave(resource, serial,
 643                                               pointer->focus->surface->resource);
 644                 }
 645
 646                 move_resources(&pointer->resource_list, focus_resource_list);
 647         }
 648
 649         if (find_resource_for_view(&pointer->resource_list, view) && refocus) {
 650                 struct wl_client *surface_client =
 651                         wl_resource_get_client(view->surface->resource);
 652
 653                 serial = wl_display_next_serial(display);
 654
 655                 if (kbd && kbd->focus != view->surface)
 656                         send_modifiers_to_client_in_list(surface_client,
 657                                                          &kbd->resource_list,
 658                                                          serial,
 659                                                          kbd);
 660
 661                 move_resources_for_client(focus_resource_list,
 662                                           &pointer->resource_list,
 663                                           surface_client);
 664
 665                 wl_resource_for_each(resource, focus_resource_list) {
 666                         wl_pointer_send_enter(resource,
 667                                               serial,
 668                                               view->surface->resource,
 669                                               sx, sy);
 670                 }
 671
 672                 pointer->focus_serial = serial;
 673         }
 674
 675         wl_list_remove(&pointer->focus_view_listener.link);
 676         wl_list_init(&pointer->focus_view_listener.link);
 677         wl_list_remove(&pointer->focus_resource_listener.link);
 678         wl_list_init(&pointer->focus_resource_listener.link);
 679         if (view)
 680                 wl_signal_add(&view->destroy_signal, &pointer->focus_view_listener);
 681         if (view && view->surface->resource)
 682                 wl_resource_add_destroy_listener(view->surface->resource,
 683                                                  &pointer->focus_resource_listener);
 684
 685         pointer->focus = view;
 686         pointer->focus_view_listener.notify = pointer_focus_view_destroyed;
 687         pointer->sx = sx;
 688         pointer->sy = sy;
 689
 690         wl_signal_emit(&pointer->focus_signal, pointer);
 691 }
 692
 693 static void
 694 send_enter_to_resource_list(struct wl_list *list,
 695                             struct weston_keyboard *keyboard,
 696                             struct weston_surface *surface,
 697                             uint32_t serial)
 698 {
 699         struct wl_resource *resource;
 700
 701         wl_resource_for_each(resource, list) {
 702                 send_modifiers_to_resource(keyboard, resource, serial);
 703                 wl_keyboard_send_enter(resource, serial,
 704                                        surface->resource,
 705                                        &keyboard->keys);
 706         }
 707 }
 708
 709 WL_EXPORT void
 710 weston_keyboard_set_focus(struct weston_keyboard *keyboard,
 711                           struct weston_surface *surface)
 712 {
 713         struct wl_resource *resource;
 714         struct wl_display *display = keyboard->seat->compositor->wl_display;
 715         uint32_t serial;
 716         struct wl_list *focus_resource_list;
 717
 718         focus_resource_list = &keyboard->focus_resource_list;
 719
 720         if (!wl_list_empty(focus_resource_list) && keyboard->focus != surface) {
 721                 serial = wl_display_next_serial(display);
 722                 wl_resource_for_each(resource, focus_resource_list) {
 723                         wl_keyboard_send_leave(resource, serial,
 724                                         keyboard->focus->resource);
 725                 }
 726                 move_resources(&keyboard->resource_list, focus_resource_list);
 727         }
 728
 729         if (find_resource_for_surface(&keyboard->resource_list, surface) &&
 730             keyboard->focus != surface) {
 731                 struct wl_client *surface_client =
 732                         wl_resource_get_client(surface->resource);
 733
 734                 serial = wl_display_next_serial(display);
 735
 736                 move_resources_for_client(focus_resource_list,
 737                                           &keyboard->resource_list,
 738                                           surface_client);
 739                 send_enter_to_resource_list(focus_resource_list,
 740                                             keyboard,
 741                                             surface,
 742                                             serial);
 743                 keyboard->focus_serial = serial;
 744         }
 745
 746         wl_list_remove(&keyboard->focus_resource_listener.link);
 747         wl_list_init(&keyboard->focus_resource_listener.link);
 748         if (surface && surface->resource)
 749                 wl_resource_add_destroy_listener(surface->resource,
 750                                                  &keyboard->focus_resource_listener);
 751
 752         keyboard->focus = surface;
 753         wl_signal_emit(&keyboard->focus_signal, keyboard);
 754 }
 755
 756 WL_EXPORT void
 757 weston_keyboard_start_grab(struct weston_keyboard *keyboard,
 758                            struct weston_keyboard_grab *grab)
 759 {
 760         keyboard->grab = grab;
 761         grab->keyboard = keyboard;
 762
 763         /* XXX focus? */
 764 }
 765
 766 WL_EXPORT void
 767 weston_keyboard_end_grab(struct weston_keyboard *keyboard)
 768 {
 769         keyboard->grab = &keyboard->default_grab;
 770 }
 771
 772 static void
 773 weston_keyboard_cancel_grab(struct weston_keyboard *keyboard)
 774 {
 775         keyboard->grab->interface->cancel(keyboard->grab);
 776 }
 777
 778 WL_EXPORT void
 779 weston_pointer_start_grab(struct weston_pointer *pointer,
 780                           struct weston_pointer_grab *grab)
 781 {
 782         pointer->grab = grab;
 783         grab->pointer = pointer;
 784         pointer->grab->interface->focus(pointer->grab);
 785 }
 786
 787 WL_EXPORT void
 788 weston_pointer_end_grab(struct weston_pointer *pointer)
 789 {
 790         pointer->grab = &pointer->default_grab;
 791         pointer->grab->interface->focus(pointer->grab);
 792 }
 793
 794 static void
 795 weston_pointer_cancel_grab(struct weston_pointer *pointer)
 796 {
 797         pointer->grab->interface->cancel(pointer->grab);
 798 }
 799
 800 WL_EXPORT void
 801 weston_touch_start_grab(struct weston_touch *touch, struct weston_touch_grab *grab)
 802 {
 803         touch->grab = grab;
 804         grab->touch = touch;
 805 }
 806
 807 WL_EXPORT void
 808 weston_touch_end_grab(struct weston_touch *touch)
 809 {
 810         touch->grab = &touch->default_grab;
 811 }
 812
 813 static void
 814 weston_touch_cancel_grab(struct weston_touch *touch)
 815 {
 816         touch->grab->interface->cancel(touch->grab);
 817 }
 818
 819 static void
 820 weston_pointer_clamp_for_output(struct weston_pointer *pointer,
 821                                 struct weston_output *output,
 822                                 wl_fixed_t *fx, wl_fixed_t *fy)
 823 {
 824         int x, y;
 825
 826         x = wl_fixed_to_int(*fx);
 827         y = wl_fixed_to_int(*fy);
 828
 829         if (x < output->x)
 830                 *fx = wl_fixed_from_int(output->x);
 831         else if (x >= output->x + output->width)
 832                 *fx = wl_fixed_from_int(output->x +
 833                                         output->width - 1);
 834         if (y < output->y)
 835                 *fy = wl_fixed_from_int(output->y);
 836         else if (y >= output->y + output->height)
 837                 *fy = wl_fixed_from_int(output->y +
 838                                         output->height - 1);
 839 }
 840
 841 WL_EXPORT void
 842 weston_pointer_clamp(struct weston_pointer *pointer, wl_fixed_t *fx, wl_fixed_t *fy)
 843 {
 844         struct weston_compositor *ec = pointer->seat->compositor;
 845         struct weston_output *output, *prev = NULL;
 846         int x, y, old_x, old_y, valid = 0;
 847
 848         x = wl_fixed_to_int(*fx);
 849         y = wl_fixed_to_int(*fy);
 850         old_x = wl_fixed_to_int(pointer->x);
 851         old_y = wl_fixed_to_int(pointer->y);
 852
 853         wl_list_for_each(output, &ec->output_list, link) {
 854                 if (pointer->seat->output && pointer->seat->output != output)
 855                         continue;
 856                 if (pixman_region32_contains_point(&output->region,
 857                                                    x, y, NULL))
 858                         valid = 1;
 859                 if (pixman_region32_contains_point(&output->region,
 860                                                    old_x, old_y, NULL))
 861                         prev = output;
 862         }
 863
 864         if (!prev)
 865                 prev = pointer->seat->output;
 866
 867         if (prev && !valid)
 868                 weston_pointer_clamp_for_output(pointer, prev, fx, fy);
 869 }
 870
 871 /* Takes absolute values */
 872 WL_EXPORT void
 873 weston_pointer_move(struct weston_pointer *pointer, wl_fixed_t x, wl_fixed_t y)
 874 {
 875         int32_t ix, iy;
 876
 877         weston_pointer_clamp (pointer, &x, &y);
 878
 879         pointer->x = x;
 880         pointer->y = y;
 881
 882         ix = wl_fixed_to_int(x);
 883         iy = wl_fixed_to_int(y);
 884
 885         if (pointer->sprite) {
 886                 weston_view_set_position(pointer->sprite,
 887                                          ix - pointer->hotspot_x,
 888                                          iy - pointer->hotspot_y);
 889                 weston_view_schedule_repaint(pointer->sprite);
 890         }
 891
 892         pointer->grab->interface->focus(pointer->grab);
 893         wl_signal_emit(&pointer->motion_signal, pointer);
 894 }
 895
 896 /** Verify if the pointer is in a valid position and move it if it isn't.
 897  */
 898 static void
 899 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data)
 900 {
 901         struct weston_pointer *pointer;
 902         struct weston_compositor *ec;
 903         struct weston_output *output, *closest = NULL;
 904         int x, y, distance, min = INT_MAX;
 905         wl_fixed_t fx, fy;
 906
 907         pointer = container_of(listener, struct weston_pointer,
 908                                output_destroy_listener);
 909         ec = pointer->seat->compositor;
 910
 911         x = wl_fixed_to_int(pointer->x);
 912         y = wl_fixed_to_int(pointer->y);
 913
 914         wl_list_for_each(output, &ec->output_list, link) {
 915                 if (pixman_region32_contains_point(&output->region,
 916                                                    x, y, NULL))
 917                         return;
 918
 919                 /* Aproximante the distance from the pointer to the center of
 920                  * the output. */
 921                 distance = abs(output->x + output->width / 2 - x) +
 922                            abs(output->y + output->height / 2 - y);
 923                 if (distance < min) {
 924                         min = distance;
 925                         closest = output;
 926                 }
 927         }
 928
 929         /* Nothing to do if there's no output left. */
 930         if (!closest)
 931                 return;
 932
 933         fx = pointer->x;
 934         fy = pointer->y;
 935
 936         weston_pointer_clamp_for_output(pointer, closest, &fx, &fy);
 937         weston_pointer_move(pointer, fx, fy);
 938 }
 939
 940 WL_EXPORT void
 941 notify_motion(struct weston_seat *seat,
 942               uint32_t time, wl_fixed_t dx, wl_fixed_t dy)
 943 {
 944         struct weston_compositor *ec = seat->compositor;
 945         struct weston_pointer *pointer = seat->pointer;
 946
 947         weston_compositor_wake(ec);
 948         pointer->grab->interface->motion(pointer->grab, time, pointer->x + dx, pointer->y + dy);
 949 }
 950
 951 static void
 952 run_modifier_bindings(struct weston_seat *seat, uint32_t old, uint32_t new)
 953 {
 954         struct weston_compositor *compositor = seat->compositor;
 955         struct weston_keyboard *keyboard = seat->keyboard;
 956         uint32_t diff;
 957         unsigned int i;
 958         struct {
 959                 uint32_t xkb;
 960                 enum weston_keyboard_modifier weston;
 961         } mods[] = {
 962                 { keyboard->xkb_info->ctrl_mod, MODIFIER_CTRL },
 963                 { keyboard->xkb_info->alt_mod, MODIFIER_ALT },
 964                 { keyboard->xkb_info->super_mod, MODIFIER_SUPER },
 965                 { keyboard->xkb_info->shift_mod, MODIFIER_SHIFT },
 966         };
 967
 968         diff = new & ~old;
 969         for (i = 0; i < ARRAY_LENGTH(mods); i++) {
 970                 if (diff & (1 << mods[i].xkb))
 971                         weston_compositor_run_modifier_binding(compositor,
 972                                                                seat,
 973                                                                mods[i].weston,
 974                                                                WL_KEYBOARD_KEY_STATE_PRESSED);
 975         }
 976
 977         diff = old & ~new;
 978         for (i = 0; i < ARRAY_LENGTH(mods); i++) {
 979                 if (diff & (1 << mods[i].xkb))
 980                         weston_compositor_run_modifier_binding(compositor,
 981                                                                seat,
 982                                                                mods[i].weston,
 983                                                                WL_KEYBOARD_KEY_STATE_RELEASED);
 984         }
 985 }
 986
 987 WL_EXPORT void
 988 notify_motion_absolute(struct weston_seat *seat,
 989                        uint32_t time, wl_fixed_t x, wl_fixed_t y)
 990 {
 991         struct weston_compositor *ec = seat->compositor;
 992         struct weston_pointer *pointer = seat->pointer;
 993
 994         weston_compositor_wake(ec);
 995         pointer->grab->interface->motion(pointer->grab, time, x, y);
 996 }
 997
 998 WL_EXPORT void
 999 weston_surface_activate(struct weston_surface *surface,
1000                         struct weston_seat *seat)
1001 {
1002         struct weston_compositor *compositor = seat->compositor;
1003
1004         if (seat->keyboard) {
1005                 weston_keyboard_set_focus(seat->keyboard, surface);
1006                 wl_data_device_set_keyboard_focus(seat);
1007         }
1008
1009         wl_signal_emit(&compositor->activate_signal, surface);
1010 }
1011
1012 WL_EXPORT void
1013 notify_button(struct weston_seat *seat, uint32_t time, int32_t button,
1014               enum wl_pointer_button_state state)
1015 {
1016         struct weston_compositor *compositor = seat->compositor;
1017         struct weston_pointer *pointer = seat->pointer;
1018
1019         if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
1020                 weston_compositor_idle_inhibit(compositor);
1021                 if (pointer->button_count == 0) {
1022                         pointer->grab_button = button;
1023                         pointer->grab_time = time;
1024                         pointer->grab_x = pointer->x;
1025                         pointer->grab_y = pointer->y;
1026                 }
1027                 pointer->button_count++;
1028         } else {
1029                 weston_compositor_idle_release(compositor);
1030                 pointer->button_count--;
1031         }
1032
1033         weston_compositor_run_button_binding(compositor, seat, time, button,
1034                                              state);
1035
1036         pointer->grab->interface->button(pointer->grab, time, button, state);
1037
1038         if (pointer->button_count == 1)
1039                 pointer->grab_serial =
1040                         wl_display_get_serial(compositor->wl_display);
1041 }
1042
1043 WL_EXPORT void
1044 notify_axis(struct weston_seat *seat, uint32_t time, uint32_t axis,
1045             wl_fixed_t value)
1046 {
1047         struct weston_compositor *compositor = seat->compositor;
1048         struct weston_pointer *pointer = seat->pointer;
1049         struct wl_resource *resource;
1050         struct wl_list *resource_list;
1051
1052         weston_compositor_wake(compositor);
1053
1054         if (!value)
1055                 return;
1056
1057         if (weston_compositor_run_axis_binding(compositor, seat,
1058                                                    time, axis, value))
1059                 return;
1060
1061         resource_list = &pointer->focus_resource_list;
1062         wl_resource_for_each(resource, resource_list)
1063                 wl_pointer_send_axis(resource, time, axis,
1064                                      value);
1065 }
1066
1067 #ifdef ENABLE_XKBCOMMON
1068 WL_EXPORT void
1069 notify_modifiers(struct weston_seat *seat, uint32_t serial)
1070 {
1071         struct weston_keyboard *keyboard = seat->keyboard;
1072         struct weston_keyboard_grab *grab = keyboard->grab;
1073         uint32_t mods_depressed, mods_latched, mods_locked, group;
1074         uint32_t mods_lookup;
1075         enum weston_led leds = 0;
1076         int changed = 0;
1077
1078         /* Serialize and update our internal state, checking to see if it's
1079          * different to the previous state. */
1080         mods_depressed = xkb_state_serialize_mods(keyboard->xkb_state.state,
1081                                                   XKB_STATE_MODS_DEPRESSED);
1082         mods_latched = xkb_state_serialize_mods(keyboard->xkb_state.state,
1083                                                 XKB_STATE_MODS_LATCHED);
1084         mods_locked = xkb_state_serialize_mods(keyboard->xkb_state.state,
1085                                                XKB_STATE_MODS_LOCKED);
1086         group = xkb_state_serialize_layout(keyboard->xkb_state.state,
1087                                            XKB_STATE_LAYOUT_EFFECTIVE);
1088
1089         if (mods_depressed != seat->keyboard->modifiers.mods_depressed ||
1090             mods_latched != seat->keyboard->modifiers.mods_latched ||
1091             mods_locked != seat->keyboard->modifiers.mods_locked ||
1092             group != seat->keyboard->modifiers.group)
1093                 changed = 1;
1094
1095         run_modifier_bindings(seat, seat->keyboard->modifiers.mods_depressed,
1096                               mods_depressed);
1097
1098         seat->keyboard->modifiers.mods_depressed = mods_depressed;
1099         seat->keyboard->modifiers.mods_latched = mods_latched;
1100         seat->keyboard->modifiers.mods_locked = mods_locked;
1101         seat->keyboard->modifiers.group = group;
1102
1103         /* And update the modifier_state for bindings. */
1104         mods_lookup = mods_depressed | mods_latched;
1105         seat->modifier_state = 0;
1106         if (mods_lookup & (1 << keyboard->xkb_info->ctrl_mod))
1107                 seat->modifier_state |= MODIFIER_CTRL;
1108         if (mods_lookup & (1 << keyboard->xkb_info->alt_mod))
1109                 seat->modifier_state |= MODIFIER_ALT;
1110         if (mods_lookup & (1 << keyboard->xkb_info->super_mod))
1111                 seat->modifier_state |= MODIFIER_SUPER;
1112         if (mods_lookup & (1 << keyboard->xkb_info->shift_mod))
1113                 seat->modifier_state |= MODIFIER_SHIFT;
1114
1115         /* Finally, notify the compositor that LEDs have changed. */
1116         if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1117                                           keyboard->xkb_info->num_led))
1118                 leds |= LED_NUM_LOCK;
1119         if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1120                                           keyboard->xkb_info->caps_led))
1121                 leds |= LED_CAPS_LOCK;
1122         if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1123                                           keyboard->xkb_info->scroll_led))
1124                 leds |= LED_SCROLL_LOCK;
1125         if (leds != keyboard->xkb_state.leds && seat->led_update)
1126                 seat->led_update(seat, leds);
1127         keyboard->xkb_state.leds = leds;
1128
1129         if (changed) {
1130                 grab->interface->modifiers(grab,
1131                                            serial,
1132                                            keyboard->modifiers.mods_depressed,
1133                                            keyboard->modifiers.mods_latched,
1134                                            keyboard->modifiers.mods_locked,
1135                                            keyboard->modifiers.group);
1136         }
1137 }
1138
1139 static void
1140 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
1141                       enum wl_keyboard_key_state state)
1142 {
1143         struct weston_keyboard *keyboard = seat->keyboard;
1144         enum xkb_key_direction direction;
1145
1146         /* Keyboard modifiers don't exist in raw keyboard mode */
1147         if (!seat->compositor->use_xkbcommon)
1148                 return;
1149
1150         if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1151                 direction = XKB_KEY_DOWN;
1152         else
1153                 direction = XKB_KEY_UP;
1154
1155         /* Offset the keycode by 8, as the evdev XKB rules reflect X's
1156          * broken keycode system, which starts at 8. */
1157         xkb_state_update_key(keyboard->xkb_state.state, key + 8, direction);
1158
1159         notify_modifiers(seat, serial);
1160 }
1161
1162 static void
1163 send_keymap(struct wl_resource *resource, struct weston_xkb_info *xkb_info)
1164 {
1165         wl_keyboard_send_keymap(resource,
1166                                 WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
1167                                 xkb_info->keymap_fd,
1168                                 xkb_info->keymap_size);
1169 }
1170
1171 static void
1172 send_modifiers(struct wl_resource *resource, uint32_t serial, struct weston_keyboard *keyboard)
1173 {
1174         wl_keyboard_send_modifiers(resource, serial,
1175                                    keyboard->modifiers.mods_depressed,
1176                                    keyboard->modifiers.mods_latched,
1177                                    keyboard->modifiers.mods_locked,
1178                                    keyboard->modifiers.group);
1179 }
1180
1181 static struct weston_xkb_info *
1182 weston_xkb_info_create(struct xkb_keymap *keymap);
1183
1184 static void
1185 update_keymap(struct weston_seat *seat)
1186 {
1187         struct weston_keyboard *keyboard = seat->keyboard;
1188         struct wl_resource *resource;
1189         struct weston_xkb_info *xkb_info;
1190         struct xkb_state *state;
1191         xkb_mod_mask_t latched_mods;
1192         xkb_mod_mask_t locked_mods;
1193
1194         xkb_info = weston_xkb_info_create(keyboard->pending_keymap);
1195
1196         xkb_keymap_unref(keyboard->pending_keymap);
1197         keyboard->pending_keymap = NULL;
1198
1199         if (!xkb_info) {
1200                 weston_log("failed to create XKB info\n");
1201                 return;
1202         }
1203
1204         state = xkb_state_new(xkb_info->keymap);
1205         if (!state) {
1206                 weston_log("failed to initialise XKB state\n");
1207                 weston_xkb_info_destroy(xkb_info);
1208                 return;
1209         }
1210
1211         latched_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
1212                                                 XKB_STATE_MODS_LATCHED);
1213         locked_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
1214                                                XKB_STATE_MODS_LOCKED);
1215         xkb_state_update_mask(state,
1216                               0, /* depressed */
1217                               latched_mods,
1218                               locked_mods,
1219                               0, 0, 0);
1220
1221         weston_xkb_info_destroy(keyboard->xkb_info);
1222         keyboard->xkb_info = xkb_info;
1223
1224         xkb_state_unref(keyboard->xkb_state.state);
1225         keyboard->xkb_state.state = state;
1226
1227         wl_resource_for_each(resource, &seat->keyboard->resource_list)
1228                 send_keymap(resource, xkb_info);
1229         wl_resource_for_each(resource, &seat->keyboard->focus_resource_list)
1230                 send_keymap(resource, xkb_info);
1231
1232         notify_modifiers(seat, wl_display_next_serial(seat->compositor->wl_display));
1233
1234         if (!latched_mods && !locked_mods)
1235                 return;
1236
1237         wl_resource_for_each(resource, &seat->keyboard->resource_list)
1238                 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), seat->keyboard);
1239         wl_resource_for_each(resource, &seat->keyboard->focus_resource_list)
1240                 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), seat->keyboard);
1241 }
1242 #else
1243 WL_EXPORT void
1244 notify_modifiers(struct weston_seat *seat, uint32_t serial)
1245 {
1246 }
1247
1248 static void
1249 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
1250                       enum wl_keyboard_key_state state)
1251 {
1252 }
1253
1254 static void
1255 update_keymap(struct weston_seat *seat)
1256 {
1257 }
1258 #endif
1259
1260 WL_EXPORT void
1261 notify_key(struct weston_seat *seat, uint32_t time, uint32_t key,
1262            enum wl_keyboard_key_state state,
1263            enum weston_key_state_update update_state)
1264 {
1265         struct weston_compositor *compositor = seat->compositor;
1266         struct weston_keyboard *keyboard = seat->keyboard;
1267         struct weston_keyboard_grab *grab = keyboard->grab;
1268         uint32_t *k, *end;
1269
1270         if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1271                 weston_compositor_idle_inhibit(compositor);
1272                 keyboard->grab_key = key;
1273                 keyboard->grab_time = time;
1274         } else {
1275                 weston_compositor_idle_release(compositor);
1276         }
1277
1278         end = keyboard->keys.data + keyboard->keys.size;
1279         for (k = keyboard->keys.data; k < end; k++) {
1280                 if (*k == key) {
1281                         /* Ignore server-generated repeats. */
1282                         if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1283                                 return;
1284                         *k = *--end;
1285                 }
1286         }
1287         keyboard->keys.size = (void *) end - keyboard->keys.data;
1288         if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1289                 k = wl_array_add(&keyboard->keys, sizeof *k);
1290                 *k = key;
1291         }
1292
1293         if (grab == &keyboard->default_grab ||
1294             grab == &keyboard->input_method_grab) {
1295                 weston_compositor_run_key_binding(compositor, seat, time, key,
1296                                                   state);
1297                 grab = keyboard->grab;
1298         }
1299
1300         grab->interface->key(grab, time, key, state);
1301
1302         if (keyboard->pending_keymap &&
1303             keyboard->keys.size == 0)
1304                 update_keymap(seat);
1305
1306         if (update_state == STATE_UPDATE_AUTOMATIC) {
1307                 update_modifier_state(seat,
1308                                       wl_display_get_serial(compositor->wl_display),
1309                                       key,
1310                                       state);
1311         }
1312 }
1313
1314 WL_EXPORT void
1315 notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
1316                      wl_fixed_t x, wl_fixed_t y)
1317 {
1318         if (output) {
1319                 weston_pointer_move(seat->pointer, x, y);
1320         } else {
1321                 /* FIXME: We should call weston_pointer_set_focus(seat,
1322                  * NULL) here, but somehow that breaks re-entry... */
1323         }
1324 }
1325
1326 static void
1327 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
1328 {
1329         struct weston_seat *ws;
1330
1331         ws = container_of(listener, struct weston_seat,
1332                           saved_kbd_focus_listener);
1333
1334         ws->saved_kbd_focus = NULL;
1335 }
1336
1337 WL_EXPORT void
1338 notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys,
1339                          enum weston_key_state_update update_state)
1340 {
1341         struct weston_compositor *compositor = seat->compositor;
1342         struct weston_keyboard *keyboard = seat->keyboard;
1343         struct weston_surface *surface;
1344         uint32_t *k, serial;
1345
1346         serial = wl_display_next_serial(compositor->wl_display);
1347         wl_array_copy(&keyboard->keys, keys);
1348         wl_array_for_each(k, &keyboard->keys) {
1349                 weston_compositor_idle_inhibit(compositor);
1350                 if (update_state == STATE_UPDATE_AUTOMATIC)
1351                         update_modifier_state(seat, serial, *k,
1352                                               WL_KEYBOARD_KEY_STATE_PRESSED);
1353         }
1354
1355         /* Run key bindings after we've updated the state. */
1356         wl_array_for_each(k, &keyboard->keys) {
1357                 weston_compositor_run_key_binding(compositor, seat, 0, *k,
1358                                                   WL_KEYBOARD_KEY_STATE_PRESSED);
1359         }
1360
1361         surface = seat->saved_kbd_focus;
1362
1363         if (surface) {
1364                 wl_list_remove(&seat->saved_kbd_focus_listener.link);
1365                 weston_keyboard_set_focus(keyboard, surface);
1366                 seat->saved_kbd_focus = NULL;
1367         }
1368 }
1369
1370 WL_EXPORT void
1371 notify_keyboard_focus_out(struct weston_seat *seat)
1372 {
1373         struct weston_compositor *compositor = seat->compositor;
1374         struct weston_keyboard *keyboard = seat->keyboard;
1375         uint32_t *k, serial;
1376
1377         serial = wl_display_next_serial(compositor->wl_display);
1378         wl_array_for_each(k, &keyboard->keys) {
1379                 weston_compositor_idle_release(compositor);
1380                 update_modifier_state(seat, serial, *k,
1381                                       WL_KEYBOARD_KEY_STATE_RELEASED);
1382         }
1383
1384         seat->modifier_state = 0;
1385
1386         if (keyboard->focus) {
1387                 seat->saved_kbd_focus = keyboard->focus;
1388                 seat->saved_kbd_focus_listener.notify =
1389                         destroy_device_saved_kbd_focus;
1390                 wl_signal_add(&keyboard->focus->destroy_signal,
1391                               &seat->saved_kbd_focus_listener);
1392         }
1393
1394         weston_keyboard_set_focus(keyboard, NULL);
1395         weston_keyboard_cancel_grab(keyboard);
1396         if (seat->pointer)
1397                 weston_pointer_cancel_grab(seat->pointer);
1398 }
1399
1400 WL_EXPORT void
1401 weston_touch_set_focus(struct weston_seat *seat, struct weston_view *view)
1402 {
1403         struct wl_list *focus_resource_list;
1404
1405         focus_resource_list = &seat->touch->focus_resource_list;
1406
1407         if (view && seat->touch->focus &&
1408             seat->touch->focus->surface == view->surface) {
1409                 seat->touch->focus = view;
1410                 return;
1411         }
1412
1413         wl_list_remove(&seat->touch->focus_resource_listener.link);
1414         wl_list_init(&seat->touch->focus_resource_listener.link);
1415         wl_list_remove(&seat->touch->focus_view_listener.link);
1416         wl_list_init(&seat->touch->focus_view_listener.link);
1417
1418         if (!wl_list_empty(focus_resource_list)) {
1419                 move_resources(&seat->touch->resource_list,
1420                                focus_resource_list);
1421         }
1422
1423         if (view) {
1424                 struct wl_client *surface_client =
1425                         wl_resource_get_client(view->surface->resource);
1426                 move_resources_for_client(focus_resource_list,
1427                                           &seat->touch->resource_list,
1428                                           surface_client);
1429                 wl_resource_add_destroy_listener(view->surface->resource,
1430                                                  &seat->touch->focus_resource_listener);
1431                 wl_signal_add(&view->destroy_signal, &seat->touch->focus_view_listener);
1432         }
1433         seat->touch->focus = view;
1434 }
1435
1436 /**
1437  * notify_touch - emulates button touches and notifies surfaces accordingly.
1438  *
1439  * It assumes always the correct cycle sequence until it gets here: touch_down
1440  * → touch_update → ... → touch_update → touch_end. The driver is responsible
1441  * for sending along such order.
1442  *
1443  */
1444 WL_EXPORT void
1445 notify_touch(struct weston_seat *seat, uint32_t time, int touch_id,
1446              wl_fixed_t x, wl_fixed_t y, int touch_type)
1447 {
1448         struct weston_compositor *ec = seat->compositor;
1449         struct weston_touch *touch = seat->touch;
1450         struct weston_touch_grab *grab = touch->grab;
1451         struct weston_view *ev;
1452         wl_fixed_t sx, sy;
1453
1454         /* Update grab's global coordinates. */
1455         if (touch_id == touch->grab_touch_id && touch_type != WL_TOUCH_UP) {
1456                 touch->grab_x = x;
1457                 touch->grab_y = y;
1458         }
1459
1460         switch (touch_type) {
1461         case WL_TOUCH_DOWN:
1462                 weston_compositor_idle_inhibit(ec);
1463
1464                 touch->num_tp++;
1465
1466                 /* the first finger down picks the view, and all further go
1467                  * to that view for the remainder of the touch session i.e.
1468                  * until all touch points are up again. */
1469                 if (touch->num_tp == 1) {
1470                         ev = weston_compositor_pick_view(ec, x, y, &sx, &sy);
1471                         weston_touch_set_focus(seat, ev);
1472                 } else if (touch->focus) {
1473                         ev = touch->focus;
1474                         weston_view_from_global_fixed(ev, x, y, &sx, &sy);
1475                 } else {
1476                         /* Unexpected condition: We have non-initial touch but
1477                          * there is no focused surface.
1478                          */
1479                         weston_log("touch event received with %d points down"
1480                                    "but no surface focused\n", touch->num_tp);
1481                         return;
1482                 }
1483
1484                 weston_compositor_run_touch_binding(ec, seat,
1485                                                     time, touch_type);
1486
1487                 grab->interface->down(grab, time, touch_id, sx, sy);
1488                 if (touch->num_tp == 1) {
1489                         touch->grab_serial =
1490                                 wl_display_get_serial(ec->wl_display);
1491                         touch->grab_touch_id = touch_id;
1492                         touch->grab_time = time;
1493                         touch->grab_x = x;
1494                         touch->grab_y = y;
1495                 }
1496
1497                 break;
1498         case WL_TOUCH_MOTION:
1499                 ev = touch->focus;
1500                 if (!ev)
1501                         break;
1502
1503                 weston_view_from_global_fixed(ev, x, y, &sx, &sy);
1504                 grab->interface->motion(grab, time, touch_id, sx, sy);
1505                 break;
1506         case WL_TOUCH_UP:
1507                 if (touch->num_tp == 0) {
1508                         /* This can happen if we start out with one or
1509                          * more fingers on the touch screen, in which
1510                          * case we didn't get the corresponding down
1511                          * event. */
1512                         weston_log("unmatched touch up event\n");
1513                         break;
1514                 }
1515                 weston_compositor_idle_release(ec);
1516                 touch->num_tp--;
1517
1518                 grab->interface->up(grab, time, touch_id);
1519                 if (touch->num_tp == 0)
1520                         weston_touch_set_focus(seat, NULL);
1521                 break;
1522         }
1523 }
1524
1525 WL_EXPORT void
1526 notify_touch_frame(struct weston_seat *seat)
1527 {
1528         struct weston_touch *touch = seat->touch;
1529         struct weston_touch_grab *grab = touch->grab;
1530
1531         grab->interface->frame(grab);
1532 }
1533
1534 static void
1535 pointer_cursor_surface_configure(struct weston_surface *es,
1536                                  int32_t dx, int32_t dy)
1537 {
1538         struct weston_pointer *pointer = es->configure_private;
1539         int x, y;
1540
1541         if (es->width == 0)
1542                 return;
1543
1544         assert(es == pointer->sprite->surface);
1545
1546         pointer->hotspot_x -= dx;
1547         pointer->hotspot_y -= dy;
1548
1549         x = wl_fixed_to_int(pointer->x) - pointer->hotspot_x;
1550         y = wl_fixed_to_int(pointer->y) - pointer->hotspot_y;
1551
1552         weston_view_set_position(pointer->sprite, x, y);
1553
1554         empty_region(&es->pending.input);
1555         empty_region(&es->input);
1556
1557         if (!weston_surface_is_mapped(es)) {
1558                 weston_layer_entry_insert(&es->compositor->cursor_layer.view_list,
1559                                           &pointer->sprite->layer_link);
1560                 weston_view_update_transform(pointer->sprite);
1561         }
1562 }
1563
1564 static void
1565 pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
1566                    uint32_t serial, struct wl_resource *surface_resource,
1567                    int32_t x, int32_t y)
1568 {
1569         struct weston_pointer *pointer = wl_resource_get_user_data(resource);
1570         struct weston_surface *surface = NULL;
1571
1572         if (surface_resource)
1573                 surface = wl_resource_get_user_data(surface_resource);
1574
1575         if (pointer->focus == NULL)
1576                 return;
1577         /* pointer->focus->surface->resource can be NULL. Surfaces like the
1578         black_surface used in shell.c for fullscreen don't have
1579         a resource, but can still have focus */
1580         if (pointer->focus->surface->resource == NULL)
1581                 return;
1582         if (wl_resource_get_client(pointer->focus->surface->resource) != client)
1583                 return;
1584         if (pointer->focus_serial - serial > UINT32_MAX / 2)
1585                 return;
1586
1587         if (surface && pointer->sprite && surface != pointer->sprite->surface) {
1588                 if (surface->configure) {
1589                         wl_resource_post_error(surface->resource,
1590                                                WL_DISPLAY_ERROR_INVALID_OBJECT,
1591                                                "surface->configure already "
1592                                                "set");
1593                         return;
1594                 }
1595         }
1596
1597         if (pointer->sprite)
1598                 pointer_unmap_sprite(pointer);
1599
1600         if (!surface)
1601                 return;
1602
1603         wl_signal_add(&surface->destroy_signal,
1604                       &pointer->sprite_destroy_listener);
1605
1606         surface->configure = pointer_cursor_surface_configure;
1607         surface->configure_private = pointer;
1608         pointer->sprite = weston_view_create(surface);
1609         pointer->hotspot_x = x;
1610         pointer->hotspot_y = y;
1611
1612         if (surface->buffer_ref.buffer)
1613                 pointer_cursor_surface_configure(surface, 0, 0);
1614 }
1615
1616 static void
1617 pointer_release(struct wl_client *client, struct wl_resource *resource)
1618 {
1619         wl_resource_destroy(resource);
1620 }
1621
1622 static const struct wl_pointer_interface pointer_interface = {
1623         pointer_set_cursor,
1624         pointer_release
1625 };
1626
1627 static void
1628 seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
1629                  uint32_t id)
1630 {
1631         struct weston_seat *seat = wl_resource_get_user_data(resource);
1632         struct wl_resource *cr;
1633
1634         if (!seat->pointer)
1635                 return;
1636
1637         cr = wl_resource_create(client, &wl_pointer_interface,
1638                                 wl_resource_get_version(resource), id);
1639         if (cr == NULL) {
1640                 wl_client_post_no_memory(client);
1641                 return;
1642         }
1643
1644         /* May be moved to focused list later by either
1645          * weston_pointer_set_focus or directly if this client is already
1646          * focused */
1647         wl_list_insert(&seat->pointer->resource_list, wl_resource_get_link(cr));
1648         wl_resource_set_implementation(cr, &pointer_interface, seat->pointer,
1649                                        unbind_resource);
1650
1651         if (seat->pointer->focus && seat->pointer->focus->surface->resource &&
1652             wl_resource_get_client(seat->pointer->focus->surface->resource) == client) {
1653                 wl_fixed_t sx, sy;
1654
1655                 weston_view_from_global_fixed(seat->pointer->focus,
1656                                               seat->pointer->x,
1657                                               seat->pointer->y,
1658                                               &sx, &sy);
1659
1660                 wl_list_remove(wl_resource_get_link(cr));
1661                 wl_list_insert(&seat->pointer->focus_resource_list,
1662                                wl_resource_get_link(cr));
1663                 wl_pointer_send_enter(cr,
1664                                       seat->pointer->focus_serial,
1665                                       seat->pointer->focus->surface->resource,
1666                                       sx, sy);
1667         }
1668 }
1669
1670 static void
1671 keyboard_release(struct wl_client *client, struct wl_resource *resource)
1672 {
1673         wl_resource_destroy(resource);
1674 }
1675
1676 static const struct wl_keyboard_interface keyboard_interface = {
1677         keyboard_release
1678 };
1679
1680 static int
1681 should_send_modifiers_to_client(struct weston_seat *seat,
1682                                 struct wl_client *client)
1683 {
1684         if (seat->keyboard &&
1685             seat->keyboard->focus &&
1686             seat->keyboard->focus->resource &&
1687             wl_resource_get_client(seat->keyboard->focus->resource) == client)
1688                 return 1;
1689
1690         if (seat->pointer &&
1691             seat->pointer->focus &&
1692             seat->pointer->focus->surface->resource &&
1693             wl_resource_get_client(seat->pointer->focus->surface->resource) == client)
1694                 return 1;
1695
1696         return 0;
1697 }
1698
1699 static void
1700 seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
1701                   uint32_t id)
1702 {
1703         struct weston_seat *seat = wl_resource_get_user_data(resource);
1704         struct weston_keyboard *keyboard = seat->keyboard;
1705         struct wl_resource *cr;
1706
1707         if (!seat->keyboard)
1708                 return;
1709
1710         cr = wl_resource_create(client, &wl_keyboard_interface,
1711                                 wl_resource_get_version(resource), id);
1712         if (cr == NULL) {
1713                 wl_client_post_no_memory(client);
1714                 return;
1715         }
1716
1717         /* May be moved to focused list later by either
1718          * weston_keyboard_set_focus or directly if this client is already
1719          * focused */
1720         wl_list_insert(&seat->keyboard->resource_list, wl_resource_get_link(cr));
1721         wl_resource_set_implementation(cr, &keyboard_interface,
1722                                        seat, unbind_resource);
1723
1724         if (wl_resource_get_version(cr) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
1725                 wl_keyboard_send_repeat_info(cr,
1726                                              seat->compositor->kb_repeat_rate,
1727                                              seat->compositor->kb_repeat_delay);
1728         }
1729
1730         if (seat->compositor->use_xkbcommon) {
1731                 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
1732                                         keyboard->xkb_info->keymap_fd,
1733                                         keyboard->xkb_info->keymap_size);
1734         } else {
1735                 int null_fd = open("/dev/null", O_RDONLY);
1736                 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP,
1737                                         null_fd,
1738                                         0);
1739                 close(null_fd);
1740         }
1741
1742         if (should_send_modifiers_to_client(seat, client)) {
1743                 send_modifiers_to_resource(seat->keyboard,
1744                                            cr,
1745                                            seat->keyboard->focus_serial);
1746         }
1747
1748         if (seat->keyboard->focus &&
1749             wl_resource_get_client(seat->keyboard->focus->resource) == client) {
1750                 struct weston_surface *surface =
1751                         (struct weston_surface *) seat->keyboard->focus;
1752
1753                 wl_list_remove(wl_resource_get_link(cr));
1754                 wl_list_insert(&seat->keyboard->focus_resource_list,
1755                                wl_resource_get_link(cr));
1756                 wl_keyboard_send_enter(cr,
1757                                        seat->keyboard->focus_serial,
1758                                        surface->resource,
1759                                        &seat->keyboard->keys);
1760
1761                 /* If this is the first keyboard resource for this
1762                  * client... */
1763                 if (seat->keyboard->focus_resource_list.prev ==
1764                     wl_resource_get_link(cr))
1765                         wl_data_device_set_keyboard_focus(seat);
1766         }
1767 }
1768
1769 static void
1770 touch_release(struct wl_client *client, struct wl_resource *resource)
1771 {
1772         wl_resource_destroy(resource);
1773 }
1774
1775 static const struct wl_touch_interface touch_interface = {
1776         touch_release
1777 };
1778
1779 static void
1780 seat_get_touch(struct wl_client *client, struct wl_resource *resource,
1781                uint32_t id)
1782 {
1783         struct weston_seat *seat = wl_resource_get_user_data(resource);
1784         struct wl_resource *cr;
1785
1786         if (!seat->touch)
1787                 return;
1788
1789         cr = wl_resource_create(client, &wl_touch_interface,
1790                                 wl_resource_get_version(resource), id);
1791         if (cr == NULL) {
1792                 wl_client_post_no_memory(client);
1793                 return;
1794         }
1795
1796         if (seat->touch->focus &&
1797             wl_resource_get_client(seat->touch->focus->surface->resource) == client) {
1798                 wl_list_insert(&seat->touch->resource_list,
1799                                wl_resource_get_link(cr));
1800         } else {
1801                 wl_list_insert(&seat->touch->focus_resource_list,
1802                                wl_resource_get_link(cr));
1803         }
1804         wl_resource_set_implementation(cr, &touch_interface,
1805                                        seat, unbind_resource);
1806 }
1807
1808 static const struct wl_seat_interface seat_interface = {
1809         seat_get_pointer,
1810         seat_get_keyboard,
1811         seat_get_touch,
1812 };
1813
1814 static void
1815 bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
1816 {
1817         struct weston_seat *seat = data;
1818         struct wl_resource *resource;
1819         enum wl_seat_capability caps = 0;
1820
1821         resource = wl_resource_create(client,
1822                                       &wl_seat_interface, MIN(version, 4), id);
1823         wl_list_insert(&seat->base_resource_list, wl_resource_get_link(resource));
1824         wl_resource_set_implementation(resource, &seat_interface, data,
1825                                        unbind_resource);
1826
1827         if (seat->pointer)
1828                 caps |= WL_SEAT_CAPABILITY_POINTER;
1829         if (seat->keyboard)
1830                 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
1831         if (seat->touch)
1832                 caps |= WL_SEAT_CAPABILITY_TOUCH;
1833
1834         wl_seat_send_capabilities(resource, caps);
1835         if (version >= WL_SEAT_NAME_SINCE_VERSION)
1836                 wl_seat_send_name(resource, seat->seat_name);
1837 }
1838
1839 #ifdef ENABLE_XKBCOMMON
1840 int
1841 weston_compositor_xkb_init(struct weston_compositor *ec,
1842                            struct xkb_rule_names *names)
1843 {
1844         ec->use_xkbcommon = 1;
1845
1846         if (ec->xkb_context == NULL) {
1847                 ec->xkb_context = xkb_context_new(0);
1848                 if (ec->xkb_context == NULL) {
1849                         weston_log("failed to create XKB context\n");
1850                         return -1;
1851                 }
1852         }
1853
1854         if (names)
1855                 ec->xkb_names = *names;
1856         if (!ec->xkb_names.rules)
1857                 ec->xkb_names.rules = strdup("evdev");
1858         if (!ec->xkb_names.model)
1859                 ec->xkb_names.model = strdup("pc105");
1860         if (!ec->xkb_names.layout)
1861                 ec->xkb_names.layout = strdup("us");
1862
1863         return 0;
1864 }
1865
1866 static void
1867 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info)
1868 {
1869         if (--xkb_info->ref_count > 0)
1870                 return;
1871
1872         if (xkb_info->keymap)
1873                 xkb_keymap_unref(xkb_info->keymap);
1874
1875         if (xkb_info->keymap_area)
1876                 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
1877         if (xkb_info->keymap_fd >= 0)
1878                 close(xkb_info->keymap_fd);
1879         free(xkb_info);
1880 }
1881
1882 void
1883 weston_compositor_xkb_destroy(struct weston_compositor *ec)
1884 {
1885         /*
1886          * If we're operating in raw keyboard mode, we never initialized
1887          * libxkbcommon so there's no cleanup to do either.
1888          */
1889         if (!ec->use_xkbcommon)
1890                 return;
1891
1892         free((char *) ec->xkb_names.rules);
1893         free((char *) ec->xkb_names.model);
1894         free((char *) ec->xkb_names.layout);
1895         free((char *) ec->xkb_names.variant);
1896         free((char *) ec->xkb_names.options);
1897
1898         if (ec->xkb_info)
1899                 weston_xkb_info_destroy(ec->xkb_info);
1900         xkb_context_unref(ec->xkb_context);
1901 }
1902
1903 static struct weston_xkb_info *
1904 weston_xkb_info_create(struct xkb_keymap *keymap)
1905 {
1906         struct weston_xkb_info *xkb_info = zalloc(sizeof *xkb_info);
1907         if (xkb_info == NULL)
1908                 return NULL;
1909
1910         xkb_info->keymap = xkb_keymap_ref(keymap);
1911         xkb_info->ref_count = 1;
1912
1913         char *keymap_str;
1914
1915         xkb_info->shift_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1916                                                        XKB_MOD_NAME_SHIFT);
1917         xkb_info->caps_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1918                                                       XKB_MOD_NAME_CAPS);
1919         xkb_info->ctrl_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1920                                                       XKB_MOD_NAME_CTRL);
1921         xkb_info->alt_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1922                                                      XKB_MOD_NAME_ALT);
1923         xkb_info->mod2_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1924                                                       "Mod2");
1925         xkb_info->mod3_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1926                                                       "Mod3");
1927         xkb_info->super_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1928                                                        XKB_MOD_NAME_LOGO);
1929         xkb_info->mod5_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1930                                                       "Mod5");
1931
1932         xkb_info->num_led = xkb_keymap_led_get_index(xkb_info->keymap,
1933                                                      XKB_LED_NAME_NUM);
1934         xkb_info->caps_led = xkb_keymap_led_get_index(xkb_info->keymap,
1935                                                       XKB_LED_NAME_CAPS);
1936         xkb_info->scroll_led = xkb_keymap_led_get_index(xkb_info->keymap,
1937                                                         XKB_LED_NAME_SCROLL);
1938
1939         keymap_str = xkb_keymap_get_as_string(xkb_info->keymap,
1940                                               XKB_KEYMAP_FORMAT_TEXT_V1);
1941         if (keymap_str == NULL) {
1942                 weston_log("failed to get string version of keymap\n");
1943                 goto err_keymap;
1944         }
1945         xkb_info->keymap_size = strlen(keymap_str) + 1;
1946
1947         xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
1948         if (xkb_info->keymap_fd < 0) {
1949                 weston_log("creating a keymap file for %lu bytes failed: %m\n",
1950                         (unsigned long) xkb_info->keymap_size);
1951                 goto err_keymap_str;
1952         }
1953
1954         xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
1955                                      PROT_READ | PROT_WRITE,
1956                                      MAP_SHARED, xkb_info->keymap_fd, 0);
1957         if (xkb_info->keymap_area == MAP_FAILED) {
1958                 weston_log("failed to mmap() %lu bytes\n",
1959                         (unsigned long) xkb_info->keymap_size);
1960                 goto err_dev_zero;
1961         }
1962         strcpy(xkb_info->keymap_area, keymap_str);
1963         free(keymap_str);
1964
1965         return xkb_info;
1966
1967 err_dev_zero:
1968         close(xkb_info->keymap_fd);
1969 err_keymap_str:
1970         free(keymap_str);
1971 err_keymap:
1972         xkb_keymap_unref(xkb_info->keymap);
1973         free(xkb_info);
1974         return NULL;
1975 }
1976
1977 static int
1978 weston_compositor_build_global_keymap(struct weston_compositor *ec)
1979 {
1980         struct xkb_keymap *keymap;
1981
1982         if (ec->xkb_info != NULL)
1983                 return 0;
1984
1985         keymap = xkb_keymap_new_from_names(ec->xkb_context,
1986                                            &ec->xkb_names,
1987                                            0);
1988         if (keymap == NULL) {
1989                 weston_log("failed to compile global XKB keymap\n");
1990                 weston_log("  tried rules %s, model %s, layout %s, variant %s, "
1991                         "options %s\n",
1992                         ec->xkb_names.rules, ec->xkb_names.model,
1993                         ec->xkb_names.layout, ec->xkb_names.variant,
1994                         ec->xkb_names.options);
1995                 return -1;
1996         }
1997
1998         ec->xkb_info = weston_xkb_info_create(keymap);
1999         xkb_keymap_unref(keymap);
2000         if (ec->xkb_info == NULL)
2001                 return -1;
2002
2003         return 0;
2004 }
2005 #else
2006 int
2007 weston_compositor_xkb_init(struct weston_compositor *ec,
2008                            struct xkb_rule_names *names)
2009 {
2010         return 0;
2011 }
2012
2013 void
2014 weston_compositor_xkb_destroy(struct weston_compositor *ec)
2015 {
2016 }
2017 #endif
2018
2019 WL_EXPORT void
2020 weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap)
2021 {
2022         if (!seat->keyboard || !keymap)
2023                 return;
2024
2025 #ifdef ENABLE_XKBCOMMON
2026         if (!seat->compositor->use_xkbcommon)
2027                 return;
2028
2029         xkb_keymap_unref(seat->keyboard->pending_keymap);
2030         seat->keyboard->pending_keymap = xkb_keymap_ref(keymap);
2031
2032         if (seat->keyboard->keys.size == 0)
2033                 update_keymap(seat);
2034 #endif
2035 }
2036
2037 WL_EXPORT int
2038 weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
2039 {
2040         struct weston_keyboard *keyboard;
2041
2042         if (seat->keyboard) {
2043                 seat->keyboard_device_count += 1;
2044                 if (seat->keyboard_device_count == 1)
2045                         seat_send_updated_caps(seat);
2046                 return 0;
2047         }
2048
2049         keyboard = weston_keyboard_create();
2050         if (keyboard == NULL) {
2051                 weston_log("failed to allocate weston keyboard struct\n");
2052                 return -1;
2053         }
2054
2055 #ifdef ENABLE_XKBCOMMON
2056         if (seat->compositor->use_xkbcommon) {
2057                 if (keymap != NULL) {
2058                         keyboard->xkb_info = weston_xkb_info_create(keymap);
2059                         if (keyboard->xkb_info == NULL)
2060                                 goto err;
2061                 } else {
2062                         if (weston_compositor_build_global_keymap(seat->compositor) < 0)
2063                                 goto err;
2064                         keyboard->xkb_info = seat->compositor->xkb_info;
2065                         keyboard->xkb_info->ref_count++;
2066                 }
2067
2068                 keyboard->xkb_state.state = xkb_state_new(keyboard->xkb_info->keymap);
2069                 if (keyboard->xkb_state.state == NULL) {
2070                         weston_log("failed to initialise XKB state\n");
2071                         goto err;
2072                 }
2073
2074                 keyboard->xkb_state.leds = 0;
2075         }
2076 #endif
2077
2078         seat->keyboard = keyboard;
2079         seat->keyboard_device_count = 1;
2080         keyboard->seat = seat;
2081
2082         seat_send_updated_caps(seat);
2083
2084         return 0;
2085
2086 err:
2087         if (keyboard->xkb_info)
2088                 weston_xkb_info_destroy(keyboard->xkb_info);
2089         free(keyboard);
2090
2091         return -1;
2092 }
2093
2094 static void
2095 weston_keyboard_reset_state(struct weston_keyboard *keyboard)
2096 {
2097         struct weston_seat *seat = keyboard->seat;
2098         struct xkb_state *state;
2099
2100 #ifdef ENABLE_XKBCOMMON
2101         if (seat->compositor->use_xkbcommon) {
2102                 state = xkb_state_new(keyboard->xkb_info->keymap);
2103                 if (!state) {
2104                         weston_log("failed to reset XKB state\n");
2105                         return;
2106                 }
2107                 xkb_state_unref(keyboard->xkb_state.state);
2108                 keyboard->xkb_state.state = state;
2109
2110                 keyboard->xkb_state.leds = 0;
2111         }
2112 #endif
2113
2114         seat->modifier_state = 0;
2115 }
2116
2117 WL_EXPORT void
2118 weston_seat_release_keyboard(struct weston_seat *seat)
2119 {
2120         seat->keyboard_device_count--;
2121         if (seat->keyboard_device_count == 0) {
2122                 weston_keyboard_set_focus(seat->keyboard, NULL);
2123                 weston_keyboard_cancel_grab(seat->keyboard);
2124                 weston_keyboard_reset_state(seat->keyboard);
2125                 seat_send_updated_caps(seat);
2126         }
2127 }
2128
2129 WL_EXPORT void
2130 weston_seat_init_pointer(struct weston_seat *seat)
2131 {
2132         struct weston_pointer *pointer;
2133
2134         if (seat->pointer) {
2135                 seat->pointer_device_count += 1;
2136                 if (seat->pointer_device_count == 1)
2137                         seat_send_updated_caps(seat);
2138                 return;
2139         }
2140
2141         pointer = weston_pointer_create(seat);
2142         if (pointer == NULL)
2143                 return;
2144
2145         seat->pointer = pointer;
2146         seat->pointer_device_count = 1;
2147         pointer->seat = seat;
2148
2149         seat_send_updated_caps(seat);
2150 }
2151
2152 WL_EXPORT void
2153 weston_seat_release_pointer(struct weston_seat *seat)
2154 {
2155         struct weston_pointer *pointer = seat->pointer;
2156
2157         seat->pointer_device_count--;
2158         if (seat->pointer_device_count == 0) {
2159                 weston_pointer_set_focus(pointer, NULL,
2160                                          wl_fixed_from_int(0),
2161                                          wl_fixed_from_int(0));
2162                 weston_pointer_cancel_grab(pointer);
2163
2164                 if (pointer->sprite)
2165                         pointer_unmap_sprite(pointer);
2166
2167                 weston_pointer_reset_state(pointer);
2168                 seat_send_updated_caps(seat);
2169         }
2170 }
2171
2172 WL_EXPORT void
2173 weston_seat_init_touch(struct weston_seat *seat)
2174 {
2175         struct weston_touch *touch;
2176
2177         if (seat->touch) {
2178                 seat->touch_device_count += 1;
2179                 if (seat->touch_device_count == 1)
2180                         seat_send_updated_caps(seat);
2181                 return;
2182         }
2183
2184         touch = weston_touch_create();
2185         if (touch == NULL)
2186                 return;
2187
2188         seat->touch = touch;
2189         seat->touch_device_count = 1;
2190         touch->seat = seat;
2191
2192         seat_send_updated_caps(seat);
2193 }
2194
2195 WL_EXPORT void
2196 weston_seat_release_touch(struct weston_seat *seat)
2197 {
2198         seat->touch_device_count--;
2199         if (seat->touch_device_count == 0) {
2200                 weston_touch_set_focus(seat, NULL);
2201                 weston_touch_cancel_grab(seat->touch);
2202                 weston_touch_reset_state(seat->touch);
2203                 seat_send_updated_caps(seat);
2204         }
2205 }
2206
2207 WL_EXPORT void
2208 weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec,
2209                  const char *seat_name)
2210 {
2211         memset(seat, 0, sizeof *seat);
2212
2213         seat->selection_data_source = NULL;
2214         wl_list_init(&seat->base_resource_list);
2215         wl_signal_init(&seat->selection_signal);
2216         wl_list_init(&seat->drag_resource_list);
2217         wl_signal_init(&seat->destroy_signal);
2218         wl_signal_init(&seat->updated_caps_signal);
2219
2220         seat->global = wl_global_create(ec->wl_display, &wl_seat_interface, 4,
2221                                         seat, bind_seat);
2222
2223         seat->compositor = ec;
2224         seat->modifier_state = 0;
2225         seat->seat_name = strdup(seat_name);
2226
2227         wl_list_insert(ec->seat_list.prev, &seat->link);
2228
2229         clipboard_create(seat);
2230
2231         wl_signal_emit(&ec->seat_created_signal, seat);
2232 }
2233
2234 WL_EXPORT void
2235 weston_seat_release(struct weston_seat *seat)
2236 {
2237         wl_list_remove(&seat->link);
2238
2239         if (seat->saved_kbd_focus)
2240                 wl_list_remove(&seat->saved_kbd_focus_listener.link);
2241
2242         if (seat->pointer)
2243                 weston_pointer_destroy(seat->pointer);
2244         if (seat->keyboard)
2245                 weston_keyboard_destroy(seat->keyboard);
2246         if (seat->touch)
2247                 weston_touch_destroy(seat->touch);
2248
2249         free (seat->seat_name);
2250
2251         wl_global_destroy(seat->global);
2252
2253         wl_signal_emit(&seat->destroy_signal, seat);
2254 }