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
PlaceholderDispatch(GSource * source,GSourceFunc cb,gpointer data)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.
GtkWidgetRealizeCallback(GSignalInvocationHint * hint,guint nparams,const GValue * pvalues,gpointer data)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
SetupGtkWidgetRealizeNotifier(base::MessagePumpGlibX * msgpump)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
RemoveGtkWidgetRealizeNotifier()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
MessagePumpGlibX()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
~MessagePumpGlibX()96 MessagePumpGlibX::~MessagePumpGlibX() {
97 #if defined(HAVE_XINPUT2)
98 RemoveGtkWidgetRealizeNotifier();
99 #endif
100 }
101
102 #if defined(HAVE_XINPUT2)
SetupXInput2ForXWindow(Window xwindow)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
RunOnce(GMainContext * context,bool block)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
EventDispatcherX(GdkEvent * event,gpointer data)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
InitializeEventsToCapture(void)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)
InitializeXInput2(void)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