Ticket #4021: touch-display.c

/* gcc -o touch-display `pkg-config --cflags --libs gtk+-3.0 gtk+-x11-3.0 xi` touch-display.c */
#include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <X11/extensions/XInput2.h>

static GHashTable *coords = NULL;

static gboolean
window_draw_cb (GtkWidget *widget,
                cairo_t   *cr,
                gpointer   user_data)
{
  GHashTableIter iter;
  GdkPoint *point;
  gpointer data;

  if (g_hash_table_size (coords) == 0)
    {
      cairo_move_to (cr, 0, 0);
      cairo_rel_line_to (cr, 1, 0);
      cairo_stroke (cr);
      return TRUE;
    }

  g_hash_table_iter_init (&iter, coords);

  cairo_save (cr);
  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
  cairo_paint (cr);
  cairo_restore (cr);

  while (g_hash_table_iter_next (&iter, NULL, &data))
    {
      point = data;

      printf("===> draw points %d %d \n", point->x, point->y);
      cairo_arc (cr, point->x, point->y,
                 30, 0, 2 * G_PI);
      cairo_set_source_rgba (cr, 1, 0, 0, 0.5);
      cairo_fill (cr);
    }

  return TRUE;
}

static void
raw_event_get_coords (XIRawEvent *raw,
                      GdkScreen  *screen,
                      GdkPoint   *point)
{
  if (raw->raw_values[0] != 0){
    point->x = (raw->raw_values[0] / 1200) *
      gdk_screen_get_width (screen);
    printf("===> point-x %d %f \n", point->x, raw->raw_values[0]);
  }
  if (raw->raw_values[1] != 0){
    point->y = (raw->raw_values[1] / 900) *
      gdk_screen_get_height (screen);
    printf("===> point-y %d %f \n", point->y, raw->raw_values[1]);
  }
}

static GdkFilterReturn
raw_event_filter (GdkXEvent *xevent,
                  GdkEvent  *event,
                  gpointer   user_data)
{
  GtkWidget *window = user_data;
  XEvent *ev = xevent;
  XIRawEvent *raw;
  XIEvent *xiev;
  GdkPoint *point = NULL;

  if (ev->type != GenericEvent)
    return GDK_FILTER_CONTINUE;

  xiev = ev->xcookie.data;

  switch (xiev->evtype)
    {
    case XI_RawTouchBegin:
      raw = (XIRawEvent *) xiev;
      point = g_new0 (GdkPoint, 1);
      g_hash_table_insert (coords,
                           GUINT_TO_POINTER (raw->detail),
                           point);
      printf("===> touch-begin %d %d \n", point->x, point->y);

      /* Fall through */
    case XI_RawTouchUpdate:
      raw = (XIRawEvent *) xiev;

      if (!point){
        point = g_hash_table_lookup (coords,
                                     GUINT_TO_POINTER (raw->detail));
      }
      if (!point)
        return GDK_FILTER_REMOVE;

      printf("===> touch-update %d %d \n", point->x, point->y);
      raw_event_get_coords (raw,
                            gtk_widget_get_screen (window),
                            point);
      gtk_widget_queue_draw (window);

      return GDK_FILTER_REMOVE;
    case XI_RawTouchEnd:

      printf("===> touch-end \n");

      raw = (XIRawEvent *) xiev;
      g_hash_table_remove (coords, GUINT_TO_POINTER (raw->detail));
      gtk_widget_queue_draw (window);

      return GDK_FILTER_REMOVE;
    default:
      break;
    }

  return GDK_FILTER_CONTINUE;
}

int
main (int argc, char *argv[])
{
  GdkRGBA transparent = { 0 };
  XIEventMask mask;
  guchar *evmask;
  GtkWidget *window;
  GdkScreen *screen;
  cairo_region_t *region;
  GdkCursor *cursor;
  Display *xdisplay;
  GdkDisplay *display;

  gtk_init (NULL, NULL);

  coords = g_hash_table_new_full (NULL, NULL, NULL,
                                  (GDestroyNotify) g_free);

  window = gtk_window_new (GTK_WINDOW_POPUP);
  g_signal_connect (window, "draw",
                    G_CALLBACK (window_draw_cb), NULL);

  screen = gtk_widget_get_screen (window);
  gtk_widget_set_visual (window,
                         gdk_screen_get_rgba_visual (screen));

  gtk_widget_realize (window);

  evmask = g_new0 (guchar, XIMaskLen (XI_LASTEVENT));
  XISetMask (evmask, XI_RawTouchBegin);
  XISetMask (evmask, XI_RawTouchEnd);
  XISetMask (evmask, XI_RawTouchUpdate);

  mask.deviceid = XIAllMasterDevices;
  mask.mask_len = sizeof (evmask);
  mask.mask = evmask;

  XISelectEvents (GDK_SCREEN_XDISPLAY (screen),
                  GDK_WINDOW_XID (gdk_screen_get_root_window (screen)),
                  &mask, 1);

  gdk_window_add_filter (NULL, raw_event_filter, window);

  region = cairo_region_create ();
  gdk_window_input_shape_combine_region (gtk_widget_get_window (window),
                                         region, 0, 0);
  cairo_region_destroy (region);

  gdk_window_set_background_rgba (gtk_widget_get_window (window),
                                  &transparent);

  gtk_window_move (GTK_WINDOW (window), 1, 1);
  gtk_widget_set_size_request (window,
                               gdk_screen_get_width (screen) / 2,
                               gdk_screen_get_height (screen) / 2);

  gtk_widget_show (window);

  display = gdk_display_get_default ();
  xdisplay = GDK_DISPLAY_XDISPLAY (display);
  XFixesHideCursor (xdisplay, GDK_WINDOW_XID (gdk_screen_get_root_window (screen)));

  gtk_main ();
}