chrome/browser/ui/ash/event_rewriter.h

   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 #ifndef CHROME_BROWSER_UI_ASH_EVENT_REWRITER_H_
   6 #define CHROME_BROWSER_UI_ASH_EVENT_REWRITER_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "ash/event_rewriter_delegate.h"
  12 #include "base/basictypes.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/containers/hash_tables.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "ui/aura/root_window_observer.h"
  17 #include "ui/base/keycodes/keyboard_codes.h"
  18
  19 #if defined(OS_CHROMEOS)
  20 #include "chrome/browser/chromeos/device_hierarchy_observer.h"
  21 #endif
  22
  23 class PrefService;
  24
  25 namespace aura {
  26 class RootWindow;
  27 }
  28
  29 #if defined(OS_CHROMEOS)
  30 namespace chromeos {
  31
  32 class KeyboardDrivenEventRewriter;
  33
  34 namespace input_method {
  35 class XKeyboard;
  36 }
  37 }
  38 #endif
  39
  40 class EventRewriter : public ash::EventRewriterDelegate,
  41                       public aura::RootWindowObserver
  42 #if defined(OS_CHROMEOS)
  43                     , public chromeos::DeviceHierarchyObserver
  44 #endif
  45 {
  46  public:
  47   enum DeviceType {
  48     kDeviceUnknown = 0,
  49     kDeviceAppleKeyboard,
  50   };
  51
  52   EventRewriter();
  53   virtual ~EventRewriter();
  54
  55   // Calls DeviceAddedInternal.
  56   DeviceType DeviceAddedForTesting(int device_id,
  57                                    const std::string& device_name);
  58   // Calls Rewrite.
  59   void RewriteForTesting(ui::KeyEvent* event);
  60
  61   const std::map<int, DeviceType>& device_id_to_type_for_testing() const {
  62     return device_id_to_type_;
  63   }
  64   void set_last_device_id_for_testing(int device_id) {
  65     last_device_id_ = device_id;
  66   }
  67   void set_pref_service_for_testing(const PrefService* pref_service) {
  68     pref_service_ = pref_service;
  69   }
  70 #if defined(OS_CHROMEOS)
  71   void set_xkeyboard_for_testing(chromeos::input_method::XKeyboard* xkeyboard) {
  72     xkeyboard_ = xkeyboard;
  73   }
  74 #endif
  75
  76   // Gets DeviceType from the |device_name|.
  77   static DeviceType GetDeviceType(const std::string& device_name);
  78
  79  private:
  80   // ash::EventRewriterDelegate overrides:
  81   virtual ash::EventRewriterDelegate::Action RewriteOrFilterKeyEvent(
  82       ui::KeyEvent* event) OVERRIDE;
  83   virtual ash::EventRewriterDelegate::Action RewriteOrFilterLocatedEvent(
  84       ui::LocatedEvent* event) OVERRIDE;
  85
  86   // aura::RootWindowObserver overrides:
  87   virtual void OnKeyboardMappingChanged(const aura::RootWindow* root) OVERRIDE;
  88
  89 #if defined(OS_CHROMEOS)
  90   // chromeos::DeviceHierarchyObserver overrides:
  91   virtual void DeviceHierarchyChanged() OVERRIDE {}
  92   virtual void DeviceAdded(int device_id) OVERRIDE;
  93   virtual void DeviceRemoved(int device_id) OVERRIDE;
  94   virtual void DeviceKeyPressedOrReleased(int device_id) OVERRIDE;
  95
  96   // We don't want to include Xlib.h here since it has polluting macros, so
  97   // define these locally.
  98   typedef unsigned long KeySym;
  99   typedef unsigned char KeyCode;
 100
 101   // Updates |*_xkeycode_| in response to a keyboard map change.
 102   void RefreshKeycodes();
 103   // Converts an X key symbol like XK_Control_L to a key code.
 104   unsigned char NativeKeySymToNativeKeycode(KeySym keysym);
 105
 106   struct KeyboardRemapping {
 107     KeySym input_keysym;
 108     unsigned int input_mods;
 109     unsigned int input_native_mods;
 110     KeySym output_keysym;
 111     ui::KeyboardCode output_keycode;
 112     unsigned int output_mods;
 113     unsigned int output_native_mods;
 114   };
 115
 116   // Given a set of KeyboardRemapping structs, it finds a matching struct
 117   // if possible, and updates the remapped event values. Returns true if a
 118   // remapping was found and remapped values were updated.
 119   bool RewriteWithKeyboardRemappingsByKeySym(
 120       const KeyboardRemapping* remappings,
 121       size_t num_remappings,
 122       KeySym keysym,
 123       unsigned int native_mods,
 124       unsigned int mods,
 125       KeySym* remapped_native_keysym,
 126       unsigned int* remapped_native_mods,
 127       ui::KeyboardCode* remapped_keycode,
 128       unsigned int* remapped_mods);
 129
 130   // Given a set of KeyboardRemapping structs, it finds a matching struct
 131   // if possible, and updates the remapped event values. This function converts
 132   // the KeySym in the KeyboardRemapping struct into the KeyCode before matching
 133   // to allow any KeyCode on the same physical key as the given KeySym to match.
 134   // Returns true if a remapping was found and remapped values were updated.
 135   bool RewriteWithKeyboardRemappingsByKeyCode(
 136       const KeyboardRemapping* remappings,
 137       size_t num_remappings,
 138       KeyCode keycode,
 139       unsigned int native_mods,
 140       unsigned int mods,
 141       KeySym* remapped_native_keysym,
 142       unsigned int* remapped_native_mods,
 143       ui::KeyboardCode* remapped_keycode,
 144       unsigned int* remapped_mods);
 145 #endif
 146
 147   // Rewrites the |event| by applying all RewriteXXX functions as needed.
 148   void Rewrite(ui::KeyEvent* event);
 149
 150   // Rewrites a modifier key press/release following the current user
 151   // preferences.
 152   bool RewriteModifiers(ui::KeyEvent* event);
 153
 154   // Rewrites Fn key press/release to Control. In some cases, Fn key is not
 155   // intercepted by the EC, but generates a key event like "XK_F15 + Mod3Mask"
 156   // as shown in crosbug.com/p/14339.
 157   bool RewriteFnKey(ui::KeyEvent* event);
 158
 159   // Rewrites a NumPad key press/release without Num Lock to a corresponding key
 160   // press/release with the lock.  Returns true when |event| is rewritten.
 161   bool RewriteNumPadKeys(ui::KeyEvent* event);
 162
 163   // Rewrites Backspace and Arrow keys following the Chrome OS keyboard spec.
 164   //  * Alt+Backspace -> Delete
 165   //  * Alt+Up -> Prior (aka PageUp)
 166   //  * Alt+Down -> Next (aka PageDown)
 167   //  * Ctrl+Alt+Up -> Home
 168   //  * Ctrl+Alt+Down -> End
 169   // When the Search key acts as a function key, it instead maps:
 170   //  * Search+Backspace -> Delete
 171   //  * Search+Up -> Prior (aka PageUp)
 172   //  * Search+Down -> Next (aka PageDown)
 173   //  * Search+Left -> Home
 174   //  * Search+Right -> End
 175   //  * Search+. -> Insert
 176   // Returns true when the |event| is rewritten.
 177   bool RewriteExtendedKeys(ui::KeyEvent* event);
 178
 179   // When the Search key acts as a function key, it remaps Search+1
 180   // through Search+= to F1 through F12. Returns true when the |event| is
 181   // rewritten.
 182   bool RewriteFunctionKeys(ui::KeyEvent* event);
 183
 184   // Rewrites the located |event|.
 185   void RewriteLocatedEvent(ui::LocatedEvent* event);
 186
 187   // Overwrites |event| with the keycodes and flags.
 188   void OverwriteEvent(ui::KeyEvent* event,
 189                       unsigned int new_native_keycode,
 190                       unsigned int new_native_state,
 191                       ui::KeyboardCode new_keycode,
 192                       int new_flags);
 193
 194   // Checks the type of the |device_name|, and inserts a new entry to
 195   // |device_id_to_type_|.
 196   DeviceType DeviceAddedInternal(int device_id, const std::string& device_name);
 197
 198   // Returns true if |last_device_id_| is Apple's.
 199   bool IsAppleKeyboard() const;
 200
 201   // Remaps |original_flags| to |remapped_flags| and |original_native_modifiers|
 202   // to |remapped_native_modifiers| following the current user prefs.
 203   void GetRemappedModifierMasks(int original_flags,
 204                                 unsigned int original_native_modifiers,
 205                                 int* remapped_flags,
 206                                 unsigned int* remapped_native_modifiers) const;
 207
 208   std::map<int, DeviceType> device_id_to_type_;
 209   int last_device_id_;
 210
 211 #if defined(OS_CHROMEOS)
 212   // A mapping from X11 KeySym keys to KeyCode values.
 213   base::hash_map<unsigned long, unsigned long> keysym_to_keycode_map_;
 214
 215   chromeos::input_method::XKeyboard* xkeyboard_;  // for testing.
 216
 217   scoped_ptr<chromeos::KeyboardDrivenEventRewriter>
 218       keyboard_driven_event_rewritter_;
 219 #endif
 220
 221   const PrefService* pref_service_;  // for testing.
 222
 223   DISALLOW_COPY_AND_ASSIGN(EventRewriter);
 224 };
 225
 226 #endif  // CHROME_BROWSER_UI_ASH_EVENT_REWRITER_H_