diff options
Diffstat (limited to 'widget/gtk/NativeKeyBindings.cpp')
| -rw-r--r-- | widget/gtk/NativeKeyBindings.cpp | 527 |
1 files changed, 527 insertions, 0 deletions
diff --git a/widget/gtk/NativeKeyBindings.cpp b/widget/gtk/NativeKeyBindings.cpp new file mode 100644 index 0000000000..f5b15367a6 --- /dev/null +++ b/widget/gtk/NativeKeyBindings.cpp @@ -0,0 +1,527 @@ +/* -*- 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/Maybe.h" +#include "mozilla/NativeKeyBindingsType.h" +#include "mozilla/StaticPrefs_ui.h" +#include "mozilla/TextEvents.h" +#include "mozilla/WritingModes.h" + +#include "NativeKeyBindings.h" +#include "nsString.h" +#include "nsGtkKeyUtils.h" + +#include <gtk/gtk.h> +#include <gdk/gdkkeysyms.h> +#include <gdk/gdkkeysyms-compat.h> +#include <gdk/gdk.h> + +namespace mozilla { +namespace widget { + +static nsTArray<CommandInt>* gCurrentCommands = nullptr; +static bool gHandled = false; + +inline void AddCommand(Command aCommand) { + MOZ_ASSERT(gCurrentCommands); + gCurrentCommands->AppendElement(static_cast<CommandInt>(aCommand)); +} + +// Common GtkEntry and GtkTextView signals +static void copy_clipboard_cb(GtkWidget* w, gpointer user_data) { + AddCommand(Command::Copy); + g_signal_stop_emission_by_name(w, "copy_clipboard"); + gHandled = true; +} + +static void cut_clipboard_cb(GtkWidget* w, gpointer user_data) { + AddCommand(Command::Cut); + 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 + // CHARS + {Command::DeleteCharBackward, Command::DeleteCharForward}, + // WORD_ENDS + {Command::DeleteWordBackward, Command::DeleteWordForward}, + // WORDS + {Command::DeleteWordBackward, Command::DeleteWordForward}, + // LINES + {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine}, + // LINE_ENDS + {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine}, + // PARAGRAPH_ENDS + {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine}, + // PARAGRAPHS + {Command::DeleteToBeginningOfLine, Command::DeleteToEndOfLine}, + // 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 + {Command::DoNothing, Command::DoNothing} // 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"); + if (count == 0) { + // Nothing to do. + return; + } + + bool forward = count > 0; + + // 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); + } + + 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) { + AddCommand(Command::WordNext); + AddCommand(Command::WordPrevious); + } else { + AddCommand(Command::WordPrevious); + AddCommand(Command::WordNext); + } + } 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) { + AddCommand(Command::BeginLine); + } else { + AddCommand(Command::EndLine); + } + } + + Command command = sDeleteCommands[del_type][forward]; + if (command == Command::DoNothing) { + return; + } + + unsigned int absCount = Abs(count); + for (unsigned int i = 0; i < absCount; ++i) { + AddCommand(command); + } +} + +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 + {Command::CharPrevious, Command::CharNext}, + {Command::SelectCharPrevious, Command::SelectCharNext}}, + {// VISUAL_POSITIONS + {Command::CharPrevious, Command::CharNext}, + {Command::SelectCharPrevious, Command::SelectCharNext}}, + {// WORDS + {Command::WordPrevious, Command::WordNext}, + {Command::SelectWordPrevious, Command::SelectWordNext}}, + {// DISPLAY_LINES + {Command::LinePrevious, Command::LineNext}, + {Command::SelectLinePrevious, Command::SelectLineNext}}, + {// DISPLAY_LINE_ENDS + {Command::BeginLine, Command::EndLine}, + {Command::SelectBeginLine, Command::SelectEndLine}}, + {// PARAGRAPHS + {Command::LinePrevious, Command::LineNext}, + {Command::SelectLinePrevious, Command::SelectLineNext}}, + {// PARAGRAPH_ENDS + {Command::BeginLine, Command::EndLine}, + {Command::SelectBeginLine, Command::SelectEndLine}}, + {// PAGES + {Command::MovePageUp, Command::MovePageDown}, + {Command::SelectPageUp, Command::SelectPageDown}}, + {// BUFFER_ENDS + {Command::MoveTop, Command::MoveBottom}, + {Command::SelectTop, Command::SelectBottom}}, + {// HORIZONTAL_PAGES (unsupported) + {Command::DoNothing, Command::DoNothing}, + {Command::DoNothing, Command::DoNothing}}}; + +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"); + if (count == 0) { + // Nothing to do. + return; + } + + 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 == Command::DoNothing) { + return; + } + + unsigned int absCount = Abs(count); + for (unsigned int i = 0; i < absCount; ++i) { + AddCommand(command); + } +} + +static void paste_clipboard_cb(GtkWidget* w, gpointer user_data) { + AddCommand(Command::Paste); + g_signal_stop_emission_by_name(w, "paste_clipboard"); + gHandled = true; +} + +// GtkTextView-only signals +static void select_all_cb(GtkWidget* aWidget, gboolean aSelect, + gpointer aUserData) { + // We don't support "Unselect All" command. + // Note that if we'd support it, `Ctrl-Shift-a` will be mapped to it and + // overrides open `about:addons` shortcut. + if (aSelect) { + AddCommand(Command::SelectAll); + } + g_signal_stop_emission_by_name(aWidget, "select_all"); + // Although we prevent the default of `GtkTExtView` with + // `g_signal_stop_emission_by_name`, but `gHandled` is used for asserting + // if it does not match with the emptiness of the command array. + // Therefore, we should not set it to `true` if we don't add a command. + gHandled |= aSelect; +} + +NativeKeyBindings* NativeKeyBindings::sInstanceForSingleLineEditor = nullptr; +NativeKeyBindings* NativeKeyBindings::sInstanceForMultiLineEditor = nullptr; + +// static +NativeKeyBindings* NativeKeyBindings::GetInstance(NativeKeyBindingsType aType) { + switch (aType) { + case NativeKeyBindingsType::SingleLineEditor: + 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 NativeKeyBindingsType::MultiLineEditor: + case NativeKeyBindingsType::RichTextEditor: + 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 NativeKeyBindingsType::SingleLineEditor: + mNativeTarget = gtk_entry_new(); + break; + default: + mNativeTarget = gtk_text_view_new(); + 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); +} + +void NativeKeyBindings::GetEditCommands(const WidgetKeyboardEvent& aEvent, + const Maybe<WritingMode>& aWritingMode, + nsTArray<CommandInt>& aCommands) { + MOZ_ASSERT(!aEvent.mFlags.mIsSynthesizedForTests); + MOZ_ASSERT(aCommands.IsEmpty()); + + // It must be a DOM event dispached by chrome script. + if (!aEvent.mNativeKeyEvent) { + return; + } + + guint keyval; + if (aEvent.mCharCode) { + keyval = gdk_unicode_to_keyval(aEvent.mCharCode); + } else if (aWritingMode.isSome() && aEvent.NeedsToRemapNavigationKey() && + aWritingMode.ref().IsVertical()) { + // TODO: Use KeyNameIndex rather than legacy keyCode. + uint32_t remappedGeckoKeyCode = + aEvent.GetRemappedKeyCode(aWritingMode.ref()); + switch (remappedGeckoKeyCode) { + case NS_VK_UP: + keyval = GDK_Up; + break; + case NS_VK_DOWN: + keyval = GDK_Down; + break; + case NS_VK_LEFT: + keyval = GDK_Left; + break; + case NS_VK_RIGHT: + keyval = GDK_Right; + break; + default: + MOZ_ASSERT_UNREACHABLE("Add a case for the new remapped key"); + return; + } + } else { + keyval = static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->keyval; + } + + if (GetEditCommandsInternal(aEvent, aCommands, keyval)) { + return; + } + + 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 (GetEditCommandsInternal(aEvent, aCommands, keyval)) { + return; + } + } + } + + // If the key event does not cause any commands, and we're for single line + // editor, let's check whether the key combination is for "select-all" in + // GtkTextView because the signal is not supported by GtkEntry. + if (aCommands.IsEmpty() && this == sInstanceForSingleLineEditor && + StaticPrefs::ui_key_use_select_all_in_single_line_editor()) { + if (NativeKeyBindings* bindingsForMultilineEditor = + GetInstance(NativeKeyBindingsType::MultiLineEditor)) { + bindingsForMultilineEditor->GetEditCommands(aEvent, aWritingMode, + aCommands); + if (aCommands.Length() == 1u && + aCommands[0u] == static_cast<CommandInt>(Command::SelectAll)) { + return; + } + aCommands.Clear(); + } + } + + /* + 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)); + */ +} + +bool NativeKeyBindings::GetEditCommandsInternal( + const WidgetKeyboardEvent& aEvent, nsTArray<CommandInt>& aCommands, + guint aKeyval) { + guint modifiers = static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->state; + + gCurrentCommands = &aCommands; + + gHandled = false; + gtk_bindings_activate(G_OBJECT(mNativeTarget), aKeyval, + GdkModifierType(modifiers)); + + gCurrentCommands = nullptr; + + return gHandled; +} + +// static +void NativeKeyBindings::GetEditCommandsForTests( + NativeKeyBindingsType aType, const WidgetKeyboardEvent& aEvent, + const Maybe<WritingMode>& aWritingMode, nsTArray<CommandInt>& aCommands) { + MOZ_DIAGNOSTIC_ASSERT(aEvent.IsTrusted()); + + if (aEvent.IsAlt() || aEvent.IsMeta() || aEvent.IsOS()) { + return; + } + + static const size_t kBackward = 0; + static const size_t kForward = 1; + const size_t extentSelection = aEvent.IsShift() ? 1 : 0; + // https://github.com/GNOME/gtk/blob/1f141c19533f4b3f397c3959ade673ce243b6138/gtk/gtktext.c#L1289 + // https://github.com/GNOME/gtk/blob/c5dd34344f0c660ceffffb3bf9da43c263db16e1/gtk/gtktextview.c#L1534 + Command command = Command::DoNothing; + const KeyNameIndex remappedKeyNameIndex = + aWritingMode.isSome() ? aEvent.GetRemappedKeyNameIndex(aWritingMode.ref()) + : aEvent.mKeyNameIndex; + switch (remappedKeyNameIndex) { + case KEY_NAME_INDEX_USE_STRING: + switch (aEvent.PseudoCharCode()) { + case 'a': + case 'A': + if (aEvent.IsControl()) { + command = Command::SelectAll; + } + break; + case 'c': + case 'C': + if (aEvent.IsControl() && !aEvent.IsShift()) { + command = Command::Copy; + } + break; + case 'u': + case 'U': + if (aType == NativeKeyBindingsType::SingleLineEditor && + aEvent.IsControl() && !aEvent.IsShift()) { + command = sDeleteCommands[GTK_DELETE_PARAGRAPH_ENDS][kBackward]; + } + break; + case 'v': + case 'V': + if (aEvent.IsControl() && !aEvent.IsShift()) { + command = Command::Paste; + } + break; + case 'x': + case 'X': + if (aEvent.IsControl() && !aEvent.IsShift()) { + command = Command::Cut; + } + break; + case '/': + if (aEvent.IsControl() && !aEvent.IsShift()) { + command = Command::SelectAll; + } + break; + default: + break; + } + break; + case KEY_NAME_INDEX_Insert: + if (aEvent.IsControl() && !aEvent.IsShift()) { + command = Command::Copy; + } else if (aEvent.IsShift() && !aEvent.IsControl()) { + command = Command::Paste; + } + break; + case KEY_NAME_INDEX_Delete: + if (aEvent.IsShift()) { + command = Command::Cut; + break; + } + [[fallthrough]]; + case KEY_NAME_INDEX_Backspace: { + const size_t direction = + remappedKeyNameIndex == KEY_NAME_INDEX_Delete ? kForward : kBackward; + const GtkDeleteType amount = + aEvent.IsControl() && aEvent.IsShift() + ? GTK_DELETE_PARAGRAPH_ENDS + // FYI: Shift key for Backspace is ignored to help mis-typing. + : (aEvent.IsControl() ? GTK_DELETE_WORD_ENDS : GTK_DELETE_CHARS); + command = sDeleteCommands[amount][direction]; + break; + } + case KEY_NAME_INDEX_ArrowLeft: + case KEY_NAME_INDEX_ArrowRight: { + const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_ArrowRight + ? kForward + : kBackward; + const GtkMovementStep amount = aEvent.IsControl() + ? GTK_MOVEMENT_WORDS + : GTK_MOVEMENT_VISUAL_POSITIONS; + command = sMoveCommands[amount][extentSelection][direction]; + break; + } + case KEY_NAME_INDEX_ArrowUp: + case KEY_NAME_INDEX_ArrowDown: { + const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_ArrowDown + ? kForward + : kBackward; + const GtkMovementStep amount = aEvent.IsControl() + ? GTK_MOVEMENT_PARAGRAPHS + : GTK_MOVEMENT_DISPLAY_LINES; + command = sMoveCommands[amount][extentSelection][direction]; + break; + } + case KEY_NAME_INDEX_Home: + case KEY_NAME_INDEX_End: { + const size_t direction = + remappedKeyNameIndex == KEY_NAME_INDEX_End ? kForward : kBackward; + const GtkMovementStep amount = aEvent.IsControl() + ? GTK_MOVEMENT_BUFFER_ENDS + : GTK_MOVEMENT_DISPLAY_LINE_ENDS; + command = sMoveCommands[amount][extentSelection][direction]; + break; + } + case KEY_NAME_INDEX_PageUp: + case KEY_NAME_INDEX_PageDown: { + const size_t direction = remappedKeyNameIndex == KEY_NAME_INDEX_PageDown + ? kForward + : kBackward; + const GtkMovementStep amount = aEvent.IsControl() + ? GTK_MOVEMENT_HORIZONTAL_PAGES + : GTK_MOVEMENT_PAGES; + command = sMoveCommands[amount][extentSelection][direction]; + break; + } + default: + break; + } + if (command != Command::DoNothing) { + aCommands.AppendElement(static_cast<CommandInt>(command)); + } +} + +} // namespace widget +} // namespace mozilla |