mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-05 16:46:26 +00:00
4fc95828b6
For making our code clearer by the stronger type check, we should change the anonymous enum for NS_TEXTRANGE_* to enum class whose name is "TextRangeType" and whose type is "RawTextRangeType" which is an alias of uint8_t. Additionally, this also adds some utility methods for them. Note that some lines which are changed by this patch become over 80 characters but it will be fixed by the following patches. MozReview-Commit-ID: 76izA1WqTkp --HG-- extra : rebase_source : 27cd8cc8f7f8e82055dbfe82aba94c02beda5fa4
1034 lines
33 KiB
C++
1034 lines
33 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 "gfxPrefs.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/TextEventDispatcher.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/TextInputProcessor.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsPresContext.h"
|
|
|
|
using namespace mozilla::widget;
|
|
|
|
namespace mozilla {
|
|
|
|
/******************************************************************************
|
|
* TextInputProcessorNotification
|
|
******************************************************************************/
|
|
|
|
class TextInputProcessorNotification final :
|
|
public nsITextInputProcessorNotification
|
|
{
|
|
public:
|
|
explicit TextInputProcessorNotification(const char* aType)
|
|
: mType(aType)
|
|
{
|
|
}
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD GetType(nsACString& aType) override final
|
|
{
|
|
aType = mType;
|
|
return NS_OK;
|
|
}
|
|
|
|
protected:
|
|
~TextInputProcessorNotification() { }
|
|
|
|
private:
|
|
nsAutoCString mType;
|
|
|
|
TextInputProcessorNotification() { }
|
|
};
|
|
|
|
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;
|
|
mDispatcher->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::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;
|
|
nsresult rv = docShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
if (aForTests) {
|
|
bool isAPZAware = gfxPrefs::TestEventsAsyncEnabled();
|
|
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 "" or "keydown".
|
|
if (aKeyboardEvent.mMessage == eKeyDown) {
|
|
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;
|
|
}
|
|
|
|
// 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
|
|
// keyup 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(
|
|
nsIDOMKeyEvent* aDOMKeyEvent,
|
|
uint32_t& aKeyFlags,
|
|
uint8_t aOptionalArgc,
|
|
WidgetKeyboardEvent*& aKeyboardEvent)
|
|
{
|
|
aKeyboardEvent = nullptr;
|
|
|
|
aKeyboardEvent =
|
|
aOptionalArgc && aDOMKeyEvent ?
|
|
aDOMKeyEvent->AsEvent()->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(nsIDOMKeyEvent* 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<TextEventDispatcher> kungfuDeathGrip(mDispatcher);
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv =
|
|
PrepareKeyboardEventForComposition(aDOMKeyEvent, 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 = mDispatcher->StartComposition(status);
|
|
*aSucceeded = status != nsEventStatus_eConsumeNoDefault &&
|
|
mDispatcher && mDispatcher->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 mDispatcher->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 mDispatcher->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 mDispatcher->SetCaretInPendingComposition(aOffset, 0);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::FlushPendingComposition(nsIDOMKeyEvent* 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();
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv =
|
|
PrepareKeyboardEventForComposition(aDOMKeyEvent, 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 = mDispatcher->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(nsIDOMKeyEvent* aDOMKeyEvent,
|
|
uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc)
|
|
{
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv =
|
|
PrepareKeyboardEventForComposition(aDOMKeyEvent, aKeyFlags, aOptionalArgc,
|
|
keyboardEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return CommitCompositionInternal(keyboardEvent, aKeyFlags);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::CommitCompositionWith(const nsAString& aCommitString,
|
|
nsIDOMKeyEvent* aDOMKeyEvent,
|
|
uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc,
|
|
bool* aSucceeded)
|
|
{
|
|
MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv =
|
|
PrepareKeyboardEventForComposition(aDOMKeyEvent, 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 = mDispatcher->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(nsIDOMKeyEvent* aDOMKeyEvent,
|
|
uint32_t aKeyFlags,
|
|
uint8_t aOptionalArgc)
|
|
{
|
|
MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
|
|
|
|
WidgetKeyboardEvent* keyboardEvent;
|
|
nsresult rv =
|
|
PrepareKeyboardEventForComposition(aDOMKeyEvent, 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 = mDispatcher->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;
|
|
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_(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)? false : true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::Keydown(nsIDOMKeyEvent* 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->AsEvent()->WidgetEventPtr()->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!originalKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return KeydownInternal(*originalKeyEvent, aKeyFlags, true, *aConsumedFlags);
|
|
}
|
|
|
|
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();
|
|
|
|
RefPtr<TextEventDispatcher> kungfuDeathGrip(mDispatcher);
|
|
rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsEventStatus status = aConsumedFlags ? nsEventStatus_eConsumeNoDefault :
|
|
nsEventStatus_eIgnore;
|
|
if (!mDispatcher->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 &&
|
|
mDispatcher->MaybeDispatchKeypressEvents(keyEvent, status)) {
|
|
aConsumedFlags |=
|
|
(status == nsEventStatus_eConsumeNoDefault) ? KEYPRESS_IS_CONSUMED :
|
|
KEYEVENT_NOT_CONSUMED;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
TextInputProcessor::Keyup(nsIDOMKeyEvent* 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->AsEvent()->WidgetEventPtr()->AsKeyboardEvent();
|
|
if (NS_WARN_IF(!originalKeyEvent)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return KeyupInternal(*originalKeyEvent, aKeyFlags, *aDoDefault);
|
|
}
|
|
|
|
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();
|
|
|
|
RefPtr<TextEventDispatcher> kungfuDeathGrip(mDispatcher);
|
|
rv = IsValidStateForComposition();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsEventStatus status = aDoDefault ? nsEventStatus_eIgnore :
|
|
nsEventStatus_eConsumeNoDefault;
|
|
mDispatcher->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());
|
|
if (!mModifierKeyDataArray) {
|
|
*aActive = false;
|
|
return NS_OK;
|
|
}
|
|
Modifiers activeModifiers = mModifierKeyDataArray->GetActiveModifiers();
|
|
Modifiers modifier = WidgetInputEvent::GetModifier(aModifierKeyName);
|
|
*aActive = ((activeModifiers & 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;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* 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
|