ash/accelerators/accelerator_dispatcher_linux.cc

   1 // Copyright 2014 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 "ash/accelerators/accelerator_dispatcher.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/run_loop.h"
   9 #include "ui/events/event.h"
  10 #include "ui/events/platform/platform_event_dispatcher.h"
  11 #include "ui/events/platform/platform_event_source.h"
  12 #include "ui/events/platform/scoped_event_dispatcher.h"
  13
  14 #if defined(USE_X11)
  15 #include <X11/Xlib.h>
  16 #endif
  17
  18 namespace ash {
  19
  20 namespace {
  21
  22 #if defined(USE_OZONE)
  23 bool IsKeyEvent(const base::NativeEvent& native_event) {
  24   const ui::KeyEvent* event = static_cast<const ui::KeyEvent*>(native_event);
  25   return event->IsKeyEvent();
  26 }
  27 #elif defined(USE_X11)
  28 bool IsKeyEvent(const XEvent* xev) {
  29   return xev->type == KeyPress || xev->type == KeyRelease;
  30 }
  31 #else
  32 #error Unknown build platform: you should have either use_ozone or use_x11.
  33 #endif
  34
  35 scoped_ptr<ui::ScopedEventDispatcher> OverrideDispatcher(
  36     ui::PlatformEventDispatcher* dispatcher) {
  37   ui::PlatformEventSource* source = ui::PlatformEventSource::GetInstance();
  38   return source ? source->OverrideDispatcher(dispatcher)
  39                 : scoped_ptr<ui::ScopedEventDispatcher>();
  40 }
  41
  42 }  // namespace
  43
  44 class AcceleratorDispatcherLinux : public AcceleratorDispatcher,
  45                                    public ui::PlatformEventDispatcher {
  46  public:
  47   AcceleratorDispatcherLinux()
  48       : restore_dispatcher_(OverrideDispatcher(this)) {}
  49
  50   virtual ~AcceleratorDispatcherLinux() {}
  51
  52  private:
  53   // AcceleratorDispatcher:
  54   virtual scoped_ptr<base::RunLoop> CreateRunLoop() OVERRIDE {
  55     return scoped_ptr<base::RunLoop>(new base::RunLoop());
  56   }
  57
  58   // ui::PlatformEventDispatcher:
  59   virtual bool CanDispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
  60     return true;
  61   }
  62
  63   virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
  64     if (IsKeyEvent(event)) {
  65       ui::KeyEvent key_event(event, false);
  66       if (MenuClosedForPossibleAccelerator(key_event)) {
  67 #if defined(USE_X11)
  68         XPutBackEvent(event->xany.display, event);
  69 #else
  70         NOTIMPLEMENTED();
  71 #endif
  72         return ui::POST_DISPATCH_NONE;
  73       }
  74
  75       if (AcceleratorProcessedForKeyEvent(key_event))
  76         return ui::POST_DISPATCH_NONE;
  77     }
  78
  79     ui::PlatformEventDispatcher* prev = *restore_dispatcher_;
  80     return prev ? prev->DispatchEvent(event)
  81                 : ui::POST_DISPATCH_PERFORM_DEFAULT;
  82   }
  83
  84   scoped_ptr<ui::ScopedEventDispatcher> restore_dispatcher_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(AcceleratorDispatcherLinux);
  87 };
  88
  89 scoped_ptr<AcceleratorDispatcher> AcceleratorDispatcher::Create(
  90     base::MessagePumpDispatcher* nested_dispatcher) {
  91   return scoped_ptr<AcceleratorDispatcher>(new AcceleratorDispatcherLinux());
  92 }
  93
  94 }  // namespace ash