mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-27 14:52:16 +00:00
b546eb7e32
`mozAutoDocUpdate` does not make it in a document change when container node of `insertBefore` has already been removed from the tree. Therefore, once `IMEContentObserver::mRootElement` is removed from the DOM tree without a focus move, `IMEContentObserver` is notified mutations not in a document change. Similar situations are handled in `IMEStateManager::OnRemoveContent` with emulating a focus change and that will destroy the active `IMEContentObserver`. Therefore, if `IMEContentObserver::mRootElement` is removed, we should emulate a focus move when `IMEStateManager` does not have focused element but there is active `IMEContentObserver` (that means it is/was in the design mode). However, checking whether the removed node contains the observing node of the active `IMEContentObserver` may be expensive. So, doing expensive things in `IMEStateManager::OnRemoveContent` may make mutations slower. Therefore, this patch makes `IMEContentObserver` observe `ParentChainChanged` and it let `IMEStateManager` know that with calling its `OnParentChainChangedOfObservingElement`. Finally, it calls `IMEStateManager::OnRemoveContent` to emulate "blur" (and refocus if it's required). Differential Revision: https://phabricator.services.mozilla.com/D218696
1072 lines
40 KiB
C++
1072 lines
40 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 "TextComposition.h"
|
|
|
|
#include "ContentEventHandler.h"
|
|
#include "IMEContentObserver.h"
|
|
#include "IMEStateManager.h"
|
|
#include "mozilla/AutoRestore.h"
|
|
#include "mozilla/EditorBase.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/IMEStateManager.h"
|
|
#include "mozilla/IntegerRange.h"
|
|
#include "mozilla/MiscEvents.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/RangeBoundary.h"
|
|
#include "mozilla/StaticPrefs_dom.h"
|
|
#include "mozilla/StaticPrefs_intl.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/dom/BrowserParent.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIMutationObserver.h"
|
|
#include "nsPresContext.h"
|
|
|
|
#ifdef XP_MACOSX
|
|
// Some defiens will be conflict with OSX SDK
|
|
# define TextRange _TextRange
|
|
# define TextRangeArray _TextRangeArray
|
|
# define Comment _Comment
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
# undef TextRange
|
|
# undef TextRangeArray
|
|
# undef Comment
|
|
#endif
|
|
|
|
using namespace mozilla::widget;
|
|
|
|
namespace mozilla {
|
|
|
|
#define IDEOGRAPHIC_SPACE (u"\x3000"_ns)
|
|
|
|
static uint32_t GetOrCreateCompositionId(WidgetCompositionEvent* aEvent) {
|
|
// If we're in the parent process, return new composition ID.
|
|
if (XRE_IsParentProcess()) {
|
|
static uint32_t sNextCompositionId = 1u;
|
|
if (MOZ_UNLIKELY(sNextCompositionId == UINT32_MAX)) {
|
|
sNextCompositionId = 1u;
|
|
}
|
|
// FYI: When we send the event to a remote process, TextComposition will
|
|
// set aEvent->mCompositionId to this value. Therefore, we don't need to
|
|
// set it here.
|
|
return sNextCompositionId++;
|
|
}
|
|
// If aEvent comes from the parent process, the event has composition ID
|
|
// considered by the parent process. Then, we should use it.
|
|
// Otherwise, aEvent is synthesized in this process, it won't cross the
|
|
// process boundary between this process and the parent process. Therefore,
|
|
// we don't need to set meaningful composition ID for the text composition.
|
|
return aEvent->mCompositionId;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextComposition
|
|
******************************************************************************/
|
|
|
|
bool TextComposition::sHandlingSelectionEvent = false;
|
|
|
|
TextComposition::TextComposition(nsPresContext* aPresContext, nsINode* aNode,
|
|
BrowserParent* aBrowserParent,
|
|
WidgetCompositionEvent* aCompositionEvent)
|
|
: mPresContext(aPresContext),
|
|
mNode(aNode),
|
|
mBrowserParent(aBrowserParent),
|
|
mNativeContext(aCompositionEvent->mNativeIMEContext),
|
|
mCompositionId(GetOrCreateCompositionId(aCompositionEvent)),
|
|
mCompositionStartOffset(0),
|
|
mTargetClauseOffsetInComposition(0),
|
|
mCompositionStartOffsetInTextNode(UINT32_MAX),
|
|
mCompositionLengthInTextNode(UINT32_MAX),
|
|
mIsSynthesizedForTests(aCompositionEvent->mFlags.mIsSynthesizedForTests),
|
|
mIsComposing(false),
|
|
mIsRequestingCommit(false),
|
|
mIsRequestingCancel(false),
|
|
mRequestedToCommitOrCancel(false),
|
|
mHasDispatchedDOMTextEvent(false),
|
|
mHasReceivedCommitEvent(false),
|
|
mWasNativeCompositionEndEventDiscarded(false),
|
|
mAllowControlCharacters(
|
|
StaticPrefs::dom_compositionevent_allow_control_characters()),
|
|
mWasCompositionStringEmpty(true) {
|
|
MOZ_ASSERT(aCompositionEvent->mNativeIMEContext.IsValid());
|
|
}
|
|
|
|
void TextComposition::Destroy() {
|
|
mPresContext = nullptr;
|
|
mNode = nullptr;
|
|
mBrowserParent = nullptr;
|
|
mContainerTextNode = nullptr;
|
|
mCompositionStartOffsetInTextNode = UINT32_MAX;
|
|
mCompositionLengthInTextNode = UINT32_MAX;
|
|
// TODO: If the editor is still alive and this is held by it, we should tell
|
|
// this being destroyed for cleaning up the stuff.
|
|
}
|
|
|
|
void TextComposition::OnCharacterDataChanged(
|
|
Text& aText, const CharacterDataChangeInfo& aInfo) {
|
|
if (mContainerTextNode != &aText ||
|
|
mCompositionStartOffsetInTextNode == UINT32_MAX ||
|
|
mCompositionLengthInTextNode == UINT32_MAX) {
|
|
return;
|
|
}
|
|
|
|
// Ignore changes after composition string.
|
|
if (aInfo.mChangeStart >=
|
|
mCompositionStartOffsetInTextNode + mCompositionLengthInTextNode) {
|
|
return;
|
|
}
|
|
|
|
// If the change ends before the composition string, we need only to adjust
|
|
// the start offset.
|
|
if (aInfo.mChangeEnd <= mCompositionStartOffsetInTextNode) {
|
|
MOZ_ASSERT(aInfo.LengthOfRemovedText() <=
|
|
mCompositionStartOffsetInTextNode);
|
|
mCompositionStartOffsetInTextNode -= aInfo.LengthOfRemovedText();
|
|
mCompositionStartOffsetInTextNode += aInfo.mReplaceLength;
|
|
return;
|
|
}
|
|
|
|
// If this is caused by a splitting text node, the composition string
|
|
// may be split out to the new right node. In the case,
|
|
// CompositionTransaction::DoTransaction handles it with warking the
|
|
// following text nodes. Therefore, we should NOT shrink the composing
|
|
// range for avoind breaking the fix of bug 1310912. Although the handling
|
|
// looks buggy so that we need to move the handling into here later.
|
|
if (aInfo.mDetails &&
|
|
aInfo.mDetails->mType == CharacterDataChangeInfo::Details::eSplit) {
|
|
return;
|
|
}
|
|
|
|
// If the change removes/replaces the last character of the composition
|
|
// string, we should shrink the composition range before the change start.
|
|
// Then, the replace string will be never updated by coming composition
|
|
// updates.
|
|
if (aInfo.mChangeEnd >=
|
|
mCompositionStartOffsetInTextNode + mCompositionLengthInTextNode) {
|
|
// If deleting the first character of the composition string, collapse IME
|
|
// selection temporarily. Updating composition string will insert new
|
|
// composition string there.
|
|
if (aInfo.mChangeStart <= mCompositionStartOffsetInTextNode) {
|
|
mCompositionStartOffsetInTextNode = aInfo.mChangeStart;
|
|
mCompositionLengthInTextNode = 0u;
|
|
return;
|
|
}
|
|
// If some characters in the composition still stay, composition range
|
|
// should be shrunken.
|
|
MOZ_ASSERT(aInfo.mChangeStart > mCompositionStartOffsetInTextNode);
|
|
mCompositionLengthInTextNode =
|
|
aInfo.mChangeStart - mCompositionStartOffsetInTextNode;
|
|
return;
|
|
}
|
|
|
|
// If removed range starts in the composition string, we need only adjust
|
|
// the length to make composition range contain the replace string.
|
|
if (aInfo.mChangeStart >= mCompositionStartOffsetInTextNode) {
|
|
MOZ_ASSERT(aInfo.LengthOfRemovedText() <= mCompositionLengthInTextNode);
|
|
mCompositionLengthInTextNode -= aInfo.LengthOfRemovedText();
|
|
mCompositionLengthInTextNode += aInfo.mReplaceLength;
|
|
return;
|
|
}
|
|
|
|
// If preceding characers of the composition string is also removed, new
|
|
// composition start will be there and new composition ends at current
|
|
// position.
|
|
const uint32_t removedLengthInCompositionString =
|
|
aInfo.mChangeEnd - mCompositionStartOffsetInTextNode;
|
|
mCompositionStartOffsetInTextNode = aInfo.mChangeStart;
|
|
mCompositionLengthInTextNode -= removedLengthInCompositionString;
|
|
mCompositionLengthInTextNode += aInfo.mReplaceLength;
|
|
}
|
|
|
|
bool TextComposition::IsValidStateForComposition(nsIWidget* aWidget) const {
|
|
return !Destroyed() && aWidget && !aWidget->Destroyed() &&
|
|
mPresContext->GetPresShell() &&
|
|
!mPresContext->PresShell()->IsDestroying();
|
|
}
|
|
|
|
bool TextComposition::MaybeDispatchCompositionUpdate(
|
|
const WidgetCompositionEvent* aCompositionEvent) {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
|
|
return false;
|
|
}
|
|
|
|
// Note that we don't need to dispatch eCompositionUpdate event even if
|
|
// mHasDispatchedDOMTextEvent is false and eCompositionCommit event is
|
|
// dispatched with empty string immediately after eCompositionStart
|
|
// because composition string has never been changed from empty string to
|
|
// non-empty string in such composition even if selected string was not
|
|
// empty string (mLastData isn't set to selected text when this receives
|
|
// eCompositionStart).
|
|
if (mLastData == aCompositionEvent->mData) {
|
|
// Even if the new composition event does not update the composition string,
|
|
// it may change IME selection.
|
|
mLastRanges = aCompositionEvent->mRanges;
|
|
return true;
|
|
}
|
|
CloneAndDispatchAs(aCompositionEvent, eCompositionUpdate);
|
|
return IsValidStateForComposition(aCompositionEvent->mWidget);
|
|
}
|
|
|
|
BaseEventFlags TextComposition::CloneAndDispatchAs(
|
|
const WidgetCompositionEvent* aCompositionEvent, EventMessage aMessage,
|
|
nsEventStatus* aStatus, EventDispatchingCallback* aCallBack) {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
MOZ_ASSERT(IsValidStateForComposition(aCompositionEvent->mWidget),
|
|
"Should be called only when it's safe to dispatch an event");
|
|
|
|
WidgetCompositionEvent compositionEvent(aCompositionEvent->IsTrusted(),
|
|
aMessage, aCompositionEvent->mWidget);
|
|
compositionEvent.mTimeStamp = aCompositionEvent->mTimeStamp;
|
|
compositionEvent.mData = aCompositionEvent->mData;
|
|
compositionEvent.mNativeIMEContext = aCompositionEvent->mNativeIMEContext;
|
|
compositionEvent.mOriginalMessage = aCompositionEvent->mMessage;
|
|
compositionEvent.mFlags.mIsSynthesizedForTests =
|
|
aCompositionEvent->mFlags.mIsSynthesizedForTests;
|
|
|
|
nsEventStatus dummyStatus = nsEventStatus_eConsumeNoDefault;
|
|
nsEventStatus* status = aStatus ? aStatus : &dummyStatus;
|
|
if (aMessage == eCompositionUpdate) {
|
|
mLastData = compositionEvent.mData;
|
|
mLastRanges = aCompositionEvent->mRanges;
|
|
}
|
|
|
|
DispatchEvent(&compositionEvent, status, aCallBack, aCompositionEvent);
|
|
return compositionEvent.mFlags;
|
|
}
|
|
|
|
void TextComposition::DispatchEvent(
|
|
WidgetCompositionEvent* aDispatchEvent, nsEventStatus* aStatus,
|
|
EventDispatchingCallback* aCallBack,
|
|
const WidgetCompositionEvent* aOriginalEvent) {
|
|
if (aDispatchEvent->mMessage == eCompositionChange) {
|
|
aDispatchEvent->mFlags.mOnlySystemGroupDispatchInContent = true;
|
|
}
|
|
RefPtr<nsINode> node = mNode;
|
|
RefPtr<nsPresContext> presContext = mPresContext;
|
|
EventDispatcher::Dispatch(node, presContext, aDispatchEvent, nullptr, aStatus,
|
|
aCallBack);
|
|
|
|
OnCompositionEventDispatched(aDispatchEvent);
|
|
}
|
|
|
|
void TextComposition::OnCompositionEventDiscarded(
|
|
WidgetCompositionEvent* aCompositionEvent) {
|
|
// Note that this method is never called for synthesized events for emulating
|
|
// commit or cancel composition.
|
|
|
|
MOZ_ASSERT(aCompositionEvent->IsTrusted(),
|
|
"Shouldn't be called with untrusted event");
|
|
|
|
if (mBrowserParent) {
|
|
Unused << mBrowserParent->SendCompositionEvent(*aCompositionEvent,
|
|
mCompositionId);
|
|
}
|
|
|
|
// XXX If composition events are discarded, should we dispatch them with
|
|
// runnable event? However, even if we do so, it might make native IME
|
|
// confused due to async modification. Especially when native IME is
|
|
// TSF.
|
|
if (!aCompositionEvent->CausesDOMCompositionEndEvent()) {
|
|
return;
|
|
}
|
|
|
|
mWasNativeCompositionEndEventDiscarded = true;
|
|
}
|
|
|
|
static inline bool IsControlChar(uint32_t aCharCode) {
|
|
return aCharCode < ' ' || aCharCode == 0x7F;
|
|
}
|
|
|
|
static size_t FindFirstControlCharacter(const nsAString& aStr) {
|
|
const char16_t* sourceBegin = aStr.BeginReading();
|
|
const char16_t* sourceEnd = aStr.EndReading();
|
|
|
|
for (const char16_t* source = sourceBegin; source < sourceEnd; ++source) {
|
|
if (*source != '\t' && IsControlChar(*source)) {
|
|
return source - sourceBegin;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void RemoveControlCharactersFrom(nsAString& aStr,
|
|
TextRangeArray* aRanges) {
|
|
size_t firstControlCharOffset = FindFirstControlCharacter(aStr);
|
|
if (firstControlCharOffset == (size_t)-1) {
|
|
return;
|
|
}
|
|
|
|
nsAutoString copy(aStr);
|
|
const char16_t* sourceBegin = copy.BeginReading();
|
|
const char16_t* sourceEnd = copy.EndReading();
|
|
|
|
char16_t* dest = aStr.BeginWriting();
|
|
if (NS_WARN_IF(!dest)) {
|
|
return;
|
|
}
|
|
|
|
char16_t* curDest = dest + firstControlCharOffset;
|
|
size_t i = firstControlCharOffset;
|
|
for (const char16_t* source = sourceBegin + firstControlCharOffset;
|
|
source < sourceEnd; ++source) {
|
|
if (*source == '\t' || *source == '\n' || !IsControlChar(*source)) {
|
|
*curDest = *source;
|
|
++curDest;
|
|
++i;
|
|
} else if (aRanges) {
|
|
aRanges->RemoveCharacter(i);
|
|
}
|
|
}
|
|
|
|
aStr.SetLength(curDest - dest);
|
|
}
|
|
|
|
nsString TextComposition::CommitStringIfCommittedAsIs() const {
|
|
nsString result(mLastData);
|
|
if (!mAllowControlCharacters) {
|
|
RemoveControlCharactersFrom(result, nullptr);
|
|
}
|
|
if (StaticPrefs::intl_ime_remove_placeholder_character_at_commit() &&
|
|
mLastData == IDEOGRAPHIC_SPACE) {
|
|
return EmptyString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void TextComposition::DispatchCompositionEvent(
|
|
WidgetCompositionEvent* aCompositionEvent, nsEventStatus* aStatus,
|
|
EventDispatchingCallback* aCallBack, bool aIsSynthesized) {
|
|
mWasCompositionStringEmpty = mString.IsEmpty();
|
|
|
|
if (aCompositionEvent->IsFollowedByCompositionEnd()) {
|
|
mHasReceivedCommitEvent = true;
|
|
}
|
|
|
|
// If this instance has requested to commit or cancel composition but
|
|
// is not synthesizing commit event, that means that the IME commits or
|
|
// cancels the composition asynchronously. Typically, iBus behaves so.
|
|
// Then, synthesized events which were dispatched immediately after
|
|
// the request has already committed our editor's composition string and
|
|
// told it to web apps. Therefore, we should ignore the delayed events.
|
|
if (mRequestedToCommitOrCancel && !aIsSynthesized) {
|
|
*aStatus = nsEventStatus_eConsumeNoDefault;
|
|
return;
|
|
}
|
|
|
|
// If the content is a container of BrowserParent, composition should be in
|
|
// the remote process.
|
|
if (mBrowserParent) {
|
|
Unused << mBrowserParent->SendCompositionEvent(*aCompositionEvent,
|
|
mCompositionId);
|
|
aCompositionEvent->StopPropagation();
|
|
if (aCompositionEvent->CausesDOMTextEvent()) {
|
|
mLastData = aCompositionEvent->mData;
|
|
mLastRanges = aCompositionEvent->mRanges;
|
|
// Although, the composition event hasn't been actually handled yet,
|
|
// emulate an editor to be handling the composition event.
|
|
EditorWillHandleCompositionChangeEvent(aCompositionEvent);
|
|
EditorDidHandleCompositionChangeEvent();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!mAllowControlCharacters) {
|
|
RemoveControlCharactersFrom(aCompositionEvent->mData,
|
|
aCompositionEvent->mRanges);
|
|
}
|
|
if (aCompositionEvent->mMessage == eCompositionCommitAsIs) {
|
|
NS_ASSERTION(!aCompositionEvent->mRanges,
|
|
"mRanges of eCompositionCommitAsIs should be null");
|
|
aCompositionEvent->mRanges = nullptr;
|
|
NS_ASSERTION(aCompositionEvent->mData.IsEmpty(),
|
|
"mData of eCompositionCommitAsIs should be empty string");
|
|
if (StaticPrefs::intl_ime_remove_placeholder_character_at_commit() &&
|
|
mLastData == IDEOGRAPHIC_SPACE) {
|
|
// If the last data is an ideographic space (FullWidth space), it might be
|
|
// a placeholder character of some Chinese IME. So, committing with
|
|
// this data might not be expected by users. Let's use empty string.
|
|
aCompositionEvent->mData.Truncate();
|
|
} else {
|
|
aCompositionEvent->mData = mLastData;
|
|
}
|
|
} else if (aCompositionEvent->mMessage == eCompositionCommit) {
|
|
NS_ASSERTION(!aCompositionEvent->mRanges,
|
|
"mRanges of eCompositionCommit should be null");
|
|
aCompositionEvent->mRanges = nullptr;
|
|
}
|
|
|
|
if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
|
|
*aStatus = nsEventStatus_eConsumeNoDefault;
|
|
return;
|
|
}
|
|
|
|
// IME may commit composition with empty string for a commit request or
|
|
// with non-empty string for a cancel request. We should prevent such
|
|
// unexpected result. E.g., web apps may be confused if they implement
|
|
// autocomplete which attempts to commit composition forcibly when the user
|
|
// selects one of suggestions but composition string is cleared by IME.
|
|
// Note that most Chinese IMEs don't expose actual composition string to us.
|
|
// They typically tell us an IDEOGRAPHIC SPACE or empty string as composition
|
|
// string. Therefore, we should hack it only when:
|
|
// 1. committing string is empty string at requesting commit but the last
|
|
// data isn't IDEOGRAPHIC SPACE.
|
|
// 2. non-empty string is committed at requesting cancel.
|
|
if (!aIsSynthesized && (mIsRequestingCommit || mIsRequestingCancel)) {
|
|
nsString* committingData = nullptr;
|
|
switch (aCompositionEvent->mMessage) {
|
|
case eCompositionEnd:
|
|
case eCompositionChange:
|
|
case eCompositionCommitAsIs:
|
|
case eCompositionCommit:
|
|
committingData = &aCompositionEvent->mData;
|
|
break;
|
|
default:
|
|
NS_WARNING(
|
|
"Unexpected event comes during committing or "
|
|
"canceling composition");
|
|
break;
|
|
}
|
|
if (committingData) {
|
|
if (mIsRequestingCommit && committingData->IsEmpty() &&
|
|
mLastData != IDEOGRAPHIC_SPACE) {
|
|
committingData->Assign(mLastData);
|
|
} else if (mIsRequestingCancel && !committingData->IsEmpty()) {
|
|
committingData->Truncate();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool dispatchEvent = true;
|
|
bool dispatchDOMTextEvent = aCompositionEvent->CausesDOMTextEvent();
|
|
|
|
// When mIsComposing is false but the committing string is different from
|
|
// the last data (E.g., previous eCompositionChange event made the
|
|
// composition string empty or didn't have clause information), we don't
|
|
// need to dispatch redundant DOM text event. (But note that we need to
|
|
// dispatch eCompositionChange event if we have not dispatched
|
|
// eCompositionChange event yet and commit string replaces selected string
|
|
// with empty string since selected string hasn't been replaced with empty
|
|
// string yet.)
|
|
if (dispatchDOMTextEvent &&
|
|
aCompositionEvent->mMessage != eCompositionChange && !mIsComposing &&
|
|
mHasDispatchedDOMTextEvent && mLastData == aCompositionEvent->mData) {
|
|
dispatchEvent = dispatchDOMTextEvent = false;
|
|
}
|
|
|
|
// widget may dispatch redundant eCompositionChange event
|
|
// which modifies neither composition string, clauses nor caret
|
|
// position. In such case, we shouldn't dispatch DOM events.
|
|
if (dispatchDOMTextEvent &&
|
|
aCompositionEvent->mMessage == eCompositionChange &&
|
|
mLastData == aCompositionEvent->mData && mRanges &&
|
|
aCompositionEvent->mRanges &&
|
|
mRanges->Equals(*aCompositionEvent->mRanges)) {
|
|
dispatchEvent = dispatchDOMTextEvent = false;
|
|
}
|
|
|
|
if (dispatchDOMTextEvent) {
|
|
if (!MaybeDispatchCompositionUpdate(aCompositionEvent)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (dispatchEvent) {
|
|
// If the composition event should cause a DOM text event, we should
|
|
// overwrite the event message as eCompositionChange because due to
|
|
// the limitation of mapping between event messages and DOM event types,
|
|
// we cannot map multiple event messages to a DOM event type.
|
|
if (dispatchDOMTextEvent &&
|
|
aCompositionEvent->mMessage != eCompositionChange) {
|
|
mHasDispatchedDOMTextEvent = true;
|
|
aCompositionEvent->mFlags = CloneAndDispatchAs(
|
|
aCompositionEvent, eCompositionChange, aStatus, aCallBack);
|
|
} else {
|
|
if (aCompositionEvent->mMessage == eCompositionChange) {
|
|
mHasDispatchedDOMTextEvent = true;
|
|
}
|
|
DispatchEvent(aCompositionEvent, aStatus, aCallBack);
|
|
}
|
|
} else {
|
|
*aStatus = nsEventStatus_eConsumeNoDefault;
|
|
}
|
|
|
|
if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
|
|
return;
|
|
}
|
|
|
|
// Emulate editor behavior of compositionchange event (DOM text event) handler
|
|
// if no editor handles composition events.
|
|
if (dispatchDOMTextEvent && !HasEditor()) {
|
|
EditorWillHandleCompositionChangeEvent(aCompositionEvent);
|
|
EditorDidHandleCompositionChangeEvent();
|
|
}
|
|
|
|
if (aCompositionEvent->CausesDOMCompositionEndEvent()) {
|
|
// Dispatch a compositionend event if it's necessary.
|
|
if (aCompositionEvent->mMessage != eCompositionEnd) {
|
|
CloneAndDispatchAs(aCompositionEvent, eCompositionEnd);
|
|
}
|
|
MOZ_ASSERT(!mIsComposing, "Why is the editor still composing?");
|
|
MOZ_ASSERT(!HasEditor(), "Why does the editor still keep to hold this?");
|
|
}
|
|
|
|
MaybeNotifyIMEOfCompositionEventHandled(aCompositionEvent);
|
|
}
|
|
|
|
// static
|
|
void TextComposition::HandleSelectionEvent(
|
|
nsPresContext* aPresContext, BrowserParent* aBrowserParent,
|
|
WidgetSelectionEvent* aSelectionEvent) {
|
|
// If the content is a container of BrowserParent, composition should be in
|
|
// the remote process.
|
|
if (aBrowserParent) {
|
|
Unused << aBrowserParent->SendSelectionEvent(*aSelectionEvent);
|
|
aSelectionEvent->StopPropagation();
|
|
return;
|
|
}
|
|
|
|
AutoRestore<bool> saveHandlingSelectionEvent(sHandlingSelectionEvent);
|
|
sHandlingSelectionEvent = true;
|
|
|
|
if (RefPtr<IMEContentObserver> contentObserver =
|
|
IMEStateManager::GetActiveContentObserver()) {
|
|
contentObserver->MaybeHandleSelectionEvent(aPresContext, aSelectionEvent);
|
|
return;
|
|
}
|
|
|
|
ContentEventHandler handler(aPresContext);
|
|
// XXX During setting selection, a selection listener may change selection
|
|
// again. In such case, sHandlingSelectionEvent doesn't indicate if
|
|
// the selection change is caused by a selection event. However, it
|
|
// must be non-realistic scenario.
|
|
handler.OnSelectionEvent(aSelectionEvent);
|
|
}
|
|
|
|
uint32_t TextComposition::GetSelectionStartOffset() {
|
|
nsCOMPtr<nsIWidget> widget = mPresContext->GetRootWidget();
|
|
WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
|
|
widget);
|
|
// Due to a bug of widget, mRanges may not be nullptr even though composition
|
|
// string is empty. So, we need to check it here for avoiding to return
|
|
// odd start offset.
|
|
if (!mLastData.IsEmpty() && mRanges && mRanges->HasClauses()) {
|
|
querySelectedTextEvent.InitForQuerySelectedText(
|
|
ToSelectionType(mRanges->GetFirstClause()->mRangeType));
|
|
} else {
|
|
NS_WARNING_ASSERTION(
|
|
!mLastData.IsEmpty() || !mRanges || !mRanges->HasClauses(),
|
|
"Shouldn't have empty clause info when composition string is empty");
|
|
querySelectedTextEvent.InitForQuerySelectedText(SelectionType::eNormal);
|
|
}
|
|
|
|
// The editor which has this composition is observed by active
|
|
// IMEContentObserver, we can use the cache of it.
|
|
RefPtr<IMEContentObserver> contentObserver =
|
|
IMEStateManager::GetActiveContentObserver();
|
|
bool doQuerySelection = true;
|
|
if (contentObserver) {
|
|
if (contentObserver->IsObserving(*this)) {
|
|
doQuerySelection = false;
|
|
contentObserver->HandleQueryContentEvent(&querySelectedTextEvent);
|
|
}
|
|
// If another editor already has focus, we cannot retrieve selection
|
|
// in the editor which has this composition...
|
|
else if (NS_WARN_IF(contentObserver->GetPresContext() == mPresContext)) {
|
|
return 0; // XXX Is this okay?
|
|
}
|
|
}
|
|
|
|
// Otherwise, using slow path (i.e., compute every time with
|
|
// ContentEventHandler)
|
|
if (doQuerySelection) {
|
|
ContentEventHandler handler(mPresContext);
|
|
handler.HandleQueryContentEvent(&querySelectedTextEvent);
|
|
}
|
|
|
|
if (NS_WARN_IF(querySelectedTextEvent.DidNotFindSelection())) {
|
|
return 0; // XXX Is this okay?
|
|
}
|
|
return querySelectedTextEvent.mReply->AnchorOffset();
|
|
}
|
|
|
|
void TextComposition::OnCompositionEventDispatched(
|
|
const WidgetCompositionEvent* aCompositionEvent) {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
|
|
return;
|
|
}
|
|
|
|
// Every composition event may cause changing composition start offset,
|
|
// especially when there is no composition string. Therefore, we need to
|
|
// update mCompositionStartOffset with the latest offset.
|
|
|
|
MOZ_ASSERT(aCompositionEvent->mMessage != eCompositionStart ||
|
|
mWasCompositionStringEmpty,
|
|
"mWasCompositionStringEmpty should be true if the dispatched "
|
|
"event is eCompositionStart");
|
|
|
|
if (mWasCompositionStringEmpty &&
|
|
!aCompositionEvent->CausesDOMCompositionEndEvent()) {
|
|
// If there was no composition string, current selection start may be the
|
|
// offset for inserting composition string.
|
|
// Update composition start offset with current selection start.
|
|
mCompositionStartOffset = GetSelectionStartOffset();
|
|
mTargetClauseOffsetInComposition = 0;
|
|
}
|
|
|
|
if (aCompositionEvent->CausesDOMTextEvent()) {
|
|
mTargetClauseOffsetInComposition = aCompositionEvent->TargetClauseOffset();
|
|
}
|
|
}
|
|
|
|
void TextComposition::OnStartOffsetUpdatedInChild(uint32_t aStartOffset) {
|
|
mCompositionStartOffset = aStartOffset;
|
|
}
|
|
|
|
void TextComposition::MaybeNotifyIMEOfCompositionEventHandled(
|
|
const WidgetCompositionEvent* aCompositionEvent) {
|
|
if (aCompositionEvent->mMessage != eCompositionStart &&
|
|
!aCompositionEvent->CausesDOMTextEvent()) {
|
|
return;
|
|
}
|
|
|
|
RefPtr<IMEContentObserver> contentObserver =
|
|
IMEStateManager::GetActiveContentObserver();
|
|
// When IMEContentObserver is managing the editor which has this composition,
|
|
// composition event handled notification should be sent after the observer
|
|
// notifies all pending notifications. Therefore, we should use it.
|
|
// XXX If IMEContentObserver suddenly loses focus after here and notifying
|
|
// widget of pending notifications, we won't notify widget of composition
|
|
// event handled. Although, this is a bug but it should be okay since
|
|
// destroying IMEContentObserver notifies IME of blur. So, native IME
|
|
// handler can treat it as this notification too.
|
|
if (contentObserver && contentObserver->IsObserving(*this)) {
|
|
contentObserver->MaybeNotifyCompositionEventHandled();
|
|
return;
|
|
}
|
|
// Otherwise, e.g., this composition is in non-active window, we should
|
|
// notify widget directly.
|
|
NotifyIME(NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED);
|
|
}
|
|
|
|
void TextComposition::DispatchCompositionEventRunnable(
|
|
EventMessage aEventMessage, const nsAString& aData,
|
|
bool aIsSynthesizingCommit) {
|
|
nsContentUtils::AddScriptRunner(new CompositionEventDispatcher(
|
|
this, mNode, aEventMessage, aData, aIsSynthesizingCommit));
|
|
}
|
|
|
|
nsresult TextComposition::RequestToCommit(nsIWidget* aWidget, bool aDiscard) {
|
|
MOZ_ASSERT(this == IMEStateManager::GetTextCompositionFor(aWidget));
|
|
// If this composition is already requested to be committed or canceled,
|
|
// or has already finished in IME, we don't need to request it again because
|
|
// request from this instance shouldn't cause committing nor canceling current
|
|
// composition in IME, and even if the first request failed, new request
|
|
// won't success, probably. And we shouldn't synthesize events for
|
|
// committing or canceling composition twice or more times.
|
|
if (!CanRequsetIMEToCommitOrCancelComposition()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
RefPtr<TextComposition> kungFuDeathGrip(this);
|
|
const nsAutoString lastData(mLastData);
|
|
|
|
if (IMEStateManager::CanSendNotificationToWidget()) {
|
|
AutoRestore<bool> saveRequestingCancel(mIsRequestingCancel);
|
|
AutoRestore<bool> saveRequestingCommit(mIsRequestingCommit);
|
|
if (aDiscard) {
|
|
mIsRequestingCancel = true;
|
|
mIsRequestingCommit = false;
|
|
} else {
|
|
mIsRequestingCancel = false;
|
|
mIsRequestingCommit = true;
|
|
}
|
|
// FYI: CompositionEvents caused by a call of NotifyIME() may be
|
|
// discarded by PresShell if it's not safe to dispatch the event.
|
|
nsresult rv = aWidget->NotifyIME(
|
|
IMENotification(aDiscard ? REQUEST_TO_CANCEL_COMPOSITION
|
|
: REQUEST_TO_COMMIT_COMPOSITION));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
mRequestedToCommitOrCancel = true;
|
|
|
|
// If the request is performed synchronously, this must be already destroyed.
|
|
if (Destroyed()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Otherwise, synthesize the commit in content.
|
|
nsAutoString data(aDiscard ? EmptyString() : lastData);
|
|
if (data == mLastData) {
|
|
DispatchCompositionEventRunnable(eCompositionCommitAsIs, u""_ns, true);
|
|
} else {
|
|
DispatchCompositionEventRunnable(eCompositionCommit, data, true);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult TextComposition::NotifyIME(IMEMessage aMessage) {
|
|
NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE);
|
|
return IMEStateManager::NotifyIME(aMessage, mPresContext, mBrowserParent);
|
|
}
|
|
|
|
void TextComposition::EditorWillHandleCompositionChangeEvent(
|
|
const WidgetCompositionEvent* aCompositionChangeEvent) {
|
|
mIsComposing = aCompositionChangeEvent->IsComposing();
|
|
mRanges = aCompositionChangeEvent->mRanges;
|
|
mEditorIsHandlingEvent = true;
|
|
|
|
MOZ_ASSERT(
|
|
mLastData == aCompositionChangeEvent->mData,
|
|
"The text of a compositionchange event must be same as previous data "
|
|
"attribute value of the latest compositionupdate event");
|
|
}
|
|
|
|
void TextComposition::OnEditorDestroyed() {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
MOZ_ASSERT(!mEditorIsHandlingEvent,
|
|
"The editor should have stopped listening events");
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
if (NS_WARN_IF(!widget)) {
|
|
// XXX If this could happen, how do we notify IME of destroying the editor?
|
|
return;
|
|
}
|
|
|
|
// Try to cancel the composition.
|
|
RequestToCommit(widget, true);
|
|
}
|
|
|
|
void TextComposition::EditorDidHandleCompositionChangeEvent() {
|
|
mString = mLastData;
|
|
mEditorIsHandlingEvent = false;
|
|
}
|
|
|
|
void TextComposition::StartHandlingComposition(EditorBase* aEditorBase) {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
MOZ_ASSERT(!HasEditor(), "There is a handling editor already");
|
|
mEditorBaseWeak = do_GetWeakReference(static_cast<nsIEditor*>(aEditorBase));
|
|
}
|
|
|
|
void TextComposition::EndHandlingComposition(EditorBase* aEditorBase) {
|
|
MOZ_RELEASE_ASSERT(!mBrowserParent);
|
|
|
|
#ifdef DEBUG
|
|
RefPtr<EditorBase> editorBase = GetEditorBase();
|
|
MOZ_ASSERT(!editorBase || editorBase == aEditorBase,
|
|
"Another editor handled the composition?");
|
|
#endif // #ifdef DEBUG
|
|
mEditorBaseWeak = nullptr;
|
|
}
|
|
|
|
already_AddRefed<EditorBase> TextComposition::GetEditorBase() const {
|
|
nsCOMPtr<nsIEditor> editor = do_QueryReferent(mEditorBaseWeak);
|
|
RefPtr<EditorBase> editorBase = static_cast<EditorBase*>(editor.get());
|
|
return editorBase.forget();
|
|
}
|
|
|
|
bool TextComposition::HasEditor() const {
|
|
return mEditorBaseWeak && mEditorBaseWeak->IsAlive();
|
|
}
|
|
|
|
RawRangeBoundary TextComposition::FirstIMESelectionStartRef() const {
|
|
RefPtr<EditorBase> editorBase = GetEditorBase();
|
|
if (!editorBase) {
|
|
return RawRangeBoundary();
|
|
}
|
|
|
|
nsISelectionController* selectionController =
|
|
editorBase->GetSelectionController();
|
|
if (NS_WARN_IF(!selectionController)) {
|
|
return RawRangeBoundary();
|
|
}
|
|
|
|
const nsRange* firstRange = nullptr;
|
|
static const SelectionType kIMESelectionTypes[] = {
|
|
SelectionType::eIMERawClause, SelectionType::eIMESelectedRawClause,
|
|
SelectionType::eIMEConvertedClause, SelectionType::eIMESelectedClause};
|
|
for (auto selectionType : kIMESelectionTypes) {
|
|
dom::Selection* selection =
|
|
selectionController->GetSelection(ToRawSelectionType(selectionType));
|
|
if (!selection) {
|
|
continue;
|
|
}
|
|
const uint32_t rangeCount = selection->RangeCount();
|
|
for (const uint32_t i : IntegerRange(rangeCount)) {
|
|
MOZ_ASSERT(selection->RangeCount() == rangeCount);
|
|
const nsRange* range = selection->GetRangeAt(i);
|
|
MOZ_ASSERT(range);
|
|
if (MOZ_UNLIKELY(NS_WARN_IF(!range)) ||
|
|
MOZ_UNLIKELY(NS_WARN_IF(!range->GetStartContainer()))) {
|
|
continue;
|
|
}
|
|
if (!firstRange) {
|
|
firstRange = range;
|
|
continue;
|
|
}
|
|
// In most cases, all composition string should be in same text node.
|
|
if (firstRange->GetStartContainer() == range->GetStartContainer()) {
|
|
if (firstRange->StartOffset() > range->StartOffset()) {
|
|
firstRange = range;
|
|
}
|
|
continue;
|
|
}
|
|
// However, if web apps have inserted different nodes in composition
|
|
// string, composition string may span 2 or more nodes.
|
|
if (firstRange->GetStartContainer()->GetNextSibling() ==
|
|
range->GetStartContainer()) {
|
|
// Fast path for some known applications like Google Keep.
|
|
firstRange = range;
|
|
continue;
|
|
}
|
|
// Unfortunately, really slow path.
|
|
// The ranges should always have a common ancestor, hence, be comparable.
|
|
if (*nsContentUtils::ComparePoints(range->StartRef(),
|
|
firstRange->StartRef()) == -1) {
|
|
firstRange = range;
|
|
}
|
|
}
|
|
}
|
|
return firstRange ? firstRange->StartRef().AsRaw() : RawRangeBoundary();
|
|
}
|
|
|
|
RawRangeBoundary TextComposition::LastIMESelectionEndRef() const {
|
|
RefPtr<EditorBase> editorBase = GetEditorBase();
|
|
if (!editorBase) {
|
|
return RawRangeBoundary();
|
|
}
|
|
|
|
nsISelectionController* selectionController =
|
|
editorBase->GetSelectionController();
|
|
if (NS_WARN_IF(!selectionController)) {
|
|
return RawRangeBoundary();
|
|
}
|
|
|
|
const nsRange* lastRange = nullptr;
|
|
static const SelectionType kIMESelectionTypes[] = {
|
|
SelectionType::eIMERawClause, SelectionType::eIMESelectedRawClause,
|
|
SelectionType::eIMEConvertedClause, SelectionType::eIMESelectedClause};
|
|
for (auto selectionType : kIMESelectionTypes) {
|
|
dom::Selection* selection =
|
|
selectionController->GetSelection(ToRawSelectionType(selectionType));
|
|
if (!selection) {
|
|
continue;
|
|
}
|
|
const uint32_t rangeCount = selection->RangeCount();
|
|
for (const uint32_t i : IntegerRange(rangeCount)) {
|
|
MOZ_ASSERT(selection->RangeCount() == rangeCount);
|
|
const nsRange* range = selection->GetRangeAt(i);
|
|
MOZ_ASSERT(range);
|
|
if (MOZ_UNLIKELY(NS_WARN_IF(!range)) ||
|
|
MOZ_UNLIKELY(NS_WARN_IF(!range->GetEndContainer()))) {
|
|
continue;
|
|
}
|
|
if (!lastRange) {
|
|
lastRange = range;
|
|
continue;
|
|
}
|
|
// In most cases, all composition string should be in same text node.
|
|
if (lastRange->GetEndContainer() == range->GetEndContainer()) {
|
|
if (lastRange->EndOffset() < range->EndOffset()) {
|
|
lastRange = range;
|
|
}
|
|
continue;
|
|
}
|
|
// However, if web apps have inserted different nodes in composition
|
|
// string, composition string may span 2 or more nodes.
|
|
if (lastRange->GetEndContainer() ==
|
|
range->GetEndContainer()->GetNextSibling()) {
|
|
// Fast path for some known applications like Google Keep.
|
|
lastRange = range;
|
|
continue;
|
|
}
|
|
// Unfortunately, really slow path.
|
|
// The ranges should always have a common ancestor, hence, be comparable.
|
|
if (*nsContentUtils::ComparePoints(lastRange->EndRef(),
|
|
range->EndRef()) == -1) {
|
|
lastRange = range;
|
|
}
|
|
}
|
|
}
|
|
return lastRange ? lastRange->EndRef().AsRaw() : RawRangeBoundary();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextComposition::CompositionEventDispatcher
|
|
******************************************************************************/
|
|
|
|
TextComposition::CompositionEventDispatcher::CompositionEventDispatcher(
|
|
TextComposition* aTextComposition, nsINode* aEventTarget,
|
|
EventMessage aEventMessage, const nsAString& aData,
|
|
bool aIsSynthesizedEvent)
|
|
: Runnable("TextComposition::CompositionEventDispatcher"),
|
|
mTextComposition(aTextComposition),
|
|
mEventTarget(aEventTarget),
|
|
mData(aData),
|
|
mEventMessage(aEventMessage),
|
|
mIsSynthesizedEvent(aIsSynthesizedEvent) {}
|
|
|
|
NS_IMETHODIMP
|
|
TextComposition::CompositionEventDispatcher::Run() {
|
|
// The widget can be different from the widget which has dispatched
|
|
// composition events because GetWidget() returns a widget which is proper
|
|
// for calling NotifyIME(). However, this must no be problem since both
|
|
// widget should share native IME context. Therefore, even if an event
|
|
// handler uses the widget for requesting IME to commit or cancel, it works.
|
|
nsCOMPtr<nsIWidget> widget(mTextComposition->GetWidget());
|
|
if (!mTextComposition->IsValidStateForComposition(widget)) {
|
|
return NS_OK; // cannot dispatch any events anymore
|
|
}
|
|
|
|
RefPtr<nsPresContext> presContext = mTextComposition->mPresContext;
|
|
nsCOMPtr<nsINode> eventTarget = mEventTarget;
|
|
RefPtr<BrowserParent> browserParent = mTextComposition->mBrowserParent;
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
switch (mEventMessage) {
|
|
case eCompositionStart: {
|
|
WidgetCompositionEvent compStart(true, eCompositionStart, widget);
|
|
compStart.mNativeIMEContext = mTextComposition->mNativeContext;
|
|
WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText,
|
|
widget);
|
|
ContentEventHandler handler(presContext);
|
|
handler.OnQuerySelectedText(&querySelectedTextEvent);
|
|
NS_ASSERTION(querySelectedTextEvent.Succeeded(),
|
|
"Failed to get selected text");
|
|
if (querySelectedTextEvent.FoundSelection()) {
|
|
compStart.mData = querySelectedTextEvent.mReply->DataRef();
|
|
}
|
|
compStart.mFlags.mIsSynthesizedForTests =
|
|
mTextComposition->IsSynthesizedForTests();
|
|
IMEStateManager::DispatchCompositionEvent(
|
|
eventTarget, presContext, browserParent, &compStart, &status, nullptr,
|
|
mIsSynthesizedEvent);
|
|
break;
|
|
}
|
|
case eCompositionChange:
|
|
case eCompositionCommitAsIs:
|
|
case eCompositionCommit: {
|
|
WidgetCompositionEvent compEvent(true, mEventMessage, widget);
|
|
compEvent.mNativeIMEContext = mTextComposition->mNativeContext;
|
|
if (mEventMessage != eCompositionCommitAsIs) {
|
|
compEvent.mData = mData;
|
|
}
|
|
compEvent.mFlags.mIsSynthesizedForTests =
|
|
mTextComposition->IsSynthesizedForTests();
|
|
IMEStateManager::DispatchCompositionEvent(
|
|
eventTarget, presContext, browserParent, &compEvent, &status, nullptr,
|
|
mIsSynthesizedEvent);
|
|
break;
|
|
}
|
|
default:
|
|
MOZ_CRASH("Unsupported event");
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextCompositionArray
|
|
******************************************************************************/
|
|
|
|
TextCompositionArray::index_type TextCompositionArray::IndexOf(
|
|
const NativeIMEContext& aNativeIMEContext) {
|
|
if (!aNativeIMEContext.IsValid()) {
|
|
return NoIndex;
|
|
}
|
|
for (index_type i = Length(); i > 0; --i) {
|
|
if (ElementAt(i - 1)->GetNativeIMEContext() == aNativeIMEContext) {
|
|
return i - 1;
|
|
}
|
|
}
|
|
return NoIndex;
|
|
}
|
|
|
|
TextCompositionArray::index_type TextCompositionArray::IndexOf(
|
|
nsIWidget* aWidget) {
|
|
return IndexOf(aWidget->GetNativeIMEContext());
|
|
}
|
|
|
|
TextCompositionArray::index_type TextCompositionArray::IndexOf(
|
|
nsPresContext* aPresContext) {
|
|
for (index_type i = Length(); i > 0; --i) {
|
|
if (ElementAt(i - 1)->GetPresContext() == aPresContext) {
|
|
return i - 1;
|
|
}
|
|
}
|
|
return NoIndex;
|
|
}
|
|
|
|
TextCompositionArray::index_type TextCompositionArray::IndexOf(
|
|
nsPresContext* aPresContext, nsINode* aNode) {
|
|
index_type index = IndexOf(aPresContext);
|
|
if (index == NoIndex) {
|
|
return NoIndex;
|
|
}
|
|
nsINode* node = ElementAt(index)->GetEventTargetNode();
|
|
return node == aNode ? index : NoIndex;
|
|
}
|
|
|
|
TextComposition* TextCompositionArray::GetCompositionFor(nsIWidget* aWidget) {
|
|
index_type i = IndexOf(aWidget);
|
|
if (i == NoIndex) {
|
|
return nullptr;
|
|
}
|
|
return ElementAt(i);
|
|
}
|
|
|
|
TextComposition* TextCompositionArray::GetCompositionFor(
|
|
const WidgetCompositionEvent* aCompositionEvent) {
|
|
index_type i = IndexOf(aCompositionEvent->mNativeIMEContext);
|
|
if (i == NoIndex) {
|
|
return nullptr;
|
|
}
|
|
return ElementAt(i);
|
|
}
|
|
|
|
TextComposition* TextCompositionArray::GetCompositionFor(
|
|
nsPresContext* aPresContext) {
|
|
index_type i = IndexOf(aPresContext);
|
|
if (i == NoIndex) {
|
|
return nullptr;
|
|
}
|
|
return ElementAt(i);
|
|
}
|
|
|
|
TextComposition* TextCompositionArray::GetCompositionFor(
|
|
nsPresContext* aPresContext, nsINode* aNode) {
|
|
index_type i = IndexOf(aPresContext, aNode);
|
|
if (i == NoIndex) {
|
|
return nullptr;
|
|
}
|
|
return ElementAt(i);
|
|
}
|
|
|
|
TextComposition* TextCompositionArray::GetCompositionInContent(
|
|
nsPresContext* aPresContext, nsIContent* aContent) {
|
|
// There should be only one composition per content object.
|
|
for (TextComposition* const composition : Reversed(*this)) {
|
|
nsINode* node = composition->GetEventTargetNode();
|
|
if (node && node->IsInclusiveFlatTreeDescendantOf(aContent)) {
|
|
return composition;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace mozilla
|