Pileus Git - ~andy/gtk/blob - gdk/broadway/gdkeventsource.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gdkeventsource.h"
  23
  24 #include "gdkinternals.h"
  25
  26 #include <stdlib.h>
  27
  28 static gboolean gdk_event_source_prepare  (GSource     *source,
  29                                            gint        *timeout);
  30 static gboolean gdk_event_source_check    (GSource     *source);
  31 static gboolean gdk_event_source_dispatch (GSource     *source,
  32                                            GSourceFunc  callback,
  33                                            gpointer     user_data);
  34 static void     gdk_event_source_finalize (GSource     *source);
  35
  36 #define HAS_FOCUS(toplevel)                           \
  37   ((toplevel)->has_focus || (toplevel)->has_pointer_focus)
  38
  39 struct _GdkEventSource
  40 {
  41   GSource source;
  42
  43   GdkDisplay *display;
  44   GPollFD event_poll_fd;
  45 };
  46
  47 static GSourceFuncs event_funcs = {
  48   gdk_event_source_prepare,
  49   gdk_event_source_check,
  50   gdk_event_source_dispatch,
  51   gdk_event_source_finalize
  52 };
  53
  54 static GList *event_sources = NULL;
  55
  56 static gboolean
  57 gdk_event_source_prepare (GSource *source,
  58                           gint    *timeout)
  59 {
  60   GdkDisplay *display = ((GdkEventSource*) source)->display;
  61   gboolean retval;
  62
  63   GDK_THREADS_ENTER ();
  64
  65   *timeout = -1;
  66   retval = (_gdk_event_queue_find_first (display) != NULL);
  67
  68   GDK_THREADS_LEAVE ();
  69
  70   return retval;
  71 }
  72
  73 static gboolean
  74 gdk_event_source_check (GSource *source)
  75 {
  76   GdkEventSource *event_source = (GdkEventSource*) source;
  77   gboolean retval;
  78
  79   GDK_THREADS_ENTER ();
  80
  81   if (event_source->event_poll_fd.revents & G_IO_IN)
  82     retval = (_gdk_event_queue_find_first (event_source->display) != NULL);
  83   else
  84     retval = FALSE;
  85
  86   GDK_THREADS_LEAVE ();
  87
  88   return retval;
  89 }
  90
  91 typedef struct {
  92   int id;
  93   int root_x;
  94   int root_y;
  95   int win_x;
  96   int win_y;
  97   guint32 state;
  98   guint64 time;
  99 } PointerData;
 100
 101 static char *
 102 parse_pointer_data (char *p, PointerData *data)
 103 {
 104   data->id = strtol (p, &p, 10);
 105   p++; /* Skip , */
 106   data->root_x = strtol (p, &p, 10);
 107   p++; /* Skip , */
 108   data->root_y = strtol (p, &p, 10);
 109   p++; /* Skip , */
 110   data->win_x = strtol (p, &p, 10);
 111   p++; /* Skip , */
 112   data->win_y = strtol (p, &p, 10);
 113   p++; /* Skip , */
 114   data->state = strtol (p, &p, 10);
 115   p++; /* Skip , */
 116   data->time = strtol(p, &p, 10);
 117
 118   return p;
 119 }
 120
 121
 122 void
 123 _gdk_broadway_events_got_input (GdkDisplay *display,
 124                                 const char *message)
 125 {
 126   GdkBroadwayDisplay *display_broadway = GDK_BROADWAY_DISPLAY (display);
 127   GdkScreen *screen;
 128   GdkWindow *root, *window;
 129   char *p;
 130   int button, dir, key, detail;
 131   guint32 serial;
 132   guint64 time;
 133   GdkEvent *event = NULL;
 134   char cmd;
 135   GList *node;
 136   PointerData data;
 137
 138   screen = gdk_display_get_default_screen (display);
 139   root = gdk_screen_get_root_window (screen);
 140
 141   p = (char *)message;
 142   cmd = *p++;
 143   serial = (guint32)strtol (p, &p, 10);
 144   p++; /* Skip , */
 145   switch (cmd) {
 146   case 'e': /* Enter */
 147     p = parse_pointer_data (p, &data);
 148     p++; /* Skip , */
 149     detail = strtol(p, &p, 10);
 150
 151     display_broadway->last_x = data.root_x;
 152     display_broadway->last_y = data.root_y;
 153
 154     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (data.id));
 155
 156     /* TODO: Unset when it dies */
 157     display_broadway->mouse_in_toplevel = window;
 158
 159     if (window)
 160       {
 161         event = gdk_event_new (GDK_ENTER_NOTIFY);
 162         event->crossing.window = g_object_ref (window);
 163         event->crossing.time = data.time;
 164         event->crossing.x = data.win_x;
 165         event->crossing.y = data.win_y;
 166         event->crossing.x_root = data.root_x;
 167         event->crossing.y_root = data.root_y;
 168         event->crossing.state = data.state;
 169         event->crossing.mode = detail;
 170         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 171         gdk_event_set_device (event, display->core_pointer);
 172
 173         node = _gdk_event_queue_append (display, event);
 174         _gdk_windowing_got_event (display, node, event, serial);
 175
 176         event = gdk_event_new (GDK_FOCUS_CHANGE);
 177         event->focus_change.window = g_object_ref (window);
 178         event->focus_change.in = TRUE;
 179         gdk_event_set_device (event, display->core_pointer);
 180
 181         node = _gdk_event_queue_append (display, event);
 182         _gdk_windowing_got_event (display, node, event, serial);
 183       }
 184     break;
 185   case 'l': /* Leave */
 186     p = parse_pointer_data (p, &data);
 187     p++; /* Skip , */
 188     detail = strtol(p, &p, 10);
 189
 190     display_broadway->last_x = data.root_x;
 191     display_broadway->last_y = data.root_y;
 192
 193     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (data.id));
 194
 195     display_broadway->mouse_in_toplevel = NULL;
 196
 197     if (window)
 198       {
 199         event = gdk_event_new (GDK_LEAVE_NOTIFY);
 200         event->crossing.window = g_object_ref (window);
 201         event->crossing.time = data.time;
 202         event->crossing.x = data.win_x;
 203         event->crossing.y = data.win_y;
 204         event->crossing.x_root = data.root_x;
 205         event->crossing.y_root = data.root_y;
 206         event->crossing.state = data.state;
 207         event->crossing.mode = GDK_CROSSING_NORMAL;
 208         event->crossing.detail = detail;
 209         gdk_event_set_device (event, display->core_pointer);
 210
 211         node = _gdk_event_queue_append (display, event);
 212         _gdk_windowing_got_event (display, node, event, serial);
 213
 214         event = gdk_event_new (GDK_FOCUS_CHANGE);
 215         event->focus_change.window = g_object_ref (window);
 216         event->focus_change.in = FALSE;
 217         gdk_event_set_device (event, display->core_pointer);
 218
 219         node = _gdk_event_queue_append (display, event);
 220         _gdk_windowing_got_event (display, node, event, serial);
 221       }
 222     break;
 223   case 'm': /* Mouse move */
 224     p = parse_pointer_data (p, &data);
 225
 226     display_broadway->last_x = data.root_x;
 227     display_broadway->last_y = data.root_y;
 228
 229     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (data.id));
 230
 231     if (window)
 232       {
 233         event = gdk_event_new (GDK_MOTION_NOTIFY);
 234         event->motion.window = g_object_ref (window);
 235         event->motion.time = data.time;
 236         event->motion.x = data.win_x;
 237         event->motion.y = data.win_y;
 238         event->motion.x_root = data.root_x;
 239         event->motion.y_root = data.root_y;
 240         event->motion.state = data.state;
 241         gdk_event_set_device (event, display->core_pointer);
 242
 243         node = _gdk_event_queue_append (display, event);
 244         _gdk_windowing_got_event (display, node, event, serial);
 245       }
 246
 247     break;
 248   case 'b':
 249   case 'B':
 250     p = parse_pointer_data (p, &data);
 251     p++; /* Skip , */
 252     button = strtol(p, &p, 10);
 253     display_broadway->last_x = data.root_x;
 254     display_broadway->last_y = data.root_y;
 255
 256     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (data.id));
 257
 258     if (window)
 259       {
 260         event = gdk_event_new (cmd == 'b' ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 261         event->button.window = g_object_ref (window);
 262         event->button.time = data.time;
 263         event->button.x = data.win_x;
 264         event->button.y = data.win_y;
 265         event->button.x_root = data.root_x;
 266         event->button.y_root = data.root_y;
 267         event->button.button = button + 1;
 268         event->button.state = data.state;
 269         gdk_event_set_device (event, display->core_pointer);
 270
 271         node = _gdk_event_queue_append (display, event);
 272         _gdk_windowing_got_event (display, node, event, serial);
 273       }
 274
 275     break;
 276   case 's':
 277     p = parse_pointer_data (p, &data);
 278     p++; /* Skip , */
 279     dir = strtol(p, &p, 10);
 280     display_broadway->last_x = data.root_x;
 281     display_broadway->last_y = data.root_y;
 282
 283     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (data.id));
 284
 285     if (window)
 286       {
 287         event = gdk_event_new (GDK_SCROLL);
 288         event->scroll.window = g_object_ref (window);
 289         event->scroll.time = data.time;
 290         event->scroll.x = data.win_x;
 291         event->scroll.y = data.win_y;
 292         event->scroll.x_root = data.root_x;
 293         event->scroll.y_root = data.root_y;
 294         event->scroll.direction = dir == 0 ? GDK_SCROLL_UP : GDK_SCROLL_DOWN;
 295         gdk_event_set_device (event, display->core_pointer);
 296
 297         node = _gdk_event_queue_append (display, event);
 298         _gdk_windowing_got_event (display, node, event, serial);
 299       }
 300
 301     break;
 302   case 'k':
 303   case 'K':
 304     key = strtol(p, &p, 10);
 305     p++; /* Skip , */
 306     time = strtol(p, &p, 10);
 307
 308     window = display_broadway->mouse_in_toplevel;
 309
 310     if (window)
 311       {
 312         event = gdk_event_new (cmd == 'k' ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
 313         event->key.window = g_object_ref (window);
 314         event->key.time = time;
 315         event->key.keyval = key;
 316         event->key.length = 0;
 317         gdk_event_set_device (event, display->core_pointer);
 318
 319         node = _gdk_event_queue_append (display, event);
 320         _gdk_windowing_got_event (display, node, event, serial);
 321       }
 322
 323     break;
 324   case 'g':
 325   case 'u':
 326     _gdk_display_device_grab_update (display, display->core_pointer, NULL, serial);
 327     break;
 328   case 'q':
 329     g_printerr ("Got unexpected query pointer reply w serial %d\n", serial);
 330     break;
 331   default:
 332     g_printerr ("Unknown input command %s\n", message);
 333     break;
 334   }
 335 }
 336
 337 void
 338 _gdk_broadway_display_queue_events (GdkDisplay *display)
 339 {
 340 }
 341
 342 static gboolean
 343 gdk_event_source_dispatch (GSource     *source,
 344                            GSourceFunc  callback,
 345                            gpointer     user_data)
 346 {
 347   GdkDisplay *display = ((GdkEventSource*) source)->display;
 348   GdkEvent *event;
 349
 350   GDK_THREADS_ENTER ();
 351
 352   event = gdk_display_get_event (display);
 353
 354   if (event)
 355     {
 356       _gdk_event_emit (event);
 357
 358       gdk_event_free (event);
 359     }
 360
 361   GDK_THREADS_LEAVE ();
 362
 363   return TRUE;
 364 }
 365
 366 static void
 367 gdk_event_source_finalize (GSource *source)
 368 {
 369   GdkEventSource *event_source = (GdkEventSource *)source;
 370
 371   event_sources = g_list_remove (event_sources, event_source);
 372 }
 373
 374 GSource *
 375 _gdk_broadway_event_source_new (GdkDisplay *display)
 376 {
 377   GSource *source;
 378   GdkEventSource *event_source;
 379   char *name;
 380
 381   source = g_source_new (&event_funcs, sizeof (GdkEventSource));
 382   name = g_strdup_printf ("GDK Broadway Event source (%s)",
 383                           gdk_display_get_name (display));
 384   g_source_set_name (source, name);
 385   g_free (name);
 386   event_source = (GdkEventSource *) source;
 387   event_source->display = display;
 388
 389   g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 390   g_source_set_can_recurse (source, TRUE);
 391   g_source_attach (source, NULL);
 392
 393   event_sources = g_list_prepend (event_sources, source);
 394
 395   return source;
 396 }