examples/tinyds-tdm-libinput.c

   1 #include <assert.h>
   2 #include <stdbool.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <signal.h>
   6 #include <time.h>
   7
   8 #include <drm_fourcc.h>
   9 #include <pixman.h>
  10 #include <wayland-server.h>
  11 #include <libds/log.h>
  12 #include <libds/backend.h>
  13 #include <libds/output.h>
  14 #include <libds/compositor.h>
  15 #include <libds/xdg_shell.h>
  16 #include <libds-tizen/allocator/tbm.h>
  17 #include <libds-tizen/backend/tdm.h>
  18 #include <libds/backend/libinput.h>
  19 #include <libds-tizen/tbm_server.h>
  20
  21 #include <libds/input_device.h>
  22 #include <libds/keyboard.h>
  23 #include <libds/touch.h>
  24 #include <libds/pointer.h>
  25 #include <libds/seat.h>
  26 #include <libds-tizen/input-devicemgr.h>
  27 #include <xkbcommon/xkbcommon.h>
  28 #include <libds/interfaces/keyboard.h>
  29
  30 #define USE_TDM_BUFFER_QUEUE
  31
  32 #ifdef USE_TDM_BUFFER_QUEUE
  33 #include "pixman-tbm-helper.h"
  34 #include "tinyds-tdm-renderer.h"
  35 #else
  36 #include <libds/swapchain.h>
  37 #endif
  38
  39 #include "pixman-helper.h"
  40
  41 #define TINYDS_UNUSED   __attribute__((unused))
  42 struct tinyds_keyboard;
  43
  44 struct tinyds_output
  45 {
  46     struct tinyds_server *server;
  47     struct ds_output *ds_output;
  48     struct ds_allocator *allocator;
  49 #ifdef USE_TDM_BUFFER_QUEUE
  50     struct tinyds_renderer renderer;
  51     struct ds_tdm_buffer_queue *buffer_queue;
  52     struct wl_listener buffer_queue_acquirable;
  53 #else
  54     struct ds_swapchain *swapchain;
  55 #endif
  56     struct ds_buffer *front_buffer;
  57
  58     struct wl_listener output_destroy;
  59     struct wl_listener output_frame;
  60
  61     int width, height;
  62
  63     bool drawable;
  64     bool damaged;
  65 };
  66
  67 struct tinyds_server
  68 {
  69     struct ds_tbm_server *tbm_server;
  70
  71     struct wl_display *display;
  72
  73     struct ds_backend *backend;
  74     struct ds_backend *input_backend;
  75     struct ds_compositor *compositor;
  76     struct ds_xdg_shell *xdg_shell;
  77     struct ds_seat *seat;
  78     uint32_t seat_caps;
  79     double output_x, output_y;
  80     struct ds_tizen_input_devicemgr *devicemgr;
  81
  82     struct tinyds_output *output;
  83     struct wl_event_source *stdin_source;
  84
  85     struct wl_list views;
  86
  87     struct wl_listener new_output;
  88     struct wl_listener new_input;
  89     struct wl_listener new_xdg_surface;
  90
  91     struct tinyds_keyboard *keyboard;
  92 };
  93
  94 struct tinyds_view
  95 {
  96     struct tinyds_server *server;
  97
  98     struct tinyds_texture *texture;
  99     struct ds_xdg_surface *xdg_surface;
 100
 101     struct wl_listener xdg_surface_map;
 102     struct wl_listener xdg_surface_unmap;
 103     struct wl_listener xdg_surface_destroy;
 104     struct wl_listener surface_commit;
 105     struct wl_list link; // tinyds_server::views
 106
 107     int x, y;
 108     bool mapped;
 109 };
 110
 111 struct tinyds_pointer
 112 {
 113     struct ds_input_device *dev;
 114     struct tinyds_server *server;
 115
 116     struct tinyds_view *focused_view;
 117
 118     struct wl_listener destroy;
 119     struct wl_listener motion; //relative
 120     struct wl_listener button;
 121     struct wl_listener frame;
 122 };
 123
 124 struct tinyds_keyboard
 125 {
 126     struct ds_input_device *dev;
 127     struct tinyds_server *server;
 128
 129     struct wl_listener destroy;
 130     struct wl_listener key;
 131 };
 132
 133 struct tinyds_touch
 134 {
 135     struct ds_input_device *dev;
 136     struct tinyds_server *server;
 137
 138     struct wl_listener destroy;
 139     struct wl_listener down;
 140     struct wl_listener up;
 141     struct wl_listener motion;
 142 };
 143
 144 struct tinyds_server tinyds;
 145
 146 static bool init_server(struct tinyds_server *server, struct wl_display *display);
 147 static int server_dispatch_stdin(int fd, uint32_t mask, void *data);
 148 static void output_handle_destroy(struct wl_listener *listener, void *data);
 149 static void output_handle_frame(struct wl_listener *listener, void *data);
 150 static void draw_server_with_damage(struct tinyds_server *server);
 151 static void draw_output(struct tinyds_output *output);
 152 static void output_swap_buffer(struct tinyds_output *output,
 153         struct ds_buffer *buffer);
 154 static void view_send_frame_done(struct tinyds_view *view);
 155 #ifdef USE_TDM_BUFFER_QUEUE
 156 static void output_buffer_queue_init(struct tinyds_output *output);
 157 static void output_renderer_init(struct tinyds_output *output);
 158 static void output_draw_with_renderer(struct tinyds_output *output);
 159 #else
 160 static void output_swapchain_init(struct tinyds_output *output,
 161         int width, int height, uint32_t format);
 162 static void output_draw_with_swapchain(struct tinyds_output *output);
 163 static void draw_view(struct tinyds_view *view, pixman_image_t *dst_image);
 164 #endif
 165 static void server_add_keyboard(struct tinyds_server *server,
 166         struct ds_input_device *dev);
 167 static void server_add_pointer(struct tinyds_server *server,
 168         struct ds_input_device *dev);
 169 static void server_add_touch(struct tinyds_server *server,
 170         struct ds_input_device *dev);
 171
 172 int
 173 main(void)
 174 {
 175     struct tinyds_server *server = &tinyds;
 176     struct wl_display *display;
 177     struct wl_event_loop *loop;
 178     const char *socket;
 179     bool res;
 180
 181     ds_log_init(DS_INF, NULL);
 182
 183     display = wl_display_create();
 184     assert(display);
 185
 186     res = init_server(server, display);
 187     assert(res);
 188
 189     socket = wl_display_add_socket_auto(display);
 190     assert(socket);
 191
 192     ds_backend_start(server->backend);
 193     ds_backend_start(server->input_backend);
 194
 195     setenv("WAYLAND_DISPLAY", socket, true);
 196
 197     ds_inf("Running Wayland compositor on WAYLAND_DISPLAY=%s", socket);
 198
 199     loop = wl_display_get_event_loop(display);
 200     server->stdin_source = wl_event_loop_add_fd(loop, STDIN_FILENO,
 201             WL_EVENT_READABLE, server_dispatch_stdin, server);
 202
 203     wl_display_run(display);
 204
 205     wl_display_destroy_clients(display);
 206     wl_display_destroy(display);
 207
 208     return 0;
 209 }
 210
 211 static void
 212 view_handle_xdg_surface_map(struct wl_listener *listener,
 213         void *data TINYDS_UNUSED)
 214 {
 215     struct tinyds_view *view;
 216     struct ds_keyboard *keyboard;
 217     view = wl_container_of(listener, view, xdg_surface_map);
 218     view->mapped = true;
 219
 220     if (!view->server->keyboard) return;
 221     keyboard = ds_input_device_get_keyboard(view->server->keyboard->dev);
 222     if (keyboard != NULL) {
 223         ds_seat_keyboard_notify_enter(view->server->seat,
 224                 ds_xdg_surface_get_surface(view->xdg_surface),
 225                 keyboard->keycodes, keyboard->num_keycodes,
 226                 &keyboard->modifiers);
 227     }
 228 }
 229
 230 static void
 231 view_handle_xdg_surface_unmap(struct wl_listener *listener,
 232         void *data TINYDS_UNUSED)
 233 {
 234     struct tinyds_view *view;
 235
 236     view = wl_container_of(listener, view, xdg_surface_unmap);
 237     view->mapped = false;
 238 }
 239
 240 static void
 241 view_handle_xdg_surface_destroy(struct wl_listener *listener,
 242         void *data TINYDS_UNUSED)
 243 {
 244     struct tinyds_view *view;
 245     struct tinyds_server *server;
 246
 247     view = wl_container_of(listener, view, xdg_surface_destroy);
 248     server = view->server;
 249
 250     wl_list_remove(&view->xdg_surface_destroy.link);
 251     wl_list_remove(&view->xdg_surface_map.link);
 252     wl_list_remove(&view->xdg_surface_unmap.link);
 253     wl_list_remove(&view->surface_commit.link);
 254     wl_list_remove(&view->link);
 255     free(view);
 256
 257     draw_server_with_damage(server);
 258 }
 259
 260 static void
 261 view_handle_surface_commit(struct wl_listener *listener,
 262         void *data TINYDS_UNUSED)
 263 {
 264     struct tinyds_view *view;
 265
 266     view = wl_container_of(listener, view, surface_commit);
 267     draw_server_with_damage(view->server);
 268 }
 269
 270 static void
 271 server_new_xdg_surface(struct wl_listener *listener, void *data)
 272 {
 273     struct tinyds_server *server;
 274     struct tinyds_view *view;
 275     struct ds_xdg_surface *xdg_surface;
 276
 277     server = wl_container_of(listener, server, new_xdg_surface);
 278     xdg_surface = data;
 279
 280     ds_inf("New xdg_surface(%p)", (void *)xdg_surface);
 281
 282     view = calloc(1, sizeof *view);
 283     assert(view);
 284
 285     view->server = server;
 286     view->xdg_surface = xdg_surface;
 287
 288     view->xdg_surface_map.notify = view_handle_xdg_surface_map;
 289     ds_xdg_surface_add_map_listener(xdg_surface,
 290             &view->xdg_surface_map);
 291
 292     view->xdg_surface_unmap.notify = view_handle_xdg_surface_unmap;
 293     ds_xdg_surface_add_unmap_listener(xdg_surface,
 294             &view->xdg_surface_unmap);
 295
 296     view->xdg_surface_destroy.notify = view_handle_xdg_surface_destroy;
 297     ds_xdg_surface_add_destroy_listener(xdg_surface,
 298             &view->xdg_surface_destroy);
 299
 300     view->surface_commit.notify = view_handle_surface_commit;
 301     ds_surface_add_commit_listener(
 302             ds_xdg_surface_get_surface(xdg_surface),
 303             &view->surface_commit);
 304
 305     wl_list_insert(server->views.prev, &view->link);
 306
 307     view->x = rand() % 1000;
 308     view->y = rand() % 500;
 309 }
 310
 311 static void
 312 backend_handle_new_output(struct wl_listener *listener, void *data)
 313 {
 314     struct tinyds_server *server;
 315     struct tinyds_output *output;
 316     struct ds_output *ds_output;
 317     const struct ds_output_mode *mode;
 318
 319     server = wl_container_of(listener, server, new_output);
 320     ds_output = data;
 321
 322     ds_inf("New output(%p)", ds_output);
 323
 324     if (server->output)
 325         return;
 326
 327     mode = ds_output_get_preferred_mode(ds_output);
 328     ds_output_set_mode(ds_output, mode);
 329
 330     output = calloc(1, sizeof *output);
 331     if (!output)
 332         return;
 333
 334     output->server = server;
 335     output->ds_output = ds_output;
 336     output->width = mode->width;
 337     output->height = mode->height;
 338     output->drawable = true;
 339     output->damaged = true;
 340
 341 #ifdef USE_TDM_BUFFER_QUEUE
 342     output_buffer_queue_init(output);
 343     output_renderer_init(output);
 344 #else
 345     output_swapchain_init(output, mode->width, mode->height,
 346             DRM_FORMAT_XRGB8888);
 347 #endif
 348
 349     output->output_destroy.notify = output_handle_destroy;
 350     ds_output_add_destroy_listener(ds_output, &output->output_destroy);
 351
 352     output->output_frame.notify = output_handle_frame;
 353     ds_output_add_frame_listener(ds_output, &output->output_frame);
 354
 355     ds_tizen_input_devicemgr_set_output_width_height(server->devicemgr, (uint32_t)output->width, (uint32_t)output->height);
 356
 357     server->output = output;
 358
 359     draw_output(output);
 360 }
 361
 362 static void
 363 backend_handle_new_input(struct wl_listener *listener, void *data)
 364 {
 365     struct tinyds_server *server;
 366     struct ds_input_device *dev = data;
 367     enum ds_input_device_type dev_type;
 368
 369     server = wl_container_of(listener, server, new_input);
 370
 371     dev_type = ds_input_device_get_type(dev);
 372
 373     switch (dev_type) {
 374         case DS_INPUT_DEVICE_KEYBOARD:
 375             server_add_keyboard(server, dev);
 376             server->seat_caps |= WL_SEAT_CAPABILITY_KEYBOARD;
 377             break;
 378         case DS_INPUT_DEVICE_TOUCH:
 379             server_add_touch(server, dev);
 380             server->seat_caps |= WL_SEAT_CAPABILITY_TOUCH;
 381             break;
 382         case DS_INPUT_DEVICE_POINTER:
 383             server_add_pointer(server, dev);
 384             server->seat_caps |= WL_SEAT_CAPABILITY_POINTER;
 385             break;
 386         default:
 387             ds_err("Unknown type(%d) of ds_input_device", dev_type);
 388             break;
 389     }
 390
 391     ds_seat_set_capabilities(server->seat, server->seat_caps);
 392 }
 393
 394 static void
 395 devicemgr_add_keymap_data(struct wl_list *list, const char *name, int keycode)
 396 {
 397     struct ds_tizen_input_devicemgr_keymap_data *data;
 398
 399     data = calloc(1, sizeof *data);
 400     if (!data) {
 401         ds_err("Failed to alloc memory\n");
 402         return;
 403     }
 404
 405     data->name = strdup(name);
 406     data->keycode = keycode;
 407
 408     wl_list_insert(list, &data->link);
 409 }
 410
 411 static void
 412 devicemgr_remove_keymap_data(struct wl_list *list, int keycode)
 413 {
 414     struct ds_tizen_input_devicemgr_keymap_data *data, *tmp;
 415
 416     wl_list_for_each_safe(data, tmp, list, link) {
 417         if (data->keycode == keycode) {
 418             wl_list_remove(&data->link);
 419             free(data);
 420         }
 421     }
 422 }
 423
 424 static void
 425 devicemgr_set_keymap(struct ds_tizen_input_devicemgr *devicemgr)
 426 {
 427     struct wl_list keymap_list;
 428     bool res;
 429
 430     wl_list_init(&keymap_list);
 431
 432     devicemgr_add_keymap_data(&keymap_list, "XF86VolumeRaise", 455);
 433     devicemgr_add_keymap_data(&keymap_list, "XF86VolumeLower", 456);
 434     devicemgr_add_keymap_data(&keymap_list, "XF86LightOn", 457);
 435     devicemgr_add_keymap_data(&keymap_list, "XF86LightOff", 458);
 436
 437     res = ds_tizen_input_devicemgr_set_keymap_list(devicemgr, &keymap_list);
 438     if (!res)
 439         ds_inf("Failed to set keymap");
 440
 441     devicemgr_remove_keymap_data(&keymap_list, 455);
 442     devicemgr_remove_keymap_data(&keymap_list, 456);
 443     devicemgr_remove_keymap_data(&keymap_list, 457);
 444     devicemgr_remove_keymap_data(&keymap_list, 458);
 445 }
 446
 447 static bool
 448 init_server(struct tinyds_server *server, struct wl_display *display)
 449 {
 450     server->display = display;
 451
 452     wl_list_init(&server->views);
 453
 454     if (wl_display_init_shm(display) != 0)
 455         return false;
 456
 457     server->backend = ds_tdm_backend_create(display);
 458     if (!server->backend)
 459         return false;
 460
 461     server->input_backend = ds_libinput_backend_create(display);
 462     if (!server->input_backend) {
 463         ds_backend_destroy(server->backend);
 464         return false;
 465     }
 466
 467     server->new_output.notify = backend_handle_new_output;
 468     ds_backend_add_new_output_listener(server->backend,
 469             &server->new_output);
 470
 471     server->new_input.notify = backend_handle_new_input;
 472     ds_backend_add_new_input_listener(server->input_backend, &server->new_input);
 473
 474     server->compositor = ds_compositor_create(display);
 475     if (!server->compositor)
 476         goto err;
 477
 478     server->tbm_server = ds_tbm_server_create(display);
 479     if (!server->tbm_server)
 480         goto err;
 481
 482     server->xdg_shell = ds_xdg_shell_create(display);
 483     if (!server->xdg_shell)
 484         goto err;
 485
 486     server->new_xdg_surface.notify = server_new_xdg_surface;
 487     ds_xdg_shell_add_new_surface_listener(server->xdg_shell,
 488             &server->new_xdg_surface);
 489
 490     server->seat = ds_seat_create(display, "seat0" /* arbitrary name */);
 491     if (!server->seat)
 492         goto err;
 493     server->seat_caps = 0;
 494
 495     server->devicemgr = ds_tizen_input_devicemgr_create(
 496             server->input_backend, server->seat);
 497     if (!server->devicemgr) {
 498         goto err;
 499     }
 500
 501     devicemgr_set_keymap(server->devicemgr);
 502     return true;
 503
 504 err:
 505     ds_backend_destroy(server->backend);
 506     ds_backend_destroy(server->input_backend);
 507
 508     return false;
 509 }
 510
 511 static void
 512 output_handle_destroy(struct wl_listener *listener, void *data TINYDS_UNUSED)
 513 {
 514     struct tinyds_output *output =
 515         wl_container_of(listener, output, output_destroy);
 516
 517     wl_list_remove(&output->output_destroy.link);
 518     wl_list_remove(&output->output_frame.link);
 519
 520     if (output->front_buffer)
 521         ds_buffer_unlock(output->front_buffer);
 522
 523 #ifdef USE_TDM_BUFFER_QUEUE
 524     fini_renderer(&output->renderer);
 525 #else
 526     if (output->swapchain)
 527         ds_swapchain_destroy(output->swapchain);
 528
 529     if (output->allocator)
 530         ds_allocator_destroy(output->allocator);
 531 #endif
 532
 533     wl_display_terminate(output->server->display);
 534
 535     output->server->output = NULL;
 536
 537     free(output);
 538 }
 539
 540 static void
 541 output_handle_frame(struct wl_listener *listener, void *data TINYDS_UNUSED)
 542 {
 543     struct tinyds_output *output =
 544         wl_container_of(listener, output, output_frame);
 545
 546     output->drawable = true;
 547     draw_output(output);
 548 }
 549
 550 static void
 551 draw_server_with_damage(struct tinyds_server *server)
 552 {
 553     server->output->damaged = true;
 554     draw_output(server->output);
 555 }
 556
 557 #ifdef USE_TDM_BUFFER_QUEUE
 558 static void
 559 output_handle_buffer_queue_acquirable(struct wl_listener *listener,
 560         void *data TINYDS_UNUSED)
 561 {
 562     struct tinyds_output *output;
 563     struct ds_buffer *buffer;
 564
 565     output = wl_container_of(listener, output, buffer_queue_acquirable);
 566
 567     buffer = ds_tdm_buffer_queue_acquire(output->buffer_queue);
 568     assert(buffer);
 569
 570     output_swap_buffer(output, buffer);
 571 }
 572
 573 static void
 574 output_buffer_queue_init(struct tinyds_output *output)
 575 {
 576     struct ds_tdm_output *tdm_output;
 577
 578     tdm_output = ds_tdm_output_from_output(output->ds_output);
 579     assert(tdm_output);
 580
 581     output->buffer_queue = ds_tdm_output_get_buffer_queue(tdm_output);
 582     assert(output->buffer_queue);
 583
 584     output->buffer_queue_acquirable.notify =
 585         output_handle_buffer_queue_acquirable;
 586     ds_tdm_buffer_queue_add_acquirable_listener(output->buffer_queue,
 587             &output->buffer_queue_acquirable);
 588 }
 589
 590 static void
 591 output_renderer_init(struct tinyds_output *output)
 592 {
 593     init_renderer(&output->renderer);
 594
 595     renderer_set_surface_queue(&output->renderer,
 596             ds_tdm_buffer_queue_get_native_queue(output->buffer_queue));
 597
 598     renderer_set_bg_color(&output->renderer, 80, 80, 80);
 599 }
 600
 601 static void
 602 output_draw_with_renderer(struct tinyds_output *output)
 603 {
 604     struct tinyds_view *view;
 605
 606     ds_dbg(">> BEGIN UPDATE TEXTURES");
 607
 608     wl_list_for_each(view, &output->server->views, link) {
 609         struct ds_buffer *ds_buffer;
 610         struct ds_tbm_client_buffer *tbm_buffer;
 611         tbm_surface_h surface;
 612
 613         if (!view->mapped)
 614             continue;
 615
 616         ds_buffer = ds_surface_get_buffer(
 617                 ds_xdg_surface_get_surface(view->xdg_surface));
 618         assert(ds_buffer);
 619
 620         tbm_buffer = ds_tbm_client_buffer_from_buffer(ds_buffer);
 621         assert(tbm_buffer);
 622
 623         surface = ds_tbm_client_buffer_get_tbm_surface(tbm_buffer);
 624
 625         renderer_add_texture(&output->renderer, surface, view->x, view->y);
 626
 627         view_send_frame_done(view);
 628     }
 629
 630     ds_dbg("<< END UPDATE TEXTURES");
 631
 632     renderer_draw(&output->renderer);
 633
 634 }
 635 #else
 636 static void
 637 output_swapchain_init(struct tinyds_output *output,
 638         int width, int height, uint32_t format);
 639
 640 {
 641     output->allocator = ds_tbm_allocator_create();
 642     assert(output->allocator);
 643
 644     output->swapchain = ds_swapchain_create(output->allocator,
 645             width, height, format);
 646     assert(output->swapchain);
 647 }
 648
 649 static void
 650 output_draw_with_swapchain(struct tinyds_output *output)
 651 {
 652     struct tinyds_view *view;
 653     struct ds_buffer *output_buffer;
 654     pixman_image_t *output_image;
 655
 656     output_buffer = ds_swapchain_acquire(output->swapchain, NULL);
 657     if (!output_buffer)
 658         return;
 659
 660     output_image = pixman_image_from_buffer(output_buffer,
 661             DS_BUFFER_DATA_PTR_ACCESS_WRITE);
 662     if (!output_image) {
 663         ds_buffer_unlock(output_buffer);
 664         return;
 665     }
 666
 667     pixman_image_fill_color(output_image, 80, 80, 80);
 668
 669     wl_list_for_each(view, &output->server->views, link) {
 670         if (!view->mapped)
 671             continue;
 672         draw_view(view, output_image);
 673     }
 674     pixman_image_unref(output_image);
 675
 676     output_swap_buffer(output, output_buffer);
 677 }
 678
 679 static void
 680 draw_view(struct tinyds_view *view, pixman_image_t *dst_image)
 681 {
 682     struct ds_buffer *buffer;
 683     pixman_image_t *src_image;
 684
 685     buffer = ds_surface_get_buffer(
 686             ds_xdg_surface_get_surface(view->xdg_surface));
 687     if (!buffer)
 688         return;
 689
 690     src_image = pixman_image_from_buffer(buffer,
 691             DS_BUFFER_DATA_PTR_ACCESS_READ);
 692     pixman_image_composite32(PIXMAN_OP_OVER,
 693             src_image,
 694             NULL,
 695             dst_image,
 696             0, 0, 0, 0,
 697             view->x, view->y,
 698             pixman_image_get_width(src_image),
 699             pixman_image_get_height(src_image));
 700     pixman_image_unref(src_image);
 701
 702     view_send_frame_done(view);
 703 }
 704 #endif
 705
 706 static void
 707 draw_output(struct tinyds_output *output)
 708 {
 709
 710     if (!output->drawable || !output->damaged)
 711         return;
 712
 713 #ifdef USE_TDM_BUFFER_QUEUE
 714     output_draw_with_renderer(output);
 715 #else
 716     output_draw_with_swapchain(output);
 717 #endif
 718
 719     output->drawable = false;
 720     output->damaged = false;
 721 }
 722
 723 static void
 724 output_swap_buffer(struct tinyds_output *output, struct ds_buffer *buffer)
 725 {
 726     ds_output_attach_buffer(output->ds_output, buffer);
 727     ds_output_commit(output->ds_output);
 728
 729     if (output->front_buffer)
 730         ds_buffer_unlock(output->front_buffer);
 731     output->front_buffer = buffer;
 732 }
 733
 734 static void
 735 view_send_frame_done(struct tinyds_view *view)
 736 {
 737     struct timespec now;
 738     clock_gettime(CLOCK_MONOTONIC, &now);
 739     ds_surface_send_frame_done(ds_xdg_surface_get_surface(view->xdg_surface),
 740             &now);
 741 }
 742
 743 static int
 744 server_dispatch_stdin(int fd, uint32_t mask, void *data)
 745 {
 746     struct tinyds_server *server = data;
 747
 748     wl_display_terminate(server->display);
 749
 750     return 1;
 751 }
 752
 753
 754 static void
 755 keyboard_handle_device_destroy(struct wl_listener *listener, void *data)
 756 {
 757     struct tinyds_keyboard *kbd;
 758
 759     kbd = wl_container_of(listener, kbd, destroy);
 760
 761     ds_inf("Keyboard(%p) destroyed", kbd);
 762
 763     wl_list_remove(&kbd->destroy.link);
 764     wl_list_remove(&kbd->key.link);
 765
 766     kbd->server->keyboard = NULL;
 767
 768     free(kbd);
 769 }
 770
 771 static bool
 772 server_handle_keybinding(struct tinyds_server *server, xkb_keysym_t sym)
 773 {
 774     switch (sym) {
 775         case XKB_KEY_BackSpace:
 776             wl_display_terminate(server->display);
 777             break;
 778         default:
 779             return false;
 780     }
 781
 782     return true;
 783 }
 784
 785 static void
 786 keyboard_handle_key(struct wl_listener *listener, void *data)
 787 {
 788     struct tinyds_keyboard *kbd;
 789     struct ds_event_keyboard_key *event = data;
 790     struct ds_keyboard *ds_keyboard;
 791     struct xkb_state *xkb_state;
 792     const xkb_keysym_t *syms;
 793     int nsyms;
 794     bool handled = false;
 795
 796     kbd = wl_container_of(listener, kbd, key);
 797
 798     ds_inf("Keyboard(%p) event key: keycode(%d), state(%d), time_msec(%d), "
 799             "update_state(%d)", kbd->dev,
 800             event->keycode, event->state, event->time_msec,
 801             event->update_state);
 802
 803     ds_keyboard = ds_input_device_get_keyboard(kbd->dev);
 804
 805     if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
 806         xkb_state = ds_keyboard_get_xkb_state(ds_keyboard);
 807         if (xkb_state) {
 808             nsyms = xkb_state_key_get_syms(xkb_state, event->keycode + 8,
 809                     &syms);
 810             for (int i = 0; i < nsyms; i++) {
 811                 handled = server_handle_keybinding(kbd->server, syms[i]);
 812             }
 813         }
 814     }
 815
 816     if (!handled) {
 817         ds_seat_keyboard_notify_key(kbd->server->seat, event->time_msec,
 818                 event->keycode, event->state);
 819     }
 820 }
 821
 822 static void
 823 server_add_keyboard(struct tinyds_server *server, struct ds_input_device *dev)
 824 {
 825     struct tinyds_keyboard *kbd;
 826     struct xkb_context *context;
 827     struct xkb_keymap *keymap;
 828
 829     kbd = calloc(1, sizeof *kbd);
 830     assert(kbd);
 831
 832     kbd->dev = dev;
 833     kbd->server = server;
 834
 835     context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
 836     keymap = xkb_keymap_new_from_names(context, NULL,
 837             XKB_KEYMAP_COMPILE_NO_FLAGS);
 838
 839     if (!keymap) {
 840         ds_err("Failed to compile keymap");
 841         xkb_context_unref(context);
 842     }
 843
 844     ds_keyboard_set_keymap(ds_input_device_get_keyboard(dev), keymap);
 845
 846     xkb_keymap_unref(keymap);
 847     xkb_context_unref(context);
 848
 849     kbd->destroy.notify = keyboard_handle_device_destroy;
 850     ds_input_device_add_destroy_listener(dev, &kbd->destroy);
 851
 852     kbd->key.notify = keyboard_handle_key;
 853     ds_keyboard_add_key_listener(ds_input_device_get_keyboard(dev), &kbd->key);
 854
 855     server->keyboard = kbd;
 856
 857     ds_inf("Keyboard(%p) added", kbd);
 858 }
 859
 860 static struct tinyds_view *
 861 server_view_at(struct tinyds_server *server, double lx, double ly,
 862         double *sx, double *sy)
 863 {
 864     struct tinyds_view *view;
 865     struct ds_surface *surface;
 866     struct ds_buffer *buffer;
 867     int x, y, w = 0, h = 0;
 868
 869     wl_list_for_each(view, &server->views, link) {
 870         surface = ds_xdg_surface_get_surface(view->xdg_surface);
 871         buffer = ds_surface_get_buffer(surface);
 872         ds_buffer_get_size(buffer, &w, &h);
 873
 874         x = view->x;
 875         y = view->y;
 876
 877         if (lx >= x && lx <= x + w && ly >= y && ly <= y + h) {
 878             *sx = lx - x;
 879             *sy = ly - y;
 880
 881             return view;
 882         }
 883     }
 884
 885     return NULL;
 886 }
 887
 888 static void
 889 touch_handle_device_destroy(struct wl_listener *listener, void *data)
 890 {
 891     struct tinyds_touch *touch;
 892
 893     touch = wl_container_of(listener, touch, destroy);
 894
 895     ds_inf("Touch(%p) destroyed", touch);
 896
 897     wl_list_remove(&touch->destroy.link);
 898     wl_list_remove(&touch->down.link);
 899     wl_list_remove(&touch->up.link);
 900     wl_list_remove(&touch->motion.link);
 901
 902     free(touch);
 903 }
 904
 905 static void
 906 touch_handle_down(struct wl_listener *listener, void *data)
 907 {
 908     struct ds_event_touch_down *event = data;
 909     struct tinyds_touch *touch;
 910     struct tinyds_view *view;
 911     struct tinyds_server *server;
 912     double sx = 0.f, sy = 0.f;
 913
 914     touch = wl_container_of(listener, touch, down);
 915
 916     server = touch->server;
 917     server->output_x = event->x * server->output->width;
 918     server->output_y = event->y * server->output->height;
 919
 920     ds_inf("Touch(%p) event down: id(%d) x %.3f y %.3f output_x %.1f output_y %.1f",
 921             touch->dev, event->id, event->x, event->y, server->output_x, server->output_y);
 922
 923     view = server_view_at(server, server->output_x, server->output_y, &sx, &sy);
 924
 925     if (view) {
 926         ds_seat_touch_notify_down(touch->server->seat, ds_xdg_surface_get_surface(view->xdg_surface),
 927                 event->time_msec, event->id, sx, sy);
 928     }
 929 }
 930
 931 static void
 932 touch_handle_up(struct wl_listener *listener, void *data)
 933 {
 934     struct ds_event_touch_up *event = data;
 935     struct tinyds_touch *touch;
 936
 937     touch = wl_container_of(listener, touch, up);
 938
 939     ds_inf("Touch(%p) event up: id(%d) time_msec(%d)",
 940             touch->dev, event->id, event->time_msec);
 941
 942     ds_seat_touch_notify_up(touch->server->seat, event->time_msec, event->id);
 943 }
 944
 945 static void
 946 touch_handle_motion(struct wl_listener *listener, void *data)
 947 {
 948     struct ds_event_touch_motion *event = data;
 949     struct tinyds_touch *touch;
 950     struct tinyds_view *view;
 951     struct tinyds_server *server;
 952     double sx = 0.f, sy = 0.f;
 953
 954     touch = wl_container_of(listener, touch, motion);
 955
 956     server = touch->server;
 957     server->output_x = event->x * server->output->width;
 958     server->output_y = event->y * server->output->height;
 959
 960     ds_inf("Touch(%p) event motion: id(%d) x %.3f y %.3f output_x %.1f output_y %.1f",
 961             touch->dev, event->id, event->x, event->y, server->output_x, server->output_y);
 962
 963     view = server_view_at(server, server->output_x, server->output_y, &sx, &sy);
 964
 965     if (view) {
 966         ds_seat_touch_notify_motion(server->seat, event->time_msec,
 967                 event->id, sx, sy);
 968     }
 969 }
 970
 971 static void
 972 server_add_touch(struct tinyds_server *server, struct ds_input_device *dev)
 973 {
 974     struct tinyds_touch *touch;
 975
 976     touch = calloc(1, sizeof *touch);
 977     assert(touch);
 978
 979     touch->dev = dev;
 980     touch->server = server;
 981
 982     touch->destroy.notify = touch_handle_device_destroy;
 983     ds_input_device_add_destroy_listener(dev, &touch->destroy);
 984
 985     touch->down.notify = touch_handle_down;
 986     ds_touch_add_down_listener(ds_input_device_get_touch(dev), &touch->down);
 987
 988     touch->up.notify = touch_handle_up;
 989     ds_touch_add_up_listener(ds_input_device_get_touch(dev), &touch->up);
 990
 991     touch->motion.notify = touch_handle_motion;
 992     ds_touch_add_motion_listener(ds_input_device_get_touch(dev), &touch->motion);
 993
 994     ds_inf("Touch(%p) added", touch);
 995 }
 996
 997 static void
 998 pointer_handle_device_destroy(struct wl_listener *listener, void *data)
 999 {
1000     struct tinyds_pointer *pointer;
1001
1002     pointer = wl_container_of(listener, pointer, destroy);
1003
1004     ds_inf("Pointer(%p) destroyed", pointer);
1005
1006     wl_list_remove(&pointer->destroy.link);
1007     wl_list_remove(&pointer->motion.link);
1008     wl_list_remove(&pointer->button.link);
1009     wl_list_remove(&pointer->frame.link);
1010
1011     free(pointer);
1012 }
1013
1014 static void
1015 pointer_handle_motion(struct wl_listener *listener, void *data)
1016 {
1017     struct tinyds_pointer *pointer;
1018     struct ds_event_pointer_motion *event = data;
1019     struct tinyds_view *view;
1020     struct tinyds_server *server;
1021     int ow = 0, oh = 0;
1022     double sx, sy;
1023
1024     pointer = wl_container_of(listener, pointer, motion);
1025
1026     server = pointer->server;
1027     if (server->output) {
1028         ow = server->output->width;
1029         oh = server->output->height;
1030     }
1031
1032     if (server->output_x + event->delta_x >= ow)
1033         server->output_x = ow;
1034     else if(server->output_x + event->delta_x <= 0.f)
1035         server->output_x = 0.f;
1036     else
1037         server->output_x = server->output_x + event->delta_x ;
1038     if (server->output_y + event->delta_y >= oh)
1039         server->output_y = oh;
1040     else if(server->output_y + event->delta_y <= 0.f)
1041         server->output_y = 0.f;
1042     else
1043         server->output_y = server->output_y + event->delta_y ;
1044
1045     ds_inf("Pointer(%p) motion: (delta_x %.1f delta_y %.1f) output_x %.1f output_y %.1f",
1046             pointer, event->delta_x, event->delta_y, server->output_x, server->output_y);
1047
1048     view = server_view_at(pointer->server, server->output_x, server->output_y, &sx, &sy);
1049
1050     if (pointer->focused_view != view) {
1051         if (pointer->focused_view) {
1052             ds_inf("Clear pointer focus from view(%p)", pointer->focused_view);
1053             ds_seat_pointer_notify_clear_focus(pointer->server->seat);
1054             pointer->focused_view = NULL;
1055         }
1056
1057         if (view) {
1058             ds_inf("Set pointer focus to view(%p)", view);
1059             ds_seat_pointer_notify_enter(pointer->server->seat,
1060                     ds_xdg_surface_get_surface(view->xdg_surface), sx, sy);
1061             pointer->focused_view = view;
1062         }
1063     }
1064
1065     if (view) {
1066         ds_seat_pointer_notify_motion(pointer->server->seat,
1067                 event->time_msec, sx, sy);
1068     }
1069 }
1070
1071 static void
1072 pointer_handle_button(struct wl_listener *listener, void *data)
1073 {
1074     struct tinyds_pointer *pointer;
1075     struct ds_event_pointer_button *event = data;
1076
1077     pointer = wl_container_of(listener, pointer, button);
1078
1079     ds_inf("Pointer(%p) button(%d): state(%s) time(%d)",
1080             pointer, event->button,
1081             (event->state == DS_BUTTON_PRESSED) ? "Pressed" : "Released",
1082             event->time_msec);
1083
1084     ds_seat_pointer_notify_button(pointer->server->seat, event->time_msec, event->button, event->state);
1085 }
1086
1087 static void
1088 pointer_handle_frame(struct wl_listener *listener, void *data)
1089 {
1090     struct tinyds_pointer *pointer;
1091
1092     pointer = wl_container_of(listener, pointer, frame);
1093
1094     ds_inf("Pointer(%p) frame", pointer);
1095     ds_seat_pointer_notify_frame(pointer->server->seat);
1096 }
1097
1098 static void
1099 server_add_pointer(struct tinyds_server *server, struct ds_input_device *dev)
1100 {
1101     struct tinyds_pointer *pointer;
1102
1103     pointer = calloc(1, sizeof *pointer);
1104     assert(pointer);
1105
1106     pointer->dev = dev;
1107     pointer->server = server;
1108     server->output_x = 200;
1109     server->output_y = 200;
1110
1111     pointer->destroy.notify = pointer_handle_device_destroy;
1112     ds_input_device_add_destroy_listener(dev, &pointer->destroy);
1113
1114     pointer->motion.notify = pointer_handle_motion;
1115     ds_pointer_add_motion_listener(ds_input_device_get_pointer(dev),
1116             &pointer->motion);
1117
1118     pointer->button.notify = pointer_handle_button;
1119     ds_pointer_add_button_listener(ds_input_device_get_pointer(dev),
1120             &pointer->button);
1121
1122     pointer->frame.notify = pointer_handle_frame;
1123     ds_pointer_add_frame_listener(ds_input_device_get_pointer(dev),
1124             &pointer->frame);
1125
1126     ds_inf("Pointer(%p) added", pointer);
1127 }