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