src/ash/wm/maximize_mode/maximize_mode_event_blocker.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/wm/maximize_mode/maximize_mode_event_blocker.h"
   6
   7 #include "ash/shell.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "ui/aura/client/cursor_client.h"
  10 #include "ui/events/event_targeter.h"
  11 #include "ui/events/keycodes/keyboard_codes.h"
  12
  13 namespace ash {
  14
  15 namespace {
  16
  17 // Event targeter to prevent delivery of mouse and touchpad events while
  18 // maximize mode is active. Other events such as touch are passed on to the
  19 // default targeter.
  20 // TODO(flackr): This should only stop events from the internal keyboard and
  21 // touchpad.
  22 class BlockKeyboardAndTouchpadTargeter : public ui::EventTargeter {
  23  public:
  24   BlockKeyboardAndTouchpadTargeter();
  25   virtual ~BlockKeyboardAndTouchpadTargeter();
  26
  27   // Sets the default targeter to use when the event is not being blocked.
  28   void SetDefaultTargeter(EventTargeter* default_targeter);
  29
  30   // Overridden from ui::EventTargeter:
  31   virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
  32                                               ui::Event* event) OVERRIDE;
  33
  34  private:
  35   // A weak pointer to the targeter this targeter is wrapping. The
  36   // default_targeter is owned by the ScopedWindowTargeter which will be valid
  37   // as long as this targeter is alive.
  38   ui::EventTargeter* default_targeter_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(BlockKeyboardAndTouchpadTargeter);
  41 };
  42
  43 BlockKeyboardAndTouchpadTargeter::BlockKeyboardAndTouchpadTargeter()
  44     : default_targeter_(NULL) {
  45 }
  46
  47 BlockKeyboardAndTouchpadTargeter::~BlockKeyboardAndTouchpadTargeter() {
  48 }
  49
  50 void BlockKeyboardAndTouchpadTargeter::SetDefaultTargeter(
  51     ui::EventTargeter* default_targeter) {
  52   default_targeter_ = default_targeter;
  53 }
  54
  55 ui::EventTarget* BlockKeyboardAndTouchpadTargeter::FindTargetForEvent(
  56     ui::EventTarget* root,
  57     ui::Event* event) {
  58   if (event->HasNativeEvent()) {
  59     if (event->IsMouseEvent())
  60       return NULL;
  61     if (event->IsKeyEvent()) {
  62       // TODO(bruthig): Fix this to block rewritten volume keys
  63       // (i.e. F9 and F10)  from the device's keyboard. https://crbug.com/368669
  64       ui::KeyEvent* key_event = static_cast<ui::KeyEvent*>(event);
  65       if (key_event->key_code() != ui::VKEY_VOLUME_DOWN &&
  66           key_event->key_code() != ui::VKEY_VOLUME_UP) {
  67         return NULL;
  68       }
  69     }
  70   }
  71   return default_targeter_->FindTargetForEvent(root, event);
  72 }
  73
  74 }  // namespace
  75
  76 MaximizeModeEventBlocker::MaximizeModeEventBlocker() {
  77   Shell::GetInstance()->AddShellObserver(this);
  78
  79   // Hide the cursor as mouse events will be blocked.
  80   aura::client::CursorClient* cursor_client_ =
  81       aura::client::GetCursorClient(Shell::GetTargetRootWindow());
  82   if (cursor_client_)
  83     cursor_client_->HideCursor();
  84
  85   // Block keyboard and mouse events on all existing and new root windows for
  86   // the lifetime of this class.
  87   aura::Window::Windows root_windows(Shell::GetAllRootWindows());
  88   for (aura::Window::Windows::iterator iter = root_windows.begin();
  89        iter != root_windows.end(); ++iter) {
  90     AddEventTargeterOn(*iter);
  91   }
  92 }
  93
  94 MaximizeModeEventBlocker::~MaximizeModeEventBlocker() {
  95   Shell::GetInstance()->RemoveShellObserver(this);
  96 }
  97
  98 void MaximizeModeEventBlocker::OnRootWindowAdded(aura::Window* root_window) {
  99   AddEventTargeterOn(root_window);
 100 }
 101
 102 void MaximizeModeEventBlocker::AddEventTargeterOn(
 103     aura::Window* root_window) {
 104   BlockKeyboardAndTouchpadTargeter* targeter =
 105       new BlockKeyboardAndTouchpadTargeter();
 106   aura::ScopedWindowTargeter* scoped_targeter = new aura::ScopedWindowTargeter(
 107       root_window, scoped_ptr<ui::EventTargeter>(targeter));
 108   targeter->SetDefaultTargeter(scoped_targeter->old_targeter());
 109   targeters_.push_back(scoped_targeter);
 110 }
 111
 112 }  // namespace ash