forked from mirrors/gecko-dev
0f39d7eda7
On Windows, Windows logo key was mapped to "OS" modifier, and on Linux, it's same and the key is called "Super" and "Hyper". That conformed to the older UI Events spec. However, UI Events declares that they should be mapped to "Meta" now and Chrome handles it as the spec in Windows and Linux. Therefore, we should align the behavior to them. Note that we've treated the legacy "Meta" modifier on Linux as DOM "Meta" modifier state, and we'll keep this as-is because in Sun/Solaris keyboard layout, they keys are mapped to the legacy "Meta". Finally, the following check only `IsMeta()` but not `IsOS()`. I think that they should've checked `IsOS()` too. Therefore, they will behave differently in Windows and Linux. * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/base/Element.cpp#3287-3288 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLInputElement.cpp#3762-3764 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLInputElement.cpp#3796-3806 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/dom/html/HTMLLabelElement.cpp#127-128 * https://searchfox.org/mozilla-central/rev/9a4666e63199bd1bcfc9095f6efec3488c358458/widget/gtk/nsGtkKeyUtils.cpp#1461-1462 Note that `KEY_NAME_INDEX_OS` will be removed in the patch for bug 1232918. Differential Revision: https://phabricator.services.mozilla.com/D183480
2541 lines
87 KiB
C++
2541 lines
87 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:expandtab:shiftwidth=4:tabstop=4:
|
|
*/
|
|
/* 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/Logging.h"
|
|
|
|
#include "nsGtkKeyUtils.h"
|
|
|
|
#include <gdk/gdkkeysyms.h>
|
|
#include <algorithm>
|
|
#include <gdk/gdk.h>
|
|
#include <dlfcn.h>
|
|
#include <gdk/gdkkeysyms-compat.h>
|
|
#ifdef MOZ_X11
|
|
# include <gdk/gdkx.h>
|
|
# include <X11/XKBlib.h>
|
|
# include "X11UndefineNone.h"
|
|
#endif
|
|
#include "IMContextWrapper.h"
|
|
#include "WidgetUtils.h"
|
|
#include "WidgetUtilsGtk.h"
|
|
#include "x11/keysym2ucs.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsGtkUtils.h"
|
|
#include "nsIBidiKeyboard.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsWindow.h"
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "mozilla/TextEventDispatcher.h"
|
|
#include "mozilla/TextEvents.h"
|
|
|
|
#ifdef MOZ_WAYLAND
|
|
# include <sys/mman.h>
|
|
# include "nsWaylandDisplay.h"
|
|
#endif
|
|
|
|
// For collecting other people's log, tell them `MOZ_LOG=KeyboardHandler:4,sync`
|
|
// rather than `MOZ_LOG=KeyboardHandler:5,sync` since using `5` may create too
|
|
// big file.
|
|
// Therefore you shouldn't use `LogLevel::Verbose` for logging usual behavior.
|
|
mozilla::LazyLogModule gKeyLog("KeyboardHandler");
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
#define IS_ASCII_ALPHABETICAL(key) \
|
|
((('a' <= key) && (key <= 'z')) || (('A' <= key) && (key <= 'Z')))
|
|
|
|
#define MOZ_MODIFIER_KEYS "MozKeymapWrapper"
|
|
|
|
KeymapWrapper* KeymapWrapper::sInstance = nullptr;
|
|
guint KeymapWrapper::sLastRepeatableHardwareKeyCode = 0;
|
|
#ifdef MOZ_X11
|
|
Time KeymapWrapper::sLastRepeatableKeyTime = 0;
|
|
#endif
|
|
KeymapWrapper::RepeatState KeymapWrapper::sRepeatState =
|
|
KeymapWrapper::NOT_PRESSED;
|
|
|
|
#ifdef MOZ_WAYLAND
|
|
wl_seat* KeymapWrapper::sSeat = nullptr;
|
|
int KeymapWrapper::sSeatID = -1;
|
|
wl_keyboard* KeymapWrapper::sKeyboard = nullptr;
|
|
#endif
|
|
|
|
static const char* GetBoolName(bool aBool) { return aBool ? "TRUE" : "FALSE"; }
|
|
|
|
static const char* GetStatusName(nsEventStatus aStatus) {
|
|
switch (aStatus) {
|
|
case nsEventStatus_eConsumeDoDefault:
|
|
return "nsEventStatus_eConsumeDoDefault";
|
|
case nsEventStatus_eConsumeNoDefault:
|
|
return "nsEventStatus_eConsumeNoDefault";
|
|
case nsEventStatus_eIgnore:
|
|
return "nsEventStatus_eIgnore";
|
|
case nsEventStatus_eSentinel:
|
|
return "nsEventStatus_eSentinel";
|
|
default:
|
|
return "Illegal value";
|
|
}
|
|
}
|
|
|
|
static const nsCString GetKeyLocationName(uint32_t aLocation) {
|
|
switch (aLocation) {
|
|
case eKeyLocationLeft:
|
|
return "KEY_LOCATION_LEFT"_ns;
|
|
case eKeyLocationRight:
|
|
return "KEY_LOCATION_RIGHT"_ns;
|
|
case eKeyLocationStandard:
|
|
return "KEY_LOCATION_STANDARD"_ns;
|
|
case eKeyLocationNumpad:
|
|
return "KEY_LOCATION_NUMPAD"_ns;
|
|
default:
|
|
return nsPrintfCString("Unknown (0x%04X)", aLocation);
|
|
}
|
|
}
|
|
|
|
static const nsCString GetCharacterCodeName(char16_t aChar) {
|
|
switch (aChar) {
|
|
case 0x0000:
|
|
return "NULL (0x0000)"_ns;
|
|
case 0x0008:
|
|
return "BACKSPACE (0x0008)"_ns;
|
|
case 0x0009:
|
|
return "CHARACTER TABULATION (0x0009)"_ns;
|
|
case 0x000A:
|
|
return "LINE FEED (0x000A)"_ns;
|
|
case 0x000B:
|
|
return "LINE TABULATION (0x000B)"_ns;
|
|
case 0x000C:
|
|
return "FORM FEED (0x000C)"_ns;
|
|
case 0x000D:
|
|
return "CARRIAGE RETURN (0x000D)"_ns;
|
|
case 0x0018:
|
|
return "CANCEL (0x0018)"_ns;
|
|
case 0x001B:
|
|
return "ESCAPE (0x001B)"_ns;
|
|
case 0x0020:
|
|
return "SPACE (0x0020)"_ns;
|
|
case 0x007F:
|
|
return "DELETE (0x007F)"_ns;
|
|
case 0x00A0:
|
|
return "NO-BREAK SPACE (0x00A0)"_ns;
|
|
case 0x00AD:
|
|
return "SOFT HYPHEN (0x00AD)"_ns;
|
|
case 0x2000:
|
|
return "EN QUAD (0x2000)"_ns;
|
|
case 0x2001:
|
|
return "EM QUAD (0x2001)"_ns;
|
|
case 0x2002:
|
|
return "EN SPACE (0x2002)"_ns;
|
|
case 0x2003:
|
|
return "EM SPACE (0x2003)"_ns;
|
|
case 0x2004:
|
|
return "THREE-PER-EM SPACE (0x2004)"_ns;
|
|
case 0x2005:
|
|
return "FOUR-PER-EM SPACE (0x2005)"_ns;
|
|
case 0x2006:
|
|
return "SIX-PER-EM SPACE (0x2006)"_ns;
|
|
case 0x2007:
|
|
return "FIGURE SPACE (0x2007)"_ns;
|
|
case 0x2008:
|
|
return "PUNCTUATION SPACE (0x2008)"_ns;
|
|
case 0x2009:
|
|
return "THIN SPACE (0x2009)"_ns;
|
|
case 0x200A:
|
|
return "HAIR SPACE (0x200A)"_ns;
|
|
case 0x200B:
|
|
return "ZERO WIDTH SPACE (0x200B)"_ns;
|
|
case 0x200C:
|
|
return "ZERO WIDTH NON-JOINER (0x200C)"_ns;
|
|
case 0x200D:
|
|
return "ZERO WIDTH JOINER (0x200D)"_ns;
|
|
case 0x200E:
|
|
return "LEFT-TO-RIGHT MARK (0x200E)"_ns;
|
|
case 0x200F:
|
|
return "RIGHT-TO-LEFT MARK (0x200F)"_ns;
|
|
case 0x2029:
|
|
return "PARAGRAPH SEPARATOR (0x2029)"_ns;
|
|
case 0x202A:
|
|
return "LEFT-TO-RIGHT EMBEDDING (0x202A)"_ns;
|
|
case 0x202B:
|
|
return "RIGHT-TO-LEFT EMBEDDING (0x202B)"_ns;
|
|
case 0x202D:
|
|
return "LEFT-TO-RIGHT OVERRIDE (0x202D)"_ns;
|
|
case 0x202E:
|
|
return "RIGHT-TO-LEFT OVERRIDE (0x202E)"_ns;
|
|
case 0x202F:
|
|
return "NARROW NO-BREAK SPACE (0x202F)"_ns;
|
|
case 0x205F:
|
|
return "MEDIUM MATHEMATICAL SPACE (0x205F)"_ns;
|
|
case 0x2060:
|
|
return "WORD JOINER (0x2060)"_ns;
|
|
case 0x2066:
|
|
return "LEFT-TO-RIGHT ISOLATE (0x2066)"_ns;
|
|
case 0x2067:
|
|
return "RIGHT-TO-LEFT ISOLATE (0x2067)"_ns;
|
|
case 0x3000:
|
|
return "IDEOGRAPHIC SPACE (0x3000)"_ns;
|
|
case 0xFEFF:
|
|
return "ZERO WIDTH NO-BREAK SPACE (0xFEFF)"_ns;
|
|
default: {
|
|
if (aChar < ' ' || (aChar >= 0x80 && aChar < 0xA0)) {
|
|
return nsPrintfCString("control (0x%04X)", aChar);
|
|
}
|
|
if (NS_IS_HIGH_SURROGATE(aChar)) {
|
|
return nsPrintfCString("high surrogate (0x%04X)", aChar);
|
|
}
|
|
if (NS_IS_LOW_SURROGATE(aChar)) {
|
|
return nsPrintfCString("low surrogate (0x%04X)", aChar);
|
|
}
|
|
return nsPrintfCString("'%s' (0x%04X)",
|
|
NS_ConvertUTF16toUTF8(nsAutoString(aChar)).get(),
|
|
aChar);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const nsCString GetCharacterCodeNames(const char16_t* aChars,
|
|
uint32_t aLength) {
|
|
if (!aLength) {
|
|
return "\"\""_ns;
|
|
}
|
|
nsCString result;
|
|
result.AssignLiteral("\"");
|
|
StringJoinAppend(result, ", "_ns, Span{aChars, aLength},
|
|
[](nsACString& dest, const char16_t charValue) {
|
|
dest.Append(GetCharacterCodeName(charValue));
|
|
});
|
|
result.AppendLiteral("\"");
|
|
return result;
|
|
}
|
|
|
|
static const nsCString GetCharacterCodeNames(const nsAString& aString) {
|
|
return GetCharacterCodeNames(aString.BeginReading(), aString.Length());
|
|
}
|
|
|
|
/* static */ const char* KeymapWrapper::GetModifierName(Modifier aModifier) {
|
|
switch (aModifier) {
|
|
case CAPS_LOCK:
|
|
return "CapsLock";
|
|
case NUM_LOCK:
|
|
return "NumLock";
|
|
case SCROLL_LOCK:
|
|
return "ScrollLock";
|
|
case SHIFT:
|
|
return "Shift";
|
|
case CTRL:
|
|
return "Ctrl";
|
|
case ALT:
|
|
return "Alt";
|
|
case SUPER:
|
|
return "Super";
|
|
case HYPER:
|
|
return "Hyper";
|
|
case META:
|
|
return "Meta";
|
|
case LEVEL3:
|
|
return "Level3";
|
|
case LEVEL5:
|
|
return "Level5";
|
|
case NOT_MODIFIER:
|
|
return "NotModifier";
|
|
default:
|
|
return "InvalidValue";
|
|
}
|
|
}
|
|
|
|
/* static */ KeymapWrapper::Modifier KeymapWrapper::GetModifierForGDKKeyval(
|
|
guint aGdkKeyval) {
|
|
switch (aGdkKeyval) {
|
|
case GDK_Caps_Lock:
|
|
return CAPS_LOCK;
|
|
case GDK_Num_Lock:
|
|
return NUM_LOCK;
|
|
case GDK_Scroll_Lock:
|
|
return SCROLL_LOCK;
|
|
case GDK_Shift_Lock:
|
|
case GDK_Shift_L:
|
|
case GDK_Shift_R:
|
|
return SHIFT;
|
|
case GDK_Control_L:
|
|
case GDK_Control_R:
|
|
return CTRL;
|
|
case GDK_Alt_L:
|
|
case GDK_Alt_R:
|
|
return ALT;
|
|
case GDK_Super_L:
|
|
case GDK_Super_R:
|
|
return SUPER;
|
|
case GDK_Hyper_L:
|
|
case GDK_Hyper_R:
|
|
return HYPER;
|
|
case GDK_Meta_L:
|
|
case GDK_Meta_R:
|
|
return META;
|
|
case GDK_ISO_Level3_Shift:
|
|
case GDK_Mode_switch:
|
|
return LEVEL3;
|
|
case GDK_ISO_Level5_Shift:
|
|
return LEVEL5;
|
|
default:
|
|
return NOT_MODIFIER;
|
|
}
|
|
}
|
|
|
|
guint KeymapWrapper::GetModifierMask(Modifier aModifier) const {
|
|
switch (aModifier) {
|
|
case CAPS_LOCK:
|
|
return GDK_LOCK_MASK;
|
|
case NUM_LOCK:
|
|
return mModifierMasks[INDEX_NUM_LOCK];
|
|
case SCROLL_LOCK:
|
|
return mModifierMasks[INDEX_SCROLL_LOCK];
|
|
case SHIFT:
|
|
return GDK_SHIFT_MASK;
|
|
case CTRL:
|
|
return GDK_CONTROL_MASK;
|
|
case ALT:
|
|
return mModifierMasks[INDEX_ALT];
|
|
case SUPER:
|
|
return mModifierMasks[INDEX_SUPER];
|
|
case HYPER:
|
|
return mModifierMasks[INDEX_HYPER];
|
|
case META:
|
|
return mModifierMasks[INDEX_META];
|
|
case LEVEL3:
|
|
return mModifierMasks[INDEX_LEVEL3];
|
|
case LEVEL5:
|
|
return mModifierMasks[INDEX_LEVEL5];
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
KeymapWrapper::ModifierKey* KeymapWrapper::GetModifierKey(
|
|
guint aHardwareKeycode) {
|
|
for (uint32_t i = 0; i < mModifierKeys.Length(); i++) {
|
|
ModifierKey& key = mModifierKeys[i];
|
|
if (key.mHardwareKeycode == aHardwareKeycode) {
|
|
return &key;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/* static */
|
|
KeymapWrapper* KeymapWrapper::GetInstance() {
|
|
if (!sInstance) {
|
|
sInstance = new KeymapWrapper();
|
|
sInstance->Init();
|
|
}
|
|
return sInstance;
|
|
}
|
|
|
|
#ifdef MOZ_WAYLAND
|
|
void KeymapWrapper::EnsureInstance() { (void)GetInstance(); }
|
|
|
|
void KeymapWrapper::InitBySystemSettingsWayland() {
|
|
MOZ_UNUSED(WaylandDisplayGet());
|
|
}
|
|
#endif
|
|
|
|
/* static */
|
|
void KeymapWrapper::Shutdown() {
|
|
if (sInstance) {
|
|
delete sInstance;
|
|
sInstance = nullptr;
|
|
}
|
|
}
|
|
|
|
KeymapWrapper::KeymapWrapper()
|
|
: mInitialized(false),
|
|
mGdkKeymap(gdk_keymap_get_default()),
|
|
mXKBBaseEventCode(0),
|
|
mOnKeysChangedSignalHandle(0),
|
|
mOnDirectionChangedSignalHandle(0) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p Constructor, mGdkKeymap=%p", this, mGdkKeymap));
|
|
|
|
g_object_ref(mGdkKeymap);
|
|
|
|
#ifdef MOZ_X11
|
|
if (GdkIsX11Display()) {
|
|
InitXKBExtension();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void KeymapWrapper::Init() {
|
|
if (mInitialized) {
|
|
return;
|
|
}
|
|
mInitialized = true;
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p Init, mGdkKeymap=%p", this, mGdkKeymap));
|
|
|
|
mModifierKeys.Clear();
|
|
memset(mModifierMasks, 0, sizeof(mModifierMasks));
|
|
|
|
#ifdef MOZ_X11
|
|
if (GdkIsX11Display()) {
|
|
InitBySystemSettingsX11();
|
|
}
|
|
#endif
|
|
#ifdef MOZ_WAYLAND
|
|
if (GdkIsWaylandDisplay()) {
|
|
InitBySystemSettingsWayland();
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOZ_X11
|
|
gdk_window_add_filter(nullptr, FilterEvents, this);
|
|
#endif
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p Init, CapsLock=0x%X, NumLock=0x%X, "
|
|
"ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
|
|
"Shift=0x%X, Ctrl=0x%X, Alt=0x%X, Meta=0x%X, Super=0x%X, Hyper=0x%X",
|
|
this, GetModifierMask(CAPS_LOCK), GetModifierMask(NUM_LOCK),
|
|
GetModifierMask(SCROLL_LOCK), GetModifierMask(LEVEL3),
|
|
GetModifierMask(LEVEL5), GetModifierMask(SHIFT),
|
|
GetModifierMask(CTRL), GetModifierMask(ALT), GetModifierMask(META),
|
|
GetModifierMask(SUPER), GetModifierMask(HYPER)));
|
|
}
|
|
|
|
#ifdef MOZ_X11
|
|
void KeymapWrapper::InitXKBExtension() {
|
|
PodZero(&mKeyboardState);
|
|
|
|
int xkbMajorVer = XkbMajorVersion;
|
|
int xkbMinorVer = XkbMinorVersion;
|
|
if (!XkbLibraryVersion(&xkbMajorVer, &xkbMinorVer)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitXKBExtension failed due to failure of "
|
|
"XkbLibraryVersion()",
|
|
this));
|
|
return;
|
|
}
|
|
|
|
Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
|
|
|
|
// XkbLibraryVersion() set xkbMajorVer and xkbMinorVer to that of the
|
|
// library, which may be newer than what is required of the server in
|
|
// XkbQueryExtension(), so these variables should be reset to
|
|
// XkbMajorVersion and XkbMinorVersion before the XkbQueryExtension call.
|
|
xkbMajorVer = XkbMajorVersion;
|
|
xkbMinorVer = XkbMinorVersion;
|
|
int opcode, baseErrorCode;
|
|
if (!XkbQueryExtension(display, &opcode, &mXKBBaseEventCode, &baseErrorCode,
|
|
&xkbMajorVer, &xkbMinorVer)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitXKBExtension failed due to failure of "
|
|
"XkbQueryExtension(), display=0x%p",
|
|
this, display));
|
|
return;
|
|
}
|
|
|
|
if (!XkbSelectEventDetails(display, XkbUseCoreKbd, XkbStateNotify,
|
|
XkbModifierStateMask, XkbModifierStateMask)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitXKBExtension failed due to failure of "
|
|
"XkbSelectEventDetails() for XModifierStateMask, display=0x%p",
|
|
this, display));
|
|
return;
|
|
}
|
|
|
|
if (!XkbSelectEventDetails(display, XkbUseCoreKbd, XkbControlsNotify,
|
|
XkbPerKeyRepeatMask, XkbPerKeyRepeatMask)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitXKBExtension failed due to failure of "
|
|
"XkbSelectEventDetails() for XkbControlsNotify, display=0x%p",
|
|
this, display));
|
|
return;
|
|
}
|
|
|
|
if (!XGetKeyboardControl(display, &mKeyboardState)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitXKBExtension failed due to failure of "
|
|
"XGetKeyboardControl(), display=0x%p",
|
|
this, display));
|
|
return;
|
|
}
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info, ("%p InitXKBExtension, Succeeded", this));
|
|
}
|
|
|
|
void KeymapWrapper::InitBySystemSettingsX11() {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettingsX11, mGdkKeymap=%p", this, mGdkKeymap));
|
|
|
|
if (!mOnKeysChangedSignalHandle) {
|
|
mOnKeysChangedSignalHandle = g_signal_connect(
|
|
mGdkKeymap, "keys-changed", (GCallback)OnKeysChanged, this);
|
|
}
|
|
if (!mOnDirectionChangedSignalHandle) {
|
|
mOnDirectionChangedSignalHandle = g_signal_connect(
|
|
mGdkKeymap, "direction-changed", (GCallback)OnDirectionChanged, this);
|
|
}
|
|
|
|
Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
|
|
|
|
int min_keycode = 0;
|
|
int max_keycode = 0;
|
|
XDisplayKeycodes(display, &min_keycode, &max_keycode);
|
|
|
|
int keysyms_per_keycode = 0;
|
|
KeySym* xkeymap =
|
|
XGetKeyboardMapping(display, min_keycode, max_keycode - min_keycode + 1,
|
|
&keysyms_per_keycode);
|
|
if (!xkeymap) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettings, "
|
|
"Failed due to null xkeymap",
|
|
this));
|
|
return;
|
|
}
|
|
|
|
XModifierKeymap* xmodmap = XGetModifierMapping(display);
|
|
if (!xmodmap) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettings, "
|
|
"Failed due to null xmodmap",
|
|
this));
|
|
XFree(xkeymap);
|
|
return;
|
|
}
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettings, min_keycode=%d, "
|
|
"max_keycode=%d, keysyms_per_keycode=%d, max_keypermod=%d",
|
|
this, min_keycode, max_keycode, keysyms_per_keycode,
|
|
xmodmap->max_keypermod));
|
|
|
|
// The modifiermap member of the XModifierKeymap structure contains 8 sets
|
|
// of max_keypermod KeyCodes, one for each modifier in the order Shift,
|
|
// Lock, Control, Mod1, Mod2, Mod3, Mod4, and Mod5.
|
|
// Only nonzero KeyCodes have meaning in each set, and zero KeyCodes are
|
|
// ignored.
|
|
|
|
// Note that two or more modifiers may use one modifier flag. E.g.,
|
|
// on Ubuntu 10.10, Alt and Meta share the Mod1 in default settings.
|
|
// And also Super and Hyper share the Mod4. In such cases, we need to
|
|
// decide which modifier flag means one of DOM modifiers.
|
|
|
|
// mod[0] is Modifier introduced by Mod1.
|
|
Modifier mod[5];
|
|
int32_t foundLevel[5];
|
|
for (uint32_t i = 0; i < ArrayLength(mod); i++) {
|
|
mod[i] = NOT_MODIFIER;
|
|
foundLevel[i] = INT32_MAX;
|
|
}
|
|
const uint32_t map_size = 8 * xmodmap->max_keypermod;
|
|
for (uint32_t i = 0; i < map_size; i++) {
|
|
KeyCode keycode = xmodmap->modifiermap[i];
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettings, "
|
|
" i=%d, keycode=0x%08X",
|
|
this, i, keycode));
|
|
if (!keycode || keycode < min_keycode || keycode > max_keycode) {
|
|
continue;
|
|
}
|
|
|
|
ModifierKey* modifierKey = GetModifierKey(keycode);
|
|
if (!modifierKey) {
|
|
modifierKey = mModifierKeys.AppendElement(ModifierKey(keycode));
|
|
}
|
|
|
|
const KeySym* syms =
|
|
xkeymap + (keycode - min_keycode) * keysyms_per_keycode;
|
|
const uint32_t bit = i / xmodmap->max_keypermod;
|
|
modifierKey->mMask |= 1 << bit;
|
|
|
|
// We need to know the meaning of Mod1, Mod2, Mod3, Mod4 and Mod5.
|
|
// Let's skip if current map is for others.
|
|
if (bit < 3) {
|
|
continue;
|
|
}
|
|
|
|
const int32_t modIndex = bit - 3;
|
|
for (int32_t j = 0; j < keysyms_per_keycode; j++) {
|
|
Modifier modifier = GetModifierForGDKKeyval(syms[j]);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p InitBySystemSettings, "
|
|
" Mod%d, j=%d, syms[j]=%s(0x%lX), modifier=%s",
|
|
this, modIndex + 1, j, gdk_keyval_name(syms[j]), syms[j],
|
|
GetModifierName(modifier)));
|
|
|
|
switch (modifier) {
|
|
case NOT_MODIFIER:
|
|
// Don't overwrite the stored information with
|
|
// NOT_MODIFIER.
|
|
break;
|
|
case CAPS_LOCK:
|
|
case SHIFT:
|
|
case CTRL:
|
|
// Ignore the modifiers defined in GDK spec. They shouldn't
|
|
// be mapped to Mod1-5 because they must not work on native
|
|
// GTK applications.
|
|
break;
|
|
default:
|
|
// If new modifier is found in higher level than stored
|
|
// value, we don't need to overwrite it.
|
|
if (j > foundLevel[modIndex]) {
|
|
break;
|
|
}
|
|
// If new modifier is more important than stored value,
|
|
// we should overwrite it with new modifier.
|
|
if (j == foundLevel[modIndex]) {
|
|
mod[modIndex] = std::min(modifier, mod[modIndex]);
|
|
break;
|
|
}
|
|
foundLevel[modIndex] = j;
|
|
mod[modIndex] = modifier;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (uint32_t i = 0; i < COUNT_OF_MODIFIER_INDEX; i++) {
|
|
Modifier modifier;
|
|
switch (i) {
|
|
case INDEX_NUM_LOCK:
|
|
modifier = NUM_LOCK;
|
|
break;
|
|
case INDEX_SCROLL_LOCK:
|
|
modifier = SCROLL_LOCK;
|
|
break;
|
|
case INDEX_ALT:
|
|
modifier = ALT;
|
|
break;
|
|
case INDEX_META:
|
|
modifier = META;
|
|
break;
|
|
case INDEX_SUPER:
|
|
modifier = SUPER;
|
|
break;
|
|
case INDEX_HYPER:
|
|
modifier = HYPER;
|
|
break;
|
|
case INDEX_LEVEL3:
|
|
modifier = LEVEL3;
|
|
break;
|
|
case INDEX_LEVEL5:
|
|
modifier = LEVEL5;
|
|
break;
|
|
default:
|
|
MOZ_CRASH("All indexes must be handled here");
|
|
}
|
|
for (uint32_t j = 0; j < ArrayLength(mod); j++) {
|
|
if (modifier == mod[j]) {
|
|
mModifierMasks[i] |= 1 << (j + 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
XFreeModifiermap(xmodmap);
|
|
XFree(xkeymap);
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOZ_WAYLAND
|
|
void KeymapWrapper::SetModifierMask(xkb_keymap* aKeymap,
|
|
ModifierIndex aModifierIndex,
|
|
const char* aModifierName) {
|
|
static auto sXkbKeymapModGetIndex =
|
|
(xkb_mod_index_t(*)(struct xkb_keymap*, const char*))dlsym(
|
|
RTLD_DEFAULT, "xkb_keymap_mod_get_index");
|
|
|
|
xkb_mod_index_t index = sXkbKeymapModGetIndex(aKeymap, aModifierName);
|
|
if (index != XKB_MOD_INVALID) {
|
|
mModifierMasks[aModifierIndex] = (1 << index);
|
|
}
|
|
}
|
|
|
|
void KeymapWrapper::SetModifierMasks(xkb_keymap* aKeymap) {
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
|
|
// This mapping is derived from get_xkb_modifiers() at gdkkeys-wayland.c
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_NUM_LOCK, XKB_MOD_NAME_NUM);
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_ALT, XKB_MOD_NAME_ALT);
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_META, "Meta");
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_SUPER, "Super");
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_HYPER, "Hyper");
|
|
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_SCROLL_LOCK, "ScrollLock");
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL3, "Level3");
|
|
keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL5, "Level5");
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p KeymapWrapper::SetModifierMasks, CapsLock=0x%X, NumLock=0x%X, "
|
|
"ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
|
|
"Shift=0x%X, Ctrl=0x%X, Alt=0x%X, Meta=0x%X, Super=0x%X, Hyper=0x%X",
|
|
keymapWrapper, keymapWrapper->GetModifierMask(CAPS_LOCK),
|
|
keymapWrapper->GetModifierMask(NUM_LOCK),
|
|
keymapWrapper->GetModifierMask(SCROLL_LOCK),
|
|
keymapWrapper->GetModifierMask(LEVEL3),
|
|
keymapWrapper->GetModifierMask(LEVEL5),
|
|
keymapWrapper->GetModifierMask(SHIFT),
|
|
keymapWrapper->GetModifierMask(CTRL),
|
|
keymapWrapper->GetModifierMask(ALT),
|
|
keymapWrapper->GetModifierMask(META),
|
|
keymapWrapper->GetModifierMask(SUPER),
|
|
keymapWrapper->GetModifierMask(HYPER)));
|
|
}
|
|
|
|
/* This keymap routine is derived from weston-2.0.0/clients/simple-im.c
|
|
*/
|
|
static void keyboard_handle_keymap(void* data, struct wl_keyboard* wl_keyboard,
|
|
uint32_t format, int fd, uint32_t size) {
|
|
KeymapWrapper::ResetKeyboard();
|
|
|
|
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
char* mapString = (char*)mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
|
|
if (mapString == MAP_FAILED) {
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
static auto sXkbContextNew =
|
|
(struct xkb_context * (*)(enum xkb_context_flags))
|
|
dlsym(RTLD_DEFAULT, "xkb_context_new");
|
|
static auto sXkbKeymapNewFromString =
|
|
(struct xkb_keymap * (*)(struct xkb_context*, const char*,
|
|
enum xkb_keymap_format,
|
|
enum xkb_keymap_compile_flags))
|
|
dlsym(RTLD_DEFAULT, "xkb_keymap_new_from_string");
|
|
|
|
struct xkb_context* xkb_context = sXkbContextNew(XKB_CONTEXT_NO_FLAGS);
|
|
struct xkb_keymap* keymap =
|
|
sXkbKeymapNewFromString(xkb_context, mapString, XKB_KEYMAP_FORMAT_TEXT_V1,
|
|
XKB_KEYMAP_COMPILE_NO_FLAGS);
|
|
|
|
munmap(mapString, size);
|
|
close(fd);
|
|
|
|
if (!keymap) {
|
|
NS_WARNING("keyboard_handle_keymap(): Failed to compile keymap!\n");
|
|
return;
|
|
}
|
|
|
|
KeymapWrapper::SetModifierMasks(keymap);
|
|
|
|
static auto sXkbKeymapUnRef =
|
|
(void (*)(struct xkb_keymap*))dlsym(RTLD_DEFAULT, "xkb_keymap_unref");
|
|
sXkbKeymapUnRef(keymap);
|
|
|
|
static auto sXkbContextUnref =
|
|
(void (*)(struct xkb_context*))dlsym(RTLD_DEFAULT, "xkb_context_unref");
|
|
sXkbContextUnref(xkb_context);
|
|
}
|
|
|
|
static void keyboard_handle_enter(void* data, struct wl_keyboard* keyboard,
|
|
uint32_t serial, struct wl_surface* surface,
|
|
struct wl_array* keys) {
|
|
KeymapWrapper::SetFocusIn(surface, serial);
|
|
}
|
|
|
|
static void keyboard_handle_leave(void* data, struct wl_keyboard* keyboard,
|
|
uint32_t serial, struct wl_surface* surface) {
|
|
KeymapWrapper::SetFocusOut(surface);
|
|
}
|
|
|
|
static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard,
|
|
uint32_t serial, uint32_t time, uint32_t key,
|
|
uint32_t state) {}
|
|
static void keyboard_handle_modifiers(void* data, struct wl_keyboard* keyboard,
|
|
uint32_t serial, uint32_t mods_depressed,
|
|
uint32_t mods_latched,
|
|
uint32_t mods_locked, uint32_t group) {}
|
|
static void keyboard_handle_repeat_info(void* data,
|
|
struct wl_keyboard* keyboard,
|
|
int32_t rate, int32_t delay) {}
|
|
|
|
static const struct wl_keyboard_listener keyboard_listener = {
|
|
keyboard_handle_keymap, keyboard_handle_enter,
|
|
keyboard_handle_leave, keyboard_handle_key,
|
|
keyboard_handle_modifiers, keyboard_handle_repeat_info};
|
|
|
|
static void seat_handle_capabilities(void* data, struct wl_seat* seat,
|
|
unsigned int caps) {
|
|
wl_keyboard* keyboard = KeymapWrapper::GetKeyboard();
|
|
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !keyboard) {
|
|
keyboard = wl_seat_get_keyboard(seat);
|
|
wl_keyboard_add_listener(keyboard, &keyboard_listener, nullptr);
|
|
KeymapWrapper::SetKeyboard(keyboard);
|
|
} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && keyboard) {
|
|
KeymapWrapper::ClearKeyboard();
|
|
}
|
|
}
|
|
|
|
static const struct wl_seat_listener seat_listener = {
|
|
seat_handle_capabilities,
|
|
};
|
|
|
|
#endif
|
|
|
|
KeymapWrapper::~KeymapWrapper() {
|
|
#ifdef MOZ_X11
|
|
gdk_window_remove_filter(nullptr, FilterEvents, this);
|
|
#endif
|
|
if (mOnKeysChangedSignalHandle) {
|
|
g_signal_handler_disconnect(mGdkKeymap, mOnKeysChangedSignalHandle);
|
|
}
|
|
if (mOnDirectionChangedSignalHandle) {
|
|
g_signal_handler_disconnect(mGdkKeymap, mOnDirectionChangedSignalHandle);
|
|
}
|
|
g_object_unref(mGdkKeymap);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info, ("%p Destructor", this));
|
|
}
|
|
|
|
#ifdef MOZ_X11
|
|
/* static */
|
|
GdkFilterReturn KeymapWrapper::FilterEvents(GdkXEvent* aXEvent,
|
|
GdkEvent* aGdkEvent,
|
|
gpointer aData) {
|
|
XEvent* xEvent = static_cast<XEvent*>(aXEvent);
|
|
switch (xEvent->type) {
|
|
case KeyPress: {
|
|
// If the key doesn't support auto repeat, ignore the event because
|
|
// even if such key (e.g., Shift) is pressed during auto repeat of
|
|
// anoter key, it doesn't stop the auto repeat.
|
|
KeymapWrapper* self = static_cast<KeymapWrapper*>(aData);
|
|
if (!self->IsAutoRepeatableKey(xEvent->xkey.keycode)) {
|
|
break;
|
|
}
|
|
if (sRepeatState == NOT_PRESSED) {
|
|
sRepeatState = FIRST_PRESS;
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("FilterEvents(aXEvent={ type=KeyPress, "
|
|
"xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
|
|
"aGdkEvent={ state=0x%08X }), "
|
|
"detected first keypress",
|
|
xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
|
|
reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
|
|
} else if (sLastRepeatableHardwareKeyCode == xEvent->xkey.keycode) {
|
|
if (sLastRepeatableKeyTime == xEvent->xkey.time &&
|
|
sLastRepeatableHardwareKeyCode ==
|
|
IMContextWrapper::
|
|
GetWaitingSynthesizedKeyPressHardwareKeyCode()) {
|
|
// On some environment, IM may generate duplicated KeyPress event
|
|
// without any special state flags. In such case, we shouldn't
|
|
// treat the event as "repeated".
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("FilterEvents(aXEvent={ type=KeyPress, "
|
|
"xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
|
|
"aGdkEvent={ state=0x%08X }), "
|
|
"igored keypress since it must be synthesized by IME",
|
|
xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
|
|
reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
|
|
break;
|
|
}
|
|
sRepeatState = REPEATING;
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("FilterEvents(aXEvent={ type=KeyPress, "
|
|
"xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
|
|
"aGdkEvent={ state=0x%08X }), "
|
|
"detected repeating keypress",
|
|
xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
|
|
reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
|
|
} else {
|
|
// If a different key is pressed while another key is pressed,
|
|
// auto repeat system repeats only the last pressed key.
|
|
// So, setting new keycode and setting repeat state as first key
|
|
// press should work fine.
|
|
sRepeatState = FIRST_PRESS;
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("FilterEvents(aXEvent={ type=KeyPress, "
|
|
"xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
|
|
"aGdkEvent={ state=0x%08X }), "
|
|
"detected different keypress",
|
|
xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
|
|
reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
|
|
}
|
|
sLastRepeatableHardwareKeyCode = xEvent->xkey.keycode;
|
|
sLastRepeatableKeyTime = xEvent->xkey.time;
|
|
break;
|
|
}
|
|
case KeyRelease: {
|
|
if (sLastRepeatableHardwareKeyCode != xEvent->xkey.keycode) {
|
|
// This case means the key release event is caused by
|
|
// a non-repeatable key such as Shift or a repeatable key that
|
|
// was pressed before sLastRepeatableHardwareKeyCode was
|
|
// pressed.
|
|
break;
|
|
}
|
|
sRepeatState = NOT_PRESSED;
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("FilterEvents(aXEvent={ type=KeyRelease, "
|
|
"xkey={ keycode=0x%08X, state=0x%08X, time=%lu } }, "
|
|
"aGdkEvent={ state=0x%08X }), "
|
|
"detected key release",
|
|
xEvent->xkey.keycode, xEvent->xkey.state, xEvent->xkey.time,
|
|
reinterpret_cast<GdkEventKey*>(aGdkEvent)->state));
|
|
break;
|
|
}
|
|
case FocusOut: {
|
|
// At moving focus, we should reset keyboard repeat state.
|
|
// Strictly, this causes incorrect behavior. However, this
|
|
// correctness must be enough for web applications.
|
|
sRepeatState = NOT_PRESSED;
|
|
break;
|
|
}
|
|
default: {
|
|
KeymapWrapper* self = static_cast<KeymapWrapper*>(aData);
|
|
if (xEvent->type != self->mXKBBaseEventCode) {
|
|
break;
|
|
}
|
|
XkbEvent* xkbEvent = (XkbEvent*)xEvent;
|
|
if (xkbEvent->any.xkb_type != XkbControlsNotify ||
|
|
!(xkbEvent->ctrls.changed_ctrls & XkbPerKeyRepeatMask)) {
|
|
break;
|
|
}
|
|
if (!XGetKeyboardControl(xkbEvent->any.display, &self->mKeyboardState)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p FilterEvents failed due to failure "
|
|
"of XGetKeyboardControl(), display=0x%p",
|
|
self, xkbEvent->any.display));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return GDK_FILTER_CONTINUE;
|
|
}
|
|
#endif
|
|
|
|
static void ResetBidiKeyboard() {
|
|
// Reset the bidi keyboard settings for the new GdkKeymap
|
|
nsCOMPtr<nsIBidiKeyboard> bidiKeyboard = nsContentUtils::GetBidiKeyboard();
|
|
if (bidiKeyboard) {
|
|
bidiKeyboard->Reset();
|
|
}
|
|
WidgetUtils::SendBidiKeyboardInfoToContent();
|
|
}
|
|
|
|
/* static */
|
|
void KeymapWrapper::ResetKeyboard() {
|
|
if (sInstance) {
|
|
sInstance->mInitialized = false;
|
|
ResetBidiKeyboard();
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
void KeymapWrapper::OnKeysChanged(GdkKeymap* aGdkKeymap,
|
|
KeymapWrapper* aKeymapWrapper) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("OnKeysChanged, aGdkKeymap=%p, aKeymapWrapper=%p", aGdkKeymap,
|
|
aKeymapWrapper));
|
|
|
|
MOZ_ASSERT(sInstance == aKeymapWrapper,
|
|
"This instance must be the singleton instance");
|
|
|
|
// We cannot reintialize here becasue we don't have GdkWindow which is using
|
|
// the GdkKeymap. We'll reinitialize it when next GetInstance() is called.
|
|
ResetKeyboard();
|
|
}
|
|
|
|
// static
|
|
void KeymapWrapper::OnDirectionChanged(GdkKeymap* aGdkKeymap,
|
|
KeymapWrapper* aKeymapWrapper) {
|
|
// XXX
|
|
// A lot of diretion-changed signal might be fired on switching bidi
|
|
// keyboard when using both ibus (with arabic layout) and fcitx (with IME).
|
|
// See https://github.com/fcitx/fcitx/issues/257
|
|
//
|
|
// Also, when using ibus, switching to IM might not cause this signal.
|
|
// See https://github.com/ibus/ibus/issues/1848
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("OnDirectionChanged, aGdkKeymap=%p, aKeymapWrapper=%p", aGdkKeymap,
|
|
aKeymapWrapper));
|
|
|
|
ResetBidiKeyboard();
|
|
}
|
|
|
|
/* static */
|
|
guint KeymapWrapper::GetCurrentModifierState() {
|
|
GdkModifierType modifiers;
|
|
GdkDisplay* display = gdk_display_get_default();
|
|
GdkScreen* screen = gdk_display_get_default_screen(display);
|
|
GdkWindow* window = gdk_screen_get_root_window(screen);
|
|
gdk_window_get_device_position(window, GdkGetPointer(), nullptr, nullptr,
|
|
&modifiers);
|
|
return static_cast<guint>(modifiers);
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::AreModifiersCurrentlyActive(Modifiers aModifiers) {
|
|
guint modifierState = GetCurrentModifierState();
|
|
return AreModifiersActive(aModifiers, modifierState);
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::AreModifiersActive(Modifiers aModifiers,
|
|
guint aModifierState) {
|
|
NS_ENSURE_TRUE(aModifiers, false);
|
|
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
for (uint32_t i = 0; i < sizeof(Modifier) * 8 && aModifiers; i++) {
|
|
Modifier modifier = static_cast<Modifier>(1 << i);
|
|
if (!(aModifiers & modifier)) {
|
|
continue;
|
|
}
|
|
if (!(aModifierState & keymapWrapper->GetModifierMask(modifier))) {
|
|
return false;
|
|
}
|
|
aModifiers &= ~modifier;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* static */
|
|
uint32_t KeymapWrapper::ComputeCurrentKeyModifiers() {
|
|
return ComputeKeyModifiers(GetCurrentModifierState());
|
|
}
|
|
|
|
/* static */
|
|
uint32_t KeymapWrapper::ComputeKeyModifiers(guint aModifierState) {
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
|
|
uint32_t keyModifiers = 0;
|
|
// DOM Meta key should be TRUE only on Mac. We need to discuss this
|
|
// issue later.
|
|
if (keymapWrapper->AreModifiersActive(SHIFT, aModifierState)) {
|
|
keyModifiers |= MODIFIER_SHIFT;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(CTRL, aModifierState)) {
|
|
keyModifiers |= MODIFIER_CONTROL;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(ALT, aModifierState)) {
|
|
keyModifiers |= MODIFIER_ALT;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(SUPER, aModifierState) ||
|
|
keymapWrapper->AreModifiersActive(HYPER, aModifierState) ||
|
|
// "Meta" state is typically mapped to `Alt` + `Shift`, but we ignore the
|
|
// state if `Alt` is mapped to "Alt" state. Additionally it's mapped to
|
|
// `Win` in Sun/Solaris keyboard layout. In this case, we want to treat
|
|
// them as DOM Meta modifier keys like "Super" state in the major Linux
|
|
// environments.
|
|
keymapWrapper->AreModifiersActive(META, aModifierState)) {
|
|
keyModifiers |= MODIFIER_META;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(LEVEL3, aModifierState) ||
|
|
keymapWrapper->AreModifiersActive(LEVEL5, aModifierState)) {
|
|
keyModifiers |= MODIFIER_ALTGRAPH;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(CAPS_LOCK, aModifierState)) {
|
|
keyModifiers |= MODIFIER_CAPSLOCK;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(NUM_LOCK, aModifierState)) {
|
|
keyModifiers |= MODIFIER_NUMLOCK;
|
|
}
|
|
if (keymapWrapper->AreModifiersActive(SCROLL_LOCK, aModifierState)) {
|
|
keyModifiers |= MODIFIER_SCROLLLOCK;
|
|
}
|
|
return keyModifiers;
|
|
}
|
|
|
|
/* static */
|
|
guint KeymapWrapper::ConvertWidgetModifierToGdkState(
|
|
nsIWidget::Modifiers aNativeModifiers) {
|
|
if (!aNativeModifiers) {
|
|
return 0;
|
|
}
|
|
struct ModifierMapEntry {
|
|
nsIWidget::Modifiers mWidgetModifier;
|
|
Modifier mModifier;
|
|
};
|
|
// TODO: Currently, we don't treat L/R of each modifier on Linux.
|
|
// TODO: No proper native modifier for Level5.
|
|
static constexpr ModifierMapEntry sModifierMap[] = {
|
|
{nsIWidget::CAPS_LOCK, Modifier::CAPS_LOCK},
|
|
{nsIWidget::NUM_LOCK, Modifier::NUM_LOCK},
|
|
{nsIWidget::SHIFT_L, Modifier::SHIFT},
|
|
{nsIWidget::SHIFT_R, Modifier::SHIFT},
|
|
{nsIWidget::CTRL_L, Modifier::CTRL},
|
|
{nsIWidget::CTRL_R, Modifier::CTRL},
|
|
{nsIWidget::ALT_L, Modifier::ALT},
|
|
{nsIWidget::ALT_R, Modifier::ALT},
|
|
{nsIWidget::ALTGRAPH, Modifier::LEVEL3},
|
|
{nsIWidget::COMMAND_L, Modifier::SUPER},
|
|
{nsIWidget::COMMAND_R, Modifier::SUPER}};
|
|
|
|
guint state = 0;
|
|
KeymapWrapper* instance = GetInstance();
|
|
for (const ModifierMapEntry& entry : sModifierMap) {
|
|
if (aNativeModifiers & entry.mWidgetModifier) {
|
|
state |= instance->GetModifierMask(entry.mModifier);
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
|
|
/* static */
|
|
void KeymapWrapper::InitInputEvent(WidgetInputEvent& aInputEvent,
|
|
guint aModifierState) {
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
|
|
aInputEvent.mModifiers = ComputeKeyModifiers(aModifierState);
|
|
|
|
// Don't log this method for non-important events because e.g., eMouseMove is
|
|
// just noisy and there is no reason to log it.
|
|
bool doLog = aInputEvent.mMessage != eMouseMove;
|
|
if (doLog) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Debug,
|
|
("%p InitInputEvent, aModifierState=0x%08X, "
|
|
"aInputEvent={ mMessage=%s, mModifiers=0x%04X (Shift: %s, "
|
|
"Control: %s, Alt: %s, Meta: %s, AltGr: %s, "
|
|
"CapsLock: %s, NumLock: %s, ScrollLock: %s })",
|
|
keymapWrapper, aModifierState, ToChar(aInputEvent.mMessage),
|
|
aInputEvent.mModifiers,
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_SHIFT),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_CONTROL),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_ALT),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_META),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_ALTGRAPH),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_CAPSLOCK),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_NUMLOCK),
|
|
GetBoolName(aInputEvent.mModifiers & MODIFIER_SCROLLLOCK)));
|
|
}
|
|
|
|
switch (aInputEvent.mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case eSimpleGestureEventClass:
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
WidgetMouseEventBase& mouseEvent = *aInputEvent.AsMouseEventBase();
|
|
mouseEvent.mButtons = 0;
|
|
if (aModifierState & GDK_BUTTON1_MASK) {
|
|
mouseEvent.mButtons |= MouseButtonsFlag::ePrimaryFlag;
|
|
}
|
|
if (aModifierState & GDK_BUTTON3_MASK) {
|
|
mouseEvent.mButtons |= MouseButtonsFlag::eSecondaryFlag;
|
|
}
|
|
if (aModifierState & GDK_BUTTON2_MASK) {
|
|
mouseEvent.mButtons |= MouseButtonsFlag::eMiddleFlag;
|
|
}
|
|
|
|
if (doLog) {
|
|
MOZ_LOG(
|
|
gKeyLog, LogLevel::Debug,
|
|
("%p InitInputEvent, aInputEvent has mButtons, "
|
|
"aInputEvent.mButtons=0x%04X (Left: %s, Right: %s, Middle: %s, "
|
|
"4th (BACK): %s, 5th (FORWARD): %s)",
|
|
keymapWrapper, mouseEvent.mButtons,
|
|
GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::ePrimaryFlag),
|
|
GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::eSecondaryFlag),
|
|
GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::eMiddleFlag),
|
|
GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::e4thFlag),
|
|
GetBoolName(mouseEvent.mButtons & MouseButtonsFlag::e5thFlag)));
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
uint32_t KeymapWrapper::ComputeDOMKeyCode(const GdkEventKey* aGdkKeyEvent) {
|
|
// If the keyval indicates it's a modifier key, we should use unshifted
|
|
// key's modifier keyval.
|
|
guint keyval = aGdkKeyEvent->keyval;
|
|
if (GetModifierForGDKKeyval(keyval)) {
|
|
// But if the keyval without modifiers isn't a modifier key, we
|
|
// shouldn't use it. E.g., Japanese keyboard layout's
|
|
// Shift + Eisu-Toggle key is CapsLock. This is an actual rare case,
|
|
// Windows uses different keycode for a physical key for different
|
|
// shift key state.
|
|
guint keyvalWithoutModifier = GetGDKKeyvalWithoutModifier(aGdkKeyEvent);
|
|
if (GetModifierForGDKKeyval(keyvalWithoutModifier)) {
|
|
keyval = keyvalWithoutModifier;
|
|
}
|
|
// Note that the modifier keycode and activating or deactivating
|
|
// modifier flag may be mismatched, but it's okay. If a DOM key
|
|
// event handler is testing a keydown event, it's more likely being
|
|
// used to test which key is being pressed than to test which
|
|
// modifier will become active. So, if we computed DOM keycode
|
|
// from modifier flag which were changing by the physical key, then
|
|
// there would be no other way for the user to generate the original
|
|
// keycode.
|
|
uint32_t DOMKeyCode = GetDOMKeyCodeFromKeyPairs(keyval);
|
|
NS_ASSERTION(DOMKeyCode, "All modifier keys must have a DOM keycode");
|
|
return DOMKeyCode;
|
|
}
|
|
|
|
// If the key isn't printable, let's look at the key pairs.
|
|
uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
|
|
if (!charCode) {
|
|
// Note that any key may be a function key because of some unusual keyboard
|
|
// layouts. I.e., even if the pressed key is a printable key of en-US
|
|
// keyboard layout, we should expose the function key's keyCode value to
|
|
// web apps because web apps should handle the keydown/keyup events as
|
|
// inputted by usual keyboard layout. For example, Hatchak keyboard
|
|
// maps Tab key to "Digit3" key and Level3 Shift makes it "Backspace".
|
|
// In this case, we should expose DOM_VK_BACK_SPACE (8).
|
|
uint32_t DOMKeyCode = GetDOMKeyCodeFromKeyPairs(keyval);
|
|
if (DOMKeyCode) {
|
|
// XXX If DOMKeyCode is a function key's keyCode value, it might be
|
|
// better to consume necessary modifiers. For example, if there is
|
|
// no Control Pad section on keyboard like notebook, Delete key is
|
|
// available only with Level3 Shift+"Backspace" key if using Hatchak.
|
|
// If web apps accept Delete key operation only when no modifiers are
|
|
// active, such users cannot use Delete key to do it. However,
|
|
// Chromium doesn't consume such necessary modifiers. So, our default
|
|
// behavior should keep not touching modifiers for compatibility, but
|
|
// it might be better to add a pref to consume necessary modifiers.
|
|
return DOMKeyCode;
|
|
}
|
|
// If aGdkKeyEvent cannot be mapped to a DOM keyCode value, we should
|
|
// refer keyCode value without modifiers because web apps should be
|
|
// able to identify the key as far as possible.
|
|
guint keyvalWithoutModifier = GetGDKKeyvalWithoutModifier(aGdkKeyEvent);
|
|
return GetDOMKeyCodeFromKeyPairs(keyvalWithoutModifier);
|
|
}
|
|
|
|
// printable numpad keys should be resolved here.
|
|
switch (keyval) {
|
|
case GDK_KP_Multiply:
|
|
return NS_VK_MULTIPLY;
|
|
case GDK_KP_Add:
|
|
return NS_VK_ADD;
|
|
case GDK_KP_Separator:
|
|
return NS_VK_SEPARATOR;
|
|
case GDK_KP_Subtract:
|
|
return NS_VK_SUBTRACT;
|
|
case GDK_KP_Decimal:
|
|
return NS_VK_DECIMAL;
|
|
case GDK_KP_Divide:
|
|
return NS_VK_DIVIDE;
|
|
case GDK_KP_0:
|
|
return NS_VK_NUMPAD0;
|
|
case GDK_KP_1:
|
|
return NS_VK_NUMPAD1;
|
|
case GDK_KP_2:
|
|
return NS_VK_NUMPAD2;
|
|
case GDK_KP_3:
|
|
return NS_VK_NUMPAD3;
|
|
case GDK_KP_4:
|
|
return NS_VK_NUMPAD4;
|
|
case GDK_KP_5:
|
|
return NS_VK_NUMPAD5;
|
|
case GDK_KP_6:
|
|
return NS_VK_NUMPAD6;
|
|
case GDK_KP_7:
|
|
return NS_VK_NUMPAD7;
|
|
case GDK_KP_8:
|
|
return NS_VK_NUMPAD8;
|
|
case GDK_KP_9:
|
|
return NS_VK_NUMPAD9;
|
|
}
|
|
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
|
|
// Ignore all modifier state except NumLock.
|
|
guint baseState =
|
|
(aGdkKeyEvent->state & keymapWrapper->GetModifierMask(NUM_LOCK));
|
|
|
|
// Basically, we should use unmodified character for deciding our keyCode.
|
|
uint32_t unmodifiedChar = keymapWrapper->GetCharCodeFor(
|
|
aGdkKeyEvent, baseState, aGdkKeyEvent->group);
|
|
if (IsBasicLatinLetterOrNumeral(unmodifiedChar)) {
|
|
// If the unmodified character is an ASCII alphabet or an ASCII
|
|
// numeric, it's the best hint for deciding our keyCode.
|
|
return WidgetUtils::ComputeKeyCodeFromChar(unmodifiedChar);
|
|
}
|
|
|
|
// If the unmodified character is not an ASCII character, that means we
|
|
// couldn't find the hint. We should reset it.
|
|
if (!IsPrintableASCIICharacter(unmodifiedChar)) {
|
|
unmodifiedChar = 0;
|
|
}
|
|
|
|
// Retry with shifted keycode.
|
|
guint shiftState = (baseState | keymapWrapper->GetModifierMask(SHIFT));
|
|
uint32_t shiftedChar = keymapWrapper->GetCharCodeFor(aGdkKeyEvent, shiftState,
|
|
aGdkKeyEvent->group);
|
|
if (IsBasicLatinLetterOrNumeral(shiftedChar)) {
|
|
// A shifted character can be an ASCII alphabet on Hebrew keyboard
|
|
// layout. And also shifted character can be an ASCII numeric on
|
|
// AZERTY keyboad layout. Then, it's a good hint for deciding our
|
|
// keyCode.
|
|
return WidgetUtils::ComputeKeyCodeFromChar(shiftedChar);
|
|
}
|
|
|
|
// If the shifted unmodified character isn't an ASCII character, we should
|
|
// discard it too.
|
|
if (!IsPrintableASCIICharacter(shiftedChar)) {
|
|
shiftedChar = 0;
|
|
}
|
|
|
|
// If current keyboard layout isn't ASCII alphabet inputtable layout,
|
|
// look for ASCII alphabet inputtable keyboard layout. If the key
|
|
// inputs an ASCII alphabet or an ASCII numeric, we should use it
|
|
// for deciding our keyCode.
|
|
uint32_t unmodCharLatin = 0;
|
|
uint32_t shiftedCharLatin = 0;
|
|
if (!keymapWrapper->IsLatinGroup(aGdkKeyEvent->group)) {
|
|
gint minGroup = keymapWrapper->GetFirstLatinGroup();
|
|
if (minGroup >= 0) {
|
|
unmodCharLatin =
|
|
keymapWrapper->GetCharCodeFor(aGdkKeyEvent, baseState, minGroup);
|
|
if (IsBasicLatinLetterOrNumeral(unmodCharLatin)) {
|
|
// If the unmodified character is an ASCII alphabet or
|
|
// an ASCII numeric, we should use it for the keyCode.
|
|
return WidgetUtils::ComputeKeyCodeFromChar(unmodCharLatin);
|
|
}
|
|
// If the unmodified character in the alternative ASCII capable
|
|
// keyboard layout isn't an ASCII character, that means we couldn't
|
|
// find the hint. We should reset it.
|
|
if (!IsPrintableASCIICharacter(unmodCharLatin)) {
|
|
unmodCharLatin = 0;
|
|
}
|
|
shiftedCharLatin =
|
|
keymapWrapper->GetCharCodeFor(aGdkKeyEvent, shiftState, minGroup);
|
|
if (IsBasicLatinLetterOrNumeral(shiftedCharLatin)) {
|
|
// If the shifted character is an ASCII alphabet or an ASCII
|
|
// numeric, we should use it for the keyCode.
|
|
return WidgetUtils::ComputeKeyCodeFromChar(shiftedCharLatin);
|
|
}
|
|
// If the shifted unmodified character in the alternative ASCII
|
|
// capable keyboard layout isn't an ASCII character, we should
|
|
// discard it too.
|
|
if (!IsPrintableASCIICharacter(shiftedCharLatin)) {
|
|
shiftedCharLatin = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the key itself or with Shift state on active keyboard layout produces
|
|
// an ASCII punctuation character, we should decide keyCode value with it.
|
|
if (unmodifiedChar || shiftedChar) {
|
|
return WidgetUtils::ComputeKeyCodeFromChar(unmodifiedChar ? unmodifiedChar
|
|
: shiftedChar);
|
|
}
|
|
|
|
// If the key itself or with Shift state on alternative ASCII capable
|
|
// keyboard layout produces an ASCII punctuation character, we should
|
|
// decide keyCode value with it. Note that We've returned 0 for long
|
|
// time if keyCode isn't for an alphabet keys or a numeric key even in
|
|
// alternative ASCII capable keyboard layout because we decided that we
|
|
// should avoid setting same keyCode value to 2 or more keys since active
|
|
// keyboard layout may have a key to input the punctuation with different
|
|
// key. However, setting keyCode to 0 makes some web applications which
|
|
// are aware of neither KeyboardEvent.key nor KeyboardEvent.code not work
|
|
// with Firefox when user selects non-ASCII capable keyboard layout such
|
|
// as Russian and Thai. So, if alternative ASCII capable keyboard layout
|
|
// has keyCode value for the key, we should use it. In other words, this
|
|
// behavior means that non-ASCII capable keyboard layout overrides some
|
|
// keys' keyCode value only if the key produces ASCII character by itself
|
|
// or with Shift key.
|
|
if (unmodCharLatin || shiftedCharLatin) {
|
|
return WidgetUtils::ComputeKeyCodeFromChar(
|
|
unmodCharLatin ? unmodCharLatin : shiftedCharLatin);
|
|
}
|
|
|
|
// Otherwise, let's decide keyCode value from the hardware_keycode
|
|
// value on major keyboard layout.
|
|
CodeNameIndex code = ComputeDOMCodeNameIndex(aGdkKeyEvent);
|
|
return WidgetKeyboardEvent::GetFallbackKeyCodeOfPunctuationKey(code);
|
|
}
|
|
|
|
KeyNameIndex KeymapWrapper::ComputeDOMKeyNameIndex(
|
|
const GdkEventKey* aGdkKeyEvent) {
|
|
switch (aGdkKeyEvent->keyval) {
|
|
#define NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX(aNativeKey, aKeyNameIndex) \
|
|
case aNativeKey: \
|
|
return aKeyNameIndex;
|
|
|
|
#include "NativeKeyToDOMKeyName.h"
|
|
|
|
#undef NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return KEY_NAME_INDEX_Unidentified;
|
|
}
|
|
|
|
/* static */
|
|
CodeNameIndex KeymapWrapper::ComputeDOMCodeNameIndex(
|
|
const GdkEventKey* aGdkKeyEvent) {
|
|
switch (aGdkKeyEvent->hardware_keycode) {
|
|
#define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, aCodeNameIndex) \
|
|
case aNativeKey: \
|
|
return aCodeNameIndex;
|
|
|
|
#include "NativeKeyToDOMCodeName.h"
|
|
|
|
#undef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::DispatchKeyDownOrKeyUpEvent(nsWindow* aWindow,
|
|
GdkEventKey* aGdkKeyEvent,
|
|
bool aIsProcessedByIME,
|
|
bool* aIsCancelled) {
|
|
MOZ_ASSERT(aIsCancelled, "aIsCancelled must not be nullptr");
|
|
|
|
*aIsCancelled = false;
|
|
|
|
if (aGdkKeyEvent->type == GDK_KEY_PRESS && aGdkKeyEvent->keyval == GDK_Tab &&
|
|
AreModifiersActive(CTRL | ALT, aGdkKeyEvent->state)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" DispatchKeyDownOrKeyUpEvent(), didn't dispatch keyboard events "
|
|
"because it's Ctrl + Alt + Tab"));
|
|
return false;
|
|
}
|
|
|
|
EventMessage message =
|
|
aGdkKeyEvent->type == GDK_KEY_PRESS ? eKeyDown : eKeyUp;
|
|
WidgetKeyboardEvent keyEvent(true, message, aWindow);
|
|
KeymapWrapper::InitKeyEvent(keyEvent, aGdkKeyEvent, aIsProcessedByIME);
|
|
return DispatchKeyDownOrKeyUpEvent(aWindow, keyEvent, aIsCancelled);
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::DispatchKeyDownOrKeyUpEvent(
|
|
nsWindow* aWindow, WidgetKeyboardEvent& aKeyboardEvent,
|
|
bool* aIsCancelled) {
|
|
MOZ_ASSERT(aIsCancelled, "aIsCancelled must not be nullptr");
|
|
|
|
*aIsCancelled = false;
|
|
|
|
RefPtr<TextEventDispatcher> dispatcher = aWindow->GetTextEventDispatcher();
|
|
nsresult rv = dispatcher->BeginNativeInputTransaction();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Error,
|
|
(" DispatchKeyDownOrKeyUpEvent(), stopped dispatching %s event "
|
|
"because of failed to initialize TextEventDispatcher",
|
|
ToChar(aKeyboardEvent.mMessage)));
|
|
return FALSE;
|
|
}
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
bool dispatched = dispatcher->DispatchKeyboardEvent(
|
|
aKeyboardEvent.mMessage, aKeyboardEvent, status, nullptr);
|
|
*aIsCancelled = (status == nsEventStatus_eConsumeNoDefault);
|
|
return dispatched;
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::MaybeDispatchContextMenuEvent(nsWindow* aWindow,
|
|
const GdkEventKey* aEvent) {
|
|
KeyNameIndex keyNameIndex = ComputeDOMKeyNameIndex(aEvent);
|
|
|
|
// Shift+F10 and ContextMenu should cause eContextMenu event.
|
|
if (keyNameIndex != KEY_NAME_INDEX_F10 &&
|
|
keyNameIndex != KEY_NAME_INDEX_ContextMenu) {
|
|
return false;
|
|
}
|
|
|
|
WidgetMouseEvent contextMenuEvent(true, eContextMenu, aWindow,
|
|
WidgetMouseEvent::eReal,
|
|
WidgetMouseEvent::eContextMenuKey);
|
|
|
|
contextMenuEvent.mRefPoint = LayoutDeviceIntPoint(0, 0);
|
|
contextMenuEvent.AssignEventTime(aWindow->GetWidgetEventTime(aEvent->time));
|
|
contextMenuEvent.mClickCount = 1;
|
|
KeymapWrapper::InitInputEvent(contextMenuEvent, aEvent->state);
|
|
|
|
if (contextMenuEvent.IsControl() || contextMenuEvent.IsMeta() ||
|
|
contextMenuEvent.IsAlt()) {
|
|
return false;
|
|
}
|
|
|
|
// If the key is ContextMenu, then an eContextMenu mouse event is
|
|
// dispatched regardless of the state of the Shift modifier. When it is
|
|
// pressed without the Shift modifier, a web page can prevent the default
|
|
// context menu action. When pressed with the Shift modifier, the web page
|
|
// cannot prevent the default context menu action.
|
|
// (PresShell::HandleEventInternal() sets mOnlyChromeDispatch to true.)
|
|
|
|
// If the key is F10, it needs Shift state because Shift+F10 is well-known
|
|
// shortcut key on Linux. However, eContextMenu with Shift state is
|
|
// special. It won't fire "contextmenu" event in the web content for
|
|
// blocking web page to prevent its default. Therefore, this combination
|
|
// should work same as ContextMenu key.
|
|
// XXX Should we allow to block web page to prevent its default with
|
|
// Ctrl+Shift+F10 or Alt+Shift+F10 instead?
|
|
if (keyNameIndex == KEY_NAME_INDEX_F10) {
|
|
if (!contextMenuEvent.IsShift()) {
|
|
return false;
|
|
}
|
|
contextMenuEvent.mModifiers &= ~MODIFIER_SHIFT;
|
|
}
|
|
|
|
aWindow->DispatchInputEvent(&contextMenuEvent);
|
|
return true;
|
|
}
|
|
|
|
/* static*/
|
|
void KeymapWrapper::HandleKeyPressEvent(nsWindow* aWindow,
|
|
GdkEventKey* aGdkKeyEvent) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("HandleKeyPressEvent(aWindow=%p, aGdkKeyEvent={ type=%s, "
|
|
"keyval=%s(0x%X), state=0x%08X, hardware_keycode=0x%08X, "
|
|
"time=%u, is_modifier=%s })",
|
|
aWindow,
|
|
((aGdkKeyEvent->type == GDK_KEY_PRESS) ? "GDK_KEY_PRESS"
|
|
: "GDK_KEY_RELEASE"),
|
|
gdk_keyval_name(aGdkKeyEvent->keyval), aGdkKeyEvent->keyval,
|
|
aGdkKeyEvent->state, aGdkKeyEvent->hardware_keycode,
|
|
aGdkKeyEvent->time, GetBoolName(aGdkKeyEvent->is_modifier)));
|
|
|
|
// if we are in the middle of composing text, XIM gets to see it
|
|
// before mozilla does.
|
|
// FYI: Don't dispatch keydown event before notifying IME of the event
|
|
// because IME may send a key event synchronously and consume the
|
|
// original event.
|
|
bool IMEWasEnabled = false;
|
|
KeyHandlingState handlingState = KeyHandlingState::eNotHandled;
|
|
RefPtr<IMContextWrapper> imContext = aWindow->GetIMContext();
|
|
if (imContext) {
|
|
IMEWasEnabled = imContext->IsEnabled();
|
|
handlingState = imContext->OnKeyEvent(aWindow, aGdkKeyEvent);
|
|
if (handlingState == KeyHandlingState::eHandled) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), the event was handled by "
|
|
"IMContextWrapper"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// work around for annoying things.
|
|
if (aGdkKeyEvent->keyval == GDK_Tab &&
|
|
AreModifiersActive(CTRL | ALT, aGdkKeyEvent->state)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), didn't dispatch keyboard events "
|
|
"because it's Ctrl + Alt + Tab"));
|
|
return;
|
|
}
|
|
|
|
// Dispatch keydown event always. At auto repeating, we should send
|
|
// KEYDOWN -> KEYPRESS -> KEYDOWN -> KEYPRESS ... -> KEYUP
|
|
// However, old distributions (e.g., Ubuntu 9.10) sent native key
|
|
// release event, so, on such platform, the DOM events will be:
|
|
// KEYDOWN -> KEYPRESS -> KEYUP -> KEYDOWN -> KEYPRESS -> KEYUP...
|
|
|
|
bool isKeyDownCancelled = false;
|
|
if (handlingState == KeyHandlingState::eNotHandled) {
|
|
if (DispatchKeyDownOrKeyUpEvent(aWindow, aGdkKeyEvent, false,
|
|
&isKeyDownCancelled) &&
|
|
(MOZ_UNLIKELY(aWindow->IsDestroyed()) || isKeyDownCancelled)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched eKeyDown event and "
|
|
"stopped handling the event because %s",
|
|
aWindow->IsDestroyed() ? "the window has been destroyed"
|
|
: "the event was consumed"));
|
|
return;
|
|
}
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched eKeyDown event and "
|
|
"it wasn't consumed"));
|
|
handlingState = KeyHandlingState::eNotHandledButEventDispatched;
|
|
}
|
|
|
|
// If a keydown event handler causes to enable IME, i.e., it moves
|
|
// focus from IME unusable content to IME usable editor, we should
|
|
// send the native key event to IME for the first input on the editor.
|
|
imContext = aWindow->GetIMContext();
|
|
if (!IMEWasEnabled && imContext && imContext->IsEnabled()) {
|
|
// Notice our keydown event was already dispatched. This prevents
|
|
// unnecessary DOM keydown event in the editor.
|
|
handlingState = imContext->OnKeyEvent(aWindow, aGdkKeyEvent, true);
|
|
if (handlingState == KeyHandlingState::eHandled) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), the event was handled by "
|
|
"IMContextWrapper which was enabled by the preceding eKeyDown "
|
|
"event"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Look for specialized app-command keys
|
|
switch (aGdkKeyEvent->keyval) {
|
|
case GDK_Back:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Back);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Back\" command event"));
|
|
return;
|
|
case GDK_Forward:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Forward);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Forward\" command "
|
|
"event"));
|
|
return;
|
|
case GDK_Reload:
|
|
case GDK_Refresh:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Reload);
|
|
return;
|
|
case GDK_Stop:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Stop);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Stop\" command event"));
|
|
return;
|
|
case GDK_Search:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Search);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Search\" command event"));
|
|
return;
|
|
case GDK_Favorites:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Bookmarks);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Bookmarks\" command "
|
|
"event"));
|
|
return;
|
|
case GDK_HomePage:
|
|
aWindow->DispatchCommandEvent(nsGkAtoms::Home);
|
|
return;
|
|
case GDK_Copy:
|
|
case GDK_F16: // F16, F20, F18, F14 are old keysyms for Copy Cut Paste Undo
|
|
aWindow->DispatchContentCommandEvent(eContentCommandCopy);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Copy\" content command "
|
|
"event"));
|
|
return;
|
|
case GDK_Cut:
|
|
case GDK_F20:
|
|
aWindow->DispatchContentCommandEvent(eContentCommandCut);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Cut\" content command "
|
|
"event"));
|
|
return;
|
|
case GDK_Paste:
|
|
case GDK_F18:
|
|
aWindow->DispatchContentCommandEvent(eContentCommandPaste);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Paste\" content command "
|
|
"event"));
|
|
return;
|
|
case GDK_Redo:
|
|
aWindow->DispatchContentCommandEvent(eContentCommandRedo);
|
|
return;
|
|
case GDK_Undo:
|
|
case GDK_F14:
|
|
aWindow->DispatchContentCommandEvent(eContentCommandUndo);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched \"Undo\" content command "
|
|
"event"));
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// before we dispatch a key, check if it's the context menu key.
|
|
// If so, send a context menu key event instead.
|
|
if (MaybeDispatchContextMenuEvent(aWindow, aGdkKeyEvent)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), stopped dispatching eKeyPress event "
|
|
"because eContextMenu event was dispatched"));
|
|
return;
|
|
}
|
|
|
|
RefPtr<TextEventDispatcher> textEventDispatcher =
|
|
aWindow->GetTextEventDispatcher();
|
|
nsresult rv = textEventDispatcher->BeginNativeInputTransaction();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Error,
|
|
(" HandleKeyPressEvent(), stopped dispatching eKeyPress event "
|
|
"because of failed to initialize TextEventDispatcher"));
|
|
return;
|
|
}
|
|
|
|
// If the character code is in the BMP, send the key press event.
|
|
// Otherwise, send a compositionchange event with the equivalent UTF-16
|
|
// string.
|
|
// TODO: Investigate other browser's behavior in this case because
|
|
// this hack is odd for UI Events.
|
|
WidgetKeyboardEvent keypressEvent(true, eKeyPress, aWindow);
|
|
KeymapWrapper::InitKeyEvent(keypressEvent, aGdkKeyEvent, false);
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
if (keypressEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING ||
|
|
keypressEvent.mKeyValue.Length() == 1) {
|
|
if (textEventDispatcher->MaybeDispatchKeypressEvents(keypressEvent, status,
|
|
aGdkKeyEvent)) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched eKeyPress event "
|
|
"(status=%s)",
|
|
GetStatusName(status)));
|
|
} else {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), didn't dispatch eKeyPress event "
|
|
"(status=%s)",
|
|
GetStatusName(status)));
|
|
}
|
|
} else {
|
|
WidgetEventTime eventTime = aWindow->GetWidgetEventTime(aGdkKeyEvent->time);
|
|
textEventDispatcher->CommitComposition(status, &keypressEvent.mKeyValue,
|
|
&eventTime);
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyPressEvent(), dispatched a set of composition "
|
|
"events"));
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::HandleKeyReleaseEvent(nsWindow* aWindow,
|
|
GdkEventKey* aGdkKeyEvent) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("HandleKeyReleaseEvent(aWindow=%p, aGdkKeyEvent={ type=%s, "
|
|
"keyval=%s(0x%X), state=0x%08X, hardware_keycode=0x%08X, "
|
|
"time=%u, is_modifier=%s })",
|
|
aWindow,
|
|
((aGdkKeyEvent->type == GDK_KEY_PRESS) ? "GDK_KEY_PRESS"
|
|
: "GDK_KEY_RELEASE"),
|
|
gdk_keyval_name(aGdkKeyEvent->keyval), aGdkKeyEvent->keyval,
|
|
aGdkKeyEvent->state, aGdkKeyEvent->hardware_keycode,
|
|
aGdkKeyEvent->time, GetBoolName(aGdkKeyEvent->is_modifier)));
|
|
|
|
RefPtr<IMContextWrapper> imContext = aWindow->GetIMContext();
|
|
if (imContext) {
|
|
KeyHandlingState handlingState =
|
|
imContext->OnKeyEvent(aWindow, aGdkKeyEvent);
|
|
if (handlingState != KeyHandlingState::eNotHandled) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyReleaseEvent(), the event was handled by "
|
|
"IMContextWrapper"));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool isCancelled = false;
|
|
if (NS_WARN_IF(!DispatchKeyDownOrKeyUpEvent(aWindow, aGdkKeyEvent, false,
|
|
&isCancelled))) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Error,
|
|
(" HandleKeyReleaseEvent(), didn't dispatch eKeyUp event"));
|
|
return false;
|
|
}
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
(" HandleKeyReleaseEvent(), dispatched eKeyUp event "
|
|
"(isCancelled=%s)",
|
|
GetBoolName(isCancelled)));
|
|
return true;
|
|
}
|
|
|
|
guint KeymapWrapper::GetModifierState(GdkEventKey* aGdkKeyEvent,
|
|
KeymapWrapper* aWrapper) {
|
|
guint state = aGdkKeyEvent->state;
|
|
if (!aGdkKeyEvent->is_modifier) {
|
|
return state;
|
|
}
|
|
#ifdef MOZ_X11
|
|
// NOTE: The state of given key event indicates adjacent state of
|
|
// modifier keys. E.g., even if the event is Shift key press event,
|
|
// the bit for Shift is still false. By the same token, even if the
|
|
// event is Shift key release event, the bit for Shift is still true.
|
|
// Unfortunately, gdk_keyboard_get_modifiers() returns current modifier
|
|
// state. It means if there're some pending modifier key press or
|
|
// key release events, the result isn't what we want.
|
|
GdkDisplay* gdkDisplay = gdk_display_get_default();
|
|
if (GdkIsX11Display(gdkDisplay)) {
|
|
GdkDisplay* gdkDisplay = gdk_display_get_default();
|
|
Display* display = gdk_x11_display_get_xdisplay(gdkDisplay);
|
|
if (XEventsQueued(display, QueuedAfterReading)) {
|
|
XEvent nextEvent;
|
|
XPeekEvent(display, &nextEvent);
|
|
if (nextEvent.type == aWrapper->mXKBBaseEventCode) {
|
|
XkbEvent* XKBEvent = (XkbEvent*)&nextEvent;
|
|
if (XKBEvent->any.xkb_type == XkbStateNotify) {
|
|
XkbStateNotifyEvent* stateNotifyEvent =
|
|
(XkbStateNotifyEvent*)XKBEvent;
|
|
state &= ~0xFF;
|
|
state |= stateNotifyEvent->lookup_mods;
|
|
}
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
#endif
|
|
#ifdef MOZ_WAYLAND
|
|
int mask = 0;
|
|
switch (aGdkKeyEvent->keyval) {
|
|
case GDK_Shift_L:
|
|
case GDK_Shift_R:
|
|
mask = aWrapper->GetModifierMask(SHIFT);
|
|
break;
|
|
case GDK_Control_L:
|
|
case GDK_Control_R:
|
|
mask = aWrapper->GetModifierMask(CTRL);
|
|
break;
|
|
case GDK_Alt_L:
|
|
case GDK_Alt_R:
|
|
mask = aWrapper->GetModifierMask(ALT);
|
|
break;
|
|
case GDK_Super_L:
|
|
case GDK_Super_R:
|
|
mask = aWrapper->GetModifierMask(SUPER);
|
|
break;
|
|
case GDK_Hyper_L:
|
|
case GDK_Hyper_R:
|
|
mask = aWrapper->GetModifierMask(HYPER);
|
|
break;
|
|
case GDK_Meta_L:
|
|
case GDK_Meta_R:
|
|
mask = aWrapper->GetModifierMask(META);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (aGdkKeyEvent->type == GDK_KEY_PRESS) {
|
|
state |= mask;
|
|
} else {
|
|
state &= ~mask;
|
|
}
|
|
#endif
|
|
return state;
|
|
}
|
|
|
|
/* static */
|
|
void KeymapWrapper::InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
|
|
GdkEventKey* aGdkKeyEvent,
|
|
bool aIsProcessedByIME) {
|
|
MOZ_ASSERT(
|
|
!aIsProcessedByIME || aKeyEvent.mMessage != eKeyPress,
|
|
"If the key event is handled by IME, keypress event shouldn't be fired");
|
|
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
|
|
aKeyEvent.mCodeNameIndex = ComputeDOMCodeNameIndex(aGdkKeyEvent);
|
|
MOZ_ASSERT(aKeyEvent.mCodeNameIndex != CODE_NAME_INDEX_USE_STRING);
|
|
aKeyEvent.mKeyNameIndex =
|
|
aIsProcessedByIME ? KEY_NAME_INDEX_Process
|
|
: keymapWrapper->ComputeDOMKeyNameIndex(aGdkKeyEvent);
|
|
if (aKeyEvent.mKeyNameIndex == KEY_NAME_INDEX_Unidentified) {
|
|
uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
|
|
if (!charCode) {
|
|
charCode = keymapWrapper->GetUnmodifiedCharCodeFor(aGdkKeyEvent);
|
|
}
|
|
if (charCode) {
|
|
aKeyEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
|
|
MOZ_ASSERT(aKeyEvent.mKeyValue.IsEmpty(),
|
|
"Uninitialized mKeyValue must be empty");
|
|
AppendUCS4ToUTF16(charCode, aKeyEvent.mKeyValue);
|
|
}
|
|
}
|
|
|
|
if (aIsProcessedByIME) {
|
|
aKeyEvent.mKeyCode = NS_VK_PROCESSKEY;
|
|
} else if (aKeyEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING ||
|
|
aKeyEvent.mMessage != eKeyPress) {
|
|
aKeyEvent.mKeyCode = ComputeDOMKeyCode(aGdkKeyEvent);
|
|
} else {
|
|
aKeyEvent.mKeyCode = 0;
|
|
}
|
|
|
|
const guint modifierState = GetModifierState(aGdkKeyEvent, keymapWrapper);
|
|
InitInputEvent(aKeyEvent, modifierState);
|
|
|
|
switch (aGdkKeyEvent->keyval) {
|
|
case GDK_Shift_L:
|
|
case GDK_Control_L:
|
|
case GDK_Alt_L:
|
|
case GDK_Super_L:
|
|
case GDK_Hyper_L:
|
|
case GDK_Meta_L:
|
|
aKeyEvent.mLocation = eKeyLocationLeft;
|
|
break;
|
|
|
|
case GDK_Shift_R:
|
|
case GDK_Control_R:
|
|
case GDK_Alt_R:
|
|
case GDK_Super_R:
|
|
case GDK_Hyper_R:
|
|
case GDK_Meta_R:
|
|
aKeyEvent.mLocation = eKeyLocationRight;
|
|
break;
|
|
|
|
case GDK_KP_0:
|
|
case GDK_KP_1:
|
|
case GDK_KP_2:
|
|
case GDK_KP_3:
|
|
case GDK_KP_4:
|
|
case GDK_KP_5:
|
|
case GDK_KP_6:
|
|
case GDK_KP_7:
|
|
case GDK_KP_8:
|
|
case GDK_KP_9:
|
|
case GDK_KP_Space:
|
|
case GDK_KP_Tab:
|
|
case GDK_KP_Enter:
|
|
case GDK_KP_F1:
|
|
case GDK_KP_F2:
|
|
case GDK_KP_F3:
|
|
case GDK_KP_F4:
|
|
case GDK_KP_Home:
|
|
case GDK_KP_Left:
|
|
case GDK_KP_Up:
|
|
case GDK_KP_Right:
|
|
case GDK_KP_Down:
|
|
case GDK_KP_Prior: // same as GDK_KP_Page_Up
|
|
case GDK_KP_Next: // same as GDK_KP_Page_Down
|
|
case GDK_KP_End:
|
|
case GDK_KP_Begin:
|
|
case GDK_KP_Insert:
|
|
case GDK_KP_Delete:
|
|
case GDK_KP_Equal:
|
|
case GDK_KP_Multiply:
|
|
case GDK_KP_Add:
|
|
case GDK_KP_Separator:
|
|
case GDK_KP_Subtract:
|
|
case GDK_KP_Decimal:
|
|
case GDK_KP_Divide:
|
|
aKeyEvent.mLocation = eKeyLocationNumpad;
|
|
break;
|
|
|
|
default:
|
|
aKeyEvent.mLocation = eKeyLocationStandard;
|
|
break;
|
|
}
|
|
|
|
// The transformations above and in gdk for the keyval are not invertible
|
|
// so link to the GdkEvent (which will vanish soon after return from the
|
|
// event callback) to give plugins access to hardware_keycode and state.
|
|
// (An XEvent would be nice but the GdkEvent is good enough.)
|
|
aKeyEvent.mNativeKeyEvent = static_cast<void*>(aGdkKeyEvent);
|
|
aKeyEvent.mIsRepeat =
|
|
sRepeatState == REPEATING &&
|
|
aGdkKeyEvent->hardware_keycode == sLastRepeatableHardwareKeyCode;
|
|
|
|
MOZ_LOG(
|
|
gKeyLog, LogLevel::Info,
|
|
("%p InitKeyEvent, modifierState=0x%08X "
|
|
"aKeyEvent={ mMessage=%s, isShift=%s, isControl=%s, "
|
|
"isAlt=%s, isMeta=%s , mKeyCode=0x%02X, mCharCode=%s, "
|
|
"mKeyNameIndex=%s, mKeyValue=%s, mCodeNameIndex=%s, mCodeValue=%s, "
|
|
"mLocation=%s, mIsRepeat=%s }",
|
|
keymapWrapper, modifierState, ToChar(aKeyEvent.mMessage),
|
|
GetBoolName(aKeyEvent.IsShift()), GetBoolName(aKeyEvent.IsControl()),
|
|
GetBoolName(aKeyEvent.IsAlt()), GetBoolName(aKeyEvent.IsMeta()),
|
|
aKeyEvent.mKeyCode,
|
|
GetCharacterCodeName(static_cast<char16_t>(aKeyEvent.mCharCode)).get(),
|
|
ToString(aKeyEvent.mKeyNameIndex).get(),
|
|
GetCharacterCodeNames(aKeyEvent.mKeyValue).get(),
|
|
ToString(aKeyEvent.mCodeNameIndex).get(),
|
|
GetCharacterCodeNames(aKeyEvent.mCodeValue).get(),
|
|
GetKeyLocationName(aKeyEvent.mLocation).get(),
|
|
GetBoolName(aKeyEvent.mIsRepeat)));
|
|
}
|
|
|
|
/* static */
|
|
uint32_t KeymapWrapper::GetCharCodeFor(const GdkEventKey* aGdkKeyEvent) {
|
|
// Anything above 0xf000 is considered a non-printable
|
|
// Exception: directly encoded UCS characters
|
|
if (aGdkKeyEvent->keyval > 0xf000 &&
|
|
(aGdkKeyEvent->keyval & 0xff000000) != 0x01000000) {
|
|
// Keypad keys are an exception: they return a value different
|
|
// from their non-keypad equivalents, but mozilla doesn't distinguish.
|
|
switch (aGdkKeyEvent->keyval) {
|
|
case GDK_KP_Space:
|
|
return ' ';
|
|
case GDK_KP_Equal:
|
|
return '=';
|
|
case GDK_KP_Multiply:
|
|
return '*';
|
|
case GDK_KP_Add:
|
|
return '+';
|
|
case GDK_KP_Separator:
|
|
return ',';
|
|
case GDK_KP_Subtract:
|
|
return '-';
|
|
case GDK_KP_Decimal:
|
|
return '.';
|
|
case GDK_KP_Divide:
|
|
return '/';
|
|
case GDK_KP_0:
|
|
return '0';
|
|
case GDK_KP_1:
|
|
return '1';
|
|
case GDK_KP_2:
|
|
return '2';
|
|
case GDK_KP_3:
|
|
return '3';
|
|
case GDK_KP_4:
|
|
return '4';
|
|
case GDK_KP_5:
|
|
return '5';
|
|
case GDK_KP_6:
|
|
return '6';
|
|
case GDK_KP_7:
|
|
return '7';
|
|
case GDK_KP_8:
|
|
return '8';
|
|
case GDK_KP_9:
|
|
return '9';
|
|
default:
|
|
return 0; // non-printables
|
|
}
|
|
}
|
|
|
|
static const long MAX_UNICODE = 0x10FFFF;
|
|
|
|
// we're supposedly printable, let's try to convert
|
|
long ucs = keysym2ucs(aGdkKeyEvent->keyval);
|
|
if ((ucs != -1) && (ucs < MAX_UNICODE)) {
|
|
return ucs;
|
|
}
|
|
|
|
// I guess we couldn't convert
|
|
return 0;
|
|
}
|
|
|
|
uint32_t KeymapWrapper::GetCharCodeFor(const GdkEventKey* aGdkKeyEvent,
|
|
guint aModifierState, gint aGroup) {
|
|
guint keyval;
|
|
if (!gdk_keymap_translate_keyboard_state(
|
|
mGdkKeymap, aGdkKeyEvent->hardware_keycode,
|
|
GdkModifierType(aModifierState), aGroup, &keyval, nullptr, nullptr,
|
|
nullptr)) {
|
|
return 0;
|
|
}
|
|
GdkEventKey tmpEvent = *aGdkKeyEvent;
|
|
tmpEvent.state = aModifierState;
|
|
tmpEvent.keyval = keyval;
|
|
tmpEvent.group = aGroup;
|
|
return GetCharCodeFor(&tmpEvent);
|
|
}
|
|
|
|
uint32_t KeymapWrapper::GetUnmodifiedCharCodeFor(
|
|
const GdkEventKey* aGdkKeyEvent) {
|
|
guint state = aGdkKeyEvent->state &
|
|
(GetModifierMask(SHIFT) | GetModifierMask(CAPS_LOCK) |
|
|
GetModifierMask(NUM_LOCK) | GetModifierMask(SCROLL_LOCK) |
|
|
GetModifierMask(LEVEL3) | GetModifierMask(LEVEL5));
|
|
uint32_t charCode =
|
|
GetCharCodeFor(aGdkKeyEvent, GdkModifierType(state), aGdkKeyEvent->group);
|
|
if (charCode) {
|
|
return charCode;
|
|
}
|
|
// If no character is mapped to the key when Level3 Shift or Level5 Shift
|
|
// is active, let's return a character which is inputted by the key without
|
|
// Level3 nor Level5 Shift.
|
|
guint stateWithoutAltGraph =
|
|
state & ~(GetModifierMask(LEVEL3) | GetModifierMask(LEVEL5));
|
|
if (state == stateWithoutAltGraph) {
|
|
return 0;
|
|
}
|
|
return GetCharCodeFor(aGdkKeyEvent, GdkModifierType(stateWithoutAltGraph),
|
|
aGdkKeyEvent->group);
|
|
}
|
|
|
|
gint KeymapWrapper::GetKeyLevel(GdkEventKey* aGdkKeyEvent) {
|
|
gint level;
|
|
if (!gdk_keymap_translate_keyboard_state(
|
|
mGdkKeymap, aGdkKeyEvent->hardware_keycode,
|
|
GdkModifierType(aGdkKeyEvent->state), aGdkKeyEvent->group, nullptr,
|
|
nullptr, &level, nullptr)) {
|
|
return -1;
|
|
}
|
|
return level;
|
|
}
|
|
|
|
gint KeymapWrapper::GetFirstLatinGroup() {
|
|
GdkKeymapKey* keys;
|
|
gint count;
|
|
gint minGroup = -1;
|
|
if (gdk_keymap_get_entries_for_keyval(mGdkKeymap, GDK_a, &keys, &count)) {
|
|
// find the minimum number group for latin inputtable layout
|
|
for (gint i = 0; i < count && minGroup != 0; ++i) {
|
|
if (keys[i].level != 0 && keys[i].level != 1) {
|
|
continue;
|
|
}
|
|
if (minGroup >= 0 && keys[i].group > minGroup) {
|
|
continue;
|
|
}
|
|
minGroup = keys[i].group;
|
|
}
|
|
g_free(keys);
|
|
}
|
|
return minGroup;
|
|
}
|
|
|
|
bool KeymapWrapper::IsLatinGroup(guint8 aGroup) {
|
|
GdkKeymapKey* keys;
|
|
gint count;
|
|
bool result = false;
|
|
if (gdk_keymap_get_entries_for_keyval(mGdkKeymap, GDK_a, &keys, &count)) {
|
|
for (gint i = 0; i < count; ++i) {
|
|
if (keys[i].level != 0 && keys[i].level != 1) {
|
|
continue;
|
|
}
|
|
if (keys[i].group == aGroup) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
g_free(keys);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool KeymapWrapper::IsAutoRepeatableKey(guint aHardwareKeyCode) {
|
|
#ifdef MOZ_X11
|
|
uint8_t indexOfArray = aHardwareKeyCode / 8;
|
|
MOZ_ASSERT(indexOfArray < ArrayLength(mKeyboardState.auto_repeats),
|
|
"invalid index");
|
|
char bitMask = 1 << (aHardwareKeyCode % 8);
|
|
return (mKeyboardState.auto_repeats[indexOfArray] & bitMask) != 0;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
/* static */
|
|
bool KeymapWrapper::IsBasicLatinLetterOrNumeral(uint32_t aCharCode) {
|
|
return (aCharCode >= 'a' && aCharCode <= 'z') ||
|
|
(aCharCode >= 'A' && aCharCode <= 'Z') ||
|
|
(aCharCode >= '0' && aCharCode <= '9');
|
|
}
|
|
|
|
/* static */
|
|
guint KeymapWrapper::GetGDKKeyvalWithoutModifier(
|
|
const GdkEventKey* aGdkKeyEvent) {
|
|
KeymapWrapper* keymapWrapper = GetInstance();
|
|
guint state =
|
|
(aGdkKeyEvent->state & keymapWrapper->GetModifierMask(NUM_LOCK));
|
|
guint keyval;
|
|
if (!gdk_keymap_translate_keyboard_state(
|
|
keymapWrapper->mGdkKeymap, aGdkKeyEvent->hardware_keycode,
|
|
GdkModifierType(state), aGdkKeyEvent->group, &keyval, nullptr,
|
|
nullptr, nullptr)) {
|
|
return 0;
|
|
}
|
|
return keyval;
|
|
}
|
|
|
|
/* static */
|
|
uint32_t KeymapWrapper::GetDOMKeyCodeFromKeyPairs(guint aGdkKeyval) {
|
|
switch (aGdkKeyval) {
|
|
case GDK_Cancel:
|
|
return NS_VK_CANCEL;
|
|
case GDK_BackSpace:
|
|
return NS_VK_BACK;
|
|
case GDK_Tab:
|
|
case GDK_ISO_Left_Tab:
|
|
return NS_VK_TAB;
|
|
case GDK_Clear:
|
|
return NS_VK_CLEAR;
|
|
case GDK_Return:
|
|
return NS_VK_RETURN;
|
|
case GDK_Shift_L:
|
|
case GDK_Shift_R:
|
|
case GDK_Shift_Lock:
|
|
return NS_VK_SHIFT;
|
|
case GDK_Control_L:
|
|
case GDK_Control_R:
|
|
return NS_VK_CONTROL;
|
|
case GDK_Alt_L:
|
|
case GDK_Alt_R:
|
|
return NS_VK_ALT;
|
|
case GDK_Meta_L:
|
|
case GDK_Meta_R:
|
|
return NS_VK_META;
|
|
|
|
// Assume that Super or Hyper is always mapped to physical Win key.
|
|
case GDK_Super_L:
|
|
case GDK_Super_R:
|
|
case GDK_Hyper_L:
|
|
case GDK_Hyper_R:
|
|
return NS_VK_WIN;
|
|
|
|
// GTK's AltGraph key is similar to Mac's Option (Alt) key. However,
|
|
// unfortunately, browsers on Mac are using NS_VK_ALT for it even though
|
|
// it's really different from Alt key on Windows.
|
|
// On the other hand, GTK's AltGrapsh keys are really different from
|
|
// Alt key. However, there is no AltGrapsh key on Windows. On Windows,
|
|
// both Ctrl and Alt keys are pressed internally when AltGr key is
|
|
// pressed. For some languages' users, AltGraph key is important, so,
|
|
// web applications on such locale may want to know AltGraph key press.
|
|
// Therefore, we should map AltGr keycode for them only on GTK.
|
|
case GDK_ISO_Level3_Shift:
|
|
case GDK_ISO_Level5_Shift:
|
|
// We assume that Mode_switch is always used for level3 shift.
|
|
case GDK_Mode_switch:
|
|
return NS_VK_ALTGR;
|
|
|
|
case GDK_Pause:
|
|
return NS_VK_PAUSE;
|
|
case GDK_Caps_Lock:
|
|
return NS_VK_CAPS_LOCK;
|
|
case GDK_Kana_Lock:
|
|
case GDK_Kana_Shift:
|
|
return NS_VK_KANA;
|
|
case GDK_Hangul:
|
|
return NS_VK_HANGUL;
|
|
// case GDK_XXX: return NS_VK_JUNJA;
|
|
// case GDK_XXX: return NS_VK_FINAL;
|
|
case GDK_Hangul_Hanja:
|
|
return NS_VK_HANJA;
|
|
case GDK_Kanji:
|
|
return NS_VK_KANJI;
|
|
case GDK_Escape:
|
|
return NS_VK_ESCAPE;
|
|
case GDK_Henkan:
|
|
return NS_VK_CONVERT;
|
|
case GDK_Muhenkan:
|
|
return NS_VK_NONCONVERT;
|
|
// case GDK_XXX: return NS_VK_ACCEPT;
|
|
// case GDK_XXX: return NS_VK_MODECHANGE;
|
|
case GDK_Page_Up:
|
|
return NS_VK_PAGE_UP;
|
|
case GDK_Page_Down:
|
|
return NS_VK_PAGE_DOWN;
|
|
case GDK_End:
|
|
return NS_VK_END;
|
|
case GDK_Home:
|
|
return NS_VK_HOME;
|
|
case GDK_Left:
|
|
return NS_VK_LEFT;
|
|
case GDK_Up:
|
|
return NS_VK_UP;
|
|
case GDK_Right:
|
|
return NS_VK_RIGHT;
|
|
case GDK_Down:
|
|
return NS_VK_DOWN;
|
|
case GDK_Select:
|
|
return NS_VK_SELECT;
|
|
case GDK_Print:
|
|
return NS_VK_PRINT;
|
|
case GDK_Execute:
|
|
return NS_VK_EXECUTE;
|
|
case GDK_Insert:
|
|
return NS_VK_INSERT;
|
|
case GDK_Delete:
|
|
return NS_VK_DELETE;
|
|
case GDK_Help:
|
|
return NS_VK_HELP;
|
|
|
|
// keypad keys
|
|
case GDK_KP_Left:
|
|
return NS_VK_LEFT;
|
|
case GDK_KP_Right:
|
|
return NS_VK_RIGHT;
|
|
case GDK_KP_Up:
|
|
return NS_VK_UP;
|
|
case GDK_KP_Down:
|
|
return NS_VK_DOWN;
|
|
case GDK_KP_Page_Up:
|
|
return NS_VK_PAGE_UP;
|
|
// Not sure what these are
|
|
// case GDK_KP_Prior: return NS_VK_;
|
|
// case GDK_KP_Next: return NS_VK_;
|
|
case GDK_KP_Begin:
|
|
return NS_VK_CLEAR; // Num-unlocked 5
|
|
case GDK_KP_Page_Down:
|
|
return NS_VK_PAGE_DOWN;
|
|
case GDK_KP_Home:
|
|
return NS_VK_HOME;
|
|
case GDK_KP_End:
|
|
return NS_VK_END;
|
|
case GDK_KP_Insert:
|
|
return NS_VK_INSERT;
|
|
case GDK_KP_Delete:
|
|
return NS_VK_DELETE;
|
|
case GDK_KP_Enter:
|
|
return NS_VK_RETURN;
|
|
|
|
case GDK_Num_Lock:
|
|
return NS_VK_NUM_LOCK;
|
|
case GDK_Scroll_Lock:
|
|
return NS_VK_SCROLL_LOCK;
|
|
|
|
// Function keys
|
|
case GDK_F1:
|
|
return NS_VK_F1;
|
|
case GDK_F2:
|
|
return NS_VK_F2;
|
|
case GDK_F3:
|
|
return NS_VK_F3;
|
|
case GDK_F4:
|
|
return NS_VK_F4;
|
|
case GDK_F5:
|
|
return NS_VK_F5;
|
|
case GDK_F6:
|
|
return NS_VK_F6;
|
|
case GDK_F7:
|
|
return NS_VK_F7;
|
|
case GDK_F8:
|
|
return NS_VK_F8;
|
|
case GDK_F9:
|
|
return NS_VK_F9;
|
|
case GDK_F10:
|
|
return NS_VK_F10;
|
|
case GDK_F11:
|
|
return NS_VK_F11;
|
|
case GDK_F12:
|
|
return NS_VK_F12;
|
|
case GDK_F13:
|
|
return NS_VK_F13;
|
|
case GDK_F14:
|
|
return NS_VK_F14;
|
|
case GDK_F15:
|
|
return NS_VK_F15;
|
|
case GDK_F16:
|
|
return NS_VK_F16;
|
|
case GDK_F17:
|
|
return NS_VK_F17;
|
|
case GDK_F18:
|
|
return NS_VK_F18;
|
|
case GDK_F19:
|
|
return NS_VK_F19;
|
|
case GDK_F20:
|
|
return NS_VK_F20;
|
|
case GDK_F21:
|
|
return NS_VK_F21;
|
|
case GDK_F22:
|
|
return NS_VK_F22;
|
|
case GDK_F23:
|
|
return NS_VK_F23;
|
|
case GDK_F24:
|
|
return NS_VK_F24;
|
|
|
|
// context menu key, keysym 0xff67, typically keycode 117 on 105-key
|
|
// (Microsoft) x86 keyboards, located between right 'Windows' key and
|
|
// right Ctrl key
|
|
case GDK_Menu:
|
|
return NS_VK_CONTEXT_MENU;
|
|
case GDK_Sleep:
|
|
return NS_VK_SLEEP;
|
|
|
|
case GDK_3270_Attn:
|
|
return NS_VK_ATTN;
|
|
case GDK_3270_CursorSelect:
|
|
return NS_VK_CRSEL;
|
|
case GDK_3270_ExSelect:
|
|
return NS_VK_EXSEL;
|
|
case GDK_3270_EraseEOF:
|
|
return NS_VK_EREOF;
|
|
case GDK_3270_Play:
|
|
return NS_VK_PLAY;
|
|
// case GDK_XXX: return NS_VK_ZOOM;
|
|
case GDK_3270_PA1:
|
|
return NS_VK_PA1;
|
|
|
|
// map Sun Keyboard special keysyms on to NS_VK keys
|
|
|
|
// Sun F11 key generates SunF36(0x1005ff10) keysym
|
|
case 0x1005ff10:
|
|
return NS_VK_F11;
|
|
// Sun F12 key generates SunF37(0x1005ff11) keysym
|
|
case 0x1005ff11:
|
|
return NS_VK_F12;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void KeymapWrapper::WillDispatchKeyboardEvent(WidgetKeyboardEvent& aKeyEvent,
|
|
GdkEventKey* aGdkKeyEvent) {
|
|
GetInstance()->WillDispatchKeyboardEventInternal(aKeyEvent, aGdkKeyEvent);
|
|
}
|
|
|
|
void KeymapWrapper::WillDispatchKeyboardEventInternal(
|
|
WidgetKeyboardEvent& aKeyEvent, GdkEventKey* aGdkKeyEvent) {
|
|
if (!aGdkKeyEvent) {
|
|
// If aGdkKeyEvent is nullptr, we're trying to dispatch a fake keyboard
|
|
// event in such case, we don't need to set alternative char codes.
|
|
// So, we don't need to do nothing here. This case is typically we're
|
|
// dispatching eKeyDown or eKeyUp event during composition.
|
|
return;
|
|
}
|
|
|
|
uint32_t charCode = GetCharCodeFor(aGdkKeyEvent);
|
|
if (!charCode) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p WillDispatchKeyboardEventInternal, "
|
|
"mKeyCode=0x%02X, charCode=0x%08X",
|
|
this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode));
|
|
return;
|
|
}
|
|
|
|
// The mCharCode was set from mKeyValue. However, for example, when Ctrl key
|
|
// is pressed, its value should indicate an ASCII character for backward
|
|
// compatibility rather than inputting character without the modifiers.
|
|
// Therefore, we need to modify mCharCode value here.
|
|
aKeyEvent.SetCharCode(charCode);
|
|
|
|
gint level = GetKeyLevel(aGdkKeyEvent);
|
|
if (level != 0 && level != 1) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p WillDispatchKeyboardEventInternal, "
|
|
"mKeyCode=0x%02X, mCharCode=0x%08X, level=%d",
|
|
this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level));
|
|
return;
|
|
}
|
|
|
|
guint baseState =
|
|
aGdkKeyEvent->state & ~(GetModifierMask(SHIFT) | GetModifierMask(CTRL) |
|
|
GetModifierMask(ALT) | GetModifierMask(META) |
|
|
GetModifierMask(SUPER) | GetModifierMask(HYPER));
|
|
|
|
// We shold send both shifted char and unshifted char, all keyboard layout
|
|
// users can use all keys. Don't change event.mCharCode. On some keyboard
|
|
// layouts, Ctrl/Alt/Meta keys are used for inputting some characters.
|
|
AlternativeCharCode altCharCodes(0, 0);
|
|
// unshifted charcode of current keyboard layout.
|
|
altCharCodes.mUnshiftedCharCode =
|
|
GetCharCodeFor(aGdkKeyEvent, baseState, aGdkKeyEvent->group);
|
|
bool isLatin = (altCharCodes.mUnshiftedCharCode <= 0xFF);
|
|
// shifted charcode of current keyboard layout.
|
|
altCharCodes.mShiftedCharCode = GetCharCodeFor(
|
|
aGdkKeyEvent, baseState | GetModifierMask(SHIFT), aGdkKeyEvent->group);
|
|
isLatin = isLatin && (altCharCodes.mShiftedCharCode <= 0xFF);
|
|
if (altCharCodes.mUnshiftedCharCode || altCharCodes.mShiftedCharCode) {
|
|
aKeyEvent.mAlternativeCharCodes.AppendElement(altCharCodes);
|
|
}
|
|
|
|
bool needLatinKeyCodes = !isLatin;
|
|
if (!needLatinKeyCodes) {
|
|
needLatinKeyCodes =
|
|
(IS_ASCII_ALPHABETICAL(altCharCodes.mUnshiftedCharCode) !=
|
|
IS_ASCII_ALPHABETICAL(altCharCodes.mShiftedCharCode));
|
|
}
|
|
|
|
// If current keyboard layout can input Latin characters, we don't need
|
|
// more information.
|
|
if (!needLatinKeyCodes) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p WillDispatchKeyboardEventInternal, "
|
|
"mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, altCharCodes={ "
|
|
"mUnshiftedCharCode=0x%08X, mShiftedCharCode=0x%08X }",
|
|
this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level,
|
|
altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode));
|
|
return;
|
|
}
|
|
|
|
// Next, find Latin inputtable keyboard layout.
|
|
gint minGroup = GetFirstLatinGroup();
|
|
if (minGroup < 0) {
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p WillDispatchKeyboardEventInternal, "
|
|
"Latin keyboard layout isn't found: "
|
|
"mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, "
|
|
"altCharCodes={ mUnshiftedCharCode=0x%08X, "
|
|
"mShiftedCharCode=0x%08X }",
|
|
this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level,
|
|
altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode));
|
|
return;
|
|
}
|
|
|
|
AlternativeCharCode altLatinCharCodes(0, 0);
|
|
uint32_t unmodifiedCh = aKeyEvent.IsShift() ? altCharCodes.mShiftedCharCode
|
|
: altCharCodes.mUnshiftedCharCode;
|
|
|
|
// unshifted charcode of found keyboard layout.
|
|
uint32_t ch = GetCharCodeFor(aGdkKeyEvent, baseState, minGroup);
|
|
altLatinCharCodes.mUnshiftedCharCode =
|
|
IsBasicLatinLetterOrNumeral(ch) ? ch : 0;
|
|
// shifted charcode of found keyboard layout.
|
|
ch = GetCharCodeFor(aGdkKeyEvent, baseState | GetModifierMask(SHIFT),
|
|
minGroup);
|
|
altLatinCharCodes.mShiftedCharCode = IsBasicLatinLetterOrNumeral(ch) ? ch : 0;
|
|
if (altLatinCharCodes.mUnshiftedCharCode ||
|
|
altLatinCharCodes.mShiftedCharCode) {
|
|
aKeyEvent.mAlternativeCharCodes.AppendElement(altLatinCharCodes);
|
|
}
|
|
// If the mCharCode is not Latin, and the level is 0 or 1, we should
|
|
// replace the mCharCode to Latin char if Alt keys are not pressed. (Alt
|
|
// should be sent the localized char for accesskey like handling of Web
|
|
// Applications.)
|
|
ch = aKeyEvent.IsShift() ? altLatinCharCodes.mShiftedCharCode
|
|
: altLatinCharCodes.mUnshiftedCharCode;
|
|
if (ch && !aKeyEvent.IsAlt() && charCode == unmodifiedCh) {
|
|
aKeyEvent.SetCharCode(ch);
|
|
}
|
|
|
|
MOZ_LOG(gKeyLog, LogLevel::Info,
|
|
("%p WillDispatchKeyboardEventInternal, "
|
|
"mKeyCode=0x%02X, mCharCode=0x%08X, level=%d, minGroup=%d, "
|
|
"altCharCodes={ mUnshiftedCharCode=0x%08X, "
|
|
"mShiftedCharCode=0x%08X } "
|
|
"altLatinCharCodes={ mUnshiftedCharCode=0x%08X, "
|
|
"mShiftedCharCode=0x%08X }",
|
|
this, aKeyEvent.mKeyCode, aKeyEvent.mCharCode, level, minGroup,
|
|
altCharCodes.mUnshiftedCharCode, altCharCodes.mShiftedCharCode,
|
|
altLatinCharCodes.mUnshiftedCharCode,
|
|
altLatinCharCodes.mShiftedCharCode));
|
|
}
|
|
|
|
#ifdef MOZ_WAYLAND
|
|
void KeymapWrapper::SetFocusIn(wl_surface* aFocusSurface,
|
|
uint32_t aFocusSerial) {
|
|
LOGW("KeymapWrapper::SetFocusIn() surface %p ID %d serial %d", aFocusSurface,
|
|
aFocusSurface ? wl_proxy_get_id((struct wl_proxy*)aFocusSurface) : 0,
|
|
aFocusSerial);
|
|
|
|
KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
|
|
keymapWrapper->mFocusSurface = aFocusSurface;
|
|
keymapWrapper->mFocusSerial = aFocusSerial;
|
|
}
|
|
|
|
// aFocusSurface can be null in case that focused surface is already destroyed.
|
|
void KeymapWrapper::SetFocusOut(wl_surface* aFocusSurface) {
|
|
KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
|
|
LOGW("KeymapWrapper::SetFocusOut surface %p ID %d", aFocusSurface,
|
|
aFocusSurface ? wl_proxy_get_id((struct wl_proxy*)aFocusSurface) : 0);
|
|
|
|
keymapWrapper->mFocusSurface = nullptr;
|
|
keymapWrapper->mFocusSerial = 0;
|
|
}
|
|
|
|
void KeymapWrapper::GetFocusInfo(wl_surface** aFocusSurface,
|
|
uint32_t* aFocusSerial) {
|
|
KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
|
|
*aFocusSurface = keymapWrapper->mFocusSurface;
|
|
*aFocusSerial = keymapWrapper->mFocusSerial;
|
|
}
|
|
|
|
void KeymapWrapper::SetSeat(wl_seat* aSeat, int aId) {
|
|
sSeat = aSeat;
|
|
sSeatID = aId;
|
|
wl_seat_add_listener(aSeat, &seat_listener, nullptr);
|
|
}
|
|
|
|
void KeymapWrapper::ClearSeat(int aId) {
|
|
if (sSeatID == aId) {
|
|
ClearKeyboard();
|
|
sSeat = nullptr;
|
|
sSeatID = -1;
|
|
}
|
|
}
|
|
|
|
wl_seat* KeymapWrapper::GetSeat() { return sSeat; }
|
|
|
|
void KeymapWrapper::SetKeyboard(wl_keyboard* aKeyboard) {
|
|
sKeyboard = aKeyboard;
|
|
}
|
|
|
|
wl_keyboard* KeymapWrapper::GetKeyboard() { return sKeyboard; }
|
|
|
|
void KeymapWrapper::ClearKeyboard() {
|
|
if (sKeyboard) {
|
|
wl_keyboard_destroy(sKeyboard);
|
|
sKeyboard = nullptr;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|