Add sticky key support for AltGr

ash/sticky_keys/sticky_keys_controller.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/sticky_keys/sticky_keys_controller.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #undef RootWindow
@@ skipping 97 matching lines @@
 
     // Reset key handlers when activating sticky keys to ensure all
     // the handlers' states are reset.
     if (enabled_) {
       shift_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_SHIFT_DOWN,
                                 new StickyKeysHandlerDelegateImpl()));
       alt_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_ALT_DOWN,
                                 new StickyKeysHandlerDelegateImpl()));
+      altgr_sticky_key_.reset(
+          new StickyKeysHandler(ui::EF_ALTGR_DOWN,
+                                new StickyKeysHandlerDelegateImpl()));
       ctrl_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_CONTROL_DOWN,
                                 new StickyKeysHandlerDelegateImpl()));
 
       overlay_.reset(new StickyKeysOverlay());
     } else if (overlay_.get()) {
       overlay_->Show(false);
     }
   }
 }
 
 bool StickyKeysController::HandleKeyEvent(ui::KeyEvent* event) {
   return shift_sticky_key_->HandleKeyEvent(event) ||
       alt_sticky_key_->HandleKeyEvent(event) ||
+      altgr_sticky_key_->HandleKeyEvent(event) ||
       ctrl_sticky_key_->HandleKeyEvent(event);
 }
 
 bool StickyKeysController::HandleMouseEvent(ui::MouseEvent* event) {
   return shift_sticky_key_->HandleMouseEvent(event) ||
       alt_sticky_key_->HandleMouseEvent(event) ||
+      altgr_sticky_key_->HandleMouseEvent(event) ||
       ctrl_sticky_key_->HandleMouseEvent(event);
 }
 
 bool StickyKeysController::HandleScrollEvent(ui::ScrollEvent* event) {
   return shift_sticky_key_->HandleScrollEvent(event) ||
       alt_sticky_key_->HandleScrollEvent(event) ||
+      altgr_sticky_key_->HandleScrollEvent(event) ||
       ctrl_sticky_key_->HandleScrollEvent(event);
 }
 
 void StickyKeysController::OnKeyEvent(ui::KeyEvent* event) {
   // Do not consume a translated key event which is generated by an IME.
   if (event->type() == ui::ET_TRANSLATED_KEY_PRESS ||
       event->type() == ui::ET_TRANSLATED_KEY_RELEASE) {
     return;
   }
 
@@ skipping 20 matching lines @@
   }
 }
 
 void StickyKeysController::UpdateOverlay() {
   overlay_->SetModifierKeyState(
       ui::EF_SHIFT_DOWN, shift_sticky_key_->current_state());
   overlay_->SetModifierKeyState(
       ui::EF_CONTROL_DOWN, ctrl_sticky_key_->current_state());
   overlay_->SetModifierKeyState(
       ui::EF_ALT_DOWN, alt_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(
+      ui::EF_ALTGR_DOWN, altgr_sticky_key_->current_state());
 
   bool key_in_use =
       shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
+      altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;
 
   overlay_->Show(enabled_ && key_in_use);
 }
 
 StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
   return overlay_.get();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 98 matching lines @@
       event->key_code() == ui::VKEY_RSHIFT) {
     is_target_key = (modifier_flag_ == ui::EF_SHIFT_DOWN);
   } else if (event->key_code() == ui::VKEY_CONTROL ||
       event->key_code() == ui::VKEY_LCONTROL ||
       event->key_code() == ui::VKEY_RCONTROL) {
     is_target_key = (modifier_flag_ == ui::EF_CONTROL_DOWN);
   } else if (event->key_code() == ui::VKEY_MENU ||
       event->key_code() == ui::VKEY_LMENU ||
       event->key_code() == ui::VKEY_RMENU) {
     is_target_key = (modifier_flag_ == ui::EF_ALT_DOWN);
+  } else if (event->key_code() == ui::VKEY_ALTGR) {
+    is_target_key = (modifier_flag_ == ui::EF_ALTGR_DOWN);
   } else {
     return event->type() == ui::ET_KEY_PRESSED ?
         NORMAL_KEY_DOWN : NORMAL_KEY_UP;
   }
 
   if (is_target_key) {
     return event->type() == ui::ET_KEY_PRESSED ?
         TARGET_MODIFIER_DOWN : TARGET_MODIFIER_UP;
   }
   return event->type() == ui::ET_KEY_PRESSED ?
@@ skipping 102 matching lines @@
 void StickyKeysHandler::AppendNativeEventMask(unsigned int* state) {
 #if defined(USE_X11)
   unsigned int& state_ref = *state;
   switch (modifier_flag_) {
     case ui::EF_CONTROL_DOWN:
       state_ref |= ControlMask;
       break;
     case ui::EF_ALT_DOWN:
       state_ref |= Mod1Mask;
       break;
+    case ui::EF_ALTGR_DOWN:
+      state_ref |= Mod5Mask;
+      break;
     case ui::EF_SHIFT_DOWN:
       state_ref |= ShiftMask;
       break;
     default:
       NOTREACHED();
   }
 #endif
 }
 
 void StickyKeysHandler::AppendModifier(ui::KeyEvent* event) {
@@ skipping 36 matching lines @@
           &xievent->mods.effective));
     }
   }
 #elif defined(USE_OZONE)
   NOTIMPLEMENTED() << "Modifier key is not handled";
 #endif
   event->set_flags(event->flags() | modifier_flag_);
 }
 
 }  // namespace ash