зеркало из https://github.com/mozilla/gecko-dev.git
370 строки
12 KiB
C++
370 строки
12 KiB
C++
/* -*- 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 nsTArray<CommandInt>* gCurrentCommands = nullptr;
|
|
static bool gHandled = false;
|
|
|
|
// Common GtkEntry and GtkTextView signals
|
|
static void
|
|
copy_clipboard_cb(GtkWidget *w, gpointer user_data)
|
|
{
|
|
gCurrentCommands->AppendElement(CommandCopy);
|
|
g_signal_stop_emission_by_name(w, "copy_clipboard");
|
|
gHandled = true;
|
|
}
|
|
|
|
static void
|
|
cut_clipboard_cb(GtkWidget *w, gpointer user_data)
|
|
{
|
|
gCurrentCommands->AppendElement(CommandCut);
|
|
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) {
|
|
gCurrentCommands->AppendElement(CommandWordNext);
|
|
gCurrentCommands->AppendElement(CommandWordPrevious);
|
|
} else {
|
|
gCurrentCommands->AppendElement(CommandWordPrevious);
|
|
gCurrentCommands->AppendElement(CommandWordNext);
|
|
}
|
|
} 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) {
|
|
gCurrentCommands->AppendElement(CommandBeginLine);
|
|
} else {
|
|
gCurrentCommands->AppendElement(CommandEndLine);
|
|
}
|
|
}
|
|
|
|
Command command = sDeleteCommands[del_type][forward];
|
|
if (!command) {
|
|
return; // unsupported command
|
|
}
|
|
|
|
unsigned int absCount = Abs(count);
|
|
for (unsigned int i = 0; i < absCount; ++i) {
|
|
gCurrentCommands->AppendElement(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
|
|
{ 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) {
|
|
gCurrentCommands->AppendElement(command);
|
|
}
|
|
}
|
|
|
|
static void
|
|
paste_clipboard_cb(GtkWidget *w, gpointer user_data)
|
|
{
|
|
gCurrentCommands->AppendElement(CommandPaste);
|
|
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)
|
|
{
|
|
gCurrentCommands->AppendElement(CommandSelectAll);
|
|
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);
|
|
}
|
|
|
|
void
|
|
NativeKeyBindings::GetEditCommands(const WidgetKeyboardEvent& aEvent,
|
|
nsTArray<CommandInt>& aCommands)
|
|
{
|
|
// 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;
|
|
}
|
|
|
|
guint keyval;
|
|
|
|
if (aEvent.mCharCode) {
|
|
keyval = gdk_unicode_to_keyval(aEvent.mCharCode);
|
|
} 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
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;
|
|
#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
|
|
|
|
gCurrentCommands = nullptr;
|
|
|
|
MOZ_ASSERT(!gHandled || !aCommands.IsEmpty());
|
|
|
|
return gHandled;
|
|
}
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|