gecko-dev/widget/windows/KeyboardLayout.h

1021 строка
33 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/. */
#ifndef KeyboardLayout_h__
#define KeyboardLayout_h__
#include "mozilla/RefPtr.h"
#include "nscore.h"
#include "nsString.h"
#include "nsWindowBase.h"
#include "nsWindowDefs.h"
#include "mozilla/Attributes.h"
#include "mozilla/EventForwards.h"
#include "mozilla/TextEventDispatcher.h"
#include "mozilla/widget/WinMessages.h"
#include "mozilla/widget/WinModifierKeyState.h"
#include <windows.h>
#define NS_NUM_OF_KEYS 70
#define VK_OEM_1 0xBA // ';:' for US
#define VK_OEM_PLUS 0xBB // '+' any country
#define VK_OEM_COMMA 0xBC
#define VK_OEM_MINUS 0xBD // '-' any country
#define VK_OEM_PERIOD 0xBE
#define VK_OEM_2 0xBF
#define VK_OEM_3 0xC0
// '/?' for Brazilian (ABNT)
#define VK_ABNT_C1 0xC1
// Separator in Numpad for Brazilian (ABNT) or JIS keyboard for Mac.
#define VK_ABNT_C2 0xC2
#define VK_OEM_4 0xDB
#define VK_OEM_5 0xDC
#define VK_OEM_6 0xDD
#define VK_OEM_7 0xDE
#define VK_OEM_8 0xDF
#define VK_OEM_102 0xE2
#define VK_OEM_CLEAR 0xFE
class nsIIdleServiceInternal;
namespace mozilla {
namespace widget {
static const uint32_t sModifierKeyMap[][3] = {
{ nsIWidget::CAPS_LOCK, VK_CAPITAL, 0 },
{ nsIWidget::NUM_LOCK, VK_NUMLOCK, 0 },
{ nsIWidget::SHIFT_L, VK_SHIFT, VK_LSHIFT },
{ nsIWidget::SHIFT_R, VK_SHIFT, VK_RSHIFT },
{ nsIWidget::CTRL_L, VK_CONTROL, VK_LCONTROL },
{ nsIWidget::CTRL_R, VK_CONTROL, VK_RCONTROL },
{ nsIWidget::ALT_L, VK_MENU, VK_LMENU },
{ nsIWidget::ALT_R, VK_MENU, VK_RMENU }
};
class KeyboardLayout;
class MOZ_STACK_CLASS UniCharsAndModifiers final
{
public:
UniCharsAndModifiers() {}
UniCharsAndModifiers operator+(const UniCharsAndModifiers& aOther) const;
UniCharsAndModifiers& operator+=(const UniCharsAndModifiers& aOther);
/**
* Append a pair of unicode character and the final modifier.
*/
void Append(char16_t aUniChar, Modifiers aModifiers);
void Clear()
{
mChars.Truncate();
mModifiers.Clear();
}
bool IsEmpty() const
{
MOZ_ASSERT(mChars.Length() == mModifiers.Length());
return mChars.IsEmpty();
}
char16_t CharAt(size_t aIndex) const
{
MOZ_ASSERT(aIndex < Length());
return mChars[aIndex];
}
Modifiers ModifiersAt(size_t aIndex) const
{
MOZ_ASSERT(aIndex < Length());
return mModifiers[aIndex];
}
size_t Length() const
{
MOZ_ASSERT(mChars.Length() == mModifiers.Length());
return mChars.Length();
}
void FillModifiers(Modifiers aModifiers);
/**
* OverwriteModifiersIfBeginsWith() assigns mModifiers with aOther between
* [0] and [aOther.mLength - 1] only when mChars begins with aOther.mChars.
*/
void OverwriteModifiersIfBeginsWith(const UniCharsAndModifiers& aOther);
bool UniCharsEqual(const UniCharsAndModifiers& aOther) const;
bool UniCharsCaseInsensitiveEqual(const UniCharsAndModifiers& aOther) const;
bool BeginsWith(const UniCharsAndModifiers& aOther) const;
const nsString& ToString() const { return mChars; }
private:
nsAutoString mChars;
// 5 is enough number for normal keyboard layout handling. On Windows,
// a dead key sequence may cause inputting up to 5 characters per key press.
AutoTArray<Modifiers, 5> mModifiers;
};
struct DeadKeyEntry;
class DeadKeyTable;
class VirtualKey
{
public:
// 0 - Normal
// 1 - Shift
// 2 - Control
// 3 - Control + Shift
// 4 - Alt
// 5 - Alt + Shift
// 6 - Alt + Control (AltGr)
// 7 - Alt + Control + Shift (AltGr + Shift)
// 8 - CapsLock
// 9 - CapsLock + Shift
// 10 - CapsLock + Control
// 11 - CapsLock + Control + Shift
// 12 - CapsLock + Alt
// 13 - CapsLock + Alt + Shift
// 14 - CapsLock + Alt + Control (CapsLock + AltGr)
// 15 - CapsLock + Alt + Control + Shift (CapsLock + AltGr + Shift)
enum ShiftStateFlag
{
STATE_SHIFT = 0x01,
STATE_CONTROL = 0x02,
STATE_ALT = 0x04,
STATE_CAPSLOCK = 0x08
};
typedef uint8_t ShiftState;
static ShiftState ModifiersToShiftState(Modifiers aModifiers);
static ShiftState ModifierKeyStateToShiftState(
const ModifierKeyState& aModKeyState)
{
return ModifiersToShiftState(aModKeyState.GetModifiers());
}
static Modifiers ShiftStateToModifiers(ShiftState aShiftState);
private:
union KeyShiftState
{
struct
{
char16_t Chars[4];
} Normal;
struct
{
const DeadKeyTable* Table;
char16_t DeadChar;
} DeadKey;
};
KeyShiftState mShiftStates[16];
uint16_t mIsDeadKey;
void SetDeadKey(ShiftState aShiftState, bool aIsDeadKey)
{
if (aIsDeadKey) {
mIsDeadKey |= 1 << aShiftState;
} else {
mIsDeadKey &= ~(1 << aShiftState);
}
}
public:
static void FillKbdState(PBYTE aKbdState, const ShiftState aShiftState);
bool IsDeadKey(ShiftState aShiftState) const
{
return (mIsDeadKey & (1 << aShiftState)) != 0;
}
void AttachDeadKeyTable(ShiftState aShiftState,
const DeadKeyTable* aDeadKeyTable)
{
mShiftStates[aShiftState].DeadKey.Table = aDeadKeyTable;
}
void SetNormalChars(ShiftState aShiftState, const char16_t* aChars,
uint32_t aNumOfChars);
void SetDeadChar(ShiftState aShiftState, char16_t aDeadChar);
const DeadKeyTable* MatchingDeadKeyTable(const DeadKeyEntry* aDeadKeyArray,
uint32_t aEntries) const;
inline char16_t GetCompositeChar(ShiftState aShiftState,
char16_t aBaseChar) const;
char16_t GetCompositeChar(const ModifierKeyState& aModKeyState,
char16_t aBaseChar) const
{
return GetCompositeChar(ModifierKeyStateToShiftState(aModKeyState),
aBaseChar);
}
UniCharsAndModifiers GetNativeUniChars(ShiftState aShiftState) const;
UniCharsAndModifiers GetNativeUniChars(
const ModifierKeyState& aModKeyState) const
{
return GetNativeUniChars(ModifierKeyStateToShiftState(aModKeyState));
}
UniCharsAndModifiers GetUniChars(ShiftState aShiftState) const;
UniCharsAndModifiers GetUniChars(const ModifierKeyState& aModKeyState) const
{
return GetUniChars(ModifierKeyStateToShiftState(aModKeyState));
}
};
class MOZ_STACK_CLASS NativeKey final
{
friend class KeyboardLayout;
public:
struct FakeCharMsg
{
UINT mCharCode;
UINT mScanCode;
bool mIsSysKey;
bool mIsDeadKey;
bool mConsumed;
FakeCharMsg()
: mCharCode(0)
, mScanCode(0)
, mIsSysKey(false)
, mIsDeadKey(false)
, mConsumed(false)
{
}
MSG GetCharMsg(HWND aWnd) const
{
MSG msg;
msg.hwnd = aWnd;
msg.message = mIsDeadKey && mIsSysKey ? WM_SYSDEADCHAR :
mIsDeadKey ? WM_DEADCHAR :
mIsSysKey ? WM_SYSCHAR :
WM_CHAR;
msg.wParam = static_cast<WPARAM>(mCharCode);
msg.lParam = static_cast<LPARAM>(mScanCode << 16);
msg.time = 0;
msg.pt.x = msg.pt.y = 0;
return msg;
}
};
NativeKey(nsWindowBase* aWidget,
const MSG& aMessage,
const ModifierKeyState& aModKeyState,
HKL aOverrideKeyboardLayout = 0,
nsTArray<FakeCharMsg>* aFakeCharMsgs = nullptr);
~NativeKey();
/**
* Handle WM_KEYDOWN message or WM_SYSKEYDOWN message. The instance must be
* initialized with WM_KEYDOWN or WM_SYSKEYDOWN.
* Returns true if dispatched keydown event or keypress event is consumed.
* Otherwise, false.
*/
bool HandleKeyDownMessage(bool* aEventDispatched = nullptr) const;
/**
* Handles WM_CHAR message or WM_SYSCHAR message. The instance must be
* initialized with them.
* Returns true if dispatched keypress event is consumed. Otherwise, false.
*/
bool HandleCharMessage(bool* aEventDispatched = nullptr) const;
/**
* Handles keyup message. Returns true if the event is consumed.
* Otherwise, false.
*/
bool HandleKeyUpMessage(bool* aEventDispatched = nullptr) const;
/**
* Handles WM_APPCOMMAND message. Returns true if the event is consumed.
* Otherwise, false.
*/
bool HandleAppCommandMessage() const;
/**
* Callback of TextEventDispatcherListener::WillDispatchKeyboardEvent().
* This method sets alternative char codes of aKeyboardEvent.
*/
void WillDispatchKeyboardEvent(WidgetKeyboardEvent& aKeyboardEvent,
uint32_t aIndex);
/**
* Returns true if aChar is a control character which shouldn't be inputted
* into focused text editor.
*/
static bool IsControlChar(char16_t aChar);
private:
NativeKey* mLastInstance;
// mRemovingMsg is set at removing a char message from
// GetFollowingCharMessage().
MSG mRemovingMsg;
// mReceivedMsg is set when another instance starts to handle the message
// unexpectedly.
MSG mReceivedMsg;
RefPtr<nsWindowBase> mWidget;
RefPtr<TextEventDispatcher> mDispatcher;
HKL mKeyboardLayout;
MSG mMsg;
// mFollowingCharMsgs stores WM_CHAR, WM_SYSCHAR, WM_DEADCHAR or
// WM_SYSDEADCHAR message which follows WM_KEYDOWN.
// Note that the stored messaged are already removed from the queue.
// FYI: 5 is enough number for usual keyboard layout handling. On Windows,
// a dead key sequence may cause inputting up to 5 characters per key press.
AutoTArray<MSG, 5> mFollowingCharMsgs;
// mRemovedOddCharMsgs stores WM_CHAR messages which are caused by ATOK or
// WXG (they are Japanese IME) when the user tries to do "Kakutei-undo"
// (it means "undo the last commit").
nsTArray<MSG> mRemovedOddCharMsgs;
// If dispatching eKeyDown or eKeyPress event causes focus change,
// the instance shouldn't handle remaning char messages. For checking it,
// this should store first focused window.
HWND mFocusedWndBeforeDispatch;
uint32_t mDOMKeyCode;
KeyNameIndex mKeyNameIndex;
CodeNameIndex mCodeNameIndex;
ModifierKeyState mModKeyState;
// mVirtualKeyCode distinguishes left key or right key of modifier key.
uint8_t mVirtualKeyCode;
// mOriginalVirtualKeyCode doesn't distinguish left key or right key of
// modifier key. However, if the given keycode is VK_PROCESS, it's resolved
// to a keycode before it's handled by IME.
uint8_t mOriginalVirtualKeyCode;
// mCommittedChars indicates the inputted characters which is committed by
// the key. If dead key fail to composite a character, mCommittedChars
// indicates both the dead characters and the base characters.
UniCharsAndModifiers mCommittedCharsAndModifiers;
// Following strings are computed by
// ComputeInputtingStringWithKeyboardLayout() which is typically called
// before dispatching keydown event.
// mInputtingStringAndModifiers's string is the string to be
// inputted into the focused editor and its modifier state is proper
// modifier state for inputting the string into the editor.
UniCharsAndModifiers mInputtingStringAndModifiers;
// mShiftedString is the string to be inputted into the editor with
// current modifier state with active shift state.
UniCharsAndModifiers mShiftedString;
// mUnshiftedString is the string to be inputted into the editor with
// current modifier state without shift state.
UniCharsAndModifiers mUnshiftedString;
// Following integers are computed by
// ComputeInputtingStringWithKeyboardLayout() which is typically called
// before dispatching keydown event. The meaning of these values is same
// as charCode.
uint32_t mShiftedLatinChar;
uint32_t mUnshiftedLatinChar;
WORD mScanCode;
bool mIsExtended;
bool mIsDeadKey;
// mIsPrintableKey is true if the key may be a printable key without
// any modifier keys. Otherwise, false.
// Please note that the event may not cause any text input even if this
// is true. E.g., it might be dead key state or Ctrl key may be pressed.
bool mIsPrintableKey;
// mCharMessageHasGone is true if the message is a keydown message and
// it's followed by at least one char message but it's gone at removing
// from the queue. This could occur if PeekMessage() or something is
// hooked by odd tool.
bool mCharMessageHasGone;
// mIsOverridingKeyboardLayout is true if the instance temporarily overriding
// keyboard layout with specified by the constructor.
bool mIsOverridingKeyboardLayout;
// mCanIgnoreModifierStateAtKeyPress is true if it's allowed to remove
// Ctrl or Alt modifier state at dispatching eKeyPress.
bool mCanIgnoreModifierStateAtKeyPress;
nsTArray<FakeCharMsg>* mFakeCharMsgs;
// When a keydown event is dispatched at handling WM_APPCOMMAND, the computed
// virtual keycode is set to this. Even if we consume WM_APPCOMMAND message,
// Windows may send WM_KEYDOWN and WM_KEYUP message for them.
// At that time, we should not dispatch key events for them.
static uint8_t sDispatchedKeyOfAppCommand;
NativeKey()
{
MOZ_CRASH("The default constructor of NativeKey isn't available");
}
void InitWithAppCommand();
void InitWithKeyChar();
/**
* InitCommittedCharsAndModifiersWithFollowingCharMessages() initializes
* mCommittedCharsAndModifiers with mFollowingCharMsgs and aModKeyState.
* If mFollowingCharMsgs includes non-printable char messages, they are
* ignored (skipped).
*/
void InitCommittedCharsAndModifiersWithFollowingCharMessages(
const ModifierKeyState& aModKeyState);
/**
* Returns true if the key event is caused by auto repeat.
*/
bool IsRepeat() const
{
switch (mMsg.message) {
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
case WM_CHAR:
case WM_SYSCHAR:
case WM_DEADCHAR:
case WM_SYSDEADCHAR:
case MOZ_WM_KEYDOWN:
return ((mMsg.lParam & (1 << 30)) != 0);
case WM_APPCOMMAND:
if (mVirtualKeyCode) {
// If we can map the WM_APPCOMMAND to a virtual keycode, we can trust
// the result of GetKeyboardState().
BYTE kbdState[256];
memset(kbdState, 0, sizeof(kbdState));
::GetKeyboardState(kbdState);
return !!kbdState[mVirtualKeyCode];
}
// If there is no virtual keycode for the command, we dispatch both
// keydown and keyup events from WM_APPCOMMAND handler. Therefore,
// even if WM_APPCOMMAND is caused by auto key repeat, web apps receive
// a pair of DOM keydown and keyup events. I.e., KeyboardEvent.repeat
// should be never true of such keys.
return false;
default:
return false;
}
}
UINT GetScanCodeWithExtendedFlag() const;
// The result is one of eKeyLocation*.
uint32_t GetKeyLocation() const;
/**
* RemoveFollowingOddCharMessages() removes odd WM_CHAR messages from the
* queue when IsIMEDoingKakuteiUndo() returns true.
*/
void RemoveFollowingOddCharMessages();
/**
* "Kakutei-Undo" of ATOK or WXG (both of them are Japanese IME) causes
* strange WM_KEYDOWN/WM_KEYUP/WM_CHAR message pattern. So, when this
* returns true, the caller needs to be careful for processing the messages.
*/
bool IsIMEDoingKakuteiUndo() const;
bool IsKeyDownMessage() const
{
return (mMsg.message == WM_KEYDOWN ||
mMsg.message == WM_SYSKEYDOWN ||
mMsg.message == MOZ_WM_KEYDOWN);
}
bool IsKeyUpMessage() const
{
return (mMsg.message == WM_KEYUP ||
mMsg.message == WM_SYSKEYUP ||
mMsg.message == MOZ_WM_KEYUP);
}
bool IsCharOrSysCharMessage(const MSG& aMSG) const
{
return IsCharOrSysCharMessage(aMSG.message);
}
bool IsCharOrSysCharMessage(UINT aMessage) const
{
return (aMessage == WM_CHAR || aMessage == WM_SYSCHAR);
}
bool IsCharMessage(const MSG& aMSG) const
{
return IsCharMessage(aMSG.message);
}
bool IsCharMessage(UINT aMessage) const
{
return (IsCharOrSysCharMessage(aMessage) || IsDeadCharMessage(aMessage));
}
bool IsDeadCharMessage(const MSG& aMSG) const
{
return IsDeadCharMessage(aMSG.message);
}
bool IsDeadCharMessage(UINT aMessage) const
{
return (aMessage == WM_DEADCHAR || aMessage == WM_SYSDEADCHAR);
}
bool IsSysCharMessage(const MSG& aMSG) const
{
return IsSysCharMessage(aMSG.message);
}
bool IsSysCharMessage(UINT aMessage) const
{
return (aMessage == WM_SYSCHAR || aMessage == WM_SYSDEADCHAR);
}
bool MayBeSameCharMessage(const MSG& aCharMsg1, const MSG& aCharMsg2) const;
bool IsSamePhysicalKeyMessage(const MSG& aKeyOrCharMsg1,
const MSG& aKeyOrCharMsg2) const;
bool IsFollowedByPrintableCharMessage() const;
bool IsFollowedByPrintableCharOrSysCharMessage() const;
bool IsFollowedByDeadCharMessage() const;
bool IsKeyMessageOnPlugin() const
{
return (mMsg.message == MOZ_WM_KEYDOWN ||
mMsg.message == MOZ_WM_KEYUP);
}
bool IsPrintableCharMessage(const MSG& aMSG) const
{
return aMSG.message == WM_CHAR &&
!IsControlChar(static_cast<char16_t>(aMSG.wParam));
}
bool IsEnterKeyPressCharMessage(const MSG& aMSG) const
{
return aMSG.message == WM_CHAR && aMSG.wParam == '\r';
}
bool IsPrintableCharOrSysCharMessage(const MSG& aMSG) const
{
return IsCharOrSysCharMessage(aMSG) &&
!IsControlChar(static_cast<char16_t>(aMSG.wParam));
}
bool IsControlCharMessage(const MSG& aMSG) const
{
return IsCharMessage(aMSG.message) &&
IsControlChar(static_cast<char16_t>(aMSG.wParam));
}
/**
* IsReservedBySystem() returns true if the key combination is reserved by
* the system. Even if it's consumed by web apps, the message should be
* sent to next wndproc.
*/
bool IsReservedBySystem() const;
/**
* GetFollowingCharMessage() returns following char message of handling
* keydown event. If the message is found, this method returns true.
* Otherwise, returns false.
*
* WARNING: Even if this returns true, aCharMsg may be WM_NULL or its
* hwnd may be different window.
*/
bool GetFollowingCharMessage(MSG& aCharMsg);
/**
* Wraps MapVirtualKeyEx() with MAPVK_VSC_TO_VK.
*/
uint8_t ComputeVirtualKeyCodeFromScanCode() const;
/**
* Wraps MapVirtualKeyEx() with MAPVK_VSC_TO_VK_EX.
*/
uint8_t ComputeVirtualKeyCodeFromScanCodeEx() const;
/**
* Wraps MapVirtualKeyEx() with MAPVK_VK_TO_VSC_EX or MAPVK_VK_TO_VSC.
*/
uint16_t ComputeScanCodeExFromVirtualKeyCode(UINT aVirtualKeyCode) const;
/**
* Wraps MapVirtualKeyEx() with MAPVK_VSC_TO_VK and MAPVK_VK_TO_CHAR.
*/
char16_t ComputeUnicharFromScanCode() const;
/**
* Initializes the aKeyEvent with the information stored in the instance.
*/
nsEventStatus InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
const ModifierKeyState& aModKeyState,
const MSG* aMsgSentToPlugin = nullptr) const;
nsEventStatus InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
const MSG* aMsgSentToPlugin = nullptr) const;
/**
* MaybeInitPluginEventOfKeyEvent() may initialize aKeyEvent::mPluginEvent
* with aMsgSentToPlugin if it's necessary.
*/
void MaybeInitPluginEventOfKeyEvent(WidgetKeyboardEvent& aKeyEvent,
const MSG& aMsgSentToPlugin) const;
/**
* Dispatches a command event for aEventCommand.
* Returns true if the event is consumed. Otherwise, false.
*/
bool DispatchCommandEvent(uint32_t aEventCommand) const;
/**
* DispatchKeyPressEventsWithRetrievedCharMessages() dispatches keypress
* event(s) with retrieved char messages.
*/
bool DispatchKeyPressEventsWithRetrievedCharMessages() const;
/**
* DispatchKeyPressEventsWithoutCharMessage() dispatches keypress event(s)
* without char messages. So, this should be used only when there are no
* following char messages.
*/
bool DispatchKeyPressEventsWithoutCharMessage() const;
/**
* MaybeDispatchPluginEventsForRemovedCharMessages() dispatches plugin events
* for removed char messages when a windowless plugin has focus.
* Returns true if the widget is destroyed or blurred during dispatching a
* plugin event.
*/
bool MaybeDispatchPluginEventsForRemovedCharMessages() const;
/**
* Checkes whether the key event down message is handled without following
* WM_CHAR messages. For example, if following WM_CHAR message indicates
* control character input, the WM_CHAR message is unclear whether it's
* caused by a printable key with Ctrl or just a function key such as Enter
* or Backspace.
*/
bool NeedsToHandleWithoutFollowingCharMessages() const;
/**
* ComputeInputtingStringWithKeyboardLayout() computes string to be inputted
* with the key and the modifier state, without shift state and with shift
* state.
*/
void ComputeInputtingStringWithKeyboardLayout();
/**
* IsFocusedWindowChanged() returns true if focused window is changed
* after the instance is created.
*/
bool IsFocusedWindowChanged() const
{
return mFocusedWndBeforeDispatch != ::GetFocus();
}
/**
* Handles WM_CHAR message or WM_SYSCHAR message. The instance must be
* initialized with WM_KEYDOWN, WM_SYSKEYDOWN or them.
* Returns true if dispatched keypress event is consumed. Otherwise, false.
*/
bool HandleCharMessage(const MSG& aCharMsg,
bool* aEventDispatched = nullptr) const;
// Calls of PeekMessage() from NativeKey might cause nested message handling
// due to (perhaps) odd API hook. NativeKey should do nothing if given
// message is tried to be retrieved by another instance.
/**
* sLatestInstacne is a pointer to the newest instance of NativeKey which is
* handling a key or char message(s).
*/
static NativeKey* sLatestInstance;
static const MSG sEmptyMSG;
static MSG sLastKeyMSG;
static bool IsEmptyMSG(const MSG& aMSG)
{
return !memcmp(&aMSG, &sEmptyMSG, sizeof(MSG));
}
bool IsAnotherInstanceRemovingCharMessage() const
{
return mLastInstance && !IsEmptyMSG(mLastInstance->mRemovingMsg);
}
public:
/**
* Returns last key MSG. If no key MSG has been received yet, the result
* is empty MSG (i.e., .message is WM_NULL).
*/
static const MSG& LastKeyMSG() { return sLastKeyMSG; }
};
class KeyboardLayout
{
public:
static KeyboardLayout* GetInstance();
static void Shutdown();
static HKL GetActiveLayout();
static nsCString GetActiveLayoutName();
static void NotifyIdleServiceOfUserActivity();
static bool IsPrintableCharKey(uint8_t aVirtualKey);
/**
* IsDeadKey() returns true if aVirtualKey is a dead key with aModKeyState.
* This method isn't stateful.
*/
bool IsDeadKey(uint8_t aVirtualKey,
const ModifierKeyState& aModKeyState) const;
/**
* IsInDeadKeySequence() returns true when it's in a dead key sequence.
* It starts when a dead key is down and ends when another key down causes
* inactivating the dead key state.
*/
bool IsInDeadKeySequence() const { return !mActiveDeadKeys.IsEmpty(); }
/**
* IsSysKey() returns true if aVirtualKey with aModKeyState causes WM_SYSKEY*
* or WM_SYS*CHAR messages.
*/
bool IsSysKey(uint8_t aVirtualKey,
const ModifierKeyState& aModKeyState) const;
/**
* GetUniCharsAndModifiers() returns characters which are inputted by
* aVirtualKey with aModKeyState. This method isn't stateful.
* Note that if the combination causes text input, the result's Ctrl and
* Alt key state are never active.
*/
UniCharsAndModifiers GetUniCharsAndModifiers(
uint8_t aVirtualKey,
const ModifierKeyState& aModKeyState) const
{
VirtualKey::ShiftState shiftState =
VirtualKey::ModifierKeyStateToShiftState(aModKeyState);
return GetUniCharsAndModifiers(aVirtualKey, shiftState);
}
/**
* GetNativeUniCharsAndModifiers() returns characters which are inputted by
* aVirtualKey with aModKeyState. The method isn't stateful.
* Note that different from GetUniCharsAndModifiers(), this returns
* actual modifier state of Ctrl and Alt.
*/
UniCharsAndModifiers GetNativeUniCharsAndModifiers(
uint8_t aVirtualKey,
const ModifierKeyState& aModKeyState) const;
/**
* OnLayoutChange() must be called before the first keydown message is
* received. LoadLayout() changes the keyboard state, that causes breaking
* dead key state. Therefore, we need to load the layout before the first
* keydown message.
*/
void OnLayoutChange(HKL aKeyboardLayout)
{
MOZ_ASSERT(!mIsOverridden);
LoadLayout(aKeyboardLayout);
}
/**
* OverrideLayout() loads the specified keyboard layout.
*/
void OverrideLayout(HKL aLayout)
{
mIsOverridden = true;
LoadLayout(aLayout);
}
/**
* RestoreLayout() loads the current keyboard layout of the thread.
*/
void RestoreLayout()
{
mIsOverridden = false;
mIsPendingToRestoreKeyboardLayout = true;
}
uint32_t ConvertNativeKeyCodeToDOMKeyCode(UINT aNativeKeyCode) const;
/**
* ConvertNativeKeyCodeToKeyNameIndex() returns KeyNameIndex value for
* non-printable keys (except some special keys like space key).
*/
KeyNameIndex ConvertNativeKeyCodeToKeyNameIndex(uint8_t aVirtualKey) const;
/**
* ConvertScanCodeToCodeNameIndex() returns CodeNameIndex value for
* the given scan code. aScanCode can be over 0xE000 since this method
* doesn't use Windows API.
*/
static CodeNameIndex ConvertScanCodeToCodeNameIndex(UINT aScanCode);
HKL GetLayout() const
{
return mIsPendingToRestoreKeyboardLayout ? ::GetKeyboardLayout(0) :
mKeyboardLayout;
}
/**
* This wraps MapVirtualKeyEx() API with MAPVK_VK_TO_VSC.
*/
WORD ComputeScanCodeForVirtualKeyCode(uint8_t aVirtualKeyCode) const;
/**
* Implementation of nsIWidget::SynthesizeNativeKeyEvent().
*/
nsresult SynthesizeNativeKeyEvent(nsWindowBase* aWidget,
int32_t aNativeKeyboardLayout,
int32_t aNativeKeyCode,
uint32_t aModifierFlags,
const nsAString& aCharacters,
const nsAString& aUnmodifiedCharacters);
private:
KeyboardLayout();
~KeyboardLayout();
static KeyboardLayout* sInstance;
static nsIIdleServiceInternal* sIdleService;
struct DeadKeyTableListEntry
{
DeadKeyTableListEntry* next;
uint8_t data[1];
};
HKL mKeyboardLayout;
VirtualKey mVirtualKeys[NS_NUM_OF_KEYS];
DeadKeyTableListEntry* mDeadKeyTableListHead;
// When mActiveDeadKeys is empty, it's not in dead key sequence.
// Otherwise, it contains virtual keycodes which are pressed in current
// dead key sequence.
nsTArray<uint8_t> mActiveDeadKeys;
// mDeadKeyShiftStates is always same length as mActiveDeadKeys.
// This stores shift states at pressing each dead key stored in
// mActiveDeadKeys.
nsTArray<VirtualKey::ShiftState> mDeadKeyShiftStates;
bool mIsOverridden;
bool mIsPendingToRestoreKeyboardLayout;
static inline int32_t GetKeyIndex(uint8_t aVirtualKey);
static int CompareDeadKeyEntries(const void* aArg1, const void* aArg2,
void* aData);
static bool AddDeadKeyEntry(char16_t aBaseChar, char16_t aCompositeChar,
DeadKeyEntry* aDeadKeyArray, uint32_t aEntries);
bool EnsureDeadKeyActive(bool aIsActive, uint8_t aDeadKey,
const PBYTE aDeadKeyKbdState);
uint32_t GetDeadKeyCombinations(uint8_t aDeadKey,
const PBYTE aDeadKeyKbdState,
uint16_t aShiftStatesWithBaseChars,
DeadKeyEntry* aDeadKeyArray,
uint32_t aMaxEntries);
/**
* Activates or deactivates dead key state.
*/
void ActivateDeadKeyState(const NativeKey& aNativeKey,
const ModifierKeyState& aModKeyState);
void DeactivateDeadKeyState();
const DeadKeyTable* AddDeadKeyTable(const DeadKeyEntry* aDeadKeyArray,
uint32_t aEntries);
void ReleaseDeadKeyTables();
/**
* Loads the specified keyboard layout. This method always clear the dead key
* state.
*/
void LoadLayout(HKL aLayout);
/**
* Gets the keyboard layout name of aLayout. Be careful, this may be too
* slow to call at handling user input.
*/
nsCString GetLayoutName(HKL aLayout) const;
/**
* InitNativeKey() must be called when actually widget receives WM_KEYDOWN or
* WM_KEYUP. This method is stateful. This saves current dead key state at
* WM_KEYDOWN. Additionally, computes current inputted character(s) and set
* them to the aNativeKey.
*/
void InitNativeKey(NativeKey& aNativeKey,
const ModifierKeyState& aModKeyState);
/**
* MaybeInitNativeKeyAsDeadKey() initializes aNativeKey only when aNativeKey
* is a dead key's event.
* When it's not in a dead key sequence, this activates the dead key state.
* When it's in a dead key sequence, this initializes aNativeKey with a
* composite character or a preceding dead char and a dead char which should
* be caused by aNativeKey.
* Returns true when this initializes aNativeKey. Otherwise, false.
*/
bool MaybeInitNativeKeyAsDeadKey(NativeKey& aNativeKey,
const ModifierKeyState& aModKeyState);
/**
* MaybeInitNativeKeyWithCompositeChar() may initialize aNativeKey with
* proper composite character when dead key produces a composite character.
* Otherwise, just returns false.
*/
bool MaybeInitNativeKeyWithCompositeChar(
NativeKey& aNativeKey,
const ModifierKeyState& aModKeyState);
/**
* See the comment of GetUniCharsAndModifiers() below.
*/
UniCharsAndModifiers GetUniCharsAndModifiers(
uint8_t aVirtualKey,
VirtualKey::ShiftState aShiftState) const;
/**
* GetDeadUniCharsAndModifiers() returns dead chars which are stored in
* current dead key sequence. So, this is stateful.
*/
UniCharsAndModifiers GetDeadUniCharsAndModifiers() const;
/**
* GetCompositeChar() returns a composite character with dead character
* caused by mActiveDeadKeys, mDeadKeyShiftStates and a base character
* (aBaseChar).
* If the combination of the dead character and the base character doesn't
* cause a composite character, this returns 0.
*/
char16_t GetCompositeChar(char16_t aBaseChar) const;
// NativeKey class should access InitNativeKey() directly, but it shouldn't
// be available outside of NativeKey. So, let's make NativeKey a friend
// class of this.
friend class NativeKey;
};
class RedirectedKeyDownMessageManager
{
public:
/*
* If a window receives WM_KEYDOWN message or WM_SYSKEYDOWM message which is
* a redirected message, NativeKey::DispatchKeyDownAndKeyPressEvent()
* prevents to dispatch eKeyDown event because it has been dispatched
* before the message was redirected. However, in some cases, WM_*KEYDOWN
* message handler may not handle actually. Then, the message handler needs
* to forget the redirected message and remove WM_CHAR message or WM_SYSCHAR
* message for the redirected keydown message. AutoFlusher class is a helper
* class for doing it. This must be created in the stack.
*/
class MOZ_STACK_CLASS AutoFlusher final
{
public:
AutoFlusher(nsWindowBase* aWidget, const MSG &aMsg) :
mCancel(!RedirectedKeyDownMessageManager::IsRedirectedMessage(aMsg)),
mWidget(aWidget), mMsg(aMsg)
{
}
~AutoFlusher()
{
if (mCancel) {
return;
}
// Prevent unnecessary keypress event
if (!mWidget->Destroyed()) {
RedirectedKeyDownMessageManager::RemoveNextCharMessage(mMsg.hwnd);
}
// Foreget the redirected message
RedirectedKeyDownMessageManager::Forget();
}
void Cancel() { mCancel = true; }
private:
bool mCancel;
RefPtr<nsWindowBase> mWidget;
const MSG &mMsg;
};
static void WillRedirect(const MSG& aMsg, bool aDefualtPrevented)
{
sRedirectedKeyDownMsg = aMsg;
sDefaultPreventedOfRedirectedMsg = aDefualtPrevented;
}
static void Forget()
{
sRedirectedKeyDownMsg.message = WM_NULL;
}
static void PreventDefault() { sDefaultPreventedOfRedirectedMsg = true; }
static bool DefaultPrevented() { return sDefaultPreventedOfRedirectedMsg; }
static bool IsRedirectedMessage(const MSG& aMsg);
/**
* RemoveNextCharMessage() should be called by WM_KEYDOWN or WM_SYSKEYDOWM
* message handler. If there is no WM_(SYS)CHAR message for it, this
* method does nothing.
* NOTE: WM_(SYS)CHAR message is posted by TranslateMessage() API which is
* called in message loop. So, WM_(SYS)KEYDOWN message should have
* WM_(SYS)CHAR message in the queue if the keydown event causes character
* input.
*/
static void RemoveNextCharMessage(HWND aWnd);
private:
// sRedirectedKeyDownMsg is WM_KEYDOWN message or WM_SYSKEYDOWN message which
// is reirected with SendInput() API by
// widget::NativeKey::DispatchKeyDownAndKeyPressEvent()
static MSG sRedirectedKeyDownMsg;
static bool sDefaultPreventedOfRedirectedMsg;
};
} // namespace widget
} // namespace mozilla
#endif