src/libinput.c

   1 /*
   2  * Copyright © 2013 Jonas Ådahl
   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 <errno.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/epoll.h>
  30 #include <unistd.h>
  31 #include <assert.h>
  32
  33 #include "libinput.h"
  34 #include "libinput-private.h"
  35 #include "evdev.h"
  36
  37 enum libinput_event_class {
  38         LIBINPUT_EVENT_CLASS_BASE,
  39         LIBINPUT_EVENT_CLASS_SEAT,
  40         LIBINPUT_EVENT_CLASS_DEVICE,
  41 };
  42
  43 struct libinput_source {
  44         libinput_source_dispatch_t dispatch;
  45         void *user_data;
  46         int fd;
  47         struct list link;
  48 };
  49
  50 struct libinput_event {
  51         enum libinput_event_type type;
  52         union libinput_event_target target;
  53 };
  54
  55 struct libinput_event_added_seat {
  56         struct libinput_event base;
  57         struct libinput_seat *seat;
  58 };
  59
  60 struct libinput_event_removed_seat {
  61         struct libinput_event base;
  62         struct libinput_seat *seat;
  63 };
  64
  65 struct libinput_event_added_device {
  66         struct libinput_event base;
  67         struct libinput_device *device;
  68 };
  69
  70 struct libinput_event_removed_device {
  71         struct libinput_event base;
  72         struct libinput_device *device;
  73 };
  74
  75 struct libinput_event_device_register_capability {
  76         struct libinput_event base;
  77         enum libinput_device_capability capability;
  78 };
  79
  80 struct libinput_event_device_unregister_capability {
  81         struct libinput_event base;
  82         enum libinput_device_capability capability;
  83 };
  84
  85 struct libinput_event_keyboard_key {
  86         struct libinput_event base;
  87         uint32_t time;
  88         uint32_t key;
  89         enum libinput_keyboard_key_state state;
  90 };
  91
  92 struct libinput_event_pointer_motion {
  93         struct libinput_event base;
  94         uint32_t time;
  95         li_fixed_t dx;
  96         li_fixed_t dy;
  97 };
  98
  99 struct libinput_event_pointer_motion_absolute {
 100         struct libinput_event base;
 101         uint32_t time;
 102         li_fixed_t x;
 103         li_fixed_t y;
 104 };
 105
 106 struct libinput_event_pointer_button {
 107         struct libinput_event base;
 108         uint32_t time;
 109         uint32_t button;
 110         enum libinput_pointer_button_state state;
 111 };
 112
 113 struct libinput_event_pointer_axis {
 114         struct libinput_event base;
 115         uint32_t time;
 116         enum libinput_pointer_axis axis;
 117         li_fixed_t value;
 118 };
 119
 120 struct libinput_event_touch_touch {
 121         struct libinput_event base;
 122         uint32_t time;
 123         uint32_t slot;
 124         li_fixed_t x;
 125         li_fixed_t y;
 126         enum libinput_touch_type touch_type;
 127 };
 128
 129 static void
 130 libinput_post_event(struct libinput *libinput,
 131                     struct libinput_event *event);
 132
 133 LIBINPUT_EXPORT enum libinput_event_type
 134 libinput_event_get_type(struct libinput_event *event)
 135 {
 136         return event->type;
 137 }
 138
 139 LIBINPUT_EXPORT union libinput_event_target
 140 libinput_event_get_target(struct libinput_event *event)
 141 {
 142         return event->target;
 143 }
 144
 145 LIBINPUT_EXPORT struct libinput_seat *
 146 libinput_event_added_seat_get_seat(struct libinput_event_added_seat *event)
 147 {
 148         return event->seat;
 149 }
 150
 151 LIBINPUT_EXPORT struct libinput_seat *
 152 libinput_event_removed_seat_get_seat(struct libinput_event_removed_seat *event)
 153 {
 154         return event->seat;
 155 }
 156
 157 LIBINPUT_EXPORT struct libinput_device *
 158 libinput_event_added_device_get_device(
 159         struct libinput_event_added_device *event)
 160 {
 161         return event->device;
 162 }
 163
 164 LIBINPUT_EXPORT struct libinput_device *
 165 libinput_event_removed_device_get_device(
 166         struct libinput_event_removed_device *event)
 167 {
 168         return event->device;
 169 }
 170
 171 LIBINPUT_EXPORT enum libinput_device_capability
 172 libinput_event_device_register_capability_get_capability(
 173         struct libinput_event_device_register_capability *event)
 174 {
 175         return event->capability;
 176 }
 177
 178 LIBINPUT_EXPORT enum libinput_device_capability
 179 libinput_event_device_unregister_capability_get_capability(
 180         struct libinput_event_device_unregister_capability *event)
 181 {
 182         return event->capability;
 183 }
 184
 185 LIBINPUT_EXPORT uint32_t
 186 libinput_event_keyboard_key_get_time(
 187         struct libinput_event_keyboard_key *event)
 188 {
 189         return event->time;
 190 }
 191
 192 LIBINPUT_EXPORT uint32_t
 193 libinput_event_keyboard_key_get_key(
 194         struct libinput_event_keyboard_key *event)
 195 {
 196         return event->key;
 197 }
 198
 199 LIBINPUT_EXPORT enum libinput_keyboard_key_state
 200 libinput_event_keyboard_key_get_state(
 201         struct libinput_event_keyboard_key *event)
 202 {
 203         return event->state;
 204 }
 205
 206 LIBINPUT_EXPORT uint32_t
 207 libinput_event_pointer_motion_get_time(
 208         struct libinput_event_pointer_motion *event)
 209 {
 210         return event->time;
 211 }
 212
 213 LIBINPUT_EXPORT li_fixed_t
 214 libinput_event_pointer_motion_get_dx(
 215         struct libinput_event_pointer_motion *event)
 216 {
 217         return event->dx;
 218 }
 219
 220 LIBINPUT_EXPORT li_fixed_t
 221 libinput_event_pointer_motion_get_dy(
 222         struct libinput_event_pointer_motion *event)
 223 {
 224         return event->dy;
 225 }
 226
 227 LIBINPUT_EXPORT uint32_t
 228 libinput_event_pointer_motion_absolute_get_time(
 229         struct libinput_event_pointer_motion_absolute *event)
 230 {
 231         return event->time;
 232 }
 233
 234 LIBINPUT_EXPORT li_fixed_t
 235 libinput_event_pointer_motion_absolute_get_x(
 236         struct libinput_event_pointer_motion_absolute *event)
 237 {
 238         return event->x;
 239 }
 240
 241 LIBINPUT_EXPORT li_fixed_t
 242 libinput_event_pointer_motion_absolute_get_y(
 243         struct libinput_event_pointer_motion_absolute *event)
 244 {
 245         return event->y;
 246 }
 247
 248 LIBINPUT_EXPORT uint32_t
 249 libinput_event_pointer_button_get_time(
 250         struct libinput_event_pointer_button *event)
 251 {
 252         return event->time;
 253 }
 254
 255 LIBINPUT_EXPORT uint32_t
 256 libinput_event_pointer_button_get_button(
 257         struct libinput_event_pointer_button *event)
 258 {
 259         return event->button;
 260 }
 261
 262 LIBINPUT_EXPORT enum libinput_pointer_button_state
 263 libinput_event_pointer_button_get_state(
 264         struct libinput_event_pointer_button *event)
 265 {
 266         return event->state;
 267 }
 268
 269 LIBINPUT_EXPORT uint32_t
 270 libinput_event_pointer_axis_get_time(
 271         struct libinput_event_pointer_axis *event)
 272 {
 273         return event->time;
 274 }
 275
 276 LIBINPUT_EXPORT enum libinput_pointer_axis
 277 libinput_event_pointer_axis_get_axis(
 278         struct libinput_event_pointer_axis *event)
 279 {
 280         return event->axis;
 281 }
 282
 283 LIBINPUT_EXPORT li_fixed_t
 284 libinput_event_pointer_axis_get_value(
 285         struct libinput_event_pointer_axis *event)
 286 {
 287         return event->value;
 288 }
 289
 290 LIBINPUT_EXPORT uint32_t
 291 libinput_event_touch_touch_get_time(
 292         struct libinput_event_touch_touch *event)
 293 {
 294         return event->time;
 295 }
 296
 297 LIBINPUT_EXPORT uint32_t
 298 libinput_event_touch_touch_get_slot(
 299         struct libinput_event_touch_touch *event)
 300 {
 301         return event->slot;
 302 }
 303
 304 LIBINPUT_EXPORT li_fixed_t
 305 libinput_event_touch_touch_get_x(
 306         struct libinput_event_touch_touch *event)
 307 {
 308         return event->x;
 309 }
 310
 311 LIBINPUT_EXPORT li_fixed_t
 312 libinput_event_touch_touch_get_y(
 313         struct libinput_event_touch_touch *event)
 314 {
 315         return event->y;
 316 }
 317
 318 LIBINPUT_EXPORT enum libinput_touch_type
 319 libinput_event_touch_touch_get_touch_type(
 320         struct libinput_event_touch_touch *event)
 321 {
 322         return event->touch_type;
 323 }
 324
 325 struct libinput_source *
 326 libinput_add_fd(struct libinput *libinput,
 327                 int fd,
 328                 libinput_source_dispatch_t dispatch,
 329                 void *user_data)
 330 {
 331         struct libinput_source *source;
 332         struct epoll_event ep;
 333
 334         source = malloc(sizeof *source);
 335         if (!source)
 336                 return NULL;
 337
 338         source->dispatch = dispatch;
 339         source->user_data = user_data;
 340         source->fd = fd;
 341
 342         memset(&ep, 0, sizeof ep);
 343         ep.events = EPOLLIN;
 344         ep.data.ptr = source;
 345
 346         if (epoll_ctl(libinput->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) {
 347                 close(source->fd);
 348                 free(source);
 349                 return NULL;
 350         }
 351
 352         return source;
 353 }
 354
 355 void
 356 libinput_remove_source(struct libinput *libinput,
 357                        struct libinput_source *source)
 358 {
 359         epoll_ctl(libinput->epoll_fd, EPOLL_CTL_DEL, source->fd, NULL);
 360         close(source->fd);
 361         source->fd = -1;
 362         list_insert(&libinput->source_destroy_list, &source->link);
 363 }
 364
 365 int
 366 libinput_init(struct libinput *libinput,
 367               const struct libinput_interface *interface,
 368               const struct libinput_interface_backend *interface_backend,
 369               void *user_data)
 370 {
 371         libinput->epoll_fd = epoll_create1(EPOLL_CLOEXEC);;
 372         if (libinput->epoll_fd < 0)
 373                 return -1;
 374
 375         libinput->events_len = 4;
 376         libinput->events = zalloc(libinput->events_len * sizeof(*libinput->events));
 377         if (!libinput->events) {
 378                 close(libinput->epoll_fd);
 379                 return -1;
 380         }
 381
 382         libinput->interface = interface;
 383         libinput->interface_backend = interface_backend;
 384         libinput->user_data = user_data;
 385         list_init(&libinput->source_destroy_list);
 386         list_init(&libinput->seat_list);
 387
 388         return 0;
 389 }
 390
 391 static void
 392 libinput_device_destroy(struct libinput_device *device);
 393
 394 static void
 395 libinput_seat_destroy(struct libinput_seat *seat);
 396
 397 static void
 398 libinput_drop_destroyed_sources(struct libinput *libinput)
 399 {
 400         struct libinput_source *source, *next;
 401
 402         list_for_each_safe(source, next, &libinput->source_destroy_list, link)
 403                 free(source);
 404         list_init(&libinput->source_destroy_list);
 405 }
 406
 407 LIBINPUT_EXPORT void
 408 libinput_destroy(struct libinput *libinput)
 409 {
 410         struct libinput_event *event;
 411         struct libinput_device *device, *next_device;
 412         struct libinput_seat *seat, *next_seat;
 413
 414         if (libinput == NULL)
 415                 return;
 416
 417         libinput->interface_backend->destroy(libinput);
 418
 419         while ((event = libinput_get_event(libinput)))
 420                libinput_event_destroy(event);
 421
 422         libinput_drop_destroyed_sources(libinput);
 423
 424         free(libinput->events);
 425
 426         list_for_each_safe(seat, next_seat, &libinput->seat_list, link) {
 427                 list_for_each_safe(device, next_device,
 428                                    &seat->devices_list,
 429                                    link)
 430                         libinput_device_destroy(device);
 431
 432                 libinput_seat_destroy(seat);
 433         }
 434
 435         close(libinput->epoll_fd);
 436         free(libinput);
 437 }
 438
 439 static enum libinput_event_class
 440 libinput_event_get_class(struct libinput_event *event)
 441 {
 442         switch (event->type) {
 443         case LIBINPUT_EVENT_ADDED_SEAT:
 444         case LIBINPUT_EVENT_REMOVED_SEAT:
 445         case LIBINPUT_EVENT_ADDED_DEVICE:
 446         case LIBINPUT_EVENT_REMOVED_DEVICE:
 447                 return LIBINPUT_EVENT_CLASS_BASE;
 448
 449         case LIBINPUT_EVENT_DEVICE_REGISTER_CAPABILITY:
 450         case LIBINPUT_EVENT_DEVICE_UNREGISTER_CAPABILITY:
 451         case LIBINPUT_EVENT_KEYBOARD_KEY:
 452         case LIBINPUT_EVENT_POINTER_MOTION:
 453         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
 454         case LIBINPUT_EVENT_POINTER_BUTTON:
 455         case LIBINPUT_EVENT_POINTER_AXIS:
 456         case LIBINPUT_EVENT_TOUCH_TOUCH:
 457                 return LIBINPUT_EVENT_CLASS_DEVICE;
 458         }
 459
 460         /* We should never end up here. */
 461         abort();
 462 }
 463
 464 LIBINPUT_EXPORT void
 465 libinput_event_destroy(struct libinput_event *event)
 466 {
 467         if (event == NULL)
 468                 return;
 469
 470         switch (libinput_event_get_class(event)) {
 471         case LIBINPUT_EVENT_CLASS_BASE:
 472                 break;
 473         case LIBINPUT_EVENT_CLASS_SEAT:
 474                 libinput_seat_unref(event->target.seat);
 475                 break;
 476         case LIBINPUT_EVENT_CLASS_DEVICE:
 477                 libinput_device_unref(event->target.device);
 478                 break;
 479         }
 480
 481         free(event);
 482 }
 483
 484 int
 485 open_restricted(struct libinput *libinput,
 486                 const char *path, int flags)
 487 {
 488         return libinput->interface->open_restricted(path,
 489                                                     flags,
 490                                                     libinput->user_data);
 491 }
 492
 493 void
 494 close_restricted(struct libinput *libinput, int fd)
 495 {
 496         return libinput->interface->close_restricted(fd, libinput->user_data);
 497 }
 498
 499 void
 500 libinput_seat_init(struct libinput_seat *seat,
 501                    struct libinput *libinput,
 502                    const char *name,
 503                    libinput_seat_destroy_func destroy)
 504 {
 505         seat->refcount = 1;
 506         seat->libinput = libinput;
 507         seat->name = strdup(name);
 508         seat->destroy = destroy;
 509         list_init(&seat->devices_list);
 510 }
 511
 512 LIBINPUT_EXPORT void
 513 libinput_seat_ref(struct libinput_seat *seat)
 514 {
 515         seat->refcount++;
 516 }
 517
 518 static void
 519 libinput_seat_destroy(struct libinput_seat *seat)
 520 {
 521         list_remove(&seat->link);
 522         free(seat->name);
 523         seat->destroy(seat);
 524 }
 525
 526 LIBINPUT_EXPORT void
 527 libinput_seat_unref(struct libinput_seat *seat)
 528 {
 529         assert(seat->refcount > 0);
 530         seat->refcount--;
 531         if (seat->refcount == 0)
 532                 libinput_seat_destroy(seat);
 533 }
 534
 535 LIBINPUT_EXPORT void
 536 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
 537 {
 538         seat->user_data = user_data;
 539 }
 540
 541 LIBINPUT_EXPORT void *
 542 libinput_seat_get_user_data(struct libinput_seat *seat)
 543 {
 544         return seat->user_data;
 545 }
 546
 547 LIBINPUT_EXPORT const char *
 548 libinput_seat_get_name(struct libinput_seat *seat)
 549 {
 550         return seat->name;
 551 }
 552
 553 void
 554 libinput_device_init(struct libinput_device *device,
 555                      struct libinput_seat *seat)
 556 {
 557         device->seat = seat;
 558         device->refcount = 1;
 559 }
 560
 561 LIBINPUT_EXPORT void
 562 libinput_device_ref(struct libinput_device *device)
 563 {
 564         device->refcount++;
 565 }
 566
 567 static void
 568 libinput_device_destroy(struct libinput_device *device)
 569 {
 570         evdev_device_destroy((struct evdev_device *) device);
 571 }
 572
 573 LIBINPUT_EXPORT void
 574 libinput_device_unref(struct libinput_device *device)
 575 {
 576         assert(device->refcount > 0);
 577         device->refcount--;
 578         if (device->refcount == 0)
 579                 libinput_device_destroy(device);
 580 }
 581
 582 LIBINPUT_EXPORT int
 583 libinput_get_fd(struct libinput *libinput)
 584 {
 585         return libinput->epoll_fd;
 586 }
 587
 588 LIBINPUT_EXPORT int
 589 libinput_dispatch(struct libinput *libinput)
 590 {
 591         struct libinput_source *source;
 592         struct epoll_event ep[32];
 593         int i, count;
 594
 595         count = epoll_wait(libinput->epoll_fd, ep, ARRAY_LENGTH(ep), 0);
 596         if (count < 0)
 597                 return -errno;
 598
 599         for (i = 0; i < count; ++i) {
 600                 source = ep[i].data.ptr;
 601                 if (source->fd == -1)
 602                         continue;
 603
 604                 source->dispatch(source->user_data);
 605         }
 606
 607         libinput_drop_destroyed_sources(libinput);
 608
 609         return 0;
 610 }
 611
 612 static void
 613 init_event_base(struct libinput_event *event,
 614                 enum libinput_event_type type,
 615                 union libinput_event_target target)
 616 {
 617         event->type = type;
 618         event->target = target;
 619 }
 620
 621 static void
 622 post_base_event(struct libinput *libinput,
 623                 enum libinput_event_type type,
 624                 struct libinput_event *event)
 625 {
 626         init_event_base(event, type,
 627                         (union libinput_event_target) { .libinput = libinput });
 628         libinput_post_event(libinput, event);
 629 }
 630
 631 static void
 632 post_device_event(struct libinput_device *device,
 633                   enum libinput_event_type type,
 634                   struct libinput_event *event)
 635 {
 636         init_event_base(event, type,
 637                         (union libinput_event_target) { .device = device });
 638         libinput_post_event(device->seat->libinput, event);
 639 }
 640
 641 void
 642 notify_added_seat(struct libinput_seat *seat)
 643 {
 644         struct libinput_event_added_seat *added_seat_event;
 645
 646         added_seat_event = malloc(sizeof *added_seat_event);
 647         if (!added_seat_event)
 648                 return;
 649
 650         *added_seat_event = (struct libinput_event_added_seat) {
 651                 .seat = seat,
 652         };
 653
 654         post_base_event(seat->libinput,
 655                         LIBINPUT_EVENT_ADDED_SEAT,
 656                         &added_seat_event->base);
 657 }
 658
 659 void
 660 notify_removed_seat(struct libinput_seat *seat)
 661 {
 662         struct libinput_event_removed_seat *removed_seat_event;
 663
 664         removed_seat_event = malloc(sizeof *removed_seat_event);
 665         if (!removed_seat_event)
 666                 return;
 667
 668         *removed_seat_event = (struct libinput_event_removed_seat) {
 669                 .seat = seat,
 670         };
 671
 672         post_base_event(seat->libinput,
 673                         LIBINPUT_EVENT_REMOVED_SEAT,
 674                         &removed_seat_event->base);
 675 }
 676
 677 void
 678 notify_added_device(struct libinput_device *device)
 679 {
 680         struct libinput_event_added_device *added_device_event;
 681
 682         added_device_event = malloc(sizeof *added_device_event);
 683         if (!added_device_event)
 684                 return;
 685
 686         *added_device_event = (struct libinput_event_added_device) {
 687                 .device = device,
 688         };
 689
 690         post_base_event(device->seat->libinput,
 691                         LIBINPUT_EVENT_ADDED_DEVICE,
 692                         &added_device_event->base);
 693 }
 694
 695 void
 696 notify_removed_device(struct libinput_device *device)
 697 {
 698         struct libinput_event_removed_device *removed_device_event;
 699
 700         removed_device_event = malloc(sizeof *removed_device_event);
 701         if (!removed_device_event)
 702                 return;
 703
 704         *removed_device_event = (struct libinput_event_removed_device) {
 705                 .device = device,
 706         };
 707
 708         post_base_event(device->seat->libinput,
 709                         LIBINPUT_EVENT_REMOVED_DEVICE,
 710                         &removed_device_event->base);
 711 }
 712
 713 void
 714 device_register_capability(struct libinput_device *device,
 715                            enum libinput_device_capability capability)
 716 {
 717         struct libinput_event_device_register_capability *capability_event;
 718
 719         capability_event = malloc(sizeof *capability_event);
 720
 721         *capability_event = (struct libinput_event_device_register_capability) {
 722                 .capability = capability,
 723         };
 724
 725         post_device_event(device,
 726                           LIBINPUT_EVENT_DEVICE_REGISTER_CAPABILITY,
 727                           &capability_event->base);
 728 }
 729
 730 void
 731 device_unregister_capability(struct libinput_device *device,
 732                              enum libinput_device_capability capability)
 733 {
 734         struct libinput_event_device_unregister_capability *capability_event;
 735
 736         capability_event = malloc(sizeof *capability_event);
 737
 738         *capability_event = (struct libinput_event_device_unregister_capability) {
 739                 .capability = capability,
 740         };
 741
 742         post_device_event(device,
 743                           LIBINPUT_EVENT_DEVICE_UNREGISTER_CAPABILITY,
 744                           &capability_event->base);
 745 }
 746
 747 void
 748 keyboard_notify_key(struct libinput_device *device,
 749                     uint32_t time,
 750                     uint32_t key,
 751                     enum libinput_keyboard_key_state state)
 752 {
 753         struct libinput_event_keyboard_key *key_event;
 754
 755         key_event = malloc(sizeof *key_event);
 756         if (!key_event)
 757                 return;
 758
 759         *key_event = (struct libinput_event_keyboard_key) {
 760                 .time = time,
 761                 .key = key,
 762                 .state = state,
 763         };
 764
 765         post_device_event(device,
 766                           LIBINPUT_EVENT_KEYBOARD_KEY,
 767                           &key_event->base);
 768 }
 769
 770 void
 771 pointer_notify_motion(struct libinput_device *device,
 772                       uint32_t time,
 773                       li_fixed_t dx,
 774                       li_fixed_t dy)
 775 {
 776         struct libinput_event_pointer_motion *motion_event;
 777
 778         motion_event = malloc(sizeof *motion_event);
 779         if (!motion_event)
 780                 return;
 781
 782         *motion_event = (struct libinput_event_pointer_motion) {
 783                 .time = time,
 784                 .dx = dx,
 785                 .dy = dy,
 786         };
 787
 788         post_device_event(device,
 789                           LIBINPUT_EVENT_POINTER_MOTION,
 790                           &motion_event->base);
 791 }
 792
 793 void
 794 pointer_notify_motion_absolute(struct libinput_device *device,
 795                                uint32_t time,
 796                                li_fixed_t x,
 797                                li_fixed_t y)
 798 {
 799         struct libinput_event_pointer_motion_absolute *motion_absolute_event;
 800
 801         motion_absolute_event = malloc(sizeof *motion_absolute_event);
 802         if (!motion_absolute_event)
 803                 return;
 804
 805         *motion_absolute_event = (struct libinput_event_pointer_motion_absolute) {
 806                 .time = time,
 807                 .x = x,
 808                 .y = y,
 809         };
 810
 811         post_device_event(device,
 812                           LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE,
 813                           &motion_absolute_event->base);
 814 }
 815
 816 void
 817 pointer_notify_button(struct libinput_device *device,
 818                       uint32_t time,
 819                       int32_t button,
 820                       enum libinput_pointer_button_state state)
 821 {
 822         struct libinput_event_pointer_button *button_event;
 823
 824         button_event = malloc(sizeof *button_event);
 825         if (!button_event)
 826                 return;
 827
 828         *button_event = (struct libinput_event_pointer_button) {
 829                 .time = time,
 830                 .button = button,
 831                 .state = state,
 832         };
 833
 834         post_device_event(device,
 835                           LIBINPUT_EVENT_POINTER_BUTTON,
 836                           &button_event->base);
 837 }
 838
 839 void
 840 pointer_notify_axis(struct libinput_device *device,
 841                     uint32_t time,
 842                     enum libinput_pointer_axis axis,
 843                     li_fixed_t value)
 844 {
 845         struct libinput_event_pointer_axis *axis_event;
 846
 847         axis_event = malloc(sizeof *axis_event);
 848         if (!axis_event)
 849                 return;
 850
 851         *axis_event = (struct libinput_event_pointer_axis) {
 852                 .time = time,
 853                 .axis = axis,
 854                 .value = value,
 855         };
 856
 857         post_device_event(device,
 858                           LIBINPUT_EVENT_POINTER_AXIS,
 859                           &axis_event->base);
 860 }
 861
 862 void
 863 touch_notify_touch(struct libinput_device *device,
 864                    uint32_t time,
 865                    int32_t slot,
 866                    li_fixed_t x,
 867                    li_fixed_t y,
 868                    enum libinput_touch_type touch_type)
 869 {
 870         struct libinput_event_touch_touch *touch_event;
 871
 872         touch_event = malloc(sizeof *touch_event);
 873         if (!touch_event)
 874                 return;
 875
 876         *touch_event = (struct libinput_event_touch_touch) {
 877                 .time = time,
 878                 .slot = slot,
 879                 .x = x,
 880                 .y = y,
 881                 .touch_type = touch_type,
 882         };
 883
 884         post_device_event(device,
 885                           LIBINPUT_EVENT_TOUCH_TOUCH,
 886                           &touch_event->base);
 887 }
 888
 889 static void
 890 libinput_post_event(struct libinput *libinput,
 891                     struct libinput_event *event)
 892 {
 893         struct libinput_event **events = libinput->events;
 894         size_t events_len = libinput->events_len;
 895         size_t events_count = libinput->events_count;
 896         size_t move_len;
 897         size_t new_out;
 898
 899         events_count++;
 900         if (events_count > events_len) {
 901                 events_len *= 2;
 902                 events = realloc(events, events_len * sizeof *events);
 903                 if (!events) {
 904                         fprintf(stderr, "Failed to reallocate event ring "
 905                                 "buffer");
 906                         return;
 907                 }
 908
 909                 if (libinput->events_count > 0 && libinput->events_in == 0) {
 910                         libinput->events_in = libinput->events_len;
 911                 } else if (libinput->events_count > 0 &&
 912                            libinput->events_out >= libinput->events_in) {
 913                         move_len = libinput->events_len - libinput->events_out;
 914                         new_out = events_len - move_len;
 915                         memmove(events + new_out,
 916                                 events + libinput->events_out,
 917                                 move_len * sizeof *events);
 918                         libinput->events_out = new_out;
 919                 }
 920
 921                 libinput->events = events;
 922                 libinput->events_len = events_len;
 923         }
 924
 925         switch (libinput_event_get_class(event)) {
 926         case LIBINPUT_EVENT_CLASS_BASE:
 927                 break;
 928         case LIBINPUT_EVENT_CLASS_SEAT:
 929                 libinput_seat_ref(event->target.seat);
 930                 break;
 931         case LIBINPUT_EVENT_CLASS_DEVICE:
 932                 libinput_device_ref(event->target.device);
 933                 break;
 934         }
 935
 936         libinput->events_count = events_count;
 937         events[libinput->events_in] = event;
 938         libinput->events_in = (libinput->events_in + 1) % libinput->events_len;
 939 }
 940
 941 LIBINPUT_EXPORT struct libinput_event *
 942 libinput_get_event(struct libinput *libinput)
 943 {
 944         struct libinput_event *event;
 945
 946         if (libinput->events_count == 0)
 947                 return NULL;
 948
 949         event = libinput->events[libinput->events_out];
 950         libinput->events_out =
 951                 (libinput->events_out + 1) % libinput->events_len;
 952         libinput->events_count--;
 953
 954         return event;
 955 }
 956
 957 LIBINPUT_EXPORT void *
 958 libinput_get_user_data(struct libinput *libinput)
 959 {
 960         return libinput->user_data;
 961 }
 962
 963 LIBINPUT_EXPORT int
 964 libinput_resume(struct libinput *libinput)
 965 {
 966         return libinput->interface_backend->resume(libinput);
 967 }
 968
 969 LIBINPUT_EXPORT void
 970 libinput_suspend(struct libinput *libinput)
 971 {
 972         libinput->interface_backend->suspend(libinput);
 973 }
 974
 975 LIBINPUT_EXPORT void
 976 libinput_device_set_user_data(struct libinput_device *device, void *user_data)
 977 {
 978         device->user_data = user_data;
 979 }
 980
 981 LIBINPUT_EXPORT void *
 982 libinput_device_get_user_data(struct libinput_device *device)
 983 {
 984         return device->user_data;
 985 }
 986
 987 LIBINPUT_EXPORT const char *
 988 libinput_device_get_sysname(struct libinput_device *device)
 989 {
 990         return evdev_device_get_sysname((struct evdev_device *) device);
 991 }
 992
 993 LIBINPUT_EXPORT const char *
 994 libinput_device_get_output_name(struct libinput_device *device)
 995 {
 996         return evdev_device_get_output((struct evdev_device *) device);
 997 }
 998
 999 LIBINPUT_EXPORT struct libinput_seat *
1000 libinput_device_get_seat(struct libinput_device *device)
1001 {
1002         return device->seat;
1003 }
1004
1005 LIBINPUT_EXPORT void
1006 libinput_device_led_update(struct libinput_device *device,
1007                            enum libinput_led leds)
1008 {
1009         evdev_device_led_update((struct evdev_device *) device, leds);
1010 }
1011
1012 LIBINPUT_EXPORT int
1013 libinput_device_get_keys(struct libinput_device *device,
1014                          char *keys, size_t size)
1015 {
1016         return evdev_device_get_keys((struct evdev_device *) device,
1017                                      keys,
1018                                      size);
1019 }
1020
1021 LIBINPUT_EXPORT void
1022 libinput_device_calibrate(struct libinput_device *device,
1023                           float calibration[6])
1024 {
1025         evdev_device_calibrate((struct evdev_device *) device, calibration);
1026 }
1027
1028 LIBINPUT_EXPORT int
1029 libinput_device_has_capability(struct libinput_device *device,
1030                                enum libinput_device_capability capability)
1031 {
1032         return evdev_device_has_capability((struct evdev_device *) device,
1033                                            capability);
1034 }