A non-GTK version of menus for touchui.

base/message_pump_glib_x.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_pump_glib_x.h"
 
 #include <gdk/gdkx.h>
 #if defined(HAVE_XINPUT2)
 #include <X11/extensions/XInput2.h>
 #else
@@ skipping 67 matching lines @@
 #endif
   InitializeEventsToCapture();
 }
 
 MessagePumpGlibX::~MessagePumpGlibX() {
 }
 
 bool MessagePumpGlibX::RunOnce(GMainContext* context, bool block) {
   GdkDisplay* gdisp = gdk_display_get_default();
   Display* display = GDK_DISPLAY_XDISPLAY(gdisp);
+  bool should_quit = false;
+
   if (XPending(display)) {
     XEvent xev;
     XPeekEvent(display, &xev);
     if (capture_x_events_[xev.type]
 #if defined(HAVE_XINPUT2)
         && (xev.type != GenericEvent || xev.xcookie.extension == xiopcode_)
 #endif
         ) {
       XNextEvent(display, &xev);
 
-      bool processed = static_cast<MessagePumpGlibXDispatcher*>
+#if defined(HAVE_XINPUT2)
+      bool have_cookie = false;
+      if (xev.type == GenericEvent &&
+          XGetEventData(xev.xgeneric.display, &xev.xcookie)) {
+        have_cookie = true;
+      }
+#endif
+
+      MessagePumpGlibXDispatcher::DispatchStatus status =
+          static_cast<MessagePumpGlibXDispatcher*>
           (GetDispatcher())->Dispatch(&xev);
 
-      if (!processed) {
+      if (status == MessagePumpGlibXDispatcher::EVENT_QUIT) {
+        should_quit = true;
+        Quit();
+      } else if (status == MessagePumpGlibXDispatcher::EVENT_IGNORED) {
         DLOG(WARNING) << "Event (" << xev.type << ") not handled.";
 
         // TODO(sad): It is necessary to put back the event so that the default
         // GDK events handler can take care of it. Without this, it is
         // impossible to use the omnibox at the moment. However, this will
         // eventually be removed once the omnibox code is updated for touchui.
         XPutBackEvent(display, &xev);
+        if (gdksource_)
+          gdksource_->source_funcs->dispatch = gdkdispatcher_;
         g_main_context_iteration(context, FALSE);
       }
+
+#if defined(HAVE_XINPUT2)
+      if (have_cookie) {
+        XFreeEventData(xev.xgeneric.display, &xev.xcookie);
+      }
+#endif
     } else {
       // TODO(sad): A couple of extra events can still sneak in during this.
       // Those should be sent back to the X queue from the dispatcher
       // EventDispatcherX.
+      if (gdksource_)
+        gdksource_->source_funcs->dispatch = gdkdispatcher_;
       g_main_context_iteration(context, FALSE);
     }
   }
 
+  if (should_quit)
+    return true;
+
   bool retvalue;
   if (gdksource_) {
     // Replace the dispatch callback of the GDK event source temporarily so that
     // it doesn't read events from X.
     gboolean (*cb)(GSource*, GSourceFunc, void*) =
         gdksource_->source_funcs->dispatch;
     gdksource_->source_funcs->dispatch = PlaceholderDispatch;
 
     dispatching_event_ = true;
     retvalue = g_main_context_iteration(context, block);
@@ skipping 42 matching lines @@
     return;
   }
 
   int major = 2, minor = 0;
   if (XIQueryVersion(xdisplay, &major, &minor) == BadRequest) {
     DLOG(WARNING) << "XInput2 not supported in the server.";
     xiopcode_ = -1;
     return;
   }
 
+  // TODO(sad): Here, we only setup so that the X windows created by GTK+ are
+  // setup for XInput2 events. We need a way to listen for XInput2 events for X
+  // windows created by other means (e.g. for context menus).
   SetupGtkWidgetRealizeNotifier(this);
 
   // Instead of asking X for the list of devices all the time, let's maintain a
   // list of slave (physical) and master (virtual) pointer devices.
   int count = 0;
   XIDeviceInfo* devices = XIQueryDevice(xdisplay, XIAllDevices, &count);
   for (int i = 0; i < count; i++) {
     XIDeviceInfo* devinfo = devices + i;
     if (devinfo->use == XISlavePointer) {
       slaves_.insert(devinfo->deviceid);
@@ skipping 44 matching lines @@
   XFlush(xdisplay);
 }
 
 #endif  // HAVE_XINPUT2
 
 void MessagePumpGlibX::EventDispatcherX(GdkEvent* event, gpointer data) {
   MessagePumpGlibX* pump_x = reinterpret_cast<MessagePumpGlibX*>(data);
 
   if (!pump_x->gdksource_) {
     pump_x->gdksource_ = g_main_current_source();
+    pump_x->gdkdispatcher_ = pump_x->gdksource_->source_funcs->dispatch;
   } else if (!pump_x->IsDispatchingEvent()) {
     if (event->type != GDK_NOTHING &&
         pump_x->capture_gdk_events_[event->type]) {
       // TODO(sad): An X event is caught by the GDK handler. Put it back in the
       // X queue so that we catch it in the next iteration. When done, the
       // following DLOG statement will be removed.
       DLOG(WARNING) << "GDK received an event it shouldn't have";
     }
   }
 
   pump_x->DispatchEvents(event);
 }
 
 }  // namespace base