Supports unicode composition(Ctrl+Shift+U) with C-S pressed.

ui/base/ime/character_composer.cc

 // Copyright (c) 2012 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 "ui/base/ime/character_composer.h"
 
+#include <X11/Xlib.h>
+
 #include <algorithm>
 #include <iterator>
 
 #include "base/third_party/icu/icu_utf.h"
 #include "base/utf_string_conversions.h"
 // Note for Gtk removal: gdkkeysyms.h only contains a set of
 // '#define GDK_KeyName 0xNNNN' macros and does not #include any Gtk headers.
 #include "third_party/gtk+/gdk/gdkkeysyms.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/glib/glib_integers.h"
+#include "ui/base/x/x11_util.h"
 
 // Note for Gtk removal: gtkimcontextsimpleseqs.h does not #include any Gtk
 // headers and only contains one big guint16 array |gtk_compose_seqs_compact|
 // which defines the main compose table. The table has internal linkage.
 // The order of header inclusion is out of order because
 // gtkimcontextsimpleseqs.h depends on guint16, which is defined in
 // "ui/base/glib/glib_integers.h".
 #include "third_party/gtk+/gtk/gtkimcontextsimpleseqs.h"
 
 namespace {
@@ skipping 315 matching lines @@
   if (!CBU_IS_UNICODE_CHAR(character))
     return false;
   if (character) {
     output->resize(CBU16_LENGTH(character));
     size_t i = 0;
     CBU16_APPEND_UNSAFE(&(*output)[0], i, character);
   }
   return true;
 }
 
+// Converts a X keycode to a X keysym with no modifiers.
+KeySym XKeyCodeToXKeySym(unsigned int keycode) {
+  Display* display = ui::GetXDisplay();
+  if (!display)
+    return NoSymbol;
+
+  XKeyEvent x_key_event = {0};
+  x_key_event.type = KeyPress;
+  x_key_event.display = display;
+  x_key_event.keycode = keycode;
+  return ::XLookupKeysym(&x_key_event, 0);
+}
+
 // Returns an hexadecimal digit integer (0 to 15) corresponding to |keyval|.
 // -1 is returned when |keyval| cannot be a hexadecimal digit.
 int KeyvalToHexDigit(unsigned int keyval) {
   if (GDK_KEY_0 <= keyval && keyval <= GDK_KEY_9)
     return keyval - GDK_KEY_0;
   if (GDK_KEY_a <= keyval && keyval <= GDK_KEY_f)
     return keyval - GDK_KEY_a + 10;
   if (GDK_KEY_A <= keyval && keyval <= GDK_KEY_F)
     return keyval - GDK_KEY_A + 10;
   return -1;  // |keyval| cannot be a hexadecimal digit.
 }
 
 }  // namespace
 
 namespace ui {
 
 CharacterComposer::CharacterComposer() : composition_mode_(KEY_SEQUENCE_MODE) {}
 
 CharacterComposer::~CharacterComposer() {}
 
 void CharacterComposer::Reset() {
   compose_buffer_.clear();
   composed_character_.clear();
   preedit_string_.clear();
   composition_mode_ = KEY_SEQUENCE_MODE;
 }
 
 bool CharacterComposer::FilterKeyPress(unsigned int keyval,
-                                       unsigned int flags) {
+                                       unsigned int keycode,
+                                       int flags) {
   composed_character_.clear();
   preedit_string_.clear();
 
   // We don't care about modifier key presses.
   if(KeypressShouldBeIgnored(keyval))
     return false;
 
   // When the user presses Ctrl+Shift+U, maybe switch to HEX_MODE.
   // We don't care about other modifiers like Alt.  When CapsLock is down, we
   // do nothing because what we receive is Ctrl+Shift+u (not U).
   if (keyval == GDK_KEY_U && (flags & EF_SHIFT_DOWN) &&
       (flags & EF_CONTROL_DOWN)) {
     if (composition_mode_ == KEY_SEQUENCE_MODE && compose_buffer_.empty()) {
       // There is no ongoing composition.  Let's switch to HEX_MODE.
       composition_mode_ = HEX_MODE;
       UpdatePreeditStringHexMode();
       return true;
     }
   }
 
   // Filter key press in an appropriate manner.
   switch (composition_mode_) {
     case KEY_SEQUENCE_MODE:
-      return FilterKeyPressSequenceMode(keyval, flags);
+      return FilterKeyPressSequenceMode(keyval, keycode, flags);
     case HEX_MODE:
-      return FilterKeyPressHexMode(keyval, flags);
+      return FilterKeyPressHexMode(keyval, keycode, flags);
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool CharacterComposer::FilterKeyPressSequenceMode(unsigned int keyval,
-                                                   unsigned int flags) {
+                                                   unsigned int keycode,
+                                                   int flags) {
   DCHECK(composition_mode_ == KEY_SEQUENCE_MODE);
   compose_buffer_.push_back(keyval);
 
   // Check compose table.
   uint32 composed_character_utf32 = 0;
   if (CheckCharacterComposeTable(compose_buffer_, &composed_character_utf32)) {
     // Key press is recognized as a part of composition.
     if (composed_character_utf32 != 0) {
       // We get a composed character.
       compose_buffer_.clear();
       UTF32CharacterToUTF16(composed_character_utf32, &composed_character_);
     }
     return true;
   }
   // Key press is not a part of composition.
   compose_buffer_.pop_back();  // Remove the keypress added this time.
   if (!compose_buffer_.empty()) {
     compose_buffer_.clear();
     return true;
   }
   return false;
 }
 
 bool CharacterComposer::FilterKeyPressHexMode(unsigned int keyval,
-                                              unsigned int flags) {
+                                              unsigned int keycode,
+                                              int flags) {
   DCHECK(composition_mode_ == HEX_MODE);
   const size_t kMaxHexSequenceLength = 8;
-  const int hex_digit = KeyvalToHexDigit(keyval);
+  int hex_digit = KeyvalToHexDigit(keyval);
+  if (hex_digit < 0) {
+    // With 101 keyboard, control + shift + 3 produces '#', but a user may
+    // have intended to type '3'.  So, if a hexadecimal character was not found,
+    // suppose a user is holding shift key (and possibly control key, too) and
+    // try a character with modifier keys removed.
+    hex_digit = KeyvalToHexDigit(XKeyCodeToXKeySym(keycode));
+  }
 
   if (keyval == GDK_KEY_Escape) {
     // Cancel composition when ESC is pressed.
     Reset();
   } else if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter ||
              keyval == GDK_KEY_ISO_Enter ||
              keyval == GDK_KEY_space || keyval == GDK_KEY_KP_Space) {
     // Commit the composed character when Enter or space is pressed.
     CommitHex();
   } else if (keyval == GDK_KEY_BackSpace) {
@@ skipping 36 matching lines @@
   std::string preedit_string_ascii("u");
   for (size_t i = 0; i != compose_buffer_.size(); ++i) {
     const int digit = compose_buffer_[i];
     DCHECK(0 <= digit && digit < 16);
     preedit_string_ascii += digit <= 9 ? ('0' + digit) : ('a' + (digit - 10));
   }
   preedit_string_ = ASCIIToUTF16(preedit_string_ascii);
 }
 
 }  // namespace ui