summaryrefslogtreecommitdiffstats
path: root/widget/gtk/NativeKeyBindings.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/gtk/NativeKeyBindings.cpp')
-rw-r--r--widget/gtk/NativeKeyBindings.cpp374
1 files changed, 374 insertions, 0 deletions
diff --git a/widget/gtk/NativeKeyBindings.cpp b/widget/gtk/NativeKeyBindings.cpp
new file mode 100644
index 000000000..55a3508e2
--- /dev/null
+++ b/widget/gtk/NativeKeyBindings.cpp
@@ -0,0 +1,374 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/TextEvents.h"
+
+#include "NativeKeyBindings.h"
+#include "nsString.h"
+#include "nsMemory.h"
+#include "nsGtkKeyUtils.h"
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdk.h>
+
+namespace mozilla {
+namespace widget {
+
+static nsIWidget::DoCommandCallback gCurrentCallback;
+static void *gCurrentCallbackData;
+static bool gHandled;
+
+// Common GtkEntry and GtkTextView signals
+static void
+copy_clipboard_cb(GtkWidget *w, gpointer user_data)
+{
+ gCurrentCallback(CommandCopy, gCurrentCallbackData);
+ g_signal_stop_emission_by_name(w, "copy_clipboard");
+ gHandled = true;
+}
+
+static void
+cut_clipboard_cb(GtkWidget *w, gpointer user_data)
+{
+ gCurrentCallback(CommandCut, gCurrentCallbackData);
+ g_signal_stop_emission_by_name(w, "cut_clipboard");
+ gHandled = true;
+}
+
+// GTK distinguishes between display lines (wrapped, as they appear on the
+// screen) and paragraphs, which are runs of text terminated by a newline.
+// We don't have this distinction, so we always use editor's notion of
+// lines, which are newline-terminated.
+
+static const Command sDeleteCommands[][2] = {
+ // backward, forward
+ { CommandDeleteCharBackward, CommandDeleteCharForward }, // CHARS
+ { CommandDeleteWordBackward, CommandDeleteWordForward }, // WORD_ENDS
+ { CommandDeleteWordBackward, CommandDeleteWordForward }, // WORDS
+ { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // LINES
+ { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // LINE_ENDS
+ { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // PARAGRAPH_ENDS
+ { CommandDeleteToBeginningOfLine, CommandDeleteToEndOfLine }, // PARAGRAPHS
+ // This deletes from the end of the previous word to the beginning of the
+ // next word, but only if the caret is not in a word.
+ // XXX need to implement in editor
+ { CommandDoNothing, CommandDoNothing } // WHITESPACE
+};
+
+static void
+delete_from_cursor_cb(GtkWidget *w, GtkDeleteType del_type,
+ gint count, gpointer user_data)
+{
+ g_signal_stop_emission_by_name(w, "delete_from_cursor");
+ bool forward = count > 0;
+
+#if (MOZ_WIDGET_GTK == 3)
+ // Ignore GTK's Ctrl-K keybinding introduced in GTK 3.14 and removed in
+ // 3.18 if the user has custom bindings set. See bug 1176929.
+ if (del_type == GTK_DELETE_PARAGRAPH_ENDS && forward && GTK_IS_ENTRY(w) &&
+ !gtk_check_version(3, 14, 1) && gtk_check_version(3, 17, 9)) {
+ GtkStyleContext* context = gtk_widget_get_style_context(w);
+ GtkStateFlags flags = gtk_widget_get_state_flags(w);
+
+ GPtrArray* array;
+ gtk_style_context_get(context, flags, "gtk-key-bindings", &array, nullptr);
+ if (!array)
+ return;
+ g_ptr_array_unref(array);
+ }
+#endif
+
+ gHandled = true;
+ if (uint32_t(del_type) >= ArrayLength(sDeleteCommands)) {
+ // unsupported deletion type
+ return;
+ }
+
+ if (del_type == GTK_DELETE_WORDS) {
+ // This works like word_ends, except we first move the caret to the
+ // beginning/end of the current word.
+ if (forward) {
+ gCurrentCallback(CommandWordNext, gCurrentCallbackData);
+ gCurrentCallback(CommandWordPrevious, gCurrentCallbackData);
+ } else {
+ gCurrentCallback(CommandWordPrevious, gCurrentCallbackData);
+ gCurrentCallback(CommandWordNext, gCurrentCallbackData);
+ }
+ } else if (del_type == GTK_DELETE_DISPLAY_LINES ||
+ del_type == GTK_DELETE_PARAGRAPHS) {
+
+ // This works like display_line_ends, except we first move the caret to the
+ // beginning/end of the current line.
+ if (forward) {
+ gCurrentCallback(CommandBeginLine, gCurrentCallbackData);
+ } else {
+ gCurrentCallback(CommandEndLine, gCurrentCallbackData);
+ }
+ }
+
+ Command command = sDeleteCommands[del_type][forward];
+ if (!command) {
+ return; // unsupported command
+ }
+
+ unsigned int absCount = Abs(count);
+ for (unsigned int i = 0; i < absCount; ++i) {
+ gCurrentCallback(command, gCurrentCallbackData);
+ }
+}
+
+static const Command sMoveCommands[][2][2] = {
+ // non-extend { backward, forward }, extend { backward, forward }
+ // GTK differentiates between logical position, which is prev/next,
+ // and visual position, which is always left/right.
+ // We should fix this to work the same way for RTL text input.
+ { // LOGICAL_POSITIONS
+ { CommandCharPrevious, CommandCharNext },
+ { CommandSelectCharPrevious, CommandSelectCharNext }
+ },
+ { // VISUAL_POSITIONS
+ { CommandCharPrevious, CommandCharNext },
+ { CommandSelectCharPrevious, CommandSelectCharNext }
+ },
+ { // WORDS
+ { CommandWordPrevious, CommandWordNext },
+ { CommandSelectWordPrevious, CommandSelectWordNext }
+ },
+ { // DISPLAY_LINES
+ { CommandLinePrevious, CommandLineNext },
+ { CommandSelectLinePrevious, CommandSelectLineNext }
+ },
+ { // DISPLAY_LINE_ENDS
+ { CommandBeginLine, CommandEndLine },
+ { CommandSelectBeginLine, CommandSelectEndLine }
+ },
+ { // PARAGRAPHS
+ { CommandLinePrevious, CommandLineNext },
+ { CommandSelectLinePrevious, CommandSelectLineNext }
+ },
+ { // PARAGRAPH_ENDS
+ { CommandBeginLine, CommandEndLine },
+ { CommandSelectBeginLine, CommandSelectEndLine }
+ },
+ { // PAGES
+ { CommandMovePageUp, CommandMovePageDown },
+ { CommandSelectPageUp, CommandSelectPageDown }
+ },
+ { // BUFFER_ENDS
+ { CommandMoveTop, CommandMoveBottom },
+ { CommandSelectTop, CommandSelectBottom }
+ },
+ { // HORIZONTAL_PAGES (unsupported)
+ { CommandDoNothing, CommandDoNothing },
+ { CommandDoNothing, CommandDoNothing }
+ }
+};
+
+static void
+move_cursor_cb(GtkWidget *w, GtkMovementStep step, gint count,
+ gboolean extend_selection, gpointer user_data)
+{
+ g_signal_stop_emission_by_name(w, "move_cursor");
+ gHandled = true;
+ bool forward = count > 0;
+ if (uint32_t(step) >= ArrayLength(sMoveCommands)) {
+ // unsupported movement type
+ return;
+ }
+
+ Command command = sMoveCommands[step][extend_selection][forward];
+ if (!command) {
+ return; // unsupported command
+ }
+
+ unsigned int absCount = Abs(count);
+ for (unsigned int i = 0; i < absCount; ++i) {
+ gCurrentCallback(command, gCurrentCallbackData);
+ }
+}
+
+static void
+paste_clipboard_cb(GtkWidget *w, gpointer user_data)
+{
+ gCurrentCallback(CommandPaste, gCurrentCallbackData);
+ g_signal_stop_emission_by_name(w, "paste_clipboard");
+ gHandled = true;
+}
+
+// GtkTextView-only signals
+static void
+select_all_cb(GtkWidget *w, gboolean select, gpointer user_data)
+{
+ gCurrentCallback(CommandSelectAll, gCurrentCallbackData);
+ g_signal_stop_emission_by_name(w, "select_all");
+ gHandled = true;
+}
+
+NativeKeyBindings* NativeKeyBindings::sInstanceForSingleLineEditor = nullptr;
+NativeKeyBindings* NativeKeyBindings::sInstanceForMultiLineEditor = nullptr;
+
+// static
+NativeKeyBindings*
+NativeKeyBindings::GetInstance(NativeKeyBindingsType aType)
+{
+ switch (aType) {
+ case nsIWidget::NativeKeyBindingsForSingleLineEditor:
+ if (!sInstanceForSingleLineEditor) {
+ sInstanceForSingleLineEditor = new NativeKeyBindings();
+ sInstanceForSingleLineEditor->Init(aType);
+ }
+ return sInstanceForSingleLineEditor;
+
+ default:
+ // fallback to multiline editor case in release build
+ MOZ_FALLTHROUGH_ASSERT("aType is invalid or not yet implemented");
+ case nsIWidget::NativeKeyBindingsForMultiLineEditor:
+ case nsIWidget::NativeKeyBindingsForRichTextEditor:
+ if (!sInstanceForMultiLineEditor) {
+ sInstanceForMultiLineEditor = new NativeKeyBindings();
+ sInstanceForMultiLineEditor->Init(aType);
+ }
+ return sInstanceForMultiLineEditor;
+ }
+}
+
+// static
+void
+NativeKeyBindings::Shutdown()
+{
+ delete sInstanceForSingleLineEditor;
+ sInstanceForSingleLineEditor = nullptr;
+ delete sInstanceForMultiLineEditor;
+ sInstanceForMultiLineEditor = nullptr;
+}
+
+void
+NativeKeyBindings::Init(NativeKeyBindingsType aType)
+{
+ switch (aType) {
+ case nsIWidget::NativeKeyBindingsForSingleLineEditor:
+ mNativeTarget = gtk_entry_new();
+ break;
+ default:
+ mNativeTarget = gtk_text_view_new();
+ if (gtk_major_version > 2 ||
+ (gtk_major_version == 2 && (gtk_minor_version > 2 ||
+ (gtk_minor_version == 2 &&
+ gtk_micro_version >= 2)))) {
+ // select_all only exists in gtk >= 2.2.2. Prior to that,
+ // ctrl+a is bound to (move to beginning, select to end).
+ g_signal_connect(mNativeTarget, "select_all",
+ G_CALLBACK(select_all_cb), this);
+ }
+ break;
+ }
+
+ g_object_ref_sink(mNativeTarget);
+
+ g_signal_connect(mNativeTarget, "copy_clipboard",
+ G_CALLBACK(copy_clipboard_cb), this);
+ g_signal_connect(mNativeTarget, "cut_clipboard",
+ G_CALLBACK(cut_clipboard_cb), this);
+ g_signal_connect(mNativeTarget, "delete_from_cursor",
+ G_CALLBACK(delete_from_cursor_cb), this);
+ g_signal_connect(mNativeTarget, "move_cursor",
+ G_CALLBACK(move_cursor_cb), this);
+ g_signal_connect(mNativeTarget, "paste_clipboard",
+ G_CALLBACK(paste_clipboard_cb), this);
+}
+
+NativeKeyBindings::~NativeKeyBindings()
+{
+ gtk_widget_destroy(mNativeTarget);
+ g_object_unref(mNativeTarget);
+}
+
+bool
+NativeKeyBindings::Execute(const WidgetKeyboardEvent& aEvent,
+ DoCommandCallback aCallback,
+ void* aCallbackData)
+{
+ // If the native key event is set, it must be synthesized for tests.
+ // We just ignore such events because this behavior depends on system
+ // settings.
+ if (!aEvent.mNativeKeyEvent) {
+ // It must be synthesized event or dispatched DOM event from chrome.
+ return false;
+ }
+
+ guint keyval;
+
+ if (aEvent.mCharCode) {
+ keyval = gdk_unicode_to_keyval(aEvent.mCharCode);
+ } else {
+ keyval =
+ static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->keyval;
+ }
+
+ if (ExecuteInternal(aEvent, aCallback, aCallbackData, keyval)) {
+ return true;
+ }
+
+ for (uint32_t i = 0; i < aEvent.mAlternativeCharCodes.Length(); ++i) {
+ uint32_t ch = aEvent.IsShift() ?
+ aEvent.mAlternativeCharCodes[i].mShiftedCharCode :
+ aEvent.mAlternativeCharCodes[i].mUnshiftedCharCode;
+ if (ch && ch != aEvent.mCharCode) {
+ keyval = gdk_unicode_to_keyval(ch);
+ if (ExecuteInternal(aEvent, aCallback, aCallbackData, keyval)) {
+ return true;
+ }
+ }
+ }
+
+/*
+gtk_bindings_activate_event is preferable, but it has unresolved bug:
+http://bugzilla.gnome.org/show_bug.cgi?id=162726
+The bug was already marked as FIXED. However, somebody reports that the
+bug still exists.
+Also gtk_bindings_activate may work with some non-shortcuts operations
+(todo: check it). See bug 411005 and bug 406407.
+
+Code, which should be used after fixing GNOME bug 162726:
+
+ gtk_bindings_activate_event(GTK_OBJECT(mNativeTarget),
+ static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent));
+*/
+
+ return false;
+}
+
+bool
+NativeKeyBindings::ExecuteInternal(const WidgetKeyboardEvent& aEvent,
+ DoCommandCallback aCallback,
+ void* aCallbackData,
+ guint aKeyval)
+{
+ guint modifiers =
+ static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->state;
+
+ gCurrentCallback = aCallback;
+ gCurrentCallbackData = aCallbackData;
+
+ gHandled = false;
+#if (MOZ_WIDGET_GTK == 2)
+ gtk_bindings_activate(GTK_OBJECT(mNativeTarget),
+ aKeyval, GdkModifierType(modifiers));
+#else
+ gtk_bindings_activate(G_OBJECT(mNativeTarget),
+ aKeyval, GdkModifierType(modifiers));
+#endif
+
+ gCurrentCallback = nullptr;
+ gCurrentCallbackData = nullptr;
+
+ return gHandled;
+}
+
+} // namespace widget
+} // namespace mozilla