linux_aura: Port GtkKeybindingsHandler to Aura.

chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.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 "content/browser/renderer_host/gtk_key_bindings_handler.h"
+#include "chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.h"
 
 #include <gdk/gdkkeysyms.h>
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
+#include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/events/event.h"
 
-namespace content {
+namespace libgtk2ui {
 
-GtkKeyBindingsHandler::GtkKeyBindingsHandler(GtkWidget* parent_widget)
-    : handler_(CreateNewHandler()) {
-  DCHECK(GTK_IS_FIXED(parent_widget));
-  // We need add the |handler_| object into gtk widget hierarchy, so that
-  // gtk_bindings_activate_event() can find correct display and keymaps from
-  // the |handler_| object.
-  gtk_fixed_put(GTK_FIXED(parent_widget), handler_.get(), -1, -1);
+Gtk2KeyBindingsHandler::Gtk2KeyBindingsHandler()
+    : fake_window_(gtk_offscreen_window_new()),
+      handler_(CreateNewHandler()),
+      has_xkb_(false) {
+  gtk_container_add(GTK_CONTAINER(fake_window_), handler_.get());
+
+  int opcode, event, error;
+  int major = XkbMajorVersion;
+  int minor = XkbMinorVersion;
+  if (XkbQueryExtension(gfx::GetXDisplay(), &opcode, &event, &error,
+                        &major, &minor))
+    has_xkb_ = true;
 }
 
-GtkKeyBindingsHandler::~GtkKeyBindingsHandler() {
+Gtk2KeyBindingsHandler::~Gtk2KeyBindingsHandler() {
   handler_.Destroy();
+  gtk_widget_destroy(fake_window_);
 }
 
-bool GtkKeyBindingsHandler::Match(const NativeWebKeyboardEvent& wke,
-                                  EditCommands* edit_commands) {
+bool Gtk2KeyBindingsHandler::Match(const content::NativeWebKeyboardEvent& wke,
+                                   content::EditCommands* edit_commands) {
   if (wke.type == blink::WebInputEvent::Char || !wke.os_event)
     return false;
 
+  GdkEventKey gdk_event;
+  BuildGdkEventKeyFromXEvent(wke.os_event->native_event(), &gdk_event);
+
   edit_commands_.clear();
   // If this key event matches a predefined key binding, corresponding signal
   // will be emitted.
-  gtk_bindings_activate_event(GTK_OBJECT(handler_.get()), &wke.os_event->key);
+  gtk_bindings_activate_event(GTK_OBJECT(handler_.get()), &gdk_event);
 
   bool matched = !edit_commands_.empty();
   if (edit_commands)
     edit_commands->swap(edit_commands_);
   return matched;
 }
 
-GtkWidget* GtkKeyBindingsHandler::CreateNewHandler() {
+GtkWidget* Gtk2KeyBindingsHandler::CreateNewHandler() {
   Handler* handler =
       static_cast<Handler*>(g_object_new(HandlerGetType(), NULL));
 
   handler->owner = this;
 
   // We don't need to show the |handler| object on screen, so set its size to
   // zero.
   gtk_widget_set_size_request(GTK_WIDGET(handler), 0, 0);
 
   // Prevents it from handling any events by itself.
   gtk_widget_set_sensitive(GTK_WIDGET(handler), FALSE);
   gtk_widget_set_events(GTK_WIDGET(handler), 0);
   gtk_widget_set_can_focus(GTK_WIDGET(handler), TRUE);
 
   return GTK_WIDGET(handler);
 }
 
-void GtkKeyBindingsHandler::EditCommandMatched(
+void Gtk2KeyBindingsHandler::EditCommandMatched(
     const std::string& name, const std::string& value) {
-  edit_commands_.push_back(EditCommand(name, value));
+  edit_commands_.push_back(content::EditCommand(name, value));
 }
 
-void GtkKeyBindingsHandler::HandlerInit(Handler *self) {
+void Gtk2KeyBindingsHandler::BuildGdkEventKeyFromXEvent(
+    const base::NativeEvent& xevent,
+    GdkEventKey* gdk_event) {
+  GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
+  GdkModifierType consumed, state;
+
+  gdk_event->type = xevent->xany.type == KeyPress ?
+                    GDK_KEY_PRESS : GDK_KEY_RELEASE;
+  gdk_event->time = xevent->xkey.time;
+  gdk_event->state = static_cast<GdkModifierType>(xevent->xkey.state);
+  gdk_event->hardware_keycode = xevent->xkey.keycode;
+
+  if (has_xkb_) {
+    gdk_event->group = XkbGroupForCoreState(xevent->xkey.state);
+  } else {
+    // TODO(erg): I don't understand what this is for. I read through parts of
+    // gdkevent-x11.c. Just calling XkbGroupForCoreState() if we have XKB is
+    // simple enough, but I don't understand X11 input handling enough to know
+    // what this is for, and reading through what GDK does to try to calculate
+    // this was not enlightening.
+    //
+    // Also, does anyone actually have servers that don't support XKB at this
+    // point?

[Elliot Glaysher, 2014/03/26 21:42:41]

piman, do you have any thoughts on what this is supposed to be?

[piman, 2014/03/26 23:44:26]

My reading of it:
GDK installs in the core keymap some keysym on some modifier keys, to switch
between 2 GDK groups. There's code to find which modifier(s) that is if any, and
then sets this to 1 if the modifier is on.

Maybe it's ok to punt for now though.
1- Non-xkb servers must be rare
2- the likelihood of that modifier key to be relevant for the edit commands is
low

The intersection of 1 and 2 is likely to be extremely small!

+    NOTIMPLEMENTED();
+    gdk_event->group = 0;
+  }
+
+  gdk_event->keyval = GDK_VoidSymbol;
+  gdk_keymap_translate_keyboard_state(
+      keymap,
+      gdk_event->hardware_keycode,
+      static_cast<GdkModifierType>(gdk_event->state),
+      gdk_event->group,
+      &gdk_event->keyval,
+      NULL, NULL, &consumed);
+
+  state = static_cast<GdkModifierType>(gdk_event->state & ~consumed);
+  gdk_keymap_add_virtual_modifiers(keymap, &state);
+  gdk_event->state |= state;
+}
+
+void Gtk2KeyBindingsHandler::HandlerInit(Handler *self) {
   self->owner = NULL;
 }
 
-void GtkKeyBindingsHandler::HandlerClassInit(HandlerClass *klass) {
+void Gtk2KeyBindingsHandler::HandlerClassInit(HandlerClass *klass) {
   GtkTextViewClass* text_view_class = GTK_TEXT_VIEW_CLASS(klass);
   GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
 
   // Overrides all virtual methods related to editor key bindings.
   text_view_class->backspace = BackSpace;
   text_view_class->copy_clipboard = CopyClipboard;
   text_view_class->cut_clipboard = CutClipboard;
   text_view_class->delete_from_cursor = DeleteFromCursor;
   text_view_class->insert_at_cursor = InsertAtCursor;
   text_view_class->move_cursor = MoveCursor;
@@ skipping 16 matching lines @@
 
   g_signal_override_class_handler("select-all",
                                   G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(SelectAll));
 
   g_signal_override_class_handler("toggle-cursor-visible",
                                   G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(ToggleCursorVisible));
 }
 
-GType GtkKeyBindingsHandler::HandlerGetType() {
+GType Gtk2KeyBindingsHandler::HandlerGetType() {
   static volatile gsize type_id_volatile = 0;
   if (g_once_init_enter(&type_id_volatile)) {
     GType type_id = g_type_register_static_simple(
         GTK_TYPE_TEXT_VIEW,
-        g_intern_static_string("GtkKeyBindingsHandler"),
+        g_intern_static_string("Gtk2KeyBindingsHandler"),
         sizeof(HandlerClass),
         reinterpret_cast<GClassInitFunc>(HandlerClassInit),
         sizeof(Handler),
         reinterpret_cast<GInstanceInitFunc>(HandlerInit),
         static_cast<GTypeFlags>(0));
     g_once_init_leave(&type_id_volatile, type_id);
   }
   return type_id_volatile;
 }
 
-GtkKeyBindingsHandler* GtkKeyBindingsHandler::GetHandlerOwner(
+Gtk2KeyBindingsHandler* Gtk2KeyBindingsHandler::GetHandlerOwner(
     GtkTextView* text_view) {
   Handler* handler = G_TYPE_CHECK_INSTANCE_CAST(
       text_view, HandlerGetType(), Handler);
   DCHECK(handler);
   return handler->owner;
 }
 
-void GtkKeyBindingsHandler::BackSpace(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::BackSpace(GtkTextView* text_view) {
   GetHandlerOwner(text_view)
       ->EditCommandMatched("DeleteBackward", std::string());
 }
 
-void GtkKeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched("Copy", std::string());
 }
 
-void GtkKeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched("Cut", std::string());
 }
 
-void GtkKeyBindingsHandler::DeleteFromCursor(
+void Gtk2KeyBindingsHandler::DeleteFromCursor(
     GtkTextView* text_view, GtkDeleteType type, gint count) {
   if (!count)
     return;
 
   const char *commands[3] = { NULL, NULL, NULL };
   switch (type) {
     case GTK_DELETE_CHARS:
       commands[0] = (count > 0 ? "DeleteForward" : "DeleteBackward");
       break;
     case GTK_DELETE_WORD_ENDS:
@@ skipping 22 matching lines @@
       break;
     case GTK_DELETE_PARAGRAPHS:
       commands[0] = "MoveToBeginningOfParagraph";
       commands[1] = "DeleteToEndOfParagraph";
       break;
     default:
       // GTK_DELETE_WHITESPACE has no corresponding editor command.
       return;
   }
 
-  GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
+  Gtk2KeyBindingsHandler* owner = GetHandlerOwner(text_view);
   if (count < 0)
     count = -count;
   for (; count > 0; --count) {
     for (const char* const* p = commands; *p; ++p)
       owner->EditCommandMatched(*p, std::string());
   }
 }
 
-void GtkKeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
-                                           const gchar* str) {
+void Gtk2KeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
+                                            const gchar* str) {
   if (str && *str)
     GetHandlerOwner(text_view)->EditCommandMatched("InsertText", str);
 }
 
-void GtkKeyBindingsHandler::MoveCursor(
+void Gtk2KeyBindingsHandler::MoveCursor(
     GtkTextView* text_view, GtkMovementStep step, gint count,
     gboolean extend_selection) {
   if (!count)
     return;
 
   std::string command;
   switch (step) {
     case GTK_MOVEMENT_LOGICAL_POSITIONS:
       command = (count > 0 ? "MoveForward" : "MoveBackward");
       break;
@@ skipping 19 matching lines @@
     case GTK_MOVEMENT_BUFFER_ENDS:
       command = (count > 0 ? "MoveToEndOfDocument" :
                  "MoveToBeginningOfDocument");
       break;
     default:
       // GTK_MOVEMENT_PARAGRAPHS and GTK_MOVEMENT_HORIZONTAL_PAGES have
       // no corresponding editor commands.
       return;
   }
 
-  GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
+  Gtk2KeyBindingsHandler* owner = GetHandlerOwner(text_view);
   if (extend_selection)
     command.append("AndModifySelection");
   if (count < 0)
     count = -count;
   for (; count > 0; --count)
     owner->EditCommandMatched(command, std::string());
 }
 
-void GtkKeyBindingsHandler::MoveViewport(
+void Gtk2KeyBindingsHandler::MoveViewport(
     GtkTextView* text_view, GtkScrollStep step, gint count) {
   // Not supported by webkit.
 }
 
-void GtkKeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched("Paste", std::string());
 }
 
-void GtkKeyBindingsHandler::SelectAll(GtkTextView* text_view, gboolean select) {
+void Gtk2KeyBindingsHandler::SelectAll(GtkTextView* text_view,
+                                       gboolean select) {
   if (select)
     GetHandlerOwner(text_view)->EditCommandMatched("SelectAll", std::string());
   else
     GetHandlerOwner(text_view)->EditCommandMatched("Unselect", std::string());
 }
 
-void GtkKeyBindingsHandler::SetAnchor(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::SetAnchor(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched("SetMark", std::string());
 }
 
-void GtkKeyBindingsHandler::ToggleCursorVisible(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::ToggleCursorVisible(GtkTextView* text_view) {
   // Not supported by webkit.
 }
 
-void GtkKeyBindingsHandler::ToggleOverwrite(GtkTextView* text_view) {
+void Gtk2KeyBindingsHandler::ToggleOverwrite(GtkTextView* text_view) {
   // Not supported by webkit.
 }
 
-gboolean GtkKeyBindingsHandler::ShowHelp(GtkWidget* widget,
-                                         GtkWidgetHelpType arg1) {
+gboolean Gtk2KeyBindingsHandler::ShowHelp(GtkWidget* widget,
+                                          GtkWidgetHelpType arg1) {
   // Just for disabling the default handler.
   return FALSE;
 }
 
-void GtkKeyBindingsHandler::MoveFocus(GtkWidget* widget,
-                                      GtkDirectionType arg1) {
+void Gtk2KeyBindingsHandler::MoveFocus(GtkWidget* widget,
+                                       GtkDirectionType arg1) {
   // Just for disabling the default handler.
 }
 
-}  // namespace content
+}  // namespace libgtk2ui