mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/widget/TextEvents.h

1546 строки
59 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 mozilla_TextEvents_h__
#define mozilla_TextEvents_h__
#include <stdint.h>
#include "mozilla/Assertions.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/EventForwards.h" // for KeyNameIndex, temporarily
#include "mozilla/FontRange.h"
#include "mozilla/Maybe.h"
#include "mozilla/NativeKeyBindingsType.h"
#include "mozilla/OwningNonNull.h"
#include "mozilla/TextRange.h"
#include "mozilla/WritingModes.h"
#include "mozilla/dom/DataTransfer.h"
#include "mozilla/dom/KeyboardEventBinding.h"
#include "mozilla/dom/StaticRange.h"
#include "mozilla/widget/IMEData.h"
#include "mozilla/ipc/IPCForwards.h"
#include "nsCOMPtr.h"
#include "nsHashtablesFwd.h"
#include "nsISelectionListener.h"
#include "nsITransferable.h"
#include "nsRect.h"
#include "nsString.h"
#include "nsTArray.h"
class nsStringHashKey;
/******************************************************************************
* virtual keycode values
******************************************************************************/
enum {
#define NS_DEFINE_VK(aDOMKeyName, aDOMKeyCode) NS_##aDOMKeyName = aDOMKeyCode,
#include "mozilla/VirtualKeyCodeList.h"
#undef NS_DEFINE_VK
NS_VK_UNKNOWN = 0xFF
};
namespace mozilla {
enum : uint32_t {
eKeyLocationStandard = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_STANDARD,
eKeyLocationLeft = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_LEFT,
eKeyLocationRight = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_RIGHT,
eKeyLocationNumpad = dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD
};
const nsCString GetDOMKeyCodeName(uint32_t aKeyCode);
namespace dom {
class PBrowserParent;
class PBrowserChild;
} // namespace dom
namespace plugins {
class PPluginInstanceChild;
} // namespace plugins
enum class AccessKeyType {
// Handle access key for chrome.
eChrome,
// Handle access key for content.
eContent,
// Don't handle access key.
eNone
};
/******************************************************************************
* mozilla::AlternativeCharCode
*
* This stores alternative charCode values of a key event with some modifiers.
* The stored values proper for testing shortcut key or access key.
******************************************************************************/
struct AlternativeCharCode {
AlternativeCharCode() = default;
AlternativeCharCode(uint32_t aUnshiftedCharCode, uint32_t aShiftedCharCode)
: mUnshiftedCharCode(aUnshiftedCharCode),
mShiftedCharCode(aShiftedCharCode) {}
uint32_t mUnshiftedCharCode = 0u;
uint32_t mShiftedCharCode = 0u;
bool operator==(const AlternativeCharCode& aOther) const {
return mUnshiftedCharCode == aOther.mUnshiftedCharCode &&
mShiftedCharCode == aOther.mShiftedCharCode;
}
bool operator!=(const AlternativeCharCode& aOther) const {
return !(*this == aOther);
}
};
/******************************************************************************
* mozilla::ShortcutKeyCandidate
*
* This stores a candidate of shortcut key combination.
******************************************************************************/
struct ShortcutKeyCandidate {
enum class ShiftState : bool {
// Can ignore `Shift` modifier state when comparing the key combination.
// E.g., Ctrl + Shift + `:` in the US keyboard layout may match with
// Ctrl + `:` shortcut.
Ignorable,
// `Shift` modifier state should be respected. I.e., Ctrl + `;` in the US
// keyboard layout never matches with Ctrl + Shift + `;` shortcut.
MatchExactly,
};
enum class SkipIfEarlierHandlerDisabled : bool {
// Even if an earlier handler is disabled, this may match with another
// handler for avoiding inaccessible shortcut with the active keyboard
// layout.
No,
// If an earlier handler (i.e., preferred handler) is disabled, this should
// not try to match. E.g., Ctrl + `-` in the French keyboard layout when
// the zoom level is the minimum value, it should not match with Ctrl + `6`
// shortcut (French keyboard layout introduces `-` when pressing Digit6 key
// without Shift, and Shift + Digit6 introduces `6`).
Yes,
};
ShortcutKeyCandidate() = default;
ShortcutKeyCandidate(
uint32_t aCharCode, ShiftState aShiftState,
SkipIfEarlierHandlerDisabled aSkipIfEarlierHandlerDisabled)
: mCharCode(aCharCode),
mShiftState(aShiftState),
mSkipIfEarlierHandlerDisabled(aSkipIfEarlierHandlerDisabled) {}
// The mCharCode value which must match keyboard shortcut definition.
uint32_t mCharCode = 0;
ShiftState mShiftState = ShiftState::MatchExactly;
SkipIfEarlierHandlerDisabled mSkipIfEarlierHandlerDisabled =
SkipIfEarlierHandlerDisabled::No;
};
/******************************************************************************
* mozilla::IgnoreModifierState
*
* This stores flags for modifiers that should be ignored when matching
* XBL handlers.
******************************************************************************/
struct IgnoreModifierState {
// When mShift is true, Shift key state will be ignored.
bool mShift;
// When mMeta is true, Meta key state will be ignored.
bool mMeta;
IgnoreModifierState() : mShift(false), mMeta(false) {}
};
/******************************************************************************
* mozilla::WidgetKeyboardEvent
******************************************************************************/
class WidgetKeyboardEvent final : public WidgetInputEvent {
private:
friend class dom::PBrowserParent;
friend class dom::PBrowserChild;
friend struct IPC::ParamTraits<WidgetKeyboardEvent>;
ALLOW_DEPRECATED_READPARAM
protected:
WidgetKeyboardEvent()
: mNativeKeyEvent(nullptr),
mKeyCode(0),
mCharCode(0),
mPseudoCharCode(0),
mLocation(eKeyLocationStandard),
mUniqueId(0),
mKeyNameIndex(KEY_NAME_INDEX_Unidentified),
mCodeNameIndex(CODE_NAME_INDEX_UNKNOWN),
mIsRepeat(false),
mIsComposing(false),
mIsSynthesizedByTIP(false),
mMaybeSkippableInRemoteProcess(true),
mUseLegacyKeyCodeAndCharCodeValues(false),
mEditCommandsForSingleLineEditorInitialized(false),
mEditCommandsForMultiLineEditorInitialized(false),
mEditCommandsForRichTextEditorInitialized(false) {}
public:
WidgetKeyboardEvent* AsKeyboardEvent() override { return this; }
WidgetKeyboardEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget,
EventClassID aEventClassID = eKeyboardEventClass,
const WidgetEventTime* aTime = nullptr)
: WidgetInputEvent(aIsTrusted, aMessage, aWidget, aEventClassID, aTime),
mNativeKeyEvent(nullptr),
mKeyCode(0),
mCharCode(0),
mPseudoCharCode(0),
mLocation(eKeyLocationStandard),
mUniqueId(0),
mKeyNameIndex(KEY_NAME_INDEX_Unidentified),
mCodeNameIndex(CODE_NAME_INDEX_UNKNOWN),
mIsRepeat(false),
mIsComposing(false),
mIsSynthesizedByTIP(false),
mMaybeSkippableInRemoteProcess(true),
mUseLegacyKeyCodeAndCharCodeValues(false),
mEditCommandsForSingleLineEditorInitialized(false),
mEditCommandsForMultiLineEditorInitialized(false),
mEditCommandsForRichTextEditorInitialized(false) {}
// IsInputtingText() and IsInputtingLineBreak() are used to check if
// it should cause eKeyPress events even on web content.
// UI Events defines that "keypress" event should be fired "if and only if
// that key normally produces a character value".
// <https://www.w3.org/TR/uievents/#event-type-keypress>
// Additionally, for backward compatiblity with all existing browsers,
// there is a spec issue for Enter key press.
// <https://github.com/w3c/uievents/issues/183>
bool IsInputtingText() const {
// NOTE: On some keyboard layout, some characters are inputted with Control
// key or Alt key, but at that time, widget clears the modifier flag
// from eKeyPress event because our TextEditor won't handle eKeyPress
// events as inputting text (bug 1346832).
// NOTE: There are some complicated issues of our traditional behavior.
// -- On Windows, KeyboardLayout::WillDispatchKeyboardEvent() clears
// MODIFIER_ALT and MODIFIER_CONTROL of eKeyPress event if it
// should be treated as inputting a character because AltGr is
// represented with both Alt key and Ctrl key are pressed, and
// some keyboard layouts may produces a character with Ctrl key.
// -- On Linux, KeymapWrapper doesn't have this hack since perhaps,
// we don't have any bug reports that user cannot input proper
// character with Alt and/or Ctrl key.
// -- On macOS, IMEInputHandler::WillDispatchKeyboardEvent() clears
// MODIFIER_ALT and MDOFIEIR_CONTROL of eKeyPress event only when
// TextInputHandler::InsertText() has been called for the event.
// I.e., they are cleared only when an editor has focus (even if IME
// is disabled in password field or by |ime-mode: disabled;|) because
// TextInputHandler::InsertText() is called while
// TextInputHandler::HandleKeyDownEvent() calls interpretKeyEvents:
// to notify text input processor of Cocoa (including IME). In other
// words, when we need to disable IME completey when no editor has
// focus, we cannot call interpretKeyEvents:. So,
// TextInputHandler::InsertText() won't be called when no editor has
// focus so that neither MODIFIER_ALT nor MODIFIER_CONTROL is
// cleared. So, fortunately, altKey and ctrlKey values of "keypress"
// events are same as the other browsers only when no editor has
// focus.
// NOTE: As mentioned above, for compatibility with the other browsers on
// macOS, we should keep MODIFIER_ALT and MODIFIER_CONTROL flags of
// eKeyPress events when no editor has focus. However, Alt key,
// labeled "option" on keyboard for Mac, is AltGraph key on the other
// platforms. So, even if MODIFIER_ALT is set, we need to dispatch
// eKeyPress event even on web content unless mCharCode is 0.
// Therefore, we need to ignore MODIFIER_ALT flag here only on macOS.
return mMessage == eKeyPress && mCharCode &&
!(mModifiers & (
#ifndef XP_MACOSX
// So, ignore MODIFIER_ALT only on macOS since
// option key is used as AltGraph key on macOS.
MODIFIER_ALT |
#endif // #ifndef XP_MAXOSX
MODIFIER_CONTROL | MODIFIER_META));
}
bool IsInputtingLineBreak() const {
return mMessage == eKeyPress && mKeyNameIndex == KEY_NAME_INDEX_Enter &&
!(mModifiers & (MODIFIER_ALT | MODIFIER_CONTROL | MODIFIER_META));
}
/**
* ShouldKeyPressEventBeFiredOnContent() should be called only when the
* instance is eKeyPress event. This returns true when the eKeyPress
* event should be fired even on content in the default event group.
*/
bool ShouldKeyPressEventBeFiredOnContent() const {
MOZ_DIAGNOSTIC_ASSERT(mMessage == eKeyPress);
if (IsInputtingText() || IsInputtingLineBreak()) {
return true;
}
// Ctrl + Enter won't cause actual input in our editor.
// However, the other browsers fire keypress event in any platforms.
// So, for compatibility with them, we should fire keypress event for
// Ctrl + Enter too.
return mMessage == eKeyPress && mKeyNameIndex == KEY_NAME_INDEX_Enter &&
!(mModifiers & (MODIFIER_ALT | MODIFIER_META | MODIFIER_SHIFT));
}
WidgetEvent* Duplicate() const override {
MOZ_ASSERT(mClass == eKeyboardEventClass,
"Duplicate() must be overridden by sub class");
// Not copying widget, it is a weak reference.
WidgetKeyboardEvent* result = new WidgetKeyboardEvent(
false, mMessage, nullptr, eKeyboardEventClass, this);
result->AssignKeyEventData(*this, true);
result->mEditCommandsForSingleLineEditor =
mEditCommandsForSingleLineEditor.Clone();
result->mEditCommandsForMultiLineEditor =
mEditCommandsForMultiLineEditor.Clone();
result->mEditCommandsForRichTextEditor =
mEditCommandsForRichTextEditor.Clone();
result->mFlags = mFlags;
return result;
}
bool CanUserGestureActivateTarget() const {
// Printable keys, 'carriage return' and 'space' are supported user gestures
// for activating the document. However, if supported key is being pressed
// combining with other operation keys, such like alt, control ..etc., we
// won't activate the target for them because at that time user might
// interact with browser or window manager which doesn't necessarily
// demonstrate user's intent to play media.
const bool isCombiningWithOperationKeys = (IsControl() && !IsAltGraph()) ||
(IsAlt() && !IsAltGraph()) ||
IsMeta();
const bool isEnterOrSpaceKey =
mKeyNameIndex == KEY_NAME_INDEX_Enter || mKeyCode == NS_VK_SPACE;
return (PseudoCharCode() || isEnterOrSpaceKey) &&
(!isCombiningWithOperationKeys ||
// ctrl-c/ctrl-x/ctrl-v is quite common shortcut for clipboard
// operation.
// XXXedgar, we have to find a better way to handle browser keyboard
// shortcut for user activation, instead of just ignoring all
// combinations, see bug 1641171.
((mKeyCode == dom::KeyboardEvent_Binding::DOM_VK_C ||
mKeyCode == dom::KeyboardEvent_Binding::DOM_VK_V ||
mKeyCode == dom::KeyboardEvent_Binding::DOM_VK_X) &&
IsAccel()));
}
// Returns true if this event is likely an user activation for a link or
// a link-like button, where modifier keys are likely be used for controlling
// where the link is opened.
//
// This returns false if the keyboard event is more likely an user-defined
// shortcut key.
bool CanReflectModifiersToUserActivation() const {
MOZ_ASSERT(CanUserGestureActivateTarget(),
"Consumer should check CanUserGestureActivateTarget first");
// 'carriage return' and 'space' are supported user gestures for activating
// a link or a button.
// A button often behaves like a link, by calling window.open inside its
// event handler.
//
// Access keys can also activate links/buttons, but access keys have their
// own modifiers, and those modifiers are not appropriate for reflecting to
// the user activation nor controlling where the link is opened.
return mKeyNameIndex == KEY_NAME_INDEX_Enter || mKeyCode == NS_VK_SPACE;
}
[[nodiscard]] bool ShouldWorkAsSpaceKey() const {
if (mKeyCode == NS_VK_SPACE) {
return true;
}
// Additionally, if the code value is "Space" and the key is not mapped to
// a function key (i.e., not a printable key), we should treat it as space
// key because the active keyboard layout may input different character
// from the ASCII white space (U+0020). For example, NBSP (U+00A0).
return mKeyNameIndex == KEY_NAME_INDEX_USE_STRING &&
mCodeNameIndex == CODE_NAME_INDEX_Space;
}
/**
* CanTreatAsUserInput() returns true if the key is pressed for perhaps
* doing something on the web app or our UI. This means that when this
* returns false, e.g., when user presses a modifier key, user is probably
* displeased by opening popup, entering fullscreen mode, etc. Therefore,
* only when this returns true, such reactions should be allowed.
*/
bool CanTreatAsUserInput() const {
if (!IsTrusted()) {
return false;
}
switch (mKeyNameIndex) {
case KEY_NAME_INDEX_Escape:
// modifier keys:
case KEY_NAME_INDEX_Alt:
case KEY_NAME_INDEX_AltGraph:
case KEY_NAME_INDEX_CapsLock:
case KEY_NAME_INDEX_Control:
case KEY_NAME_INDEX_Fn:
case KEY_NAME_INDEX_FnLock:
case KEY_NAME_INDEX_Meta:
case KEY_NAME_INDEX_NumLock:
case KEY_NAME_INDEX_ScrollLock:
case KEY_NAME_INDEX_Shift:
case KEY_NAME_INDEX_Symbol:
case KEY_NAME_INDEX_SymbolLock:
// legacy modifier keys:
case KEY_NAME_INDEX_Hyper:
case KEY_NAME_INDEX_Super:
return false;
default:
return true;
}
}
/**
* ShouldInteractionTimeRecorded() returns true if the handling time of
* the event should be recorded with the telemetry.
*/
bool ShouldInteractionTimeRecorded() const {
// Let's record only when we can treat the instance is a user input.
return CanTreatAsUserInput();
}
// OS translated Unicode chars which are used for accesskey and accelkey
// handling. The handlers will try from first character to last character.
CopyableTArray<AlternativeCharCode> mAlternativeCharCodes;
// DOM KeyboardEvent.key only when mKeyNameIndex is KEY_NAME_INDEX_USE_STRING.
nsString mKeyValue;
// DOM KeyboardEvent.code only when mCodeNameIndex is
// CODE_NAME_INDEX_USE_STRING.
nsString mCodeValue;
// OS-specific native event can optionally be preserved.
// This is used to retrieve editing shortcut keys in the environment.
void* mNativeKeyEvent;
// A DOM keyCode value or 0. If a keypress event whose mCharCode is 0, this
// should be 0.
uint32_t mKeyCode;
// If the instance is a keypress event of a printable key, this is a UTF-16
// value of the key. Otherwise, 0. This value must not be a control
// character when some modifiers are active. Then, this value should be an
// unmodified value except Shift and AltGr.
uint32_t mCharCode;
// mPseudoCharCode is valid only when mMessage is an eKeyDown event.
// This stores mCharCode value of keypress event which is fired with same
// key value and same modifier state.
uint32_t mPseudoCharCode;
// One of eKeyLocation*
uint32_t mLocation;
// Unique id associated with a keydown / keypress event. It's ok if this wraps
// over long periods.
uint32_t mUniqueId;
// DOM KeyboardEvent.key
KeyNameIndex mKeyNameIndex;
// DOM KeyboardEvent.code
CodeNameIndex mCodeNameIndex;
// Indicates whether the event is generated by auto repeat or not.
// if this is keyup event, always false.
bool mIsRepeat;
// Indicates whether the event is generated during IME (or deadkey)
// composition. This is initialized by EventStateManager. So, key event
// dispatchers don't need to initialize this.
bool mIsComposing;
// Indicates whether the event is synthesized from Text Input Processor
// or an actual event from nsAppShell.
bool mIsSynthesizedByTIP;
// Indicates whether the event is skippable in remote process.
// Don't refer this member directly when you need to check this.
// Use CanSkipInRemoteProcess() instead.
bool mMaybeSkippableInRemoteProcess;
// Indicates whether the event should return legacy keyCode value and
// charCode value to web apps (one of them is always 0) or not, when it's
// an eKeyPress event.
bool mUseLegacyKeyCodeAndCharCodeValues;
bool CanSkipInRemoteProcess() const {
// If this is a repeat event (i.e., generated by auto-repeat feature of
// the platform), remove process may skip to handle it because of
// performances reasons.. However, if it's caused by odd keyboard utils,
// we should not ignore any key events even marked as repeated since
// generated key sequence may be important to input proper text. E.g.,
// "SinhalaTamil IME" on Windows emulates dead key like input with
// generating WM_KEYDOWN for VK_PACKET (inputting any Unicode characters
// without keyboard layout information) and VK_BACK (Backspace) to remove
// previous character(s) and those messages may be marked as "repeat" by
// their bug.
return mIsRepeat && mMaybeSkippableInRemoteProcess;
}
/**
* If the key is an arrow key, and the current selection is in a vertical
* content, the caret should be moved to physically. However, arrow keys
* are mapped to logical move commands in horizontal content. Therefore,
* we need to check writing mode if and only if the key is an arrow key, and
* need to remap the command to logical command in vertical content if the
* writing mode at selection is vertical. These methods help to convert
* arrow keys in horizontal content to correspnding direction arrow keys
* in vertical content.
*/
bool NeedsToRemapNavigationKey() const {
// TODO: Use mKeyNameIndex instead.
return mKeyCode >= NS_VK_LEFT && mKeyCode <= NS_VK_DOWN;
}
uint32_t GetRemappedKeyCode(const WritingMode& aWritingMode) const {
if (!aWritingMode.IsVertical()) {
return mKeyCode;
}
switch (mKeyCode) {
case NS_VK_LEFT:
return aWritingMode.IsVerticalLR() ? NS_VK_UP : NS_VK_DOWN;
case NS_VK_RIGHT:
return aWritingMode.IsVerticalLR() ? NS_VK_DOWN : NS_VK_UP;
case NS_VK_UP:
return NS_VK_LEFT;
case NS_VK_DOWN:
return NS_VK_RIGHT;
default:
return mKeyCode;
}
}
KeyNameIndex GetRemappedKeyNameIndex(const WritingMode& aWritingMode) const {
if (!aWritingMode.IsVertical()) {
return mKeyNameIndex;
}
uint32_t remappedKeyCode = GetRemappedKeyCode(aWritingMode);
if (remappedKeyCode == mKeyCode) {
return mKeyNameIndex;
}
switch (remappedKeyCode) {
case NS_VK_LEFT:
return KEY_NAME_INDEX_ArrowLeft;
case NS_VK_RIGHT:
return KEY_NAME_INDEX_ArrowRight;
case NS_VK_UP:
return KEY_NAME_INDEX_ArrowUp;
case NS_VK_DOWN:
return KEY_NAME_INDEX_ArrowDown;
default:
MOZ_ASSERT_UNREACHABLE("Add a case for the new remapped key");
return mKeyNameIndex;
}
}
/**
* Retrieves all edit commands from mWidget. This shouldn't be called when
* the instance is an untrusted event, doesn't have widget or in non-chrome
* process.
*
* @param aWritingMode
* When writing mode of focused element is vertical, this
* will resolve some key's physical direction to logical
* direction. For doing it, this must be set to the
* writing mode at current selection. However, when there
* is no focused element and no selection ranges, this
* should be set to Nothing(). Using the result of
* `TextEventDispatcher::MaybeQueryWritingModeAtSelection()`
* is recommended.
*/
MOZ_CAN_RUN_SCRIPT void InitAllEditCommands(
const Maybe<WritingMode>& aWritingMode);
/**
* Retrieves edit commands from mWidget only for aType. This shouldn't be
* called when the instance is an untrusted event or doesn't have widget.
*
* @param aWritingMode
* When writing mode of focused element is vertical, this
* will resolve some key's physical direction to logical
* direction. For doing it, this must be set to the
* writing mode at current selection. However, when there
* is no focused element and no selection ranges, this
* should be set to Nothing(). Using the result of
* `TextEventDispatcher::MaybeQueryWritingModeAtSelection()`
* is recommended.
* @return false if some resource is not available to get
* commands unexpectedly. Otherwise, true even if
* retrieved command is nothing.
*/
MOZ_CAN_RUN_SCRIPT bool InitEditCommandsFor(
NativeKeyBindingsType aType, const Maybe<WritingMode>& aWritingMode);
/**
* PreventNativeKeyBindings() makes the instance to not cause any edit
* actions even if it matches with a native key binding.
*/
void PreventNativeKeyBindings() {
mEditCommandsForSingleLineEditor.Clear();
mEditCommandsForMultiLineEditor.Clear();
mEditCommandsForRichTextEditor.Clear();
mEditCommandsForSingleLineEditorInitialized = true;
mEditCommandsForMultiLineEditorInitialized = true;
mEditCommandsForRichTextEditorInitialized = true;
}
/**
* EditCommandsConstRef() returns reference to edit commands for aType.
*/
const nsTArray<CommandInt>& EditCommandsConstRef(
NativeKeyBindingsType aType) const {
return const_cast<WidgetKeyboardEvent*>(this)->EditCommandsRef(aType);
}
/**
* IsEditCommandsInitialized() returns true if edit commands for aType
* was already initialized. Otherwise, false.
*/
bool IsEditCommandsInitialized(NativeKeyBindingsType aType) const {
return const_cast<WidgetKeyboardEvent*>(this)->IsEditCommandsInitializedRef(
aType);
}
/**
* AreAllEditCommandsInitialized() returns true if edit commands for all
* types were already initialized. Otherwise, false.
*/
bool AreAllEditCommandsInitialized() const {
return mEditCommandsForSingleLineEditorInitialized &&
mEditCommandsForMultiLineEditorInitialized &&
mEditCommandsForRichTextEditorInitialized;
}
/**
* Execute edit commands for aType.
*
* @return true if the caller should do nothing anymore.
* false, otherwise.
*/
typedef void (*DoCommandCallback)(Command, void*);
MOZ_CAN_RUN_SCRIPT bool ExecuteEditCommands(NativeKeyBindingsType aType,
DoCommandCallback aCallback,
void* aCallbackData);
// If the key should cause keypress events, this returns true.
// Otherwise, false.
bool ShouldCauseKeypressEvents() const;
// mCharCode value of non-eKeyPress events is always 0. However, if
// non-eKeyPress event has one or more alternative char code values,
// its first item should be the mCharCode value of following eKeyPress event.
// PseudoCharCode() returns mCharCode value for eKeyPress event,
// the first alternative char code value of non-eKeyPress event or 0.
uint32_t PseudoCharCode() const {
return mMessage == eKeyPress ? mCharCode : mPseudoCharCode;
}
void SetCharCode(uint32_t aCharCode) {
if (mMessage == eKeyPress) {
mCharCode = aCharCode;
} else {
mPseudoCharCode = aCharCode;
}
}
void GetDOMKeyName(nsAString& aKeyName) {
if (mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {
aKeyName = mKeyValue;
return;
}
GetDOMKeyName(mKeyNameIndex, aKeyName);
}
void GetDOMCodeName(nsAString& aCodeName) {
if (mCodeNameIndex == CODE_NAME_INDEX_USE_STRING) {
aCodeName = mCodeValue;
return;
}
GetDOMCodeName(mCodeNameIndex, aCodeName);
}
/**
* GetFallbackKeyCodeOfPunctuationKey() returns a DOM keyCode value for
* aCodeNameIndex. This is keyCode value of the key when active keyboard
* layout is ANSI (US), JIS or ABNT keyboard layout (the latter 2 layouts
* are used only when ANSI doesn't have the key). The result is useful
* if the key doesn't produce ASCII character with active keyboard layout
* nor with alternative ASCII capable keyboard layout.
*/
static uint32_t GetFallbackKeyCodeOfPunctuationKey(
CodeNameIndex aCodeNameIndex);
bool IsModifierKeyEvent() const {
return GetModifierForKeyName(mKeyNameIndex) != MODIFIER_NONE;
}
/**
* Get the candidates for shortcut key.
*
* @param aCandidates [out] the candidate shortcut key combination list.
* the first item is most preferred.
*/
void GetShortcutKeyCandidates(ShortcutKeyCandidateArray& aCandidates) const;
/**
* Get the candidates for access key.
*
* @param aCandidates [out] the candidate access key list.
* the first item is most preferred.
*/
void GetAccessKeyCandidates(nsTArray<uint32_t>& aCandidates) const;
/**
* Check whether the modifiers match with chrome access key or
* content access key.
*/
bool ModifiersMatchWithAccessKey(AccessKeyType aType) const;
/**
* Return active modifiers which may match with access key.
* For example, even if Alt is access key modifier, then, when Control,
* CapseLock and NumLock are active, this returns only MODIFIER_CONTROL.
*/
Modifiers ModifiersForAccessKeyMatching() const;
/**
* Return access key modifiers.
*/
static Modifiers AccessKeyModifiers(AccessKeyType aType);
static void Shutdown();
/**
* ComputeLocationFromCodeValue() returns one of .mLocation value
* (eKeyLocation*) which is the most preferred value for the specified code
* value.
*/
static uint32_t ComputeLocationFromCodeValue(CodeNameIndex aCodeNameIndex);
/**
* ComputeKeyCodeFromKeyNameIndex() return a .mKeyCode value which can be
* mapped from the specified key value. Note that this returns 0 if the
* key name index is KEY_NAME_INDEX_Unidentified or KEY_NAME_INDEX_USE_STRING.
* This means that this method is useful only for non-printable keys.
*/
static uint32_t ComputeKeyCodeFromKeyNameIndex(KeyNameIndex aKeyNameIndex);
/**
* ComputeCodeNameIndexFromKeyNameIndex() returns a code name index which
* is typically mapped to given key name index on the platform.
* Note that this returns CODE_NAME_INDEX_UNKNOWN if the key name index is
* KEY_NAME_INDEX_Unidentified or KEY_NAME_INDEX_USE_STRING.
* This means that this method is useful only for non-printable keys.
*
* @param aKeyNameIndex A non-printable key name index.
* @param aLocation Should be one of location value. This is
* important when aKeyNameIndex may exist in
* both Numpad or Standard, or in both Left or
* Right. If this is nothing, this method
* returns Left or Standard position's code
* value.
*/
static CodeNameIndex ComputeCodeNameIndexFromKeyNameIndex(
KeyNameIndex aKeyNameIndex, const Maybe<uint32_t>& aLocation);
/**
* GetModifierForKeyName() returns a value of Modifier which is activated
* by the aKeyNameIndex.
*/
static Modifier GetModifierForKeyName(KeyNameIndex aKeyNameIndex);
/**
* IsLeftOrRightModiferKeyNameIndex() returns true if aKeyNameIndex is a
* modifier key which may be in Left and Right location.
*/
static bool IsLeftOrRightModiferKeyNameIndex(KeyNameIndex aKeyNameIndex) {
switch (aKeyNameIndex) {
case KEY_NAME_INDEX_Alt:
case KEY_NAME_INDEX_Control:
case KEY_NAME_INDEX_Meta:
case KEY_NAME_INDEX_Shift:
return true;
default:
return false;
}
}
/**
* IsLockableModifier() returns true if aKeyNameIndex is a lockable modifier
* key such as CapsLock and NumLock.
*/
static bool IsLockableModifier(KeyNameIndex aKeyNameIndex);
static void GetDOMKeyName(KeyNameIndex aKeyNameIndex, nsAString& aKeyName);
static void GetDOMCodeName(CodeNameIndex aCodeNameIndex,
nsAString& aCodeName);
static KeyNameIndex GetKeyNameIndex(const nsAString& aKeyValue);
static CodeNameIndex GetCodeNameIndex(const nsAString& aCodeValue);
static const char* GetCommandStr(Command aCommand);
void AssignKeyEventData(const WidgetKeyboardEvent& aEvent,
bool aCopyTargets) {
AssignInputEventData(aEvent, aCopyTargets);
mKeyCode = aEvent.mKeyCode;
mCharCode = aEvent.mCharCode;
mPseudoCharCode = aEvent.mPseudoCharCode;
mLocation = aEvent.mLocation;
mAlternativeCharCodes = aEvent.mAlternativeCharCodes.Clone();
mIsRepeat = aEvent.mIsRepeat;
mIsComposing = aEvent.mIsComposing;
mKeyNameIndex = aEvent.mKeyNameIndex;
mCodeNameIndex = aEvent.mCodeNameIndex;
mKeyValue = aEvent.mKeyValue;
mCodeValue = aEvent.mCodeValue;
// Don't copy mNativeKeyEvent because it may be referred after its instance
// is destroyed.
mNativeKeyEvent = nullptr;
mUniqueId = aEvent.mUniqueId;
mIsSynthesizedByTIP = aEvent.mIsSynthesizedByTIP;
mMaybeSkippableInRemoteProcess = aEvent.mMaybeSkippableInRemoteProcess;
mUseLegacyKeyCodeAndCharCodeValues =
aEvent.mUseLegacyKeyCodeAndCharCodeValues;
// Don't copy mEditCommandsFor*Editor because it may require a lot of
// memory space. For example, if the event is dispatched but grabbed by
// a JS variable, they are not necessary anymore.
mEditCommandsForSingleLineEditorInitialized =
aEvent.mEditCommandsForSingleLineEditorInitialized;
mEditCommandsForMultiLineEditorInitialized =
aEvent.mEditCommandsForMultiLineEditorInitialized;
mEditCommandsForRichTextEditorInitialized =
aEvent.mEditCommandsForRichTextEditorInitialized;
}
void AssignCommands(const WidgetKeyboardEvent& aEvent) {
mEditCommandsForSingleLineEditorInitialized =
aEvent.mEditCommandsForSingleLineEditorInitialized;
if (mEditCommandsForSingleLineEditorInitialized) {
mEditCommandsForSingleLineEditor =
aEvent.mEditCommandsForSingleLineEditor.Clone();
} else {
mEditCommandsForSingleLineEditor.Clear();
}
mEditCommandsForMultiLineEditorInitialized =
aEvent.mEditCommandsForMultiLineEditorInitialized;
if (mEditCommandsForMultiLineEditorInitialized) {
mEditCommandsForMultiLineEditor =
aEvent.mEditCommandsForMultiLineEditor.Clone();
} else {
mEditCommandsForMultiLineEditor.Clear();
}
mEditCommandsForRichTextEditorInitialized =
aEvent.mEditCommandsForRichTextEditorInitialized;
if (mEditCommandsForRichTextEditorInitialized) {
mEditCommandsForRichTextEditor =
aEvent.mEditCommandsForRichTextEditor.Clone();
} else {
mEditCommandsForRichTextEditor.Clear();
}
}
private:
static const char16_t* const kKeyNames[];
static const char16_t* const kCodeNames[];
typedef nsTHashMap<nsStringHashKey, KeyNameIndex> KeyNameIndexHashtable;
typedef nsTHashMap<nsStringHashKey, CodeNameIndex> CodeNameIndexHashtable;
static KeyNameIndexHashtable* sKeyNameIndexHashtable;
static CodeNameIndexHashtable* sCodeNameIndexHashtable;
// mEditCommandsFor*Editor store edit commands. This should be initialized
// with InitEditCommandsFor().
// XXX Ideally, this should be array of Command rather than CommandInt.
// However, ParamTraits isn't aware of enum array.
CopyableTArray<CommandInt> mEditCommandsForSingleLineEditor;
CopyableTArray<CommandInt> mEditCommandsForMultiLineEditor;
CopyableTArray<CommandInt> mEditCommandsForRichTextEditor;
nsTArray<CommandInt>& EditCommandsRef(NativeKeyBindingsType aType) {
switch (aType) {
case NativeKeyBindingsType::SingleLineEditor:
return mEditCommandsForSingleLineEditor;
case NativeKeyBindingsType::MultiLineEditor:
return mEditCommandsForMultiLineEditor;
case NativeKeyBindingsType::RichTextEditor:
return mEditCommandsForRichTextEditor;
default:
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE(
"Invalid native key binding type");
}
}
// mEditCommandsFor*EditorInitialized are set to true when
// InitEditCommandsFor() initializes edit commands for the type.
bool mEditCommandsForSingleLineEditorInitialized;
bool mEditCommandsForMultiLineEditorInitialized;
bool mEditCommandsForRichTextEditorInitialized;
bool& IsEditCommandsInitializedRef(NativeKeyBindingsType aType) {
switch (aType) {
case NativeKeyBindingsType::SingleLineEditor:
return mEditCommandsForSingleLineEditorInitialized;
case NativeKeyBindingsType::MultiLineEditor:
return mEditCommandsForMultiLineEditorInitialized;
case NativeKeyBindingsType::RichTextEditor:
return mEditCommandsForRichTextEditorInitialized;
default:
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE(
"Invalid native key binding type");
}
}
};
/******************************************************************************
* mozilla::WidgetCompositionEvent
******************************************************************************/
class WidgetCompositionEvent : public WidgetGUIEvent {
private:
friend class mozilla::dom::PBrowserParent;
friend class mozilla::dom::PBrowserChild;
ALLOW_DEPRECATED_READPARAM
WidgetCompositionEvent() : mOriginalMessage(eVoidEvent) {}
public:
virtual WidgetCompositionEvent* AsCompositionEvent() override { return this; }
WidgetCompositionEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget,
const WidgetEventTime* aTime = nullptr)
: WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eCompositionEventClass,
aTime),
mNativeIMEContext(aWidget),
mOriginalMessage(eVoidEvent) {}
virtual WidgetEvent* Duplicate() const override {
MOZ_ASSERT(mClass == eCompositionEventClass,
"Duplicate() must be overridden by sub class");
// Not copying widget, it is a weak reference.
WidgetCompositionEvent* result =
new WidgetCompositionEvent(false, mMessage, nullptr, this);
result->AssignCompositionEventData(*this, true);
result->mFlags = mFlags;
return result;
}
// The composition string or the commit string. If the instance is a
// compositionstart event, this is initialized with selected text by
// TextComposition automatically.
nsString mData;
RefPtr<TextRangeArray> mRanges;
// mNativeIMEContext stores the native IME context which causes the
// composition event.
widget::NativeIMEContext mNativeIMEContext;
// If the instance is a clone of another event, mOriginalMessage stores
// the another event's mMessage.
EventMessage mOriginalMessage;
// Composition ID considered by TextComposition. If the event has not been
// handled by TextComposition yet, this is 0. And also if the event is for
// a composition synthesized in a content process, this is always 0.
uint32_t mCompositionId = 0;
void AssignCompositionEventData(const WidgetCompositionEvent& aEvent,
bool aCopyTargets) {
AssignGUIEventData(aEvent, aCopyTargets);
mData = aEvent.mData;
mOriginalMessage = aEvent.mOriginalMessage;
mRanges = aEvent.mRanges;
// Currently, we don't need to copy the other members because they are
// for internal use only (not available from JS).
}
bool IsComposing() const { return mRanges && mRanges->IsComposing(); }
uint32_t TargetClauseOffset() const {
return mRanges ? mRanges->TargetClauseOffset() : 0;
}
uint32_t TargetClauseLength() const {
uint32_t length = UINT32_MAX;
if (mRanges) {
length = mRanges->TargetClauseLength();
}
return length == UINT32_MAX ? mData.Length() : length;
}
uint32_t RangeCount() const { return mRanges ? mRanges->Length() : 0; }
bool CausesDOMTextEvent() const {
return mMessage == eCompositionChange || mMessage == eCompositionCommit ||
mMessage == eCompositionCommitAsIs;
}
bool CausesDOMCompositionEndEvent() const {
return mMessage == eCompositionEnd || mMessage == eCompositionCommit ||
mMessage == eCompositionCommitAsIs;
}
bool IsFollowedByCompositionEnd() const {
return IsFollowedByCompositionEnd(mOriginalMessage);
}
static bool IsFollowedByCompositionEnd(EventMessage aEventMessage) {
return aEventMessage == eCompositionCommit ||
aEventMessage == eCompositionCommitAsIs;
}
};
/******************************************************************************
* mozilla::WidgetQueryContentEvent
******************************************************************************/
class WidgetQueryContentEvent : public WidgetGUIEvent {
private:
friend class dom::PBrowserParent;
friend class dom::PBrowserChild;
ALLOW_DEPRECATED_READPARAM
WidgetQueryContentEvent()
: mUseNativeLineBreak(true),
mWithFontRanges(false),
mNeedsToFlushLayout(true) {
MOZ_CRASH("WidgetQueryContentEvent is created without proper arguments");
}
public:
virtual WidgetQueryContentEvent* AsQueryContentEvent() override {
return this;
}
WidgetQueryContentEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget)
: WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eQueryContentEventClass),
mUseNativeLineBreak(true),
mWithFontRanges(false),
mNeedsToFlushLayout(true) {}
WidgetQueryContentEvent(EventMessage aMessage,
const WidgetQueryContentEvent& aOtherEvent)
: WidgetGUIEvent(aOtherEvent.IsTrusted(), aMessage,
const_cast<nsIWidget*>(aOtherEvent.mWidget.get()),
eQueryContentEventClass),
mUseNativeLineBreak(aOtherEvent.mUseNativeLineBreak),
mWithFontRanges(false),
mNeedsToFlushLayout(aOtherEvent.mNeedsToFlushLayout) {}
WidgetEvent* Duplicate() const override {
// This event isn't an internal event of any DOM event.
NS_ASSERTION(!IsAllowedToDispatchDOMEvent(),
"WidgetQueryContentEvent needs to support Duplicate()");
MOZ_CRASH("WidgetQueryContentEvent doesn't support Duplicate()");
}
struct Options final {
bool mUseNativeLineBreak;
bool mRelativeToInsertionPoint;
explicit Options()
: mUseNativeLineBreak(true), mRelativeToInsertionPoint(false) {}
explicit Options(const WidgetQueryContentEvent& aEvent)
: mUseNativeLineBreak(aEvent.mUseNativeLineBreak),
mRelativeToInsertionPoint(aEvent.mInput.mRelativeToInsertionPoint) {}
};
void Init(const Options& aOptions) {
mUseNativeLineBreak = aOptions.mUseNativeLineBreak;
mInput.mRelativeToInsertionPoint = aOptions.mRelativeToInsertionPoint;
MOZ_ASSERT(mInput.IsValidEventMessage(mMessage));
}
void InitForQueryTextContent(int64_t aOffset, uint32_t aLength,
const Options& aOptions = Options()) {
NS_ASSERTION(mMessage == eQueryTextContent, "wrong initializer is called");
mInput.mOffset = aOffset;
mInput.mLength = aLength;
Init(aOptions);
MOZ_ASSERT(mInput.IsValidOffset());
}
void InitForQueryCaretRect(int64_t aOffset,
const Options& aOptions = Options()) {
NS_ASSERTION(mMessage == eQueryCaretRect, "wrong initializer is called");
mInput.mOffset = aOffset;
Init(aOptions);
MOZ_ASSERT(mInput.IsValidOffset());
}
void InitForQueryTextRect(int64_t aOffset, uint32_t aLength,
const Options& aOptions = Options()) {
NS_ASSERTION(mMessage == eQueryTextRect, "wrong initializer is called");
mInput.mOffset = aOffset;
mInput.mLength = aLength;
Init(aOptions);
MOZ_ASSERT(mInput.IsValidOffset());
}
void InitForQuerySelectedText(SelectionType aSelectionType,
const Options& aOptions = Options()) {
MOZ_ASSERT(mMessage == eQuerySelectedText);
MOZ_ASSERT(aSelectionType != SelectionType::eNone);
mInput.mSelectionType = aSelectionType;
Init(aOptions);
}
void InitForQueryDOMWidgetHittest(
const mozilla::LayoutDeviceIntPoint& aPoint) {
NS_ASSERTION(mMessage == eQueryDOMWidgetHittest,
"wrong initializer is called");
mRefPoint = aPoint;
}
void InitForQueryTextRectArray(uint32_t aOffset, uint32_t aLength,
const Options& aOptions = Options()) {
NS_ASSERTION(mMessage == eQueryTextRectArray,
"wrong initializer is called");
mInput.mOffset = aOffset;
mInput.mLength = aLength;
Init(aOptions);
}
void RequestFontRanges() {
MOZ_ASSERT(mMessage == eQueryTextContent);
mWithFontRanges = true;
}
bool Succeeded() const {
if (mReply.isNothing()) {
return false;
}
switch (mMessage) {
case eQueryTextContent:
case eQueryTextRect:
case eQueryCaretRect:
return mReply->mOffsetAndData.isSome();
default:
return true;
}
}
bool Failed() const { return !Succeeded(); }
bool FoundSelection() const {
MOZ_ASSERT(mMessage == eQuerySelectedText);
return Succeeded() && mReply->mOffsetAndData.isSome();
}
bool FoundChar() const {
MOZ_ASSERT(mMessage == eQueryCharacterAtPoint);
return Succeeded() && mReply->mOffsetAndData.isSome();
}
bool FoundTentativeCaretOffset() const {
MOZ_ASSERT(mMessage == eQueryCharacterAtPoint);
return Succeeded() && mReply->mTentativeCaretOffset.isSome();
}
bool DidNotFindSelection() const {
MOZ_ASSERT(mMessage == eQuerySelectedText);
return Failed() || mReply->mOffsetAndData.isNothing();
}
bool DidNotFindChar() const {
MOZ_ASSERT(mMessage == eQueryCharacterAtPoint);
return Failed() || mReply->mOffsetAndData.isNothing();
}
bool DidNotFindTentativeCaretOffset() const {
MOZ_ASSERT(mMessage == eQueryCharacterAtPoint);
return Failed() || mReply->mTentativeCaretOffset.isNothing();
}
bool mUseNativeLineBreak;
bool mWithFontRanges;
bool mNeedsToFlushLayout;
struct Input final {
uint32_t EndOffset() const {
CheckedInt<uint32_t> endOffset = CheckedInt<uint32_t>(mOffset) + mLength;
return NS_WARN_IF(!endOffset.isValid()) ? UINT32_MAX : endOffset.value();
}
int64_t mOffset;
uint32_t mLength;
SelectionType mSelectionType;
// If mOffset is true, mOffset is relative to the start offset of
// composition if there is, otherwise, the start of the first selection
// range.
bool mRelativeToInsertionPoint;
Input()
: mOffset(0),
mLength(0),
mSelectionType(SelectionType::eNormal),
mRelativeToInsertionPoint(false) {}
bool IsValidOffset() const {
return mRelativeToInsertionPoint || mOffset >= 0;
}
bool IsValidEventMessage(EventMessage aEventMessage) const {
if (!mRelativeToInsertionPoint) {
return true;
}
switch (aEventMessage) {
case eQueryTextContent:
case eQueryCaretRect:
case eQueryTextRect:
return true;
default:
return false;
}
}
bool MakeOffsetAbsolute(uint32_t aInsertionPointOffset) {
if (NS_WARN_IF(!mRelativeToInsertionPoint)) {
return true;
}
mRelativeToInsertionPoint = false;
// If mOffset + aInsertionPointOffset becomes negative value,
// we should assume the absolute offset is 0.
if (mOffset < 0 && -mOffset > aInsertionPointOffset) {
mOffset = 0;
return true;
}
// Otherwise, we don't allow too large offset.
CheckedInt<uint32_t> absOffset(mOffset + aInsertionPointOffset);
if (NS_WARN_IF(!absOffset.isValid())) {
mOffset = UINT32_MAX;
return false;
}
mOffset = absOffset.value();
return true;
}
} mInput;
struct Reply final {
EventMessage const mEventMessage;
void* mContentsRoot = nullptr;
Maybe<OffsetAndData<uint32_t>> mOffsetAndData;
// mTentativeCaretOffset is used by only eQueryCharacterAtPoint.
// This is the offset where caret would be if user clicked at the mRefPoint.
Maybe<uint32_t> mTentativeCaretOffset;
// mRect is used by eQueryTextRect, eQueryCaretRect, eQueryCharacterAtPoint
// and eQueryEditorRect. The coordinates is system coordinates relative to
// the top level widget of mFocusedWidget. E.g., if a <xul:panel> which
// is owned by a window has focused editor, the offset of mRect is relative
// to the owner window, not the <xul:panel>.
mozilla::LayoutDeviceIntRect mRect;
// The return widget has the caret. This is set at all query events.
nsIWidget* mFocusedWidget = nullptr;
// mozilla::WritingMode value at the end (focus) of the selection
mozilla::WritingMode mWritingMode;
// Used by eQuerySelectionAsTransferable
nsCOMPtr<nsITransferable> mTransferable;
// Used by eQueryTextContent with font ranges requested
CopyableAutoTArray<mozilla::FontRange, 1> mFontRanges;
// Used by eQueryTextRectArray
CopyableTArray<mozilla::LayoutDeviceIntRect> mRectArray;
// true if selection is reversed (end < start)
bool mReversed = false;
// true if DOM element under mouse belongs to widget
bool mWidgetIsHit = false;
// true if mContentRoot is focused editable content
bool mIsEditableContent = false;
Reply() = delete;
explicit Reply(EventMessage aEventMessage) : mEventMessage(aEventMessage) {}
// Don't allow to copy/move because of `mEventMessage`.
Reply(const Reply& aOther) = delete;
Reply(Reply&& aOther) = delete;
Reply& operator=(const Reply& aOther) = delete;
Reply& operator=(Reply&& aOther) = delete;
MOZ_NEVER_INLINE_DEBUG uint32_t StartOffset() const {
MOZ_ASSERT(mOffsetAndData.isSome());
return mOffsetAndData->StartOffset();
}
MOZ_NEVER_INLINE_DEBUG uint32_t EndOffset() const {
MOZ_ASSERT(mOffsetAndData.isSome());
return mOffsetAndData->EndOffset();
}
MOZ_NEVER_INLINE_DEBUG uint32_t DataLength() const {
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mOffsetAndData.isSome() ? mOffsetAndData->Length() : 0;
}
MOZ_NEVER_INLINE_DEBUG uint32_t AnchorOffset() const {
MOZ_ASSERT(mEventMessage == eQuerySelectedText);
MOZ_ASSERT(mOffsetAndData.isSome());
return StartOffset() + (mReversed ? DataLength() : 0);
}
MOZ_NEVER_INLINE_DEBUG uint32_t FocusOffset() const {
MOZ_ASSERT(mEventMessage == eQuerySelectedText);
MOZ_ASSERT(mOffsetAndData.isSome());
return StartOffset() + (mReversed ? 0 : DataLength());
}
const WritingMode& WritingModeRef() const {
MOZ_ASSERT(mEventMessage == eQuerySelectedText ||
mEventMessage == eQueryCaretRect ||
mEventMessage == eQueryTextRect);
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mWritingMode;
}
MOZ_NEVER_INLINE_DEBUG const nsString& DataRef() const {
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mOffsetAndData.isSome() ? mOffsetAndData->DataRef()
: EmptyString();
}
MOZ_NEVER_INLINE_DEBUG bool IsDataEmpty() const {
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mOffsetAndData.isSome() ? mOffsetAndData->IsDataEmpty() : true;
}
MOZ_NEVER_INLINE_DEBUG bool IsOffsetInRange(uint32_t aOffset) const {
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mOffsetAndData.isSome() ? mOffsetAndData->IsOffsetInRange(aOffset)
: false;
}
MOZ_NEVER_INLINE_DEBUG bool IsOffsetInRangeOrEndOffset(
uint32_t aOffset) const {
MOZ_ASSERT(mOffsetAndData.isSome() ||
mEventMessage == eQuerySelectedText);
return mOffsetAndData.isSome()
? mOffsetAndData->IsOffsetInRangeOrEndOffset(aOffset)
: false;
}
MOZ_NEVER_INLINE_DEBUG void TruncateData(uint32_t aLength = 0) {
MOZ_ASSERT(mOffsetAndData.isSome());
mOffsetAndData->TruncateData(aLength);
}
friend std::ostream& operator<<(std::ostream& aStream,
const Reply& aReply) {
aStream << "{ ";
if (aReply.mEventMessage == eQuerySelectedText ||
aReply.mEventMessage == eQueryTextContent ||
aReply.mEventMessage == eQueryTextRect ||
aReply.mEventMessage == eQueryCaretRect ||
aReply.mEventMessage == eQueryCharacterAtPoint) {
aStream << "mOffsetAndData=" << ToString(aReply.mOffsetAndData).c_str()
<< ", ";
if (aReply.mEventMessage == eQueryCharacterAtPoint) {
aStream << "mTentativeCaretOffset="
<< ToString(aReply.mTentativeCaretOffset).c_str() << ", ";
}
}
if (aReply.mOffsetAndData.isSome() && aReply.mOffsetAndData->Length()) {
if (aReply.mEventMessage == eQuerySelectedText) {
aStream << ", mReversed=" << (aReply.mReversed ? "true" : "false");
}
if (aReply.mEventMessage == eQuerySelectionAsTransferable) {
aStream << ", mTransferable=0x" << aReply.mTransferable;
}
}
if (aReply.mEventMessage == eQuerySelectedText ||
aReply.mEventMessage == eQueryTextRect ||
aReply.mEventMessage == eQueryCaretRect) {
aStream << ", mWritingMode=" << ToString(aReply.mWritingMode).c_str();
}
aStream << ", mContentsRoot=0x" << aReply.mContentsRoot
<< ", mIsEditableContent="
<< (aReply.mIsEditableContent ? "true" : "false")
<< ", mFocusedWidget=0x" << aReply.mFocusedWidget;
if (aReply.mEventMessage == eQueryTextContent) {
aStream << ", mFontRanges={ Length()=" << aReply.mFontRanges.Length()
<< " }";
} else if (aReply.mEventMessage == eQueryTextRect ||
aReply.mEventMessage == eQueryCaretRect ||
aReply.mEventMessage == eQueryCharacterAtPoint) {
aStream << ", mRect=" << ToString(aReply.mRect).c_str();
} else if (aReply.mEventMessage == eQueryTextRectArray) {
aStream << ", mRectArray={ Length()=" << aReply.mRectArray.Length()
<< " }";
} else if (aReply.mEventMessage == eQueryDOMWidgetHittest) {
aStream << ", mWidgetIsHit="
<< (aReply.mWidgetIsHit ? "true" : "false");
}
return aStream << " }";
}
};
void EmplaceReply() { mReply.emplace(mMessage); }
Maybe<Reply> mReply;
// values of mComputedScrollAction
enum { SCROLL_ACTION_NONE, SCROLL_ACTION_LINE, SCROLL_ACTION_PAGE };
};
/******************************************************************************
* mozilla::WidgetSelectionEvent
******************************************************************************/
class WidgetSelectionEvent : public WidgetGUIEvent {
private:
friend class mozilla::dom::PBrowserParent;
friend class mozilla::dom::PBrowserChild;
ALLOW_DEPRECATED_READPARAM
WidgetSelectionEvent()
: mOffset(0),
mLength(0),
mReversed(false),
mExpandToClusterBoundary(true),
mSucceeded(false),
mUseNativeLineBreak(true),
mReason(nsISelectionListener::NO_REASON) {}
public:
virtual WidgetSelectionEvent* AsSelectionEvent() override { return this; }
WidgetSelectionEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget)
: WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eSelectionEventClass),
mOffset(0),
mLength(0),
mReversed(false),
mExpandToClusterBoundary(true),
mSucceeded(false),
mUseNativeLineBreak(true),
mReason(nsISelectionListener::NO_REASON) {}
virtual WidgetEvent* Duplicate() const override {
// This event isn't an internal event of any DOM event.
NS_ASSERTION(!IsAllowedToDispatchDOMEvent(),
"WidgetSelectionEvent needs to support Duplicate()");
MOZ_CRASH("WidgetSelectionEvent doesn't support Duplicate()");
return nullptr;
}
// Start offset of selection
uint32_t mOffset;
// Length of selection
uint32_t mLength;
// Selection "anchor" should be in front
bool mReversed;
// Cluster-based or character-based
bool mExpandToClusterBoundary;
// true if setting selection succeeded.
bool mSucceeded;
// true if native line breaks are used for mOffset and mLength
bool mUseNativeLineBreak;
// Fennec provides eSetSelection reason codes for downstream
// use in AccessibleCaret visibility logic.
int16_t mReason;
};
/******************************************************************************
* mozilla::InternalEditorInputEvent
******************************************************************************/
class InternalEditorInputEvent : public InternalUIEvent {
public:
InternalEditorInputEvent() = delete;
virtual InternalEditorInputEvent* AsEditorInputEvent() override {
return this;
}
InternalEditorInputEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget = nullptr,
const WidgetEventTime* aTime = nullptr)
: InternalUIEvent(aIsTrusted, aMessage, aWidget, eEditorInputEventClass,
aTime) {}
virtual WidgetEvent* Duplicate() const override {
MOZ_ASSERT(mClass == eEditorInputEventClass,
"Duplicate() must be overridden by sub class");
// Not copying widget, it is a weak reference.
InternalEditorInputEvent* result =
new InternalEditorInputEvent(false, mMessage, nullptr, this);
result->AssignEditorInputEventData(*this, true);
result->mFlags = mFlags;
return result;
}
nsString mData = VoidString();
RefPtr<dom::DataTransfer> mDataTransfer;
OwningNonNullStaticRangeArray mTargetRanges;
EditorInputType mInputType = EditorInputType::eUnknown;
bool mIsComposing = false;
void AssignEditorInputEventData(const InternalEditorInputEvent& aEvent,
bool aCopyTargets) {
AssignUIEventData(aEvent, aCopyTargets);
mData = aEvent.mData;
mDataTransfer = aEvent.mDataTransfer;
mTargetRanges = aEvent.mTargetRanges.Clone();
mInputType = aEvent.mInputType;
mIsComposing = aEvent.mIsComposing;
}
void GetDOMInputTypeName(nsAString& aInputTypeName) {
GetDOMInputTypeName(mInputType, aInputTypeName);
}
static void GetDOMInputTypeName(EditorInputType aInputType,
nsAString& aInputTypeName);
static EditorInputType GetEditorInputType(const nsAString& aInputType);
static void Shutdown();
private:
static const char16_t* const kInputTypeNames[];
using InputTypeHashtable = nsTHashMap<nsStringHashKey, EditorInputType>;
static InputTypeHashtable* sInputTypeHashtable;
};
/******************************************************************************
* mozilla::InternalLegacyTextEvent
******************************************************************************/
class InternalLegacyTextEvent : public InternalUIEvent {
public:
InternalLegacyTextEvent() = delete;
virtual InternalLegacyTextEvent* AsLegacyTextEvent() override { return this; }
InternalLegacyTextEvent(bool aIsTrusted, EventMessage aMessage,
nsIWidget* aWidget = nullptr,
const WidgetEventTime* aTime = nullptr)
: InternalUIEvent(aIsTrusted, aMessage, aWidget, eLegacyTextEventClass,
aTime) {}
virtual WidgetEvent* Duplicate() const override {
MOZ_ASSERT(mClass == eLegacyTextEventClass,
"Duplicate() must be overridden by sub class");
// Not copying widget, it is a weak reference.
InternalLegacyTextEvent* result =
new InternalLegacyTextEvent(false, mMessage, nullptr, this);
result->AssignLegacyTextEventData(*this, true);
result->mFlags = mFlags;
return result;
}
nsString mData;
RefPtr<dom::DataTransfer> mDataTransfer;
EditorInputType mInputType = EditorInputType::eUnknown;
void AssignLegacyTextEventData(const InternalLegacyTextEvent& aEvent,
bool aCopyTargets) {
AssignUIEventData(aEvent, aCopyTargets);
mData = aEvent.mData;
mDataTransfer = aEvent.mDataTransfer;
mInputType = aEvent.mInputType;
}
};
} // namespace mozilla
#endif // mozilla_TextEvents_h__
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку