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         if (libinput_event_get_type(event) == LIBINPUT_EVENT_ADDED_SEAT ||
 482             libinput_event_get_type(event) == LIBINPUT_EVENT_REMOVED_SEAT)
 483                 libinput_seat_unref(((struct libinput_event_added_seat*)event)->seat);
 484
 485         free(event);
 486 }
 487
 488 int
 489 open_restricted(struct libinput *libinput,
 490                 const char *path, int flags)
 491 {
 492         return libinput->interface->open_restricted(path,
 493                                                     flags,
 494                                                     libinput->user_data);
 495 }
 496
 497 void
 498 close_restricted(struct libinput *libinput, int fd)
 499 {
 500         return libinput->interface->close_restricted(fd, libinput->user_data);
 501 }
 502
 503 void
 504 libinput_seat_init(struct libinput_seat *seat,
 505                    struct libinput *libinput,
 506                    const char *name,
 507                    libinput_seat_destroy_func destroy)
 508 {
 509         seat->refcount = 1;
 510         seat->libinput = libinput;
 511         seat->name = strdup(name);
 512         seat->destroy = destroy;
 513         list_init(&seat->devices_list);
 514 }
 515
 516 LIBINPUT_EXPORT void
 517 libinput_seat_ref(struct libinput_seat *seat)
 518 {
 519         seat->refcount++;
 520 }
 521
 522 static void
 523 libinput_seat_destroy(struct libinput_seat *seat)
 524 {
 525         list_remove(&seat->link);
 526         free(seat->name);
 527         seat->destroy(seat);
 528 }
 529
 530 LIBINPUT_EXPORT void
 531 libinput_seat_unref(struct libinput_seat *seat)
 532 {
 533         assert(seat->refcount > 0);
 534         seat->refcount--;
 535         if (seat->refcount == 0)
 536                 libinput_seat_destroy(seat);
 537 }
 538
 539 LIBINPUT_EXPORT void
 540 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
 541 {
 542         seat->user_data = user_data;
 543 }
 544
 545 LIBINPUT_EXPORT void *
 546 libinput_seat_get_user_data(struct libinput_seat *seat)
 547 {
 548         return seat->user_data;
 549 }
 550
 551 LIBINPUT_EXPORT const char *
 552 libinput_seat_get_name(struct libinput_seat *seat)
 553 {
 554         return seat->name;
 555 }
 556
 557 void
 558 libinput_device_init(struct libinput_device *device,
 559                      struct libinput_seat *seat)
 560 {
 561         device->seat = seat;
 562         device->refcount = 1;
 563 }
 564
 565 LIBINPUT_EXPORT void
 566 libinput_device_ref(struct libinput_device *device)
 567 {
 568         device->refcount++;
 569 }
 570
 571 static void
 572 libinput_device_destroy(struct libinput_device *device)
 573 {
 574         evdev_device_destroy((struct evdev_device *) device);
 575 }
 576
 577 LIBINPUT_EXPORT void
 578 libinput_device_unref(struct libinput_device *device)
 579 {
 580         assert(device->refcount > 0);
 581         device->refcount--;
 582         if (device->refcount == 0)
 583                 libinput_device_destroy(device);
 584 }
 585
 586 LIBINPUT_EXPORT int
 587 libinput_get_fd(struct libinput *libinput)
 588 {
 589         return libinput->epoll_fd;
 590 }
 591
 592 LIBINPUT_EXPORT int
 593 libinput_dispatch(struct libinput *libinput)
 594 {
 595         struct libinput_source *source;
 596         struct epoll_event ep[32];
 597         int i, count;
 598
 599         count = epoll_wait(libinput->epoll_fd, ep, ARRAY_LENGTH(ep), 0);
 600         if (count < 0)
 601                 return -errno;
 602
 603         for (i = 0; i < count; ++i) {
 604                 source = ep[i].data.ptr;
 605                 if (source->fd == -1)
 606                         continue;
 607
 608                 source->dispatch(source->user_data);
 609         }
 610
 611         libinput_drop_destroyed_sources(libinput);
 612
 613         return 0;
 614 }
 615
 616 static void
 617 init_event_base(struct libinput_event *event,
 618                 enum libinput_event_type type,
 619                 union libinput_event_target target)
 620 {
 621         event->type = type;
 622         event->target = target;
 623 }
 624
 625 static void
 626 post_base_event(struct libinput *libinput,
 627                 enum libinput_event_type type,
 628                 struct libinput_event *event)
 629 {
 630         init_event_base(event, type,
 631                         (union libinput_event_target) { .libinput = libinput });
 632         libinput_post_event(libinput, event);
 633 }
 634
 635 static void
 636 post_device_event(struct libinput_device *device,
 637                   enum libinput_event_type type,
 638                   struct libinput_event *event)
 639 {
 640         init_event_base(event, type,
 641                         (union libinput_event_target) { .device = device });
 642         libinput_post_event(device->seat->libinput, event);
 643 }
 644
 645 void
 646 notify_added_seat(struct libinput_seat *seat)
 647 {
 648         struct libinput_event_added_seat *added_seat_event;
 649
 650         added_seat_event = malloc(sizeof *added_seat_event);
 651         if (!added_seat_event)
 652                 return;
 653
 654         libinput_seat_ref(seat);
 655
 656         *added_seat_event = (struct libinput_event_added_seat) {
 657                 .seat = seat,
 658         };
 659
 660         post_base_event(seat->libinput,
 661                         LIBINPUT_EVENT_ADDED_SEAT,
 662                         &added_seat_event->base);
 663 }
 664
 665 void
 666 notify_removed_seat(struct libinput_seat *seat)
 667 {
 668         struct libinput_event_removed_seat *removed_seat_event;
 669
 670         removed_seat_event = malloc(sizeof *removed_seat_event);
 671         if (!removed_seat_event)
 672                 return;
 673
 674         libinput_seat_ref(seat);
 675
 676         *removed_seat_event = (struct libinput_event_removed_seat) {
 677                 .seat = seat,
 678         };
 679
 680         post_base_event(seat->libinput,
 681                         LIBINPUT_EVENT_REMOVED_SEAT,
 682                         &removed_seat_event->base);
 683 }
 684
 685 void
 686 notify_added_device(struct libinput_device *device)
 687 {
 688         struct libinput_event_added_device *added_device_event;
 689
 690         added_device_event = malloc(sizeof *added_device_event);
 691         if (!added_device_event)
 692                 return;
 693
 694         *added_device_event = (struct libinput_event_added_device) {
 695                 .device = device,
 696         };
 697
 698         post_base_event(device->seat->libinput,
 699                         LIBINPUT_EVENT_ADDED_DEVICE,
 700                         &added_device_event->base);
 701 }
 702
 703 void
 704 notify_removed_device(struct libinput_device *device)
 705 {
 706         struct libinput_event_removed_device *removed_device_event;
 707
 708         removed_device_event = malloc(sizeof *removed_device_event);
 709         if (!removed_device_event)
 710                 return;
 711
 712         *removed_device_event = (struct libinput_event_removed_device) {
 713                 .device = device,
 714         };
 715
 716         post_base_event(device->seat->libinput,
 717                         LIBINPUT_EVENT_REMOVED_DEVICE,
 718                         &removed_device_event->base);
 719 }
 720
 721 void
 722 device_register_capability(struct libinput_device *device,
 723                            enum libinput_device_capability capability)
 724 {
 725         struct libinput_event_device_register_capability *capability_event;
 726
 727         capability_event = malloc(sizeof *capability_event);
 728
 729         *capability_event = (struct libinput_event_device_register_capability) {
 730                 .capability = capability,
 731         };
 732
 733         post_device_event(device,
 734                           LIBINPUT_EVENT_DEVICE_REGISTER_CAPABILITY,
 735                           &capability_event->base);
 736 }
 737
 738 void
 739 device_unregister_capability(struct libinput_device *device,
 740                              enum libinput_device_capability capability)
 741 {
 742         struct libinput_event_device_unregister_capability *capability_event;
 743
 744         capability_event = malloc(sizeof *capability_event);
 745
 746         *capability_event = (struct libinput_event_device_unregister_capability) {
 747                 .capability = capability,
 748         };
 749
 750         post_device_event(device,
 751                           LIBINPUT_EVENT_DEVICE_UNREGISTER_CAPABILITY,
 752                           &capability_event->base);
 753 }
 754
 755 void
 756 keyboard_notify_key(struct libinput_device *device,
 757                     uint32_t time,
 758                     uint32_t key,
 759                     enum libinput_keyboard_key_state state)
 760 {
 761         struct libinput_event_keyboard_key *key_event;
 762
 763         key_event = malloc(sizeof *key_event);
 764         if (!key_event)
 765                 return;
 766
 767         *key_event = (struct libinput_event_keyboard_key) {
 768                 .time = time,
 769                 .key = key,
 770                 .state = state,
 771         };
 772
 773         post_device_event(device,
 774                           LIBINPUT_EVENT_KEYBOARD_KEY,
 775                           &key_event->base);
 776 }
 777
 778 void
 779 pointer_notify_motion(struct libinput_device *device,
 780                       uint32_t time,
 781                       li_fixed_t dx,
 782                       li_fixed_t dy)
 783 {
 784         struct libinput_event_pointer_motion *motion_event;
 785
 786         motion_event = malloc(sizeof *motion_event);
 787         if (!motion_event)
 788                 return;
 789
 790         *motion_event = (struct libinput_event_pointer_motion) {
 791                 .time = time,
 792                 .dx = dx,
 793                 .dy = dy,
 794         };
 795
 796         post_device_event(device,
 797                           LIBINPUT_EVENT_POINTER_MOTION,
 798                           &motion_event->base);
 799 }
 800
 801 void
 802 pointer_notify_motion_absolute(struct libinput_device *device,
 803                                uint32_t time,
 804                                li_fixed_t x,
 805                                li_fixed_t y)
 806 {
 807         struct libinput_event_pointer_motion_absolute *motion_absolute_event;
 808
 809         motion_absolute_event = malloc(sizeof *motion_absolute_event);
 810         if (!motion_absolute_event)
 811                 return;
 812
 813         *motion_absolute_event = (struct libinput_event_pointer_motion_absolute) {
 814                 .time = time,
 815                 .x = x,
 816                 .y = y,
 817         };
 818
 819         post_device_event(device,
 820                           LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE,
 821                           &motion_absolute_event->base);
 822 }
 823
 824 void
 825 pointer_notify_button(struct libinput_device *device,
 826                       uint32_t time,
 827                       int32_t button,
 828                       enum libinput_pointer_button_state state)
 829 {
 830         struct libinput_event_pointer_button *button_event;
 831
 832         button_event = malloc(sizeof *button_event);
 833         if (!button_event)
 834                 return;
 835
 836         *button_event = (struct libinput_event_pointer_button) {
 837                 .time = time,
 838                 .button = button,
 839                 .state = state,
 840         };
 841
 842         post_device_event(device,
 843                           LIBINPUT_EVENT_POINTER_BUTTON,
 844                           &button_event->base);
 845 }
 846
 847 void
 848 pointer_notify_axis(struct libinput_device *device,
 849                     uint32_t time,
 850                     enum libinput_pointer_axis axis,
 851                     li_fixed_t value)
 852 {
 853         struct libinput_event_pointer_axis *axis_event;
 854
 855         axis_event = malloc(sizeof *axis_event);
 856         if (!axis_event)
 857                 return;
 858
 859         *axis_event = (struct libinput_event_pointer_axis) {
 860                 .time = time,
 861                 .axis = axis,
 862                 .value = value,
 863         };
 864
 865         post_device_event(device,
 866                           LIBINPUT_EVENT_POINTER_AXIS,
 867                           &axis_event->base);
 868 }
 869
 870 void
 871 touch_notify_touch(struct libinput_device *device,
 872                    uint32_t time,
 873                    int32_t slot,
 874                    li_fixed_t x,
 875                    li_fixed_t y,
 876                    enum libinput_touch_type touch_type)
 877 {
 878         struct libinput_event_touch_touch *touch_event;
 879
 880         touch_event = malloc(sizeof *touch_event);
 881         if (!touch_event)
 882                 return;
 883
 884         *touch_event = (struct libinput_event_touch_touch) {
 885                 .time = time,
 886                 .slot = slot,
 887                 .x = x,
 888                 .y = y,
 889                 .touch_type = touch_type,
 890         };
 891
 892         post_device_event(device,
 893                           LIBINPUT_EVENT_TOUCH_TOUCH,
 894                           &touch_event->base);
 895 }
 896
 897 static void
 898 libinput_post_event(struct libinput *libinput,
 899                     struct libinput_event *event)
 900 {
 901         struct libinput_event **events = libinput->events;
 902         size_t events_len = libinput->events_len;
 903         size_t events_count = libinput->events_count;
 904         size_t move_len;
 905         size_t new_out;
 906
 907         events_count++;
 908         if (events_count > events_len) {
 909                 events_len *= 2;
 910                 events = realloc(events, events_len * sizeof *events);
 911                 if (!events) {
 912                         fprintf(stderr, "Failed to reallocate event ring "
 913                                 "buffer");
 914                         return;
 915                 }
 916
 917                 if (libinput->events_count > 0 && libinput->events_in == 0) {
 918                         libinput->events_in = libinput->events_len;
 919                 } else if (libinput->events_count > 0 &&
 920                            libinput->events_out >= libinput->events_in) {
 921                         move_len = libinput->events_len - libinput->events_out;
 922                         new_out = events_len - move_len;
 923                         memmove(events + new_out,
 924                                 events + libinput->events_out,
 925                                 move_len * sizeof *events);
 926                         libinput->events_out = new_out;
 927                 }
 928
 929                 libinput->events = events;
 930                 libinput->events_len = events_len;
 931         }
 932
 933         switch (libinput_event_get_class(event)) {
 934         case LIBINPUT_EVENT_CLASS_BASE:
 935                 break;
 936         case LIBINPUT_EVENT_CLASS_SEAT:
 937                 libinput_seat_ref(event->target.seat);
 938                 break;
 939         case LIBINPUT_EVENT_CLASS_DEVICE:
 940                 libinput_device_ref(event->target.device);
 941                 break;
 942         }
 943
 944         libinput->events_count = events_count;
 945         events[libinput->events_in] = event;
 946         libinput->events_in = (libinput->events_in + 1) % libinput->events_len;
 947 }
 948
 949 LIBINPUT_EXPORT struct libinput_event *
 950 libinput_get_event(struct libinput *libinput)
 951 {
 952         struct libinput_event *event;
 953
 954         if (libinput->events_count == 0)
 955                 return NULL;
 956
 957         event = libinput->events[libinput->events_out];
 958         libinput->events_out =
 959                 (libinput->events_out + 1) % libinput->events_len;
 960         libinput->events_count--;
 961
 962         return event;
 963 }
 964
 965 LIBINPUT_EXPORT void *
 966 libinput_get_user_data(struct libinput *libinput)
 967 {
 968         return libinput->user_data;
 969 }
 970
 971 LIBINPUT_EXPORT int
 972 libinput_resume(struct libinput *libinput)
 973 {
 974         return libinput->interface_backend->resume(libinput);
 975 }
 976
 977 LIBINPUT_EXPORT void
 978 libinput_suspend(struct libinput *libinput)
 979 {
 980         libinput->interface_backend->suspend(libinput);
 981 }
 982
 983 LIBINPUT_EXPORT void
 984 libinput_device_set_user_data(struct libinput_device *device, void *user_data)
 985 {
 986         device->user_data = user_data;
 987 }
 988
 989 LIBINPUT_EXPORT void *
 990 libinput_device_get_user_data(struct libinput_device *device)
 991 {
 992         return device->user_data;
 993 }
 994
 995 LIBINPUT_EXPORT const char *
 996 libinput_device_get_sysname(struct libinput_device *device)
 997 {
 998         return evdev_device_get_sysname((struct evdev_device *) device);
 999 }
1000
1001 LIBINPUT_EXPORT const char *
1002 libinput_device_get_output_name(struct libinput_device *device)
1003 {
1004         return evdev_device_get_output((struct evdev_device *) device);
1005 }
1006
1007 LIBINPUT_EXPORT struct libinput_seat *
1008 libinput_device_get_seat(struct libinput_device *device)
1009 {
1010         return device->seat;
1011 }
1012
1013 LIBINPUT_EXPORT void
1014 libinput_device_led_update(struct libinput_device *device,
1015                            enum libinput_led leds)
1016 {
1017         evdev_device_led_update((struct evdev_device *) device, leds);
1018 }
1019
1020 LIBINPUT_EXPORT int
1021 libinput_device_get_keys(struct libinput_device *device,
1022                          char *keys, size_t size)
1023 {
1024         return evdev_device_get_keys((struct evdev_device *) device,
1025                                      keys,
1026                                      size);
1027 }
1028
1029 LIBINPUT_EXPORT void
1030 libinput_device_calibrate(struct libinput_device *device,
1031                           float calibration[6])
1032 {
1033         evdev_device_calibrate((struct evdev_device *) device, calibration);
1034 }
1035
1036 LIBINPUT_EXPORT int
1037 libinput_device_has_capability(struct libinput_device *device,
1038                                enum libinput_device_capability capability)
1039 {
1040         return evdev_device_has_capability((struct evdev_device *) device,
1041                                            capability);
1042 }