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 #include "timer.h"
  37
  38 struct libinput_source {
  39         libinput_source_dispatch_t dispatch;
  40         void *user_data;
  41         int fd;
  42         struct list link;
  43 };
  44
  45 struct libinput_event {
  46         enum libinput_event_type type;
  47         struct libinput_device *device;
  48 };
  49
  50 struct libinput_event_device_notify {
  51         struct libinput_event base;
  52 };
  53
  54 struct libinput_event_keyboard {
  55         struct libinput_event base;
  56         uint32_t time;
  57         uint32_t key;
  58         uint32_t seat_key_count;
  59         enum libinput_keyboard_key_state state;
  60 };
  61
  62 struct libinput_event_pointer {
  63         struct libinput_event base;
  64         uint32_t time;
  65         double x;
  66         double y;
  67         uint32_t button;
  68         uint32_t seat_button_count;
  69         enum libinput_button_state state;
  70         enum libinput_pointer_axis axis;
  71         double value;
  72 };
  73
  74 struct libinput_event_touch {
  75         struct libinput_event base;
  76         uint32_t time;
  77         int32_t slot;
  78         int32_t seat_slot;
  79         double x;
  80         double y;
  81 };
  82
  83 static void
  84 libinput_default_log_func(enum libinput_log_priority priority,
  85                           void *data,
  86                           const char *format, va_list args)
  87 {
  88         const char *prefix;
  89
  90         switch(priority) {
  91         case LIBINPUT_LOG_PRIORITY_DEBUG: prefix = "debug"; break;
  92         case LIBINPUT_LOG_PRIORITY_INFO: prefix = "info"; break;
  93         case LIBINPUT_LOG_PRIORITY_ERROR: prefix = "error"; break;
  94         default: prefix="<invalid priority>"; break;
  95         }
  96
  97         fprintf(stderr, "libinput %s: ", prefix);
  98         vfprintf(stderr, format, args);
  99 }
 100
 101 struct log_data {
 102         enum libinput_log_priority priority;
 103         libinput_log_handler handler;
 104         void *user_data;
 105 };
 106
 107 static struct log_data log_data = {
 108         .priority = LIBINPUT_LOG_PRIORITY_ERROR,
 109         .handler = libinput_default_log_func,
 110         .user_data = NULL,
 111 };
 112
 113 void
 114 log_msg_va(enum libinput_log_priority priority,
 115            const char *format,
 116            va_list args)
 117 {
 118         if (log_data.handler && log_data.priority <= priority)
 119                 log_data.handler(priority, log_data.user_data, format, args);
 120 }
 121
 122 void
 123 log_msg(enum libinput_log_priority priority, const char *format, ...)
 124 {
 125         va_list args;
 126
 127         va_start(args, format);
 128         log_msg_va(priority, format, args);
 129         va_end(args);
 130 }
 131
 132 LIBINPUT_EXPORT void
 133 libinput_log_set_priority(enum libinput_log_priority priority)
 134 {
 135         log_data.priority = priority;
 136 }
 137
 138 LIBINPUT_EXPORT enum libinput_log_priority
 139 libinput_log_get_priority(void)
 140 {
 141         return log_data.priority;
 142 }
 143
 144 LIBINPUT_EXPORT void
 145 libinput_log_set_handler(libinput_log_handler log_handler,
 146                          void *user_data)
 147 {
 148         log_data.handler = log_handler;
 149         log_data.user_data = user_data;
 150 }
 151
 152 static void
 153 libinput_post_event(struct libinput *libinput,
 154                     struct libinput_event *event);
 155
 156 LIBINPUT_EXPORT enum libinput_event_type
 157 libinput_event_get_type(struct libinput_event *event)
 158 {
 159         return event->type;
 160 }
 161
 162 LIBINPUT_EXPORT struct libinput *
 163 libinput_event_get_context(struct libinput_event *event)
 164 {
 165         return event->device->seat->libinput;
 166 }
 167
 168 LIBINPUT_EXPORT struct libinput_device *
 169 libinput_event_get_device(struct libinput_event *event)
 170 {
 171         return event->device;
 172 }
 173
 174 LIBINPUT_EXPORT struct libinput_event_pointer *
 175 libinput_event_get_pointer_event(struct libinput_event *event)
 176 {
 177         switch (event->type) {
 178         case LIBINPUT_EVENT_NONE:
 179                 abort(); /* not used as actual event type */
 180         case LIBINPUT_EVENT_DEVICE_ADDED:
 181         case LIBINPUT_EVENT_DEVICE_REMOVED:
 182         case LIBINPUT_EVENT_KEYBOARD_KEY:
 183                 break;
 184         case LIBINPUT_EVENT_POINTER_MOTION:
 185         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
 186         case LIBINPUT_EVENT_POINTER_BUTTON:
 187         case LIBINPUT_EVENT_POINTER_AXIS:
 188                 return (struct libinput_event_pointer *) event;
 189         case LIBINPUT_EVENT_TOUCH_DOWN:
 190         case LIBINPUT_EVENT_TOUCH_UP:
 191         case LIBINPUT_EVENT_TOUCH_MOTION:
 192         case LIBINPUT_EVENT_TOUCH_CANCEL:
 193         case LIBINPUT_EVENT_TOUCH_FRAME:
 194                 break;
 195         }
 196
 197         return NULL;
 198 }
 199
 200 LIBINPUT_EXPORT struct libinput_event_keyboard *
 201 libinput_event_get_keyboard_event(struct libinput_event *event)
 202 {
 203         switch (event->type) {
 204         case LIBINPUT_EVENT_NONE:
 205                 abort(); /* not used as actual event type */
 206         case LIBINPUT_EVENT_DEVICE_ADDED:
 207         case LIBINPUT_EVENT_DEVICE_REMOVED:
 208                 break;
 209         case LIBINPUT_EVENT_KEYBOARD_KEY:
 210                 return (struct libinput_event_keyboard *) event;
 211         case LIBINPUT_EVENT_POINTER_MOTION:
 212         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
 213         case LIBINPUT_EVENT_POINTER_BUTTON:
 214         case LIBINPUT_EVENT_POINTER_AXIS:
 215         case LIBINPUT_EVENT_TOUCH_DOWN:
 216         case LIBINPUT_EVENT_TOUCH_UP:
 217         case LIBINPUT_EVENT_TOUCH_MOTION:
 218         case LIBINPUT_EVENT_TOUCH_CANCEL:
 219         case LIBINPUT_EVENT_TOUCH_FRAME:
 220                 break;
 221         }
 222
 223         return NULL;
 224 }
 225
 226 LIBINPUT_EXPORT struct libinput_event_touch *
 227 libinput_event_get_touch_event(struct libinput_event *event)
 228 {
 229         switch (event->type) {
 230         case LIBINPUT_EVENT_NONE:
 231                 abort(); /* not used as actual event type */
 232         case LIBINPUT_EVENT_DEVICE_ADDED:
 233         case LIBINPUT_EVENT_DEVICE_REMOVED:
 234         case LIBINPUT_EVENT_KEYBOARD_KEY:
 235         case LIBINPUT_EVENT_POINTER_MOTION:
 236         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
 237         case LIBINPUT_EVENT_POINTER_BUTTON:
 238         case LIBINPUT_EVENT_POINTER_AXIS:
 239                 break;
 240         case LIBINPUT_EVENT_TOUCH_DOWN:
 241         case LIBINPUT_EVENT_TOUCH_UP:
 242         case LIBINPUT_EVENT_TOUCH_MOTION:
 243         case LIBINPUT_EVENT_TOUCH_CANCEL:
 244         case LIBINPUT_EVENT_TOUCH_FRAME:
 245                 return (struct libinput_event_touch *) event;
 246         }
 247
 248         return NULL;
 249 }
 250
 251 LIBINPUT_EXPORT struct libinput_event_device_notify *
 252 libinput_event_get_device_notify_event(struct libinput_event *event)
 253 {
 254         switch (event->type) {
 255         case LIBINPUT_EVENT_NONE:
 256                 abort(); /* not used as actual event type */
 257         case LIBINPUT_EVENT_DEVICE_ADDED:
 258         case LIBINPUT_EVENT_DEVICE_REMOVED:
 259                 return (struct libinput_event_device_notify *) event;
 260         case LIBINPUT_EVENT_KEYBOARD_KEY:
 261         case LIBINPUT_EVENT_POINTER_MOTION:
 262         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
 263         case LIBINPUT_EVENT_POINTER_BUTTON:
 264         case LIBINPUT_EVENT_POINTER_AXIS:
 265         case LIBINPUT_EVENT_TOUCH_DOWN:
 266         case LIBINPUT_EVENT_TOUCH_UP:
 267         case LIBINPUT_EVENT_TOUCH_MOTION:
 268         case LIBINPUT_EVENT_TOUCH_CANCEL:
 269         case LIBINPUT_EVENT_TOUCH_FRAME:
 270                 break;
 271         }
 272
 273         return NULL;
 274 }
 275
 276 LIBINPUT_EXPORT uint32_t
 277 libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
 278 {
 279         return event->time;
 280 }
 281
 282 LIBINPUT_EXPORT uint32_t
 283 libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
 284 {
 285         return event->key;
 286 }
 287
 288 LIBINPUT_EXPORT enum libinput_keyboard_key_state
 289 libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
 290 {
 291         return event->state;
 292 }
 293
 294 LIBINPUT_EXPORT uint32_t
 295 libinput_event_keyboard_get_seat_key_count(
 296         struct libinput_event_keyboard *event)
 297 {
 298         return event->seat_key_count;
 299 }
 300
 301 LIBINPUT_EXPORT uint32_t
 302 libinput_event_pointer_get_time(struct libinput_event_pointer *event)
 303 {
 304         return event->time;
 305 }
 306
 307 LIBINPUT_EXPORT double
 308 libinput_event_pointer_get_dx(struct libinput_event_pointer *event)
 309 {
 310         return event->x;
 311 }
 312
 313 LIBINPUT_EXPORT double
 314 libinput_event_pointer_get_dy(struct libinput_event_pointer *event)
 315 {
 316         return event->y;
 317 }
 318
 319 LIBINPUT_EXPORT double
 320 libinput_event_pointer_get_absolute_x(struct libinput_event_pointer *event)
 321 {
 322         return event->x;
 323 }
 324
 325 LIBINPUT_EXPORT double
 326 libinput_event_pointer_get_absolute_y(struct libinput_event_pointer *event)
 327 {
 328         return event->y;
 329 }
 330
 331 LIBINPUT_EXPORT double
 332 libinput_event_pointer_get_absolute_x_transformed(
 333         struct libinput_event_pointer *event,
 334         uint32_t width)
 335 {
 336         struct evdev_device *device =
 337                 (struct evdev_device *) event->base.device;
 338
 339         return evdev_device_transform_x(device, event->x, width);
 340 }
 341
 342 LIBINPUT_EXPORT double
 343 libinput_event_pointer_get_absolute_y_transformed(
 344         struct libinput_event_pointer *event,
 345         uint32_t height)
 346 {
 347         struct evdev_device *device =
 348                 (struct evdev_device *) event->base.device;
 349
 350         return evdev_device_transform_y(device, event->y, height);
 351 }
 352
 353 LIBINPUT_EXPORT uint32_t
 354 libinput_event_pointer_get_button(struct libinput_event_pointer *event)
 355 {
 356         return event->button;
 357 }
 358
 359 LIBINPUT_EXPORT enum libinput_button_state
 360 libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
 361 {
 362         return event->state;
 363 }
 364
 365 LIBINPUT_EXPORT uint32_t
 366 libinput_event_pointer_get_seat_button_count(
 367         struct libinput_event_pointer *event)
 368 {
 369         return event->seat_button_count;
 370 }
 371
 372 LIBINPUT_EXPORT enum libinput_pointer_axis
 373 libinput_event_pointer_get_axis(struct libinput_event_pointer *event)
 374 {
 375         return event->axis;
 376 }
 377
 378 LIBINPUT_EXPORT double
 379 libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event)
 380 {
 381         return event->value;
 382 }
 383
 384 LIBINPUT_EXPORT uint32_t
 385 libinput_event_touch_get_time(struct libinput_event_touch *event)
 386 {
 387         return event->time;
 388 }
 389
 390 LIBINPUT_EXPORT int32_t
 391 libinput_event_touch_get_slot(struct libinput_event_touch *event)
 392 {
 393         return event->slot;
 394 }
 395
 396 LIBINPUT_EXPORT int32_t
 397 libinput_event_touch_get_seat_slot(struct libinput_event_touch *event)
 398 {
 399         return event->seat_slot;
 400 }
 401
 402 LIBINPUT_EXPORT double
 403 libinput_event_touch_get_x(struct libinput_event_touch *event)
 404 {
 405         return event->x;
 406 }
 407
 408 LIBINPUT_EXPORT double
 409 libinput_event_touch_get_x_transformed(struct libinput_event_touch *event,
 410                                        uint32_t width)
 411 {
 412         struct evdev_device *device =
 413                 (struct evdev_device *) event->base.device;
 414
 415         return evdev_device_transform_x(device, event->x, width);
 416 }
 417
 418 LIBINPUT_EXPORT double
 419 libinput_event_touch_get_y_transformed(struct libinput_event_touch *event,
 420                                        uint32_t height)
 421 {
 422         struct evdev_device *device =
 423                 (struct evdev_device *) event->base.device;
 424
 425         return evdev_device_transform_y(device, event->y, height);
 426 }
 427
 428 LIBINPUT_EXPORT double
 429 libinput_event_touch_get_y(struct libinput_event_touch *event)
 430 {
 431         return event->y;
 432 }
 433
 434 struct libinput_source *
 435 libinput_add_fd(struct libinput *libinput,
 436                 int fd,
 437                 libinput_source_dispatch_t dispatch,
 438                 void *user_data)
 439 {
 440         struct libinput_source *source;
 441         struct epoll_event ep;
 442
 443         source = malloc(sizeof *source);
 444         if (!source)
 445                 return NULL;
 446
 447         source->dispatch = dispatch;
 448         source->user_data = user_data;
 449         source->fd = fd;
 450
 451         memset(&ep, 0, sizeof ep);
 452         ep.events = EPOLLIN;
 453         ep.data.ptr = source;
 454
 455         if (epoll_ctl(libinput->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) {
 456                 close(source->fd);
 457                 free(source);
 458                 return NULL;
 459         }
 460
 461         return source;
 462 }
 463
 464 void
 465 libinput_remove_source(struct libinput *libinput,
 466                        struct libinput_source *source)
 467 {
 468         epoll_ctl(libinput->epoll_fd, EPOLL_CTL_DEL, source->fd, NULL);
 469         source->fd = -1;
 470         list_insert(&libinput->source_destroy_list, &source->link);
 471 }
 472
 473 int
 474 libinput_init(struct libinput *libinput,
 475               const struct libinput_interface *interface,
 476               const struct libinput_interface_backend *interface_backend,
 477               void *user_data)
 478 {
 479         libinput->epoll_fd = epoll_create1(EPOLL_CLOEXEC);;
 480         if (libinput->epoll_fd < 0)
 481                 return -1;
 482
 483         libinput->events_len = 4;
 484         libinput->events = zalloc(libinput->events_len * sizeof(*libinput->events));
 485         if (!libinput->events) {
 486                 close(libinput->epoll_fd);
 487                 return -1;
 488         }
 489
 490         libinput->interface = interface;
 491         libinput->interface_backend = interface_backend;
 492         libinput->user_data = user_data;
 493         list_init(&libinput->source_destroy_list);
 494         list_init(&libinput->seat_list);
 495
 496         if (libinput_timer_subsys_init(libinput) != 0) {
 497                 free(libinput->events);
 498                 close(libinput->epoll_fd);
 499                 return -1;
 500         }
 501
 502         return 0;
 503 }
 504
 505 static void
 506 libinput_device_destroy(struct libinput_device *device);
 507
 508 static void
 509 libinput_seat_destroy(struct libinput_seat *seat);
 510
 511 static void
 512 libinput_drop_destroyed_sources(struct libinput *libinput)
 513 {
 514         struct libinput_source *source, *next;
 515
 516         list_for_each_safe(source, next, &libinput->source_destroy_list, link)
 517                 free(source);
 518         list_init(&libinput->source_destroy_list);
 519 }
 520
 521 LIBINPUT_EXPORT void
 522 libinput_destroy(struct libinput *libinput)
 523 {
 524         struct libinput_event *event;
 525         struct libinput_device *device, *next_device;
 526         struct libinput_seat *seat, *next_seat;
 527
 528         if (libinput == NULL)
 529                 return;
 530
 531         libinput_suspend(libinput);
 532
 533         libinput->interface_backend->destroy(libinput);
 534
 535         while ((event = libinput_get_event(libinput)))
 536                libinput_event_destroy(event);
 537
 538         free(libinput->events);
 539
 540         list_for_each_safe(seat, next_seat, &libinput->seat_list, link) {
 541                 list_for_each_safe(device, next_device,
 542                                    &seat->devices_list,
 543                                    link)
 544                         libinput_device_destroy(device);
 545
 546                 libinput_seat_destroy(seat);
 547         }
 548
 549         libinput_timer_subsys_destroy(libinput);
 550         libinput_drop_destroyed_sources(libinput);
 551         close(libinput->epoll_fd);
 552         free(libinput);
 553 }
 554
 555 LIBINPUT_EXPORT void
 556 libinput_event_destroy(struct libinput_event *event)
 557 {
 558         if (event == NULL)
 559                 return;
 560
 561         if (event->device)
 562                 libinput_device_unref(event->device);
 563
 564         free(event);
 565 }
 566
 567 int
 568 open_restricted(struct libinput *libinput,
 569                 const char *path, int flags)
 570 {
 571         return libinput->interface->open_restricted(path,
 572                                                     flags,
 573                                                     libinput->user_data);
 574 }
 575
 576 void
 577 close_restricted(struct libinput *libinput, int fd)
 578 {
 579         return libinput->interface->close_restricted(fd, libinput->user_data);
 580 }
 581
 582 void
 583 libinput_seat_init(struct libinput_seat *seat,
 584                    struct libinput *libinput,
 585                    const char *physical_name,
 586                    const char *logical_name,
 587                    libinput_seat_destroy_func destroy)
 588 {
 589         seat->refcount = 1;
 590         seat->libinput = libinput;
 591         seat->physical_name = strdup(physical_name);
 592         seat->logical_name = strdup(logical_name);
 593         seat->destroy = destroy;
 594         list_init(&seat->devices_list);
 595         list_insert(&libinput->seat_list, &seat->link);
 596 }
 597
 598 LIBINPUT_EXPORT void
 599 libinput_seat_ref(struct libinput_seat *seat)
 600 {
 601         seat->refcount++;
 602 }
 603
 604 static void
 605 libinput_seat_destroy(struct libinput_seat *seat)
 606 {
 607         list_remove(&seat->link);
 608         free(seat->logical_name);
 609         free(seat->physical_name);
 610         seat->destroy(seat);
 611 }
 612
 613 LIBINPUT_EXPORT void
 614 libinput_seat_unref(struct libinput_seat *seat)
 615 {
 616         assert(seat->refcount > 0);
 617         seat->refcount--;
 618         if (seat->refcount == 0)
 619                 libinput_seat_destroy(seat);
 620 }
 621
 622 LIBINPUT_EXPORT void
 623 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
 624 {
 625         seat->user_data = user_data;
 626 }
 627
 628 LIBINPUT_EXPORT void *
 629 libinput_seat_get_user_data(struct libinput_seat *seat)
 630 {
 631         return seat->user_data;
 632 }
 633
 634 LIBINPUT_EXPORT const char *
 635 libinput_seat_get_physical_name(struct libinput_seat *seat)
 636 {
 637         return seat->physical_name;
 638 }
 639
 640 LIBINPUT_EXPORT const char *
 641 libinput_seat_get_logical_name(struct libinput_seat *seat)
 642 {
 643         return seat->logical_name;
 644 }
 645
 646 void
 647 libinput_device_init(struct libinput_device *device,
 648                      struct libinput_seat *seat)
 649 {
 650         device->seat = seat;
 651         device->refcount = 1;
 652 }
 653
 654 LIBINPUT_EXPORT void
 655 libinput_device_ref(struct libinput_device *device)
 656 {
 657         device->refcount++;
 658 }
 659
 660 static void
 661 libinput_device_destroy(struct libinput_device *device)
 662 {
 663         evdev_device_destroy((struct evdev_device *) device);
 664 }
 665
 666 LIBINPUT_EXPORT void
 667 libinput_device_unref(struct libinput_device *device)
 668 {
 669         assert(device->refcount > 0);
 670         device->refcount--;
 671         if (device->refcount == 0)
 672                 libinput_device_destroy(device);
 673 }
 674
 675 LIBINPUT_EXPORT int
 676 libinput_get_fd(struct libinput *libinput)
 677 {
 678         return libinput->epoll_fd;
 679 }
 680
 681 LIBINPUT_EXPORT int
 682 libinput_dispatch(struct libinput *libinput)
 683 {
 684         struct libinput_source *source;
 685         struct epoll_event ep[32];
 686         int i, count;
 687
 688         count = epoll_wait(libinput->epoll_fd, ep, ARRAY_LENGTH(ep), 0);
 689         if (count < 0)
 690                 return -errno;
 691
 692         for (i = 0; i < count; ++i) {
 693                 source = ep[i].data.ptr;
 694                 if (source->fd == -1)
 695                         continue;
 696
 697                 source->dispatch(source->user_data);
 698         }
 699
 700         libinput_drop_destroyed_sources(libinput);
 701
 702         return 0;
 703 }
 704
 705 static uint32_t
 706 update_seat_key_count(struct libinput_seat *seat,
 707                       int32_t key,
 708                       enum libinput_keyboard_key_state state)
 709 {
 710         assert(key >= 0 && key <= KEY_MAX);
 711
 712         switch (state) {
 713         case LIBINPUT_KEYBOARD_KEY_STATE_PRESSED:
 714                 return ++seat->button_count[key];
 715         case LIBINPUT_KEYBOARD_KEY_STATE_RELEASED:
 716                 /* We might not have received the first PRESSED event. */
 717                 if (seat->button_count[key] == 0)
 718                         return 0;
 719
 720                 return --seat->button_count[key];
 721         }
 722
 723         return 0;
 724 }
 725
 726 static uint32_t
 727 update_seat_button_count(struct libinput_seat *seat,
 728                          int32_t button,
 729                          enum libinput_button_state state)
 730 {
 731         assert(button >= 0 && button <= KEY_MAX);
 732
 733         switch (state) {
 734         case LIBINPUT_BUTTON_STATE_PRESSED:
 735                 return ++seat->button_count[button];
 736         case LIBINPUT_BUTTON_STATE_RELEASED:
 737                 /* We might not have received the first PRESSED event. */
 738                 if (seat->button_count[button] == 0)
 739                         return 0;
 740
 741                 return --seat->button_count[button];
 742         }
 743
 744         return 0;
 745 }
 746
 747 static void
 748 init_event_base(struct libinput_event *event,
 749                 struct libinput_device *device,
 750                 enum libinput_event_type type)
 751 {
 752         event->type = type;
 753         event->device = device;
 754 }
 755
 756 static void
 757 post_base_event(struct libinput_device *device,
 758                 enum libinput_event_type type,
 759                 struct libinput_event *event)
 760 {
 761         struct libinput *libinput = device->seat->libinput;
 762         init_event_base(event, device, type);
 763         libinput_post_event(libinput, event);
 764 }
 765
 766 static void
 767 post_device_event(struct libinput_device *device,
 768                   enum libinput_event_type type,
 769                   struct libinput_event *event)
 770 {
 771         init_event_base(event, device, type);
 772         libinput_post_event(device->seat->libinput, event);
 773 }
 774
 775 void
 776 notify_added_device(struct libinput_device *device)
 777 {
 778         struct libinput_event_device_notify *added_device_event;
 779
 780         added_device_event = zalloc(sizeof *added_device_event);
 781         if (!added_device_event)
 782                 return;
 783
 784         post_base_event(device,
 785                         LIBINPUT_EVENT_DEVICE_ADDED,
 786                         &added_device_event->base);
 787 }
 788
 789 void
 790 notify_removed_device(struct libinput_device *device)
 791 {
 792         struct libinput_event_device_notify *removed_device_event;
 793
 794         removed_device_event = zalloc(sizeof *removed_device_event);
 795         if (!removed_device_event)
 796                 return;
 797
 798         post_base_event(device,
 799                         LIBINPUT_EVENT_DEVICE_REMOVED,
 800                         &removed_device_event->base);
 801 }
 802
 803 void
 804 keyboard_notify_key(struct libinput_device *device,
 805                     uint32_t time,
 806                     uint32_t key,
 807                     enum libinput_keyboard_key_state state)
 808 {
 809         struct libinput_event_keyboard *key_event;
 810         uint32_t seat_key_count;
 811
 812         key_event = zalloc(sizeof *key_event);
 813         if (!key_event)
 814                 return;
 815
 816         seat_key_count = update_seat_key_count(device->seat, key, state);
 817
 818         *key_event = (struct libinput_event_keyboard) {
 819                 .time = time,
 820                 .key = key,
 821                 .state = state,
 822                 .seat_key_count = seat_key_count,
 823         };
 824
 825         post_device_event(device,
 826                           LIBINPUT_EVENT_KEYBOARD_KEY,
 827                           &key_event->base);
 828 }
 829
 830 void
 831 pointer_notify_motion(struct libinput_device *device,
 832                       uint32_t time,
 833                       double dx,
 834                       double dy)
 835 {
 836         struct libinput_event_pointer *motion_event;
 837
 838         motion_event = zalloc(sizeof *motion_event);
 839         if (!motion_event)
 840                 return;
 841
 842         *motion_event = (struct libinput_event_pointer) {
 843                 .time = time,
 844                 .x = dx,
 845                 .y = dy,
 846         };
 847
 848         post_device_event(device,
 849                           LIBINPUT_EVENT_POINTER_MOTION,
 850                           &motion_event->base);
 851 }
 852
 853 void
 854 pointer_notify_motion_absolute(struct libinput_device *device,
 855                                uint32_t time,
 856                                double x,
 857                                double y)
 858 {
 859         struct libinput_event_pointer *motion_absolute_event;
 860
 861         motion_absolute_event = zalloc(sizeof *motion_absolute_event);
 862         if (!motion_absolute_event)
 863                 return;
 864
 865         *motion_absolute_event = (struct libinput_event_pointer) {
 866                 .time = time,
 867                 .x = x,
 868                 .y = y,
 869         };
 870
 871         post_device_event(device,
 872                           LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE,
 873                           &motion_absolute_event->base);
 874 }
 875
 876 void
 877 pointer_notify_button(struct libinput_device *device,
 878                       uint32_t time,
 879                       int32_t button,
 880                       enum libinput_button_state state)
 881 {
 882         struct libinput_event_pointer *button_event;
 883         int32_t seat_button_count;
 884
 885         button_event = zalloc(sizeof *button_event);
 886         if (!button_event)
 887                 return;
 888
 889         seat_button_count = update_seat_button_count(device->seat,
 890                                                      button,
 891                                                      state);
 892
 893         *button_event = (struct libinput_event_pointer) {
 894                 .time = time,
 895                 .button = button,
 896                 .state = state,
 897                 .seat_button_count = seat_button_count,
 898         };
 899
 900         post_device_event(device,
 901                           LIBINPUT_EVENT_POINTER_BUTTON,
 902                           &button_event->base);
 903 }
 904
 905 void
 906 pointer_notify_axis(struct libinput_device *device,
 907                     uint32_t time,
 908                     enum libinput_pointer_axis axis,
 909                     double value)
 910 {
 911         struct libinput_event_pointer *axis_event;
 912
 913         axis_event = zalloc(sizeof *axis_event);
 914         if (!axis_event)
 915                 return;
 916
 917         *axis_event = (struct libinput_event_pointer) {
 918                 .time = time,
 919                 .axis = axis,
 920                 .value = value,
 921         };
 922
 923         post_device_event(device,
 924                           LIBINPUT_EVENT_POINTER_AXIS,
 925                           &axis_event->base);
 926 }
 927
 928 void
 929 touch_notify_touch_down(struct libinput_device *device,
 930                         uint32_t time,
 931                         int32_t slot,
 932                         int32_t seat_slot,
 933                         double x,
 934                         double y)
 935 {
 936         struct libinput_event_touch *touch_event;
 937
 938         touch_event = zalloc(sizeof *touch_event);
 939         if (!touch_event)
 940                 return;
 941
 942         *touch_event = (struct libinput_event_touch) {
 943                 .time = time,
 944                 .slot = slot,
 945                 .seat_slot = seat_slot,
 946                 .x = x,
 947                 .y = y,
 948         };
 949
 950         post_device_event(device,
 951                           LIBINPUT_EVENT_TOUCH_DOWN,
 952                           &touch_event->base);
 953 }
 954
 955 void
 956 touch_notify_touch_motion(struct libinput_device *device,
 957                           uint32_t time,
 958                           int32_t slot,
 959                           int32_t seat_slot,
 960                           double x,
 961                           double y)
 962 {
 963         struct libinput_event_touch *touch_event;
 964
 965         touch_event = zalloc(sizeof *touch_event);
 966         if (!touch_event)
 967                 return;
 968
 969         *touch_event = (struct libinput_event_touch) {
 970                 .time = time,
 971                 .slot = slot,
 972                 .seat_slot = seat_slot,
 973                 .x = x,
 974                 .y = y,
 975         };
 976
 977         post_device_event(device,
 978                           LIBINPUT_EVENT_TOUCH_MOTION,
 979                           &touch_event->base);
 980 }
 981
 982 void
 983 touch_notify_touch_up(struct libinput_device *device,
 984                       uint32_t time,
 985                       int32_t slot,
 986                       int32_t seat_slot)
 987 {
 988         struct libinput_event_touch *touch_event;
 989
 990         touch_event = zalloc(sizeof *touch_event);
 991         if (!touch_event)
 992                 return;
 993
 994         *touch_event = (struct libinput_event_touch) {
 995                 .time = time,
 996                 .slot = slot,
 997                 .seat_slot = seat_slot,
 998         };
 999
1000         post_device_event(device,
1001                           LIBINPUT_EVENT_TOUCH_UP,
1002                           &touch_event->base);
1003 }
1004
1005 void
1006 touch_notify_frame(struct libinput_device *device,
1007                    uint32_t time)
1008 {
1009         struct libinput_event_touch *touch_event;
1010
1011         touch_event = zalloc(sizeof *touch_event);
1012         if (!touch_event)
1013                 return;
1014
1015         *touch_event = (struct libinput_event_touch) {
1016                 .time = time,
1017         };
1018
1019         post_device_event(device,
1020                           LIBINPUT_EVENT_TOUCH_FRAME,
1021                           &touch_event->base);
1022 }
1023
1024
1025 static void
1026 libinput_post_event(struct libinput *libinput,
1027                     struct libinput_event *event)
1028 {
1029         struct libinput_event **events = libinput->events;
1030         size_t events_len = libinput->events_len;
1031         size_t events_count = libinput->events_count;
1032         size_t move_len;
1033         size_t new_out;
1034
1035         events_count++;
1036         if (events_count > events_len) {
1037                 events_len *= 2;
1038                 events = realloc(events, events_len * sizeof *events);
1039                 if (!events) {
1040                         fprintf(stderr, "Failed to reallocate event ring "
1041                                 "buffer");
1042                         return;
1043                 }
1044
1045                 if (libinput->events_count > 0 && libinput->events_in == 0) {
1046                         libinput->events_in = libinput->events_len;
1047                 } else if (libinput->events_count > 0 &&
1048                            libinput->events_out >= libinput->events_in) {
1049                         move_len = libinput->events_len - libinput->events_out;
1050                         new_out = events_len - move_len;
1051                         memmove(events + new_out,
1052                                 events + libinput->events_out,
1053                                 move_len * sizeof *events);
1054                         libinput->events_out = new_out;
1055                 }
1056
1057                 libinput->events = events;
1058                 libinput->events_len = events_len;
1059         }
1060
1061         if (event->device)
1062                 libinput_device_ref(event->device);
1063
1064         libinput->events_count = events_count;
1065         events[libinput->events_in] = event;
1066         libinput->events_in = (libinput->events_in + 1) % libinput->events_len;
1067 }
1068
1069 LIBINPUT_EXPORT struct libinput_event *
1070 libinput_get_event(struct libinput *libinput)
1071 {
1072         struct libinput_event *event;
1073
1074         if (libinput->events_count == 0)
1075                 return NULL;
1076
1077         event = libinput->events[libinput->events_out];
1078         libinput->events_out =
1079                 (libinput->events_out + 1) % libinput->events_len;
1080         libinput->events_count--;
1081
1082         return event;
1083 }
1084
1085 LIBINPUT_EXPORT enum libinput_event_type
1086 libinput_next_event_type(struct libinput *libinput)
1087 {
1088         struct libinput_event *event;
1089
1090         if (libinput->events_count == 0)
1091                 return LIBINPUT_EVENT_NONE;
1092
1093         event = libinput->events[libinput->events_out];
1094         return event->type;
1095 }
1096
1097 LIBINPUT_EXPORT void *
1098 libinput_get_user_data(struct libinput *libinput)
1099 {
1100         return libinput->user_data;
1101 }
1102
1103 LIBINPUT_EXPORT int
1104 libinput_resume(struct libinput *libinput)
1105 {
1106         return libinput->interface_backend->resume(libinput);
1107 }
1108
1109 LIBINPUT_EXPORT void
1110 libinput_suspend(struct libinput *libinput)
1111 {
1112         libinput->interface_backend->suspend(libinput);
1113 }
1114
1115 LIBINPUT_EXPORT void
1116 libinput_device_set_user_data(struct libinput_device *device, void *user_data)
1117 {
1118         device->user_data = user_data;
1119 }
1120
1121 LIBINPUT_EXPORT void *
1122 libinput_device_get_user_data(struct libinput_device *device)
1123 {
1124         return device->user_data;
1125 }
1126
1127 LIBINPUT_EXPORT const char *
1128 libinput_device_get_sysname(struct libinput_device *device)
1129 {
1130         return evdev_device_get_sysname((struct evdev_device *) device);
1131 }
1132
1133 LIBINPUT_EXPORT const char *
1134 libinput_device_get_output_name(struct libinput_device *device)
1135 {
1136         return evdev_device_get_output((struct evdev_device *) device);
1137 }
1138
1139 LIBINPUT_EXPORT struct libinput_seat *
1140 libinput_device_get_seat(struct libinput_device *device)
1141 {
1142         return device->seat;
1143 }
1144
1145 LIBINPUT_EXPORT void
1146 libinput_device_led_update(struct libinput_device *device,
1147                            enum libinput_led leds)
1148 {
1149         evdev_device_led_update((struct evdev_device *) device, leds);
1150 }
1151
1152 LIBINPUT_EXPORT int
1153 libinput_device_get_keys(struct libinput_device *device,
1154                          char *keys, size_t size)
1155 {
1156         return evdev_device_get_keys((struct evdev_device *) device,
1157                                      keys,
1158                                      size);
1159 }
1160
1161 LIBINPUT_EXPORT void
1162 libinput_device_calibrate(struct libinput_device *device,
1163                           float calibration[6])
1164 {
1165         evdev_device_calibrate((struct evdev_device *) device, calibration);
1166 }
1167
1168 LIBINPUT_EXPORT int
1169 libinput_device_has_capability(struct libinput_device *device,
1170                                enum libinput_device_capability capability)
1171 {
1172         return evdev_device_has_capability((struct evdev_device *) device,
1173                                            capability);
1174 }
1175
1176 LIBINPUT_EXPORT struct libinput_event *
1177 libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event)
1178 {
1179         return &event->base;
1180 }
1181
1182 LIBINPUT_EXPORT struct libinput_event *
1183 libinput_event_keyboard_get_base_event(struct libinput_event_keyboard *event)
1184 {
1185         return &event->base;
1186 }
1187
1188 LIBINPUT_EXPORT struct libinput_event *
1189 libinput_event_pointer_get_base_event(struct libinput_event_pointer *event)
1190 {
1191         return &event->base;
1192 }
1193
1194 LIBINPUT_EXPORT struct libinput_event *
1195 libinput_event_touch_get_base_event(struct libinput_event_touch *event)
1196 {
1197         return &event->base;
1198 }