Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/message_pump_glib_x.h"
      6 
      7 #include <gdk/gdkx.h>
      8 #if defined(HAVE_XINPUT2)
      9 #include <X11/extensions/XInput2.h>
     10 #else
     11 #include <X11/Xlib.h>
     12 #endif
     13 
     14 #include "base/message_pump_glib_x_dispatch.h"
     15 
     16 namespace {
     17 
     18 gboolean PlaceholderDispatch(GSource* source,
     19                              GSourceFunc cb,
     20                              gpointer data) {
     21   return TRUE;
     22 }
     23 
     24 #if defined(HAVE_XINPUT2)
     25 
     26 // Setup XInput2 select for the GtkWidget.
     27 gboolean GtkWidgetRealizeCallback(GSignalInvocationHint* hint, guint nparams,
     28                                   const GValue* pvalues, gpointer data) {
     29   GtkWidget* widget = GTK_WIDGET(g_value_get_object(pvalues));
     30   GdkWindow* window = widget->window;
     31   base::MessagePumpGlibX* msgpump = static_cast<base::MessagePumpGlibX*>(data);
     32 
     33   DCHECK(window);  // TODO(sad): Remove once determined if necessary.
     34 
     35   if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_TOPLEVEL &&
     36       GDK_WINDOW_TYPE(window) != GDK_WINDOW_CHILD &&
     37       GDK_WINDOW_TYPE(window) != GDK_WINDOW_DIALOG)
     38     return true;
     39 
     40   // TODO(sad): Do we need to set a flag on |window| to make sure we don't
     41   // select for the same GdkWindow multiple times? Does it matter?
     42   msgpump->SetupXInput2ForXWindow(GDK_WINDOW_XID(window));
     43 
     44   return true;
     45 }
     46 
     47 // We need to capture all the GDK windows that get created, and start
     48 // listening for XInput2 events. So we setup a callback to the 'realize'
     49 // signal for GTK+ widgets, so that whenever the signal triggers for any
     50 // GtkWidget, which means the GtkWidget should now have a GdkWindow, we can
     51 // setup XInput2 events for the GdkWindow.
     52 static guint realize_signal_id = 0;
     53 static guint realize_hook_id = 0;
     54 
     55 void SetupGtkWidgetRealizeNotifier(base::MessagePumpGlibX* msgpump) {
     56   gpointer klass = g_type_class_ref(GTK_TYPE_WIDGET);
     57 
     58   g_signal_parse_name("realize", GTK_TYPE_WIDGET,
     59                       &realize_signal_id, NULL, FALSE);
     60   realize_hook_id = g_signal_add_emission_hook(realize_signal_id, 0,
     61       GtkWidgetRealizeCallback, static_cast<gpointer>(msgpump), NULL);
     62 
     63   g_type_class_unref(klass);
     64 }
     65 
     66 void RemoveGtkWidgetRealizeNotifier() {
     67   if (realize_signal_id != 0)
     68     g_signal_remove_emission_hook(realize_signal_id, realize_hook_id);
     69   realize_signal_id = 0;
     70   realize_hook_id = 0;
     71 }
     72 
     73 #endif  // HAVE_XINPUT2
     74 
     75 }  // namespace
     76 
     77 namespace base {
     78 
     79 MessagePumpGlibX::MessagePumpGlibX() : base::MessagePumpForUI(),
     80 #if defined(HAVE_XINPUT2)
     81     xiopcode_(-1),
     82     pointer_devices_(),
     83 #endif
     84     gdksource_(NULL),
     85     dispatching_event_(false),
     86     capture_x_events_(0),
     87     capture_gdk_events_(0) {
     88   gdk_event_handler_set(&EventDispatcherX, this, NULL);
     89 
     90 #if defined(HAVE_XINPUT2)
     91   InitializeXInput2();
     92 #endif
     93   InitializeEventsToCapture();
     94 }
     95 
     96 MessagePumpGlibX::~MessagePumpGlibX() {
     97 #if defined(HAVE_XINPUT2)
     98   RemoveGtkWidgetRealizeNotifier();
     99 #endif
    100 }
    101 
    102 #if defined(HAVE_XINPUT2)
    103 void MessagePumpGlibX::SetupXInput2ForXWindow(Window xwindow) {
    104   Display* xdisplay = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
    105 
    106   // Setup mask for mouse events.
    107   unsigned char mask[(XI_LASTEVENT + 7)/8];
    108   memset(mask, 0, sizeof(mask));
    109 
    110   XISetMask(mask, XI_ButtonPress);
    111   XISetMask(mask, XI_ButtonRelease);
    112   XISetMask(mask, XI_Motion);
    113 
    114   XIEventMask evmasks[pointer_devices_.size()];
    115   int count = 0;
    116   for (std::set<int>::const_iterator iter = pointer_devices_.begin();
    117        iter != pointer_devices_.end();
    118        ++iter, ++count) {
    119     evmasks[count].deviceid = *iter;
    120     evmasks[count].mask_len = sizeof(mask);
    121     evmasks[count].mask = mask;
    122   }
    123 
    124   XISelectEvents(xdisplay, xwindow, evmasks, pointer_devices_.size());
    125 
    126   // TODO(sad): Setup masks for keyboard events.
    127 
    128   XFlush(xdisplay);
    129 }
    130 #endif  // HAVE_XINPUT2
    131 
    132 bool MessagePumpGlibX::RunOnce(GMainContext* context, bool block) {
    133   GdkDisplay* gdisp = gdk_display_get_default();
    134   if (!gdisp || !GetDispatcher())
    135     return MessagePumpForUI::RunOnce(context, block);
    136 
    137   Display* display = GDK_DISPLAY_XDISPLAY(gdisp);
    138   bool should_quit = false;
    139 
    140   if (XPending(display)) {
    141     XEvent xev;
    142     XPeekEvent(display, &xev);
    143     if (capture_x_events_[xev.type]
    144 #if defined(HAVE_XINPUT2)
    145         && (xev.type != GenericEvent || xev.xcookie.extension == xiopcode_)
    146 #endif
    147         ) {
    148       XNextEvent(display, &xev);
    149 
    150 #if defined(HAVE_XINPUT2)
    151       bool have_cookie = false;
    152       if (xev.type == GenericEvent &&
    153           XGetEventData(xev.xgeneric.display, &xev.xcookie)) {
    154         have_cookie = true;
    155       }
    156 #endif
    157 
    158       MessagePumpGlibXDispatcher::DispatchStatus status =
    159           static_cast<MessagePumpGlibXDispatcher*>
    160           (GetDispatcher())->DispatchX(&xev);
    161 
    162       if (status == MessagePumpGlibXDispatcher::EVENT_QUIT) {
    163         should_quit = true;
    164         Quit();
    165       } else if (status == MessagePumpGlibXDispatcher::EVENT_IGNORED) {
    166         DLOG(WARNING) << "Event (" << xev.type << ") not handled.";
    167 
    168         // TODO(sad): It is necessary to put back the event so that the default
    169         // GDK events handler can take care of it. Without this, it is
    170         // impossible to use the omnibox at the moment. However, this will
    171         // eventually be removed once the omnibox code is updated for touchui.
    172         XPutBackEvent(display, &xev);
    173         if (gdksource_)
    174           gdksource_->source_funcs->dispatch = gdkdispatcher_;
    175         g_main_context_iteration(context, FALSE);
    176       }
    177 
    178 #if defined(HAVE_XINPUT2)
    179       if (have_cookie) {
    180         XFreeEventData(xev.xgeneric.display, &xev.xcookie);
    181       }
    182 #endif
    183     } else {
    184       // TODO(sad): A couple of extra events can still sneak in during this.
    185       // Those should be sent back to the X queue from the dispatcher
    186       // EventDispatcherX.
    187       if (gdksource_)
    188         gdksource_->source_funcs->dispatch = gdkdispatcher_;
    189       g_main_context_iteration(context, FALSE);
    190     }
    191   }
    192 
    193   if (should_quit)
    194     return true;
    195 
    196   bool retvalue;
    197   if (gdksource_) {
    198     // Replace the dispatch callback of the GDK event source temporarily so that
    199     // it doesn't read events from X.
    200     gboolean (*cb)(GSource*, GSourceFunc, void*) =
    201         gdksource_->source_funcs->dispatch;
    202     gdksource_->source_funcs->dispatch = PlaceholderDispatch;
    203 
    204     dispatching_event_ = true;
    205     retvalue = g_main_context_iteration(context, block);
    206     dispatching_event_ = false;
    207 
    208     gdksource_->source_funcs->dispatch = cb;
    209   } else {
    210     retvalue = g_main_context_iteration(context, block);
    211   }
    212 
    213   return retvalue;
    214 }
    215 
    216 void MessagePumpGlibX::EventDispatcherX(GdkEvent* event, gpointer data) {
    217   MessagePumpGlibX* pump_x = reinterpret_cast<MessagePumpGlibX*>(data);
    218 
    219   if (!pump_x->gdksource_) {
    220     pump_x->gdksource_ = g_main_current_source();
    221     if (pump_x->gdksource_)
    222       pump_x->gdkdispatcher_ = pump_x->gdksource_->source_funcs->dispatch;
    223   } else if (!pump_x->IsDispatchingEvent()) {
    224     if (event->type != GDK_NOTHING &&
    225         pump_x->capture_gdk_events_[event->type]) {
    226       // TODO(sad): An X event is caught by the GDK handler. Put it back in the
    227       // X queue so that we catch it in the next iteration. When done, the
    228       // following DLOG statement will be removed.
    229       DLOG(WARNING) << "GDK received an event it shouldn't have";
    230     }
    231   }
    232 
    233   pump_x->DispatchEvents(event);
    234 }
    235 
    236 void MessagePumpGlibX::InitializeEventsToCapture(void) {
    237   // TODO(sad): Decide which events we want to capture and update the tables
    238   // accordingly.
    239   capture_x_events_[KeyPress] = true;
    240   capture_gdk_events_[GDK_KEY_PRESS] = true;
    241 
    242   capture_x_events_[KeyRelease] = true;
    243   capture_gdk_events_[GDK_KEY_RELEASE] = true;
    244 
    245   capture_x_events_[ButtonPress] = true;
    246   capture_gdk_events_[GDK_BUTTON_PRESS] = true;
    247 
    248   capture_x_events_[ButtonRelease] = true;
    249   capture_gdk_events_[GDK_BUTTON_RELEASE] = true;
    250 
    251   capture_x_events_[MotionNotify] = true;
    252   capture_gdk_events_[GDK_MOTION_NOTIFY] = true;
    253 
    254 #if defined(HAVE_XINPUT2)
    255   capture_x_events_[GenericEvent] = true;
    256 #endif
    257 }
    258 
    259 #if defined(HAVE_XINPUT2)
    260 void MessagePumpGlibX::InitializeXInput2(void) {
    261   GdkDisplay* display = gdk_display_get_default();
    262   if (!display)
    263     return;
    264 
    265   Display* xdisplay = GDK_DISPLAY_XDISPLAY(display);
    266   int event, err;
    267 
    268   if (!XQueryExtension(xdisplay, "XInputExtension", &xiopcode_, &event, &err)) {
    269     DLOG(WARNING) << "X Input extension not available.";
    270     xiopcode_ = -1;
    271     return;
    272   }
    273 
    274   int major = 2, minor = 0;
    275   if (XIQueryVersion(xdisplay, &major, &minor) == BadRequest) {
    276     DLOG(WARNING) << "XInput2 not supported in the server.";
    277     xiopcode_ = -1;
    278     return;
    279   }
    280 
    281   // TODO(sad): Here, we only setup so that the X windows created by GTK+ are
    282   // setup for XInput2 events. We need a way to listen for XInput2 events for X
    283   // windows created by other means (e.g. for context menus).
    284   SetupGtkWidgetRealizeNotifier(this);
    285 
    286   // Instead of asking X for the list of devices all the time, let's maintain a
    287   // list of pointer devices we care about.
    288   // It is not necessary to select for slave devices. XInput2 provides enough
    289   // information to the event callback to decide which slave device triggered
    290   // the event, thus decide whether the 'pointer event' is a 'mouse event' or a
    291   // 'touch event'.
    292   // If the touch device has 'GrabDevice' set and 'SendCoreEvents' unset (which
    293   // is possible), then the device is detected as a floating device, and a
    294   // floating device is not connected to a master device. So it is necessary to
    295   // also select on the floating devices.
    296   int count = 0;
    297   XIDeviceInfo* devices = XIQueryDevice(xdisplay, XIAllDevices, &count);
    298   for (int i = 0; i < count; i++) {
    299     XIDeviceInfo* devinfo = devices + i;
    300     if (devinfo->use == XIFloatingSlave || devinfo->use == XIMasterPointer)
    301       pointer_devices_.insert(devinfo->deviceid);
    302   }
    303   XIFreeDeviceInfo(devices);
    304 
    305   // TODO(sad): Select on root for XI_HierarchyChanged so that floats_ and
    306   // masters_ can be kept up-to-date. This is a relatively rare event, so we can
    307   // put it off for a later time.
    308   // Note: It is not necessary to listen for XI_DeviceChanged events.
    309 }
    310 #endif  // HAVE_XINPUT2
    311 
    312 }  // namespace base
    313