зеркало из https://github.com/mozilla/gecko-dev.git
1794 строки
56 KiB
C++
1794 строки
56 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/dom/Event.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/StaticPrefs_test.h"
|
|
#include "mozilla/TextEventDispatcher.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/TextInputProcessor.h"
|
|
#include "mozilla/widget/IMEData.h"
|
|
#include "mozilla/dom/KeyboardEvent.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsPresContext.h"
|
|
|
|
using mozilla::dom::Event;
|
|
using mozilla::dom::KeyboardEvent;
|
|
using namespace mozilla::widget;
|
|
|
|
namespace mozilla {
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessorNotification
|
|
******************************************************************************/
|
|
|
|
class TextInputProcessorNotification final
|
|
: public nsITextInputProcessorNotification {
|
|
typedef IMENotification::SelectionChangeData SelectionChangeData;
|
|
typedef IMENotification::SelectionChangeDataBase SelectionChangeDataBase;
|
|
typedef IMENotification::TextChangeData TextChangeData;
|
|
typedef IMENotification::TextChangeDataBase TextChangeDataBase;
|
|
|
|
public:
|
|
explicit TextInputProcessorNotification(const char* aType)
|
|
: mType(aType), mTextChangeData() {}
|
|
|
|
explicit TextInputProcessorNotification(
|
|
const TextChangeDataBase& aTextChangeData)
|
|
: mType("notify-text-change"), mTextChangeData(aTextChangeData) {}
|
|
|
|
explicit TextInputProcessorNotification(
|
|
const SelectionChangeDataBase& aSelectionChangeData)
|
|
: mType("notify-selection-change"),
|
|
mSelectionChangeData(aSelectionChangeData) {
|
|
// SelectionChangeDataBase::mString still refers nsString instance owned
|
|
// by aSelectionChangeData. So, this needs to copy the instance.
|
|
nsString* string = new nsString(aSelectionChangeData.String());
|
|
mSelectionChangeData.mString = string;
|
|
}
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD GetType(nsACString& aType) final {
|
|
aType = mType;
|
|
return NS_OK;
|
|
}
|
|
|
|
// "notify-text-change" and "notify-selection-change"
|
|
NS_IMETHOD GetOffset(uint32_t* aOffset) final {
|
|
if (NS_WARN_IF(!aOffset)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aOffset = mSelectionChangeData.mOffset;
|
|
return NS_OK;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aOffset = mTextChangeData.mStartOffset;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
// "notify-selection-change"
|
|
NS_IMETHOD GetText(nsAString& aText) final {
|
|
if (IsSelectionChange()) {
|
|
aText = mSelectionChangeData.String();
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetCollapsed(bool* aCollapsed) final {
|
|
if (NS_WARN_IF(!aCollapsed)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aCollapsed = mSelectionChangeData.IsCollapsed();
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetLength(uint32_t* aLength) final {
|
|
if (NS_WARN_IF(!aLength)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aLength = mSelectionChangeData.Length();
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetReversed(bool* aReversed) final {
|
|
if (NS_WARN_IF(!aReversed)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aReversed = mSelectionChangeData.mReversed;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetWritingMode(nsACString& aWritingMode) final {
|
|
if (IsSelectionChange()) {
|
|
WritingMode writingMode = mSelectionChangeData.GetWritingMode();
|
|
if (!writingMode.IsVertical()) {
|
|
aWritingMode.AssignLiteral("horizontal-tb");
|
|
} else if (writingMode.IsVerticalLR()) {
|
|
aWritingMode.AssignLiteral("vertical-lr");
|
|
} else {
|
|
aWritingMode.AssignLiteral("vertical-rl");
|
|
}
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetCausedByComposition(bool* aCausedByComposition) final {
|
|
if (NS_WARN_IF(!aCausedByComposition)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aCausedByComposition = mSelectionChangeData.mCausedByComposition;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetCausedBySelectionEvent(bool* aCausedBySelectionEvent) final {
|
|
if (NS_WARN_IF(!aCausedBySelectionEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aCausedBySelectionEvent = mSelectionChangeData.mCausedBySelectionEvent;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetOccurredDuringComposition(
|
|
bool* aOccurredDuringComposition) final {
|
|
if (NS_WARN_IF(!aOccurredDuringComposition)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsSelectionChange()) {
|
|
*aOccurredDuringComposition =
|
|
mSelectionChangeData.mOccurredDuringComposition;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
// "notify-text-change"
|
|
NS_IMETHOD GetRemovedLength(uint32_t* aLength) final {
|
|
if (NS_WARN_IF(!aLength)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aLength = mTextChangeData.OldLength();
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetAddedLength(uint32_t* aLength) final {
|
|
if (NS_WARN_IF(!aLength)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aLength = mTextChangeData.NewLength();
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetCausedOnlyByComposition(bool* aCausedOnlyByComposition) final {
|
|
if (NS_WARN_IF(!aCausedOnlyByComposition)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aCausedOnlyByComposition = mTextChangeData.mCausedOnlyByComposition;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetIncludingChangesDuringComposition(
|
|
bool* aIncludingChangesDuringComposition) final {
|
|
if (NS_WARN_IF(!aIncludingChangesDuringComposition)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aIncludingChangesDuringComposition =
|
|
mTextChangeData.mIncludingChangesDuringComposition;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_IMETHOD GetIncludingChangesWithoutComposition(
|
|
bool* aIncludingChangesWithoutComposition) final {
|
|
if (NS_WARN_IF(!aIncludingChangesWithoutComposition)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (IsTextChange()) {
|
|
*aIncludingChangesWithoutComposition =
|
|
mTextChangeData.mIncludingChangesWithoutComposition;
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
protected:
|
|
virtual ~TextInputProcessorNotification() {
|
|
if (IsSelectionChange()) {
|
|
delete mSelectionChangeData.mString;
|
|
mSelectionChangeData.mString = nullptr;
|
|
}
|
|
}
|
|
|
|
bool IsTextChange() const {
|
|
return mType.EqualsLiteral("notify-text-change");
|
|
}
|
|
|
|
bool IsSelectionChange() const {
|
|
return mType.EqualsLiteral("notify-selection-change");
|
|
}
|
|
|
|
private:
|
|
nsAutoCString mType;
|
|
union {
|
|
TextChangeDataBase mTextChangeData;
|
|
SelectionChangeDataBase mSelectionChangeData;
|
|
};
|
|
|
|
TextInputProcessorNotification() : mTextChangeData() {}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(TextInputProcessorNotification,
|
|
nsITextInputProcessorNotification)
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessor
|
|
******************************************************************************/
|
|
|
|
NS_IMPL_ISUPPORTS(TextInputProcessor, nsITextInputProcessor,
|
|
TextEventDispatcherListener, nsISupportsWeakReference)
|
|
|
|
TextInputProcessor::TextInputProcessor()
|
|
: mDispatcher(nullptr), mForTests(false) {}
|
|
|
|
TextInputProcessor::~TextInputProcessor() {
|
|
if (mDispatcher && mDispatcher->IsComposing()) {
|
|
// If this is composing and not canceling the composition, nobody can steal
|
|
// the rights of TextEventDispatcher from this instance. Therefore, this
|
|
// needs to cancel the composition here.
|
|
if (NS_SUCCEEDED(IsValidStateForComposition())) {
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
kungFuDeathGrip->CommitComposition(status, &EmptyString());
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TextInputProcessor::IsComposing() const {
|
|
return mDispatcher && mDispatcher->IsComposing();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::GetHasComposition(bool* aHasComposition) {
|
|
MOZ_RELEASE_ASSERT(aHasComposition, "aHasComposition must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
*aHasComposition = IsComposing();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::BeginInputTransaction(
|
|
mozIDOMWindow* aWindow, nsITextInputProcessorCallback* aCallback,
|
|
bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
if (NS_WARN_IF(!aCallback)) {
|
|
*aSucceeded = false;
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return BeginInputTransactionInternal(aWindow, aCallback, false, *aSucceeded);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::BeginInputTransactionForTests(
|
|
mozIDOMWindow* aWindow, nsITextInputProcessorCallback* aCallback,
|
|
uint8_t aOptionalArgc, bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
nsITextInputProcessorCallback* callback =
|
|
aOptionalArgc >= 1 ? aCallback : nullptr;
|
|
return BeginInputTransactionInternal(aWindow, callback, true, *aSucceeded);
|
|
}
|
|
|
|
nsresult TextInputProcessor::BeginInputTransactionForFuzzing(
|
|
nsPIDOMWindowInner* aWindow, nsITextInputProcessorCallback* aCallback,
|
|
bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
return BeginInputTransactionInternal(aWindow, aCallback, false, *aSucceeded);
|
|
}
|
|
|
|
nsresult TextInputProcessor::BeginInputTransactionInternal(
|
|
mozIDOMWindow* aWindow, nsITextInputProcessorCallback* aCallback,
|
|
bool aForTests, bool& aSucceeded) {
|
|
aSucceeded = false;
|
|
if (NS_WARN_IF(!aWindow)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
nsCOMPtr<nsPIDOMWindowInner> pWindow = nsPIDOMWindowInner::From(aWindow);
|
|
if (NS_WARN_IF(!pWindow)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
nsCOMPtr<nsIDocShell> docShell(pWindow->GetDocShell());
|
|
if (NS_WARN_IF(!docShell)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
RefPtr<nsPresContext> presContext = docShell->GetPresContext();
|
|
if (NS_WARN_IF(!presContext)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
nsCOMPtr<nsIWidget> widget = presContext->GetRootWidget();
|
|
if (NS_WARN_IF(!widget)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
RefPtr<TextEventDispatcher> dispatcher = widget->GetTextEventDispatcher();
|
|
MOZ_RELEASE_ASSERT(dispatcher, "TextEventDispatcher must not be null");
|
|
|
|
// If the instance was initialized and is being initialized for same
|
|
// dispatcher and same purpose, we don't need to initialize the dispatcher
|
|
// again.
|
|
if (mDispatcher && dispatcher == mDispatcher && aCallback == mCallback &&
|
|
aForTests == mForTests) {
|
|
aSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
// If this instance is composing or dispatching an event, don't allow to
|
|
// initialize again. Especially, if we allow to begin input transaction with
|
|
// another TextEventDispatcher during dispatching an event, it may cause that
|
|
// nobody cannot begin input transaction with it if the last event causes
|
|
// opening modal dialog.
|
|
if (mDispatcher &&
|
|
(mDispatcher->IsComposing() || mDispatcher->IsDispatchingEvent())) {
|
|
return NS_ERROR_ALREADY_INITIALIZED;
|
|
}
|
|
|
|
// And also if another instance is composing with the new dispatcher or
|
|
// dispatching an event, it'll fail to steal its ownership. Then, we should
|
|
// not throw an exception, just return false.
|
|
if (dispatcher->IsComposing() || dispatcher->IsDispatchingEvent()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// This instance has finished preparing to link to the dispatcher. Therefore,
|
|
// let's forget the old dispatcher and purpose.
|
|
if (mDispatcher) {
|
|
mDispatcher->EndInputTransaction(this);
|
|
if (NS_WARN_IF(mDispatcher)) {
|
|
// Forcibly initialize the members if we failed to end the input
|
|
// transaction.
|
|
UnlinkFromTextEventDispatcher();
|
|
}
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
if (aForTests) {
|
|
bool isAPZAware = StaticPrefs::test_events_async_enabled();
|
|
rv = dispatcher->BeginTestInputTransaction(this, isAPZAware);
|
|
} else {
|
|
rv = dispatcher->BeginInputTransaction(this);
|
|
}
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
mDispatcher = dispatcher;
|
|
mCallback = aCallback;
|
|
mForTests = aForTests;
|
|
aSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
void TextInputProcessor::UnlinkFromTextEventDispatcher() {
|
|
mDispatcher = nullptr;
|
|
mForTests = false;
|
|
if (mCallback) {
|
|
nsCOMPtr<nsITextInputProcessorCallback> callback(mCallback);
|
|
mCallback = nullptr;
|
|
|
|
RefPtr<TextInputProcessorNotification> notification =
|
|
new TextInputProcessorNotification("notify-end-input-transaction");
|
|
bool result = false;
|
|
callback->OnNotify(this, notification, &result);
|
|
}
|
|
}
|
|
|
|
nsresult TextInputProcessor::IsValidStateForComposition() {
|
|
if (NS_WARN_IF(!mDispatcher)) {
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
|
|
nsresult rv = mDispatcher->GetState();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool TextInputProcessor::IsValidEventTypeForComposition(
|
|
const WidgetKeyboardEvent& aKeyboardEvent) const {
|
|
// The key event type of composition methods must be "", "keydown" or "keyup".
|
|
if (aKeyboardEvent.mMessage == eKeyDown ||
|
|
aKeyboardEvent.mMessage == eKeyUp) {
|
|
return true;
|
|
}
|
|
if (aKeyboardEvent.mMessage == eUnidentifiedEvent &&
|
|
aKeyboardEvent.mSpecifiedEventType &&
|
|
nsDependentAtomString(aKeyboardEvent.mSpecifiedEventType)
|
|
.EqualsLiteral("on")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
TextInputProcessor::EventDispatcherResult
|
|
TextInputProcessor::MaybeDispatchKeydownForComposition(
|
|
const WidgetKeyboardEvent* aKeyboardEvent, uint32_t aKeyFlags) {
|
|
EventDispatcherResult result;
|
|
|
|
result.mResult = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(result.mResult))) {
|
|
result.mCanContinue = false;
|
|
return result;
|
|
}
|
|
|
|
if (!aKeyboardEvent) {
|
|
return result;
|
|
}
|
|
|
|
// If the mMessage is eKeyUp, the caller doesn't want TIP to dispatch
|
|
// eKeyDown event.
|
|
if (aKeyboardEvent->mMessage == eKeyUp) {
|
|
return result;
|
|
}
|
|
|
|
// Modifier keys are not allowed because managing modifier state in this
|
|
// method makes this messy.
|
|
if (NS_WARN_IF(aKeyboardEvent->IsModifierKeyEvent())) {
|
|
result.mResult = NS_ERROR_INVALID_ARG;
|
|
result.mCanContinue = false;
|
|
return result;
|
|
}
|
|
|
|
uint32_t consumedFlags = 0;
|
|
|
|
result.mResult =
|
|
KeydownInternal(*aKeyboardEvent, aKeyFlags, false, consumedFlags);
|
|
result.mDoDefault = !consumedFlags;
|
|
if (NS_WARN_IF(NS_FAILED(result.mResult))) {
|
|
result.mCanContinue = false;
|
|
return result;
|
|
}
|
|
|
|
result.mCanContinue = NS_SUCCEEDED(IsValidStateForComposition());
|
|
return result;
|
|
}
|
|
|
|
TextInputProcessor::EventDispatcherResult
|
|
TextInputProcessor::MaybeDispatchKeyupForComposition(
|
|
const WidgetKeyboardEvent* aKeyboardEvent, uint32_t aKeyFlags) {
|
|
EventDispatcherResult result;
|
|
|
|
if (!aKeyboardEvent) {
|
|
return result;
|
|
}
|
|
|
|
// If the mMessage is eKeyDown, the caller doesn't want TIP to dispatch
|
|
// eKeyUp event.
|
|
if (aKeyboardEvent->mMessage == eKeyDown) {
|
|
return result;
|
|
}
|
|
|
|
// If the widget has been destroyed, we can do nothing here.
|
|
result.mResult = IsValidStateForComposition();
|
|
if (NS_FAILED(result.mResult)) {
|
|
result.mCanContinue = false;
|
|
return result;
|
|
}
|
|
|
|
result.mResult = KeyupInternal(*aKeyboardEvent, aKeyFlags, result.mDoDefault);
|
|
if (NS_WARN_IF(NS_FAILED(result.mResult))) {
|
|
result.mCanContinue = false;
|
|
return result;
|
|
}
|
|
|
|
result.mCanContinue = NS_SUCCEEDED(IsValidStateForComposition());
|
|
return result;
|
|
}
|
|
|
|
nsresult TextInputProcessor::PrepareKeyboardEventForComposition(
|
|
KeyboardEvent* aDOMKeyEvent, uint32_t& aKeyFlags, uint8_t aOptionalArgc,
|
|
WidgetKeyboardEvent*& aKeyboardEvent) {
|
|
aKeyboardEvent = nullptr;
|
|
|
|
aKeyboardEvent = aOptionalArgc && aDOMKeyEvent
|
|
? aDOMKeyEvent->WidgetEventPtr()->AsKeyboardEvent()
|
|
: nullptr;
|
|
if (!aKeyboardEvent || aOptionalArgc < 2) {
|
|
aKeyFlags = 0;
|
|
}
|
|
|
|
if (!aKeyboardEvent) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (NS_WARN_IF(!IsValidEventTypeForComposition(*aKeyboardEvent))) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::StartComposition(Event* aDOMKeyEvent, uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc, bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
*aSucceeded = false;
|
|
|
|
RefPtr<KeyboardEvent> keyEvent;
|
|
if (aDOMKeyEvent) {
|
|
keyEvent = aDOMKeyEvent->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!keyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv = PrepareKeyboardEventForComposition(
|
|
keyEvent, aKeyFlags, aOptionalArgc, keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
EventDispatcherResult dispatcherResult =
|
|
MaybeDispatchKeydownForComposition(keyboardEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(dispatcherResult.mResult)) ||
|
|
!dispatcherResult.mCanContinue) {
|
|
return dispatcherResult.mResult;
|
|
}
|
|
|
|
if (dispatcherResult.mDoDefault) {
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
rv = kungFuDeathGrip->StartComposition(status);
|
|
*aSucceeded = status != nsEventStatus_eConsumeNoDefault &&
|
|
kungFuDeathGrip && kungFuDeathGrip->IsComposing();
|
|
}
|
|
|
|
MaybeDispatchKeyupForComposition(keyboardEvent, aKeyFlags);
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::SetPendingCompositionString(const nsAString& aString) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
nsresult rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return kungFuDeathGrip->SetPendingCompositionString(aString);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::AppendClauseToPendingComposition(uint32_t aLength,
|
|
uint32_t aAttribute) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
TextRangeType textRangeType;
|
|
switch (aAttribute) {
|
|
case ATTR_RAW_CLAUSE:
|
|
case ATTR_SELECTED_RAW_CLAUSE:
|
|
case ATTR_CONVERTED_CLAUSE:
|
|
case ATTR_SELECTED_CLAUSE:
|
|
textRangeType = ToTextRangeType(aAttribute);
|
|
break;
|
|
default:
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
nsresult rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return kungFuDeathGrip->AppendClauseToPendingComposition(aLength,
|
|
textRangeType);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::SetCaretInPendingComposition(uint32_t aOffset) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
nsresult rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return kungFuDeathGrip->SetCaretInPendingComposition(aOffset, 0);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::FlushPendingComposition(Event* aDOMKeyEvent,
|
|
uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc,
|
|
bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
// Even if this doesn't flush pending composition actually, we need to reset
|
|
// pending composition for starting next composition with new user input.
|
|
AutoPendingCompositionResetter resetter(this);
|
|
|
|
*aSucceeded = false;
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
bool wasComposing = IsComposing();
|
|
|
|
RefPtr<KeyboardEvent> keyEvent;
|
|
if (aDOMKeyEvent) {
|
|
keyEvent = aDOMKeyEvent->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!keyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv = PrepareKeyboardEventForComposition(
|
|
keyEvent, aKeyFlags, aOptionalArgc, keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
EventDispatcherResult dispatcherResult =
|
|
MaybeDispatchKeydownForComposition(keyboardEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(dispatcherResult.mResult)) ||
|
|
!dispatcherResult.mCanContinue) {
|
|
return dispatcherResult.mResult;
|
|
}
|
|
|
|
// Even if the preceding keydown event was consumed, if the composition
|
|
// was already started, we shouldn't prevent the change of composition.
|
|
if (dispatcherResult.mDoDefault || wasComposing) {
|
|
// Preceding keydown event may cause destroying the widget.
|
|
if (NS_FAILED(IsValidStateForComposition())) {
|
|
return NS_OK;
|
|
}
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
rv = kungFuDeathGrip->FlushPendingComposition(status);
|
|
*aSucceeded = status != nsEventStatus_eConsumeNoDefault;
|
|
}
|
|
|
|
MaybeDispatchKeyupForComposition(keyboardEvent, aKeyFlags);
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::CommitComposition(Event* aDOMKeyEvent, uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
RefPtr<KeyboardEvent> keyEvent;
|
|
if (aDOMKeyEvent) {
|
|
keyEvent = aDOMKeyEvent->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!keyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv = PrepareKeyboardEventForComposition(
|
|
keyEvent, aKeyFlags, aOptionalArgc, keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return CommitCompositionInternal(keyboardEvent, aKeyFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::CommitCompositionWith(const nsAString& aCommitString,
|
|
Event* aDOMKeyEvent,
|
|
uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc,
|
|
bool* aSucceeded) {
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
RefPtr<KeyboardEvent> keyEvent;
|
|
if (aDOMKeyEvent) {
|
|
keyEvent = aDOMKeyEvent->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!keyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv = PrepareKeyboardEventForComposition(
|
|
keyEvent, aKeyFlags, aOptionalArgc, keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return CommitCompositionInternal(keyboardEvent, aKeyFlags, &aCommitString,
|
|
aSucceeded);
|
|
}
|
|
|
|
nsresult TextInputProcessor::CommitCompositionInternal(
|
|
const WidgetKeyboardEvent* aKeyboardEvent, uint32_t aKeyFlags,
|
|
const nsAString* aCommitString, bool* aSucceeded) {
|
|
if (aSucceeded) {
|
|
*aSucceeded = false;
|
|
}
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
bool wasComposing = IsComposing();
|
|
|
|
EventDispatcherResult dispatcherResult =
|
|
MaybeDispatchKeydownForComposition(aKeyboardEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(dispatcherResult.mResult)) ||
|
|
!dispatcherResult.mCanContinue) {
|
|
return dispatcherResult.mResult;
|
|
}
|
|
|
|
// Even if the preceding keydown event was consumed, if the composition
|
|
// was already started, we shouldn't prevent the commit of composition.
|
|
nsresult rv = NS_OK;
|
|
if (dispatcherResult.mDoDefault || wasComposing) {
|
|
// Preceding keydown event may cause destroying the widget.
|
|
if (NS_FAILED(IsValidStateForComposition())) {
|
|
return NS_OK;
|
|
}
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
rv = kungFuDeathGrip->CommitComposition(status, aCommitString);
|
|
if (aSucceeded) {
|
|
*aSucceeded = status != nsEventStatus_eConsumeNoDefault;
|
|
}
|
|
}
|
|
|
|
MaybeDispatchKeyupForComposition(aKeyboardEvent, aKeyFlags);
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::CancelComposition(Event* aDOMKeyEvent, uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
RefPtr<KeyboardEvent> keyEvent;
|
|
if (aDOMKeyEvent) {
|
|
keyEvent = aDOMKeyEvent->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!keyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv = PrepareKeyboardEventForComposition(
|
|
keyEvent, aKeyFlags, aOptionalArgc, keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return CancelCompositionInternal(keyboardEvent, aKeyFlags);
|
|
}
|
|
|
|
nsresult TextInputProcessor::CancelCompositionInternal(
|
|
const WidgetKeyboardEvent* aKeyboardEvent, uint32_t aKeyFlags) {
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
|
|
EventDispatcherResult dispatcherResult =
|
|
MaybeDispatchKeydownForComposition(aKeyboardEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(dispatcherResult.mResult)) ||
|
|
!dispatcherResult.mCanContinue) {
|
|
return dispatcherResult.mResult;
|
|
}
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsresult rv = kungFuDeathGrip->CommitComposition(status, &EmptyString());
|
|
|
|
MaybeDispatchKeyupForComposition(aKeyboardEvent, aKeyFlags);
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::NotifyIME(TextEventDispatcher* aTextEventDispatcher,
|
|
const IMENotification& aNotification) {
|
|
// If This is called while this is being initialized, ignore the call.
|
|
// In such case, this method should return NS_ERROR_NOT_IMPLEMENTED because
|
|
// we can say, TextInputProcessor doesn't implement any handlers of the
|
|
// requests and notifications.
|
|
if (!mDispatcher) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
MOZ_ASSERT(aTextEventDispatcher == mDispatcher,
|
|
"Wrong TextEventDispatcher notifies this");
|
|
NS_ASSERTION(mForTests || mCallback,
|
|
"mCallback can be null only when IME is initialized for tests");
|
|
if (mCallback) {
|
|
RefPtr<TextInputProcessorNotification> notification;
|
|
switch (aNotification.mMessage) {
|
|
case REQUEST_TO_COMMIT_COMPOSITION: {
|
|
NS_ASSERTION(aTextEventDispatcher->IsComposing(),
|
|
"Why is this requested without composition?");
|
|
notification = new TextInputProcessorNotification("request-to-commit");
|
|
break;
|
|
}
|
|
case REQUEST_TO_CANCEL_COMPOSITION: {
|
|
NS_ASSERTION(aTextEventDispatcher->IsComposing(),
|
|
"Why is this requested without composition?");
|
|
notification = new TextInputProcessorNotification("request-to-cancel");
|
|
break;
|
|
}
|
|
case NOTIFY_IME_OF_FOCUS:
|
|
notification = new TextInputProcessorNotification("notify-focus");
|
|
break;
|
|
case NOTIFY_IME_OF_BLUR:
|
|
notification = new TextInputProcessorNotification("notify-blur");
|
|
break;
|
|
case NOTIFY_IME_OF_TEXT_CHANGE:
|
|
notification =
|
|
new TextInputProcessorNotification(aNotification.mTextChangeData);
|
|
break;
|
|
case NOTIFY_IME_OF_SELECTION_CHANGE:
|
|
notification = new TextInputProcessorNotification(
|
|
aNotification.mSelectionChangeData);
|
|
break;
|
|
case NOTIFY_IME_OF_POSITION_CHANGE:
|
|
notification =
|
|
new TextInputProcessorNotification("notify-position-change");
|
|
break;
|
|
default:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
MOZ_RELEASE_ASSERT(notification);
|
|
bool result = false;
|
|
nsresult rv = mCallback->OnNotify(this, notification, &result);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return result ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
switch (aNotification.mMessage) {
|
|
case REQUEST_TO_COMMIT_COMPOSITION: {
|
|
NS_ASSERTION(aTextEventDispatcher->IsComposing(),
|
|
"Why is this requested without composition?");
|
|
CommitCompositionInternal();
|
|
return NS_OK;
|
|
}
|
|
case REQUEST_TO_CANCEL_COMPOSITION: {
|
|
NS_ASSERTION(aTextEventDispatcher->IsComposing(),
|
|
"Why is this requested without composition?");
|
|
CancelCompositionInternal();
|
|
return NS_OK;
|
|
}
|
|
default:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP_(IMENotificationRequests)
|
|
TextInputProcessor::GetIMENotificationRequests() {
|
|
// TextInputProcessor should support all change notifications.
|
|
return IMENotificationRequests(
|
|
IMENotificationRequests::NOTIFY_TEXT_CHANGE |
|
|
IMENotificationRequests::NOTIFY_POSITION_CHANGE);
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
TextInputProcessor::OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher) {
|
|
// If This is called while this is being initialized, ignore the call.
|
|
if (!mDispatcher) {
|
|
return;
|
|
}
|
|
MOZ_ASSERT(aTextEventDispatcher == mDispatcher,
|
|
"Wrong TextEventDispatcher notifies this");
|
|
UnlinkFromTextEventDispatcher();
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
TextInputProcessor::WillDispatchKeyboardEvent(
|
|
TextEventDispatcher* aTextEventDispatcher,
|
|
WidgetKeyboardEvent& aKeyboardEvent, uint32_t aIndexOfKeypress,
|
|
void* aData) {
|
|
// TextInputProcessor doesn't set alternative char code nor modify charCode
|
|
// even when Ctrl key is pressed.
|
|
}
|
|
|
|
nsresult TextInputProcessor::PrepareKeyboardEventToDispatch(
|
|
WidgetKeyboardEvent& aKeyboardEvent, uint32_t aKeyFlags) {
|
|
if (NS_WARN_IF(aKeyboardEvent.mCodeNameIndex == CODE_NAME_INDEX_USE_STRING)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if ((aKeyFlags & KEY_NON_PRINTABLE_KEY) &&
|
|
NS_WARN_IF(aKeyboardEvent.mKeyNameIndex == KEY_NAME_INDEX_USE_STRING)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if ((aKeyFlags & KEY_FORCE_PRINTABLE_KEY) &&
|
|
aKeyboardEvent.mKeyNameIndex != KEY_NAME_INDEX_USE_STRING) {
|
|
aKeyboardEvent.GetDOMKeyName(aKeyboardEvent.mKeyValue);
|
|
aKeyboardEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
|
|
}
|
|
if (aKeyFlags & KEY_KEEP_KEY_LOCATION_STANDARD) {
|
|
// If .location is initialized with specific value, using
|
|
// KEY_KEEP_KEY_LOCATION_STANDARD must be a bug of the caller.
|
|
// Let's throw an exception for notifying the developer of this bug.
|
|
if (NS_WARN_IF(aKeyboardEvent.mLocation)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
} else if (!aKeyboardEvent.mLocation) {
|
|
// If KeyboardEvent.mLocation is 0, it may be uninitialized. If so, we
|
|
// should compute proper mLocation value from its .code value.
|
|
aKeyboardEvent.mLocation =
|
|
WidgetKeyboardEvent::ComputeLocationFromCodeValue(
|
|
aKeyboardEvent.mCodeNameIndex);
|
|
}
|
|
|
|
if (aKeyFlags & KEY_KEEP_KEYCODE_ZERO) {
|
|
// If .keyCode is initialized with specific value, using
|
|
// KEY_KEEP_KEYCODE_ZERO must be a bug of the caller. Let's throw an
|
|
// exception for notifying the developer of such bug.
|
|
if (NS_WARN_IF(aKeyboardEvent.mKeyCode)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
} else if (!aKeyboardEvent.mKeyCode &&
|
|
aKeyboardEvent.mKeyNameIndex > KEY_NAME_INDEX_Unidentified &&
|
|
aKeyboardEvent.mKeyNameIndex < KEY_NAME_INDEX_USE_STRING) {
|
|
// If KeyboardEvent.keyCode is 0, it may be uninitialized. If so, we may
|
|
// be able to decide a good .keyCode value if the .key value is a
|
|
// non-printable key.
|
|
aKeyboardEvent.mKeyCode =
|
|
WidgetKeyboardEvent::ComputeKeyCodeFromKeyNameIndex(
|
|
aKeyboardEvent.mKeyNameIndex);
|
|
}
|
|
|
|
aKeyboardEvent.mIsSynthesizedByTIP = !mForTests;
|
|
|
|
// When this emulates real input only in content process, we need to
|
|
// initialize edit commands with the main process's widget via PuppetWidget
|
|
// because they are initialized by BrowserParent before content process treats
|
|
// them.
|
|
if (aKeyboardEvent.mIsSynthesizedByTIP && !XRE_IsParentProcess()) {
|
|
// Note that retrieving edit commands from content process is expensive.
|
|
// Let's skip it when the keyboard event is inputting text.
|
|
if (!aKeyboardEvent.IsInputtingText()) {
|
|
// FYI: WidgetKeyboardEvent::InitAllEditCommands() isn't available here
|
|
// since it checks whether it's called in the main process to
|
|
// avoid performance issues so that we need to initialize each
|
|
// command manually here.
|
|
if (NS_WARN_IF(!aKeyboardEvent.InitEditCommandsFor(
|
|
nsIWidget::NativeKeyBindingsForSingleLineEditor))) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
if (NS_WARN_IF(!aKeyboardEvent.InitEditCommandsFor(
|
|
nsIWidget::NativeKeyBindingsForMultiLineEditor))) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
if (NS_WARN_IF(!aKeyboardEvent.InitEditCommandsFor(
|
|
nsIWidget::NativeKeyBindingsForRichTextEditor))) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
} else {
|
|
aKeyboardEvent.PreventNativeKeyBindings();
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::Keydown(Event* aDOMKeyEvent, uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc, uint32_t* aConsumedFlags) {
|
|
MOZ_RELEASE_ASSERT(aConsumedFlags, "aConsumedFlags must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
if (!aOptionalArgc) {
|
|
aKeyFlags = 0;
|
|
}
|
|
if (NS_WARN_IF(!aDOMKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
WidgetKeyboardEvent* originalKeyEvent =
|
|
aDOMKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!originalKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return KeydownInternal(*originalKeyEvent, aKeyFlags, true, *aConsumedFlags);
|
|
}
|
|
|
|
nsresult TextInputProcessor::Keydown(const WidgetKeyboardEvent& aKeyboardEvent,
|
|
uint32_t aKeyFlags,
|
|
uint32_t* aConsumedFlags) {
|
|
uint32_t consumedFlags = 0;
|
|
return KeydownInternal(aKeyboardEvent, aKeyFlags, true,
|
|
aConsumedFlags ? *aConsumedFlags : consumedFlags);
|
|
}
|
|
|
|
nsresult TextInputProcessor::KeydownInternal(
|
|
const WidgetKeyboardEvent& aKeyboardEvent, uint32_t aKeyFlags,
|
|
bool aAllowToDispatchKeypress, uint32_t& aConsumedFlags) {
|
|
aConsumedFlags = KEYEVENT_NOT_CONSUMED;
|
|
|
|
// We shouldn't modify the internal WidgetKeyboardEvent.
|
|
WidgetKeyboardEvent keyEvent(aKeyboardEvent);
|
|
nsresult rv = PrepareKeyboardEventToDispatch(keyEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
aConsumedFlags = (aKeyFlags & KEY_DEFAULT_PREVENTED) ? KEYDOWN_IS_CONSUMED
|
|
: KEYEVENT_NOT_CONSUMED;
|
|
|
|
if (WidgetKeyboardEvent::GetModifierForKeyName(keyEvent.mKeyNameIndex)) {
|
|
ModifierKeyData modifierKeyData(keyEvent);
|
|
if (WidgetKeyboardEvent::IsLockableModifier(keyEvent.mKeyNameIndex)) {
|
|
// If the modifier key is lockable modifier key such as CapsLock,
|
|
// let's toggle modifier key state at keydown.
|
|
ToggleModifierKey(modifierKeyData);
|
|
} else {
|
|
// Activate modifier flag before dispatching keydown event (i.e., keydown
|
|
// event should indicate the releasing modifier is active.
|
|
ActivateModifierKey(modifierKeyData);
|
|
}
|
|
if (aKeyFlags & KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT) {
|
|
return NS_OK;
|
|
}
|
|
} else if (NS_WARN_IF(aKeyFlags & KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
keyEvent.mModifiers = GetActiveModifiers();
|
|
|
|
if (!aAllowToDispatchKeypress &&
|
|
!(aKeyFlags & KEY_DONT_MARK_KEYDOWN_AS_PROCESSED)) {
|
|
keyEvent.mKeyCode = NS_VK_PROCESSKEY;
|
|
keyEvent.mKeyNameIndex = KEY_NAME_INDEX_Process;
|
|
}
|
|
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsEventStatus status =
|
|
aConsumedFlags ? nsEventStatus_eConsumeNoDefault : nsEventStatus_eIgnore;
|
|
if (!kungFuDeathGrip->DispatchKeyboardEvent(eKeyDown, keyEvent, status)) {
|
|
// If keydown event isn't dispatched, we don't need to dispatch keypress
|
|
// events.
|
|
return NS_OK;
|
|
}
|
|
|
|
aConsumedFlags |= (status == nsEventStatus_eConsumeNoDefault)
|
|
? KEYDOWN_IS_CONSUMED
|
|
: KEYEVENT_NOT_CONSUMED;
|
|
|
|
if (aAllowToDispatchKeypress &&
|
|
kungFuDeathGrip->MaybeDispatchKeypressEvents(keyEvent, status)) {
|
|
aConsumedFlags |= (status == nsEventStatus_eConsumeNoDefault)
|
|
? KEYPRESS_IS_CONSUMED
|
|
: KEYEVENT_NOT_CONSUMED;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::Keyup(Event* aDOMKeyEvent, uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc, bool* aDoDefault) {
|
|
MOZ_RELEASE_ASSERT(aDoDefault, "aDoDefault must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
if (!aOptionalArgc) {
|
|
aKeyFlags = 0;
|
|
}
|
|
if (NS_WARN_IF(!aDOMKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
WidgetKeyboardEvent* originalKeyEvent =
|
|
aDOMKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!originalKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return KeyupInternal(*originalKeyEvent, aKeyFlags, *aDoDefault);
|
|
}
|
|
|
|
nsresult TextInputProcessor::Keyup(const WidgetKeyboardEvent& aKeyboardEvent,
|
|
uint32_t aKeyFlags, bool* aDoDefault) {
|
|
bool doDefault = false;
|
|
return KeyupInternal(aKeyboardEvent, aKeyFlags,
|
|
aDoDefault ? *aDoDefault : doDefault);
|
|
}
|
|
|
|
nsresult TextInputProcessor::KeyupInternal(
|
|
const WidgetKeyboardEvent& aKeyboardEvent, uint32_t aKeyFlags,
|
|
bool& aDoDefault) {
|
|
aDoDefault = false;
|
|
|
|
// We shouldn't modify the internal WidgetKeyboardEvent.
|
|
WidgetKeyboardEvent keyEvent(aKeyboardEvent);
|
|
nsresult rv = PrepareKeyboardEventToDispatch(keyEvent, aKeyFlags);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
aDoDefault = !(aKeyFlags & KEY_DEFAULT_PREVENTED);
|
|
|
|
if (WidgetKeyboardEvent::GetModifierForKeyName(keyEvent.mKeyNameIndex)) {
|
|
if (!WidgetKeyboardEvent::IsLockableModifier(keyEvent.mKeyNameIndex)) {
|
|
// Inactivate modifier flag before dispatching keyup event (i.e., keyup
|
|
// event shouldn't indicate the releasing modifier is active.
|
|
InactivateModifierKey(ModifierKeyData(keyEvent));
|
|
}
|
|
if (aKeyFlags & KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT) {
|
|
return NS_OK;
|
|
}
|
|
} else if (NS_WARN_IF(aKeyFlags & KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
keyEvent.mModifiers = GetActiveModifiers();
|
|
|
|
if (aKeyFlags & KEY_MARK_KEYUP_AS_PROCESSED) {
|
|
keyEvent.mKeyCode = NS_VK_PROCESSKEY;
|
|
keyEvent.mKeyNameIndex = KEY_NAME_INDEX_Process;
|
|
}
|
|
|
|
RefPtr<TextEventDispatcher> kungFuDeathGrip(mDispatcher);
|
|
rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsEventStatus status =
|
|
aDoDefault ? nsEventStatus_eIgnore : nsEventStatus_eConsumeNoDefault;
|
|
kungFuDeathGrip->DispatchKeyboardEvent(eKeyUp, keyEvent, status);
|
|
aDoDefault = (status != nsEventStatus_eConsumeNoDefault);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::GetModifierState(const nsAString& aModifierKeyName,
|
|
bool* aActive) {
|
|
MOZ_RELEASE_ASSERT(aActive, "aActive must not be null");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
Modifiers modifier = WidgetInputEvent::GetModifier(aModifierKeyName);
|
|
*aActive = ((GetActiveModifiers() & modifier) != 0);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::ShareModifierStateOf(nsITextInputProcessor* aOther) {
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
if (!aOther) {
|
|
mModifierKeyDataArray = nullptr;
|
|
return NS_OK;
|
|
}
|
|
TextInputProcessor* other = static_cast<TextInputProcessor*>(aOther);
|
|
if (!other->mModifierKeyDataArray) {
|
|
other->mModifierKeyDataArray = new ModifierKeyDataArray();
|
|
}
|
|
mModifierKeyDataArray = other->mModifierKeyDataArray;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::ComputeCodeValueOfNonPrintableKey(
|
|
const nsAString& aKeyValue, JS::Handle<JS::Value> aLocation,
|
|
uint8_t aOptionalArgc, nsAString& aCodeValue) {
|
|
aCodeValue.Truncate();
|
|
|
|
Maybe<uint32_t> location;
|
|
if (aOptionalArgc) {
|
|
if (aLocation.isNullOrUndefined()) {
|
|
// location should be nothing.
|
|
} else if (aLocation.isInt32()) {
|
|
location = mozilla::Some(static_cast<uint32_t>(aLocation.toInt32()));
|
|
} else {
|
|
NS_WARNING_ASSERTION(aLocation.isNullOrUndefined() || aLocation.isInt32(),
|
|
"aLocation must be undefined, null or int");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
KeyNameIndex keyNameIndex = WidgetKeyboardEvent::GetKeyNameIndex(aKeyValue);
|
|
if (keyNameIndex == KEY_NAME_INDEX_Unidentified ||
|
|
keyNameIndex == KEY_NAME_INDEX_USE_STRING) {
|
|
return NS_OK;
|
|
}
|
|
|
|
CodeNameIndex codeNameIndex =
|
|
WidgetKeyboardEvent::ComputeCodeNameIndexFromKeyNameIndex(keyNameIndex,
|
|
location);
|
|
if (codeNameIndex == CODE_NAME_INDEX_UNKNOWN) {
|
|
return NS_OK;
|
|
}
|
|
MOZ_ASSERT(codeNameIndex != CODE_NAME_INDEX_USE_STRING);
|
|
WidgetKeyboardEvent::GetDOMCodeName(codeNameIndex, aCodeValue);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::GuessCodeValueOfPrintableKeyInUSEnglishKeyboardLayout(
|
|
const nsAString& aKeyValue, JS::Handle<JS::Value> aLocation,
|
|
uint8_t aOptionalArgc, nsAString& aCodeValue) {
|
|
aCodeValue.Truncate();
|
|
|
|
Maybe<uint32_t> location;
|
|
if (aOptionalArgc) {
|
|
if (aLocation.isNullOrUndefined()) {
|
|
// location should be nothing.
|
|
} else if (aLocation.isInt32()) {
|
|
location = mozilla::Some(static_cast<uint32_t>(aLocation.toInt32()));
|
|
} else {
|
|
NS_WARNING_ASSERTION(aLocation.isNullOrUndefined() || aLocation.isInt32(),
|
|
"aLocation must be undefined, null or int");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
CodeNameIndex codeNameIndex =
|
|
GuessCodeNameIndexOfPrintableKeyInUSEnglishLayout(aKeyValue, location);
|
|
if (codeNameIndex == CODE_NAME_INDEX_UNKNOWN) {
|
|
return NS_OK;
|
|
}
|
|
MOZ_ASSERT(codeNameIndex != CODE_NAME_INDEX_USE_STRING);
|
|
WidgetKeyboardEvent::GetDOMCodeName(codeNameIndex, aCodeValue);
|
|
return NS_OK;
|
|
}
|
|
|
|
// static
|
|
CodeNameIndex
|
|
TextInputProcessor::GuessCodeNameIndexOfPrintableKeyInUSEnglishLayout(
|
|
const nsAString& aKeyValue, const Maybe<uint32_t>& aLocation) {
|
|
if (aKeyValue.IsEmpty()) {
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
// US keyboard layout can input only one character per key. So, we can
|
|
// assume that if the key value is 2 or more characters, it's a known
|
|
// key name or not a usual key emulation.
|
|
if (aKeyValue.Length() > 1) {
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
if (aLocation.isSome() &&
|
|
aLocation.value() ==
|
|
dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD) {
|
|
switch (aKeyValue[0]) {
|
|
case '+':
|
|
return CODE_NAME_INDEX_NumpadAdd;
|
|
case '-':
|
|
return CODE_NAME_INDEX_NumpadSubtract;
|
|
case '*':
|
|
return CODE_NAME_INDEX_NumpadMultiply;
|
|
case '/':
|
|
return CODE_NAME_INDEX_NumpadDivide;
|
|
case '.':
|
|
return CODE_NAME_INDEX_NumpadDecimal;
|
|
case '0':
|
|
return CODE_NAME_INDEX_Numpad0;
|
|
case '1':
|
|
return CODE_NAME_INDEX_Numpad1;
|
|
case '2':
|
|
return CODE_NAME_INDEX_Numpad2;
|
|
case '3':
|
|
return CODE_NAME_INDEX_Numpad3;
|
|
case '4':
|
|
return CODE_NAME_INDEX_Numpad4;
|
|
case '5':
|
|
return CODE_NAME_INDEX_Numpad5;
|
|
case '6':
|
|
return CODE_NAME_INDEX_Numpad6;
|
|
case '7':
|
|
return CODE_NAME_INDEX_Numpad7;
|
|
case '8':
|
|
return CODE_NAME_INDEX_Numpad8;
|
|
case '9':
|
|
return CODE_NAME_INDEX_Numpad9;
|
|
default:
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
if (aLocation.isSome() &&
|
|
aLocation.value() !=
|
|
dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_STANDARD) {
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
|
|
// TODO: Support characters inputted with option key on macOS.
|
|
switch (aKeyValue[0]) {
|
|
case 'a':
|
|
case 'A':
|
|
return CODE_NAME_INDEX_KeyA;
|
|
case 'b':
|
|
case 'B':
|
|
return CODE_NAME_INDEX_KeyB;
|
|
case 'c':
|
|
case 'C':
|
|
return CODE_NAME_INDEX_KeyC;
|
|
case 'd':
|
|
case 'D':
|
|
return CODE_NAME_INDEX_KeyD;
|
|
case 'e':
|
|
case 'E':
|
|
return CODE_NAME_INDEX_KeyE;
|
|
case 'f':
|
|
case 'F':
|
|
return CODE_NAME_INDEX_KeyF;
|
|
case 'g':
|
|
case 'G':
|
|
return CODE_NAME_INDEX_KeyG;
|
|
case 'h':
|
|
case 'H':
|
|
return CODE_NAME_INDEX_KeyH;
|
|
case 'i':
|
|
case 'I':
|
|
return CODE_NAME_INDEX_KeyI;
|
|
case 'j':
|
|
case 'J':
|
|
return CODE_NAME_INDEX_KeyJ;
|
|
case 'k':
|
|
case 'K':
|
|
return CODE_NAME_INDEX_KeyK;
|
|
case 'l':
|
|
case 'L':
|
|
return CODE_NAME_INDEX_KeyL;
|
|
case 'm':
|
|
case 'M':
|
|
return CODE_NAME_INDEX_KeyM;
|
|
case 'n':
|
|
case 'N':
|
|
return CODE_NAME_INDEX_KeyN;
|
|
case 'o':
|
|
case 'O':
|
|
return CODE_NAME_INDEX_KeyO;
|
|
case 'p':
|
|
case 'P':
|
|
return CODE_NAME_INDEX_KeyP;
|
|
case 'q':
|
|
case 'Q':
|
|
return CODE_NAME_INDEX_KeyQ;
|
|
case 'r':
|
|
case 'R':
|
|
return CODE_NAME_INDEX_KeyR;
|
|
case 's':
|
|
case 'S':
|
|
return CODE_NAME_INDEX_KeyS;
|
|
case 't':
|
|
case 'T':
|
|
return CODE_NAME_INDEX_KeyT;
|
|
case 'u':
|
|
case 'U':
|
|
return CODE_NAME_INDEX_KeyU;
|
|
case 'v':
|
|
case 'V':
|
|
return CODE_NAME_INDEX_KeyV;
|
|
case 'w':
|
|
case 'W':
|
|
return CODE_NAME_INDEX_KeyW;
|
|
case 'x':
|
|
case 'X':
|
|
return CODE_NAME_INDEX_KeyX;
|
|
case 'y':
|
|
case 'Y':
|
|
return CODE_NAME_INDEX_KeyY;
|
|
case 'z':
|
|
case 'Z':
|
|
return CODE_NAME_INDEX_KeyZ;
|
|
|
|
case '`':
|
|
case '~':
|
|
return CODE_NAME_INDEX_Backquote;
|
|
case '1':
|
|
case '!':
|
|
return CODE_NAME_INDEX_Digit1;
|
|
case '2':
|
|
case '@':
|
|
return CODE_NAME_INDEX_Digit2;
|
|
case '3':
|
|
case '#':
|
|
return CODE_NAME_INDEX_Digit3;
|
|
case '4':
|
|
case '$':
|
|
return CODE_NAME_INDEX_Digit4;
|
|
case '5':
|
|
case '%':
|
|
return CODE_NAME_INDEX_Digit5;
|
|
case '6':
|
|
case '^':
|
|
return CODE_NAME_INDEX_Digit6;
|
|
case '7':
|
|
case '&':
|
|
return CODE_NAME_INDEX_Digit7;
|
|
case '8':
|
|
case '*':
|
|
return CODE_NAME_INDEX_Digit8;
|
|
case '9':
|
|
case '(':
|
|
return CODE_NAME_INDEX_Digit9;
|
|
case '0':
|
|
case ')':
|
|
return CODE_NAME_INDEX_Digit0;
|
|
case '-':
|
|
case '_':
|
|
return CODE_NAME_INDEX_Minus;
|
|
case '=':
|
|
case '+':
|
|
return CODE_NAME_INDEX_Equal;
|
|
|
|
case '[':
|
|
case '{':
|
|
return CODE_NAME_INDEX_BracketLeft;
|
|
case ']':
|
|
case '}':
|
|
return CODE_NAME_INDEX_BracketRight;
|
|
case '\\':
|
|
case '|':
|
|
return CODE_NAME_INDEX_Backslash;
|
|
|
|
case ';':
|
|
case ':':
|
|
return CODE_NAME_INDEX_Semicolon;
|
|
case '\'':
|
|
case '"':
|
|
return CODE_NAME_INDEX_Quote;
|
|
|
|
case ',':
|
|
case '<':
|
|
return CODE_NAME_INDEX_Comma;
|
|
case '.':
|
|
case '>':
|
|
return CODE_NAME_INDEX_Period;
|
|
case '/':
|
|
case '?':
|
|
return CODE_NAME_INDEX_Slash;
|
|
|
|
case ' ':
|
|
return CODE_NAME_INDEX_Space;
|
|
|
|
default:
|
|
return CODE_NAME_INDEX_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::GuessKeyCodeValueOfPrintableKeyInUSEnglishKeyboardLayout(
|
|
const nsAString& aKeyValue, JS::Handle<JS::Value> aLocation,
|
|
uint8_t aOptionalArgc, uint32_t* aKeyCodeValue) {
|
|
if (NS_WARN_IF(!aKeyCodeValue)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
Maybe<uint32_t> location;
|
|
if (aOptionalArgc) {
|
|
if (aLocation.isNullOrUndefined()) {
|
|
// location should be nothing.
|
|
} else if (aLocation.isInt32()) {
|
|
location = mozilla::Some(static_cast<uint32_t>(aLocation.toInt32()));
|
|
} else {
|
|
NS_WARNING_ASSERTION(aLocation.isNullOrUndefined() || aLocation.isInt32(),
|
|
"aLocation must be undefined, null or int");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
*aKeyCodeValue =
|
|
GuessKeyCodeOfPrintableKeyInUSEnglishLayout(aKeyValue, location);
|
|
return NS_OK;
|
|
}
|
|
|
|
// static
|
|
uint32_t TextInputProcessor::GuessKeyCodeOfPrintableKeyInUSEnglishLayout(
|
|
const nsAString& aKeyValue, const Maybe<uint32_t>& aLocation) {
|
|
if (aKeyValue.IsEmpty()) {
|
|
return 0;
|
|
}
|
|
// US keyboard layout can input only one character per key. So, we can
|
|
// assume that if the key value is 2 or more characters, it's a known
|
|
// key name of a non-printable key or not a usual key emulation.
|
|
if (aKeyValue.Length() > 1) {
|
|
return 0;
|
|
}
|
|
|
|
if (aLocation.isSome() &&
|
|
aLocation.value() ==
|
|
dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_NUMPAD) {
|
|
switch (aKeyValue[0]) {
|
|
case '+':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_ADD;
|
|
case '-':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_SUBTRACT;
|
|
case '*':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_MULTIPLY;
|
|
case '/':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_DIVIDE;
|
|
case '.':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_DECIMAL;
|
|
case '0':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD0;
|
|
case '1':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD1;
|
|
case '2':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD2;
|
|
case '3':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD3;
|
|
case '4':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD4;
|
|
case '5':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD5;
|
|
case '6':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD6;
|
|
case '7':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD7;
|
|
case '8':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD8;
|
|
case '9':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_NUMPAD9;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (aLocation.isSome() &&
|
|
aLocation.value() !=
|
|
dom::KeyboardEvent_Binding::DOM_KEY_LOCATION_STANDARD) {
|
|
return 0;
|
|
}
|
|
|
|
// TODO: Support characters inputted with option key on macOS.
|
|
switch (aKeyValue[0]) {
|
|
case 'a':
|
|
case 'A':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_A;
|
|
case 'b':
|
|
case 'B':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_B;
|
|
case 'c':
|
|
case 'C':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_C;
|
|
case 'd':
|
|
case 'D':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_D;
|
|
case 'e':
|
|
case 'E':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_E;
|
|
case 'f':
|
|
case 'F':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_F;
|
|
case 'g':
|
|
case 'G':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_G;
|
|
case 'h':
|
|
case 'H':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_H;
|
|
case 'i':
|
|
case 'I':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_I;
|
|
case 'j':
|
|
case 'J':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_J;
|
|
case 'k':
|
|
case 'K':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_K;
|
|
case 'l':
|
|
case 'L':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_L;
|
|
case 'm':
|
|
case 'M':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_M;
|
|
case 'n':
|
|
case 'N':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_N;
|
|
case 'o':
|
|
case 'O':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_O;
|
|
case 'p':
|
|
case 'P':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_P;
|
|
case 'q':
|
|
case 'Q':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_Q;
|
|
case 'r':
|
|
case 'R':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_R;
|
|
case 's':
|
|
case 'S':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_S;
|
|
case 't':
|
|
case 'T':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_T;
|
|
case 'u':
|
|
case 'U':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_U;
|
|
case 'v':
|
|
case 'V':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_V;
|
|
case 'w':
|
|
case 'W':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_W;
|
|
case 'x':
|
|
case 'X':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_X;
|
|
case 'y':
|
|
case 'Y':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_Y;
|
|
case 'z':
|
|
case 'Z':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_Z;
|
|
|
|
case '`':
|
|
case '~':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_BACK_QUOTE;
|
|
case '1':
|
|
case '!':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_1;
|
|
case '2':
|
|
case '@':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_2;
|
|
case '3':
|
|
case '#':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_3;
|
|
case '4':
|
|
case '$':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_4;
|
|
case '5':
|
|
case '%':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_5;
|
|
case '6':
|
|
case '^':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_6;
|
|
case '7':
|
|
case '&':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_7;
|
|
case '8':
|
|
case '*':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_8;
|
|
case '9':
|
|
case '(':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_9;
|
|
case '0':
|
|
case ')':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_0;
|
|
case '-':
|
|
case '_':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_HYPHEN_MINUS;
|
|
case '=':
|
|
case '+':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_EQUALS;
|
|
|
|
case '[':
|
|
case '{':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_OPEN_BRACKET;
|
|
case ']':
|
|
case '}':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_CLOSE_BRACKET;
|
|
case '\\':
|
|
case '|':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_BACK_SLASH;
|
|
|
|
case ';':
|
|
case ':':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_SEMICOLON;
|
|
case '\'':
|
|
case '"':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_QUOTE;
|
|
|
|
case ',':
|
|
case '<':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_COMMA;
|
|
case '.':
|
|
case '>':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_PERIOD;
|
|
case '/':
|
|
case '?':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_SLASH;
|
|
|
|
case ' ':
|
|
return dom::KeyboardEvent_Binding::DOM_VK_SPACE;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessor::AutoPendingCompositionResetter
|
|
******************************************************************************/
|
|
TextInputProcessor::AutoPendingCompositionResetter::
|
|
AutoPendingCompositionResetter(TextInputProcessor* aTIP)
|
|
: mTIP(aTIP) {
|
|
MOZ_RELEASE_ASSERT(mTIP.get(), "mTIP must not be null");
|
|
}
|
|
|
|
TextInputProcessor::AutoPendingCompositionResetter::
|
|
~AutoPendingCompositionResetter() {
|
|
if (mTIP->mDispatcher) {
|
|
mTIP->mDispatcher->ClearPendingComposition();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessor::ModifierKeyData
|
|
******************************************************************************/
|
|
TextInputProcessor::ModifierKeyData::ModifierKeyData(
|
|
const WidgetKeyboardEvent& aKeyboardEvent)
|
|
: mKeyNameIndex(aKeyboardEvent.mKeyNameIndex),
|
|
mCodeNameIndex(aKeyboardEvent.mCodeNameIndex) {
|
|
mModifier = WidgetKeyboardEvent::GetModifierForKeyName(mKeyNameIndex);
|
|
MOZ_ASSERT(mModifier, "mKeyNameIndex must be a modifier key name");
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessor::ModifierKeyDataArray
|
|
******************************************************************************/
|
|
Modifiers TextInputProcessor::ModifierKeyDataArray::GetActiveModifiers() const {
|
|
Modifiers result = MODIFIER_NONE;
|
|
for (uint32_t i = 0; i < Length(); i++) {
|
|
result |= ElementAt(i).mModifier;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void TextInputProcessor::ModifierKeyDataArray::ActivateModifierKey(
|
|
const TextInputProcessor::ModifierKeyData& aModifierKeyData) {
|
|
if (Contains(aModifierKeyData)) {
|
|
return;
|
|
}
|
|
AppendElement(aModifierKeyData);
|
|
}
|
|
|
|
void TextInputProcessor::ModifierKeyDataArray::InactivateModifierKey(
|
|
const TextInputProcessor::ModifierKeyData& aModifierKeyData) {
|
|
RemoveElement(aModifierKeyData);
|
|
}
|
|
|
|
void TextInputProcessor::ModifierKeyDataArray::ToggleModifierKey(
|
|
const TextInputProcessor::ModifierKeyData& aModifierKeyData) {
|
|
auto index = IndexOf(aModifierKeyData);
|
|
if (index == NoIndex) {
|
|
AppendElement(aModifierKeyData);
|
|
return;
|
|
}
|
|
RemoveElementAt(index);
|
|
}
|
|
|
|
} // namespace mozilla
|