| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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_loop/message_pump_aurax11.h" | |
| 6 | |
| 7 #include <glib.h> | |
| 8 #include <X11/X.h> | |
| 9 #include <X11/extensions/XInput2.h> | |
| 10 #include <X11/XKBlib.h> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/message_loop/message_loop.h" | |
| 14 | |
| 15 namespace base { | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 gboolean XSourcePrepare(GSource* source, gint* timeout_ms) { | |
| 20 if (XPending(MessagePumpAuraX11::GetDefaultXDisplay())) | |
| 21 *timeout_ms = 0; | |
| 22 else | |
| 23 *timeout_ms = -1; | |
| 24 return FALSE; | |
| 25 } | |
| 26 | |
| 27 gboolean XSourceCheck(GSource* source) { | |
| 28 return XPending(MessagePumpAuraX11::GetDefaultXDisplay()); | |
| 29 } | |
| 30 | |
| 31 gboolean XSourceDispatch(GSource* source, | |
| 32 GSourceFunc unused_func, | |
| 33 gpointer data) { | |
| 34 MessagePumpAuraX11* pump = static_cast<MessagePumpAuraX11*>(data); | |
| 35 return pump->DispatchXEvents(); | |
| 36 } | |
| 37 | |
| 38 GSourceFuncs XSourceFuncs = { | |
| 39 XSourcePrepare, | |
| 40 XSourceCheck, | |
| 41 XSourceDispatch, | |
| 42 NULL | |
| 43 }; | |
| 44 | |
| 45 // The connection is essentially a global that's accessed through a static | |
| 46 // method and destroyed whenever ~MessagePumpAuraX11() is called. We do this | |
| 47 // for historical reasons so user code can call | |
| 48 // MessagePumpForUI::GetDefaultXDisplay() where MessagePumpForUI is a typedef | |
| 49 // to whatever type in the current build. | |
| 50 // | |
| 51 // TODO(erg): This can be changed to something more sane like | |
| 52 // MessagePumpAuraX11::Current()->display() once MessagePumpGtk goes away. | |
| 53 Display* g_xdisplay = NULL; | |
| 54 int g_xinput_opcode = -1; | |
| 55 | |
| 56 bool InitializeXInput2Internal() { | |
| 57 Display* display = MessagePumpAuraX11::GetDefaultXDisplay(); | |
| 58 if (!display) | |
| 59 return false; | |
| 60 | |
| 61 int event, err; | |
| 62 | |
| 63 int xiopcode; | |
| 64 if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) { | |
| 65 DVLOG(1) << "X Input extension not available."; | |
| 66 return false; | |
| 67 } | |
| 68 g_xinput_opcode = xiopcode; | |
| 69 | |
| 70 #if defined(USE_XI2_MT) | |
| 71 // USE_XI2_MT also defines the required XI2 minor minimum version. | |
| 72 int major = 2, minor = USE_XI2_MT; | |
| 73 #else | |
| 74 int major = 2, minor = 0; | |
| 75 #endif | |
| 76 if (XIQueryVersion(display, &major, &minor) == BadRequest) { | |
| 77 DVLOG(1) << "XInput2 not supported in the server."; | |
| 78 return false; | |
| 79 } | |
| 80 #if defined(USE_XI2_MT) | |
| 81 if (major < 2 || (major == 2 && minor < USE_XI2_MT)) { | |
| 82 DVLOG(1) << "XI version on server is " << major << "." << minor << ". " | |
| 83 << "But 2." << USE_XI2_MT << " is required."; | |
| 84 return false; | |
| 85 } | |
| 86 #endif | |
| 87 | |
| 88 return true; | |
| 89 } | |
| 90 | |
| 91 Window FindEventTarget(const NativeEvent& xev) { | |
| 92 Window target = xev->xany.window; | |
| 93 if (xev->type == GenericEvent && | |
| 94 static_cast<XIEvent*>(xev->xcookie.data)->extension == g_xinput_opcode) { | |
| 95 target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event; | |
| 96 } | |
| 97 return target; | |
| 98 } | |
| 99 | |
| 100 bool InitializeXInput2() { | |
| 101 static bool xinput2_supported = InitializeXInput2Internal(); | |
| 102 return xinput2_supported; | |
| 103 } | |
| 104 | |
| 105 bool InitializeXkb() { | |
| 106 Display* display = MessagePumpAuraX11::GetDefaultXDisplay(); | |
| 107 if (!display) | |
| 108 return false; | |
| 109 | |
| 110 int opcode, event, error; | |
| 111 int major = XkbMajorVersion; | |
| 112 int minor = XkbMinorVersion; | |
| 113 if (!XkbQueryExtension(display, &opcode, &event, &error, &major, &minor)) { | |
| 114 DVLOG(1) << "Xkb extension not available."; | |
| 115 return false; | |
| 116 } | |
| 117 | |
| 118 // Ask the server not to send KeyRelease event when the user holds down a key. | |
| 119 // crbug.com/138092 | |
| 120 Bool supported_return; | |
| 121 if (!XkbSetDetectableAutoRepeat(display, True, &supported_return)) { | |
| 122 DVLOG(1) << "XKB not supported in the server."; | |
| 123 return false; | |
| 124 } | |
| 125 | |
| 126 return true; | |
| 127 } | |
| 128 | |
| 129 } // namespace | |
| 130 | |
| 131 MessagePumpAuraX11::MessagePumpAuraX11() : MessagePumpGlib(), | |
| 132 x_source_(NULL) { | |
| 133 InitializeXInput2(); | |
| 134 InitializeXkb(); | |
| 135 InitXSource(); | |
| 136 | |
| 137 // Can't put this in the initializer list because g_xdisplay may not exist | |
| 138 // until after InitXSource(). | |
| 139 x_root_window_ = DefaultRootWindow(g_xdisplay); | |
| 140 } | |
| 141 | |
| 142 MessagePumpAuraX11::~MessagePumpAuraX11() { | |
| 143 g_source_destroy(x_source_); | |
| 144 g_source_unref(x_source_); | |
| 145 XCloseDisplay(g_xdisplay); | |
| 146 g_xdisplay = NULL; | |
| 147 } | |
| 148 | |
| 149 // static | |
| 150 Display* MessagePumpAuraX11::GetDefaultXDisplay() { | |
| 151 if (!g_xdisplay) | |
| 152 g_xdisplay = XOpenDisplay(NULL); | |
| 153 return g_xdisplay; | |
| 154 } | |
| 155 | |
| 156 // static | |
| 157 bool MessagePumpAuraX11::HasXInput2() { | |
| 158 return InitializeXInput2(); | |
| 159 } | |
| 160 | |
| 161 // static | |
| 162 MessagePumpAuraX11* MessagePumpAuraX11::Current() { | |
| 163 MessageLoopForUI* loop = MessageLoopForUI::current(); | |
| 164 return static_cast<MessagePumpAuraX11*>(loop->pump_ui()); | |
| 165 } | |
| 166 | |
| 167 void MessagePumpAuraX11::AddDispatcherForWindow( | |
| 168 MessagePumpDispatcher* dispatcher, | |
| 169 unsigned long xid) { | |
| 170 dispatchers_.insert(std::make_pair(xid, dispatcher)); | |
| 171 } | |
| 172 | |
| 173 void MessagePumpAuraX11::RemoveDispatcherForWindow(unsigned long xid) { | |
| 174 dispatchers_.erase(xid); | |
| 175 } | |
| 176 | |
| 177 void MessagePumpAuraX11::AddDispatcherForRootWindow( | |
| 178 MessagePumpDispatcher* dispatcher) { | |
| 179 root_window_dispatchers_.AddObserver(dispatcher); | |
| 180 } | |
| 181 | |
| 182 void MessagePumpAuraX11::RemoveDispatcherForRootWindow( | |
| 183 MessagePumpDispatcher* dispatcher) { | |
| 184 root_window_dispatchers_.RemoveObserver(dispatcher); | |
| 185 } | |
| 186 | |
| 187 void MessagePumpAuraX11::AddObserver(MessagePumpObserver* observer) { | |
| 188 observers_.AddObserver(observer); | |
| 189 } | |
| 190 | |
| 191 void MessagePumpAuraX11::RemoveObserver(MessagePumpObserver* observer) { | |
| 192 observers_.RemoveObserver(observer); | |
| 193 } | |
| 194 | |
| 195 bool MessagePumpAuraX11::DispatchXEvents() { | |
| 196 Display* display = GetDefaultXDisplay(); | |
| 197 DCHECK(display); | |
| 198 MessagePumpDispatcher* dispatcher = | |
| 199 GetDispatcher() ? GetDispatcher() : this; | |
| 200 | |
| 201 // In the general case, we want to handle all pending events before running | |
| 202 // the tasks. This is what happens in the message_pump_glib case. | |
| 203 while (XPending(display)) { | |
| 204 XEvent xev; | |
| 205 XNextEvent(display, &xev); | |
| 206 if (dispatcher && ProcessXEvent(dispatcher, &xev)) | |
| 207 return TRUE; | |
| 208 } | |
| 209 return TRUE; | |
| 210 } | |
| 211 | |
| 212 void MessagePumpAuraX11::BlockUntilWindowMapped(unsigned long xid) { | |
| 213 XEvent event; | |
| 214 | |
| 215 Display* display = GetDefaultXDisplay(); | |
| 216 DCHECK(display); | |
| 217 | |
| 218 MessagePumpDispatcher* dispatcher = | |
| 219 GetDispatcher() ? GetDispatcher() : this; | |
| 220 | |
| 221 do { | |
| 222 // Block until there's a message of |event_mask| type on |w|. Then remove | |
| 223 // it from the queue and stuff it in |event|. | |
| 224 XWindowEvent(display, xid, StructureNotifyMask, &event); | |
| 225 ProcessXEvent(dispatcher, &event); | |
| 226 } while (event.type != MapNotify); | |
| 227 } | |
| 228 | |
| 229 void MessagePumpAuraX11::InitXSource() { | |
| 230 // CHECKs are to help track down crbug.com/113106. | |
| 231 CHECK(!x_source_); | |
| 232 Display* display = GetDefaultXDisplay(); | |
| 233 CHECK(display) << "Unable to get connection to X server"; | |
| 234 x_poll_.reset(new GPollFD()); | |
| 235 CHECK(x_poll_.get()); | |
| 236 x_poll_->fd = ConnectionNumber(display); | |
| 237 x_poll_->events = G_IO_IN; | |
| 238 | |
| 239 x_source_ = g_source_new(&XSourceFuncs, sizeof(GSource)); | |
| 240 g_source_add_poll(x_source_, x_poll_.get()); | |
| 241 g_source_set_can_recurse(x_source_, TRUE); | |
| 242 g_source_set_callback(x_source_, NULL, this, NULL); | |
| 243 g_source_attach(x_source_, g_main_context_default()); | |
| 244 } | |
| 245 | |
| 246 bool MessagePumpAuraX11::ProcessXEvent(MessagePumpDispatcher* dispatcher, | |
| 247 XEvent* xev) { | |
| 248 bool should_quit = false; | |
| 249 | |
| 250 bool have_cookie = false; | |
| 251 if (xev->type == GenericEvent && | |
| 252 XGetEventData(xev->xgeneric.display, &xev->xcookie)) { | |
| 253 have_cookie = true; | |
| 254 } | |
| 255 | |
| 256 if (!WillProcessXEvent(xev)) { | |
| 257 if (!dispatcher->Dispatch(xev)) { | |
| 258 should_quit = true; | |
| 259 Quit(); | |
| 260 } | |
| 261 DidProcessXEvent(xev); | |
| 262 } | |
| 263 | |
| 264 if (have_cookie) { | |
| 265 XFreeEventData(xev->xgeneric.display, &xev->xcookie); | |
| 266 } | |
| 267 | |
| 268 return should_quit; | |
| 269 } | |
| 270 | |
| 271 bool MessagePumpAuraX11::WillProcessXEvent(XEvent* xevent) { | |
| 272 if (!observers().might_have_observers()) | |
| 273 return false; | |
| 274 ObserverListBase<MessagePumpObserver>::Iterator it(observers()); | |
| 275 MessagePumpObserver* obs; | |
| 276 while ((obs = it.GetNext()) != NULL) { | |
| 277 if (obs->WillProcessEvent(xevent)) | |
| 278 return true; | |
| 279 } | |
| 280 return false; | |
| 281 } | |
| 282 | |
| 283 void MessagePumpAuraX11::DidProcessXEvent(XEvent* xevent) { | |
| 284 FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent)); | |
| 285 } | |
| 286 | |
| 287 MessagePumpDispatcher* MessagePumpAuraX11::GetDispatcherForXEvent( | |
| 288 const NativeEvent& xev) const { | |
| 289 ::Window x_window = FindEventTarget(xev); | |
| 290 DispatchersMap::const_iterator it = dispatchers_.find(x_window); | |
| 291 return it != dispatchers_.end() ? it->second : NULL; | |
| 292 } | |
| 293 | |
| 294 bool MessagePumpAuraX11::Dispatch(const NativeEvent& xev) { | |
| 295 // MappingNotify events (meaning that the keyboard or pointer buttons have | |
| 296 // been remapped) aren't associated with a window; send them to all | |
| 297 // dispatchers. | |
| 298 if (xev->type == MappingNotify) { | |
| 299 for (DispatchersMap::const_iterator it = dispatchers_.begin(); | |
| 300 it != dispatchers_.end(); ++it) { | |
| 301 it->second->Dispatch(xev); | |
| 302 } | |
| 303 return true; | |
| 304 } | |
| 305 | |
| 306 if (FindEventTarget(xev) == x_root_window_) { | |
| 307 FOR_EACH_OBSERVER(MessagePumpDispatcher, root_window_dispatchers_, | |
| 308 Dispatch(xev)); | |
| 309 return true; | |
| 310 } | |
| 311 MessagePumpDispatcher* dispatcher = GetDispatcherForXEvent(xev); | |
| 312 return dispatcher ? dispatcher->Dispatch(xev) : true; | |
| 313 } | |
| 314 | |
| 315 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23880006:
gtk: Allow building both the X11 and Gtk message-pumps for gtk. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src