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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gdkeventsource.h"
  21
  22 #include "gdkinternals.h"
  23
  24 #include <stdlib.h>
  25
  26 static gboolean gdk_event_source_prepare  (GSource     *source,
  27                                            gint        *timeout);
  28 static gboolean gdk_event_source_check    (GSource     *source);
  29 static gboolean gdk_event_source_dispatch (GSource     *source,
  30                                            GSourceFunc  callback,
  31                                            gpointer     user_data);
  32 static void     gdk_event_source_finalize (GSource     *source);
  33
  34 #define HAS_FOCUS(toplevel)                           \
  35   ((toplevel)->has_focus || (toplevel)->has_pointer_focus)
  36
  37 struct _GdkEventSource
  38 {
  39   GSource source;
  40
  41   GdkDisplay *display;
  42   GPollFD event_poll_fd;
  43 };
  44
  45 static GSourceFuncs event_funcs = {
  46   gdk_event_source_prepare,
  47   gdk_event_source_check,
  48   gdk_event_source_dispatch,
  49   gdk_event_source_finalize
  50 };
  51
  52 static GList *event_sources = NULL;
  53
  54 static gboolean
  55 gdk_event_source_prepare (GSource *source,
  56                           gint    *timeout)
  57 {
  58   GdkDisplay *display = ((GdkEventSource*) source)->display;
  59   gboolean retval;
  60
  61   gdk_threads_enter ();
  62
  63   *timeout = -1;
  64   retval = (_gdk_event_queue_find_first (display) != NULL);
  65
  66   gdk_threads_leave ();
  67
  68   return retval;
  69 }
  70
  71 static gboolean
  72 gdk_event_source_check (GSource *source)
  73 {
  74   GdkEventSource *event_source = (GdkEventSource*) source;
  75   gboolean retval;
  76
  77   gdk_threads_enter ();
  78
  79   if (event_source->event_poll_fd.revents & G_IO_IN)
  80     retval = (_gdk_event_queue_find_first (event_source->display) != NULL);
  81   else
  82     retval = FALSE;
  83
  84   gdk_threads_leave ();
  85
  86   return retval;
  87 }
  88
  89 void
  90 _gdk_broadway_events_got_input (BroadwayInputMsg *message)
  91 {
  92   GdkDisplay *display = gdk_display_get_default ();
  93   GdkBroadwayDisplay *display_broadway = GDK_BROADWAY_DISPLAY (display);
  94   GdkScreen *screen;
  95   GdkWindow *window;
  96   GdkEvent *event = NULL;
  97   GList *node;
  98
  99   switch (message->base.type) {
 100   case BROADWAY_EVENT_ENTER:
 101     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
 102     if (window)
 103       {
 104         event = gdk_event_new (GDK_ENTER_NOTIFY);
 105         event->crossing.window = g_object_ref (window);
 106         event->crossing.time = message->base.time;
 107         event->crossing.x = message->pointer.win_x;
 108         event->crossing.y = message->pointer.win_y;
 109         event->crossing.x_root = message->pointer.root_x;
 110         event->crossing.y_root = message->pointer.root_y;
 111         event->crossing.state = message->pointer.state;
 112         event->crossing.mode = message->crossing.mode;
 113         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 114         gdk_event_set_device (event, display->core_pointer);
 115
 116         node = _gdk_event_queue_append (display, event);
 117         _gdk_windowing_got_event (display, node, event, message->base.serial);
 118
 119         event = gdk_event_new (GDK_FOCUS_CHANGE);
 120         event->focus_change.window = g_object_ref (window);
 121         event->focus_change.in = TRUE;
 122         gdk_event_set_device (event, display->core_pointer);
 123
 124         node = _gdk_event_queue_append (display, event);
 125         _gdk_windowing_got_event (display, node, event, message->base.serial);
 126       }
 127     break;
 128   case BROADWAY_EVENT_LEAVE:
 129     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
 130     if (window)
 131       {
 132         event = gdk_event_new (GDK_LEAVE_NOTIFY);
 133         event->crossing.window = g_object_ref (window);
 134         event->crossing.time = message->base.time;
 135         event->crossing.x = message->pointer.win_x;
 136         event->crossing.y = message->pointer.win_y;
 137         event->crossing.x_root = message->pointer.root_x;
 138         event->crossing.y_root = message->pointer.root_y;
 139         event->crossing.state = message->pointer.state;
 140         event->crossing.mode = message->crossing.mode;
 141         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 142         gdk_event_set_device (event, display->core_pointer);
 143
 144         node = _gdk_event_queue_append (display, event);
 145         _gdk_windowing_got_event (display, node, event, message->base.serial);
 146
 147         event = gdk_event_new (GDK_FOCUS_CHANGE);
 148         event->focus_change.window = g_object_ref (window);
 149         event->focus_change.in = FALSE;
 150         gdk_event_set_device (event, display->core_pointer);
 151
 152         node = _gdk_event_queue_append (display, event);
 153         _gdk_windowing_got_event (display, node, event, message->base.serial);
 154       }
 155     break;
 156   case BROADWAY_EVENT_POINTER_MOVE:
 157     if (_gdk_broadway_moveresize_handle_event (display, message))
 158       break;
 159
 160     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
 161     if (window)
 162       {
 163         event = gdk_event_new (GDK_MOTION_NOTIFY);
 164         event->motion.window = g_object_ref (window);
 165         event->motion.time = message->base.time;
 166         event->motion.x = message->pointer.win_x;
 167         event->motion.y = message->pointer.win_y;
 168         event->motion.x_root = message->pointer.root_x;
 169         event->motion.y_root = message->pointer.root_y;
 170         event->motion.state = message->pointer.state;
 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, message->base.serial);
 175       }
 176
 177     break;
 178   case BROADWAY_EVENT_BUTTON_PRESS:
 179   case BROADWAY_EVENT_BUTTON_RELEASE:
 180     if (message->base.type != 'b' &&
 181         _gdk_broadway_moveresize_handle_event (display, message))
 182       break;
 183
 184     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
 185     if (window)
 186       {
 187         event = gdk_event_new (message->base.type == 'b' ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 188         event->button.window = g_object_ref (window);
 189         event->button.time = message->base.time;
 190         event->button.x = message->pointer.win_x;
 191         event->button.y = message->pointer.win_y;
 192         event->button.x_root = message->pointer.root_x;
 193         event->button.y_root = message->pointer.root_y;
 194         event->button.button = message->button.button;
 195         event->button.state = message->pointer.state;
 196         gdk_event_set_device (event, display->core_pointer);
 197
 198         node = _gdk_event_queue_append (display, event);
 199         _gdk_windowing_got_event (display, node, event, message->base.serial);
 200       }
 201
 202     break;
 203   case BROADWAY_EVENT_SCROLL:
 204     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
 205     if (window)
 206       {
 207         event = gdk_event_new (GDK_SCROLL);
 208         event->scroll.window = g_object_ref (window);
 209         event->scroll.time = message->base.time;
 210         event->scroll.x = message->pointer.win_x;
 211         event->scroll.y = message->pointer.win_y;
 212         event->scroll.x_root = message->pointer.root_x;
 213         event->scroll.y_root = message->pointer.root_y;
 214         event->scroll.direction = message->scroll.dir == 0 ? GDK_SCROLL_UP : GDK_SCROLL_DOWN;
 215         gdk_event_set_device (event, display->core_pointer);
 216
 217         node = _gdk_event_queue_append (display, event);
 218         _gdk_windowing_got_event (display, node, event, message->base.serial);
 219       }
 220
 221     break;
 222   case BROADWAY_EVENT_KEY_PRESS:
 223   case BROADWAY_EVENT_KEY_RELEASE:
 224     window = g_hash_table_lookup (display_broadway->id_ht,
 225                                   GINT_TO_POINTER (message->key.mouse_window_id));
 226     if (window)
 227       {
 228         event = gdk_event_new (message->base.type == 'k' ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
 229         event->key.window = g_object_ref (window);
 230         event->key.time = message->base.time;
 231         event->key.keyval = message->key.key;
 232         event->key.state = message->key.state;
 233         event->key.hardware_keycode = message->key.key;
 234         event->key.length = 0;
 235         gdk_event_set_device (event, display->core_pointer);
 236
 237         node = _gdk_event_queue_append (display, event);
 238         _gdk_windowing_got_event (display, node, event, message->base.serial);
 239       }
 240
 241     break;
 242   case BROADWAY_EVENT_GRAB_NOTIFY:
 243   case BROADWAY_EVENT_UNGRAB_NOTIFY:
 244     _gdk_display_device_grab_update (display, display->core_pointer, NULL, message->base.serial);
 245     break;
 246
 247   case BROADWAY_EVENT_CONFIGURE_NOTIFY:
 248     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->configure_notify.id));
 249     if (window)
 250       {
 251         window->x = message->configure_notify.x;
 252         window->y = message->configure_notify.y;
 253         window->width = message->configure_notify.width;
 254         window->height = message->configure_notify.height;
 255         _gdk_window_update_size (window);
 256         _gdk_broadway_window_resize_surface (window);
 257
 258         event = gdk_event_new (GDK_CONFIGURE);
 259         event->configure.window = g_object_ref (window);
 260         event->configure.x = message->configure_notify.x;
 261         event->configure.y = message->configure_notify.y;
 262         event->configure.width = message->configure_notify.width;
 263         event->configure.height = message->configure_notify.height;
 264
 265         node = _gdk_event_queue_append (display, event);
 266         _gdk_windowing_got_event (display, node, event, message->base.serial);
 267
 268         if (window->resize_count >= 1)
 269           {
 270             window->resize_count -= 1;
 271
 272             if (window->resize_count == 0)
 273               _gdk_broadway_moveresize_configure_done (display, window);
 274           }
 275       }
 276     break;
 277
 278   case BROADWAY_EVENT_DELETE_NOTIFY:
 279     window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->delete_notify.id));
 280     if (window)
 281       {
 282         event = gdk_event_new (GDK_DELETE);
 283         event->any.window = g_object_ref (window);
 284
 285         node = _gdk_event_queue_append (display, event);
 286         _gdk_windowing_got_event (display, node, event, message->base.serial);
 287       }
 288     break;
 289
 290   case BROADWAY_EVENT_SCREEN_SIZE_CHANGED:
 291     screen = gdk_display_get_default_screen (display);
 292     window = gdk_screen_get_root_window (screen);
 293     window->width = message->screen_resize_notify.width;
 294     window->height = message->screen_resize_notify.height;
 295
 296     _gdk_window_update_size (window);
 297     _gdk_broadway_screen_size_changed (screen, &message->screen_resize_notify);
 298     break;
 299
 300   default:
 301     g_printerr ("_gdk_broadway_events_got_input - Unknown input command %c\n", message->base.type);
 302     break;
 303   }
 304 }
 305
 306 void
 307 _gdk_broadway_display_queue_events (GdkDisplay *display)
 308 {
 309 }
 310
 311 static gboolean
 312 gdk_event_source_dispatch (GSource     *source,
 313                            GSourceFunc  callback,
 314                            gpointer     user_data)
 315 {
 316   GdkDisplay *display = ((GdkEventSource*) source)->display;
 317   GdkEvent *event;
 318
 319   gdk_threads_enter ();
 320
 321   event = gdk_display_get_event (display);
 322
 323   if (event)
 324     {
 325       _gdk_event_emit (event);
 326
 327       gdk_event_free (event);
 328     }
 329
 330   gdk_threads_leave ();
 331
 332   return TRUE;
 333 }
 334
 335 static void
 336 gdk_event_source_finalize (GSource *source)
 337 {
 338   GdkEventSource *event_source = (GdkEventSource *)source;
 339
 340   event_sources = g_list_remove (event_sources, event_source);
 341 }
 342
 343 GSource *
 344 _gdk_broadway_event_source_new (GdkDisplay *display)
 345 {
 346   GSource *source;
 347   GdkEventSource *event_source;
 348   char *name;
 349
 350   source = g_source_new (&event_funcs, sizeof (GdkEventSource));
 351   name = g_strdup_printf ("GDK Broadway Event source (%s)",
 352                           gdk_display_get_name (display));
 353   g_source_set_name (source, name);
 354   g_free (name);
 355   event_source = (GdkEventSource *) source;
 356   event_source->display = display;
 357
 358   g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 359   g_source_set_can_recurse (source, TRUE);
 360   g_source_attach (source, NULL);
 361
 362   event_sources = g_list_prepend (event_sources, source);
 363
 364   return source;
 365 }