mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-10 11:55:49 +00:00
6e8192fd45
EditorBase stores a text node, offset in it and length in it of composition string directly. However, this wastes memory space if user never uses IME or user only sometimes uses IME. Additionally, storing all data in TextComposition is better than current design when other classes like CompositionTransaction wants some information of both EditorBase and TextComposition. This patch moves those 3 members from EditorBase to TextComposition. MozReview-Commit-ID: 4N7wmGGfxmt --HG-- extra : rebase_source : bd7cb37fe9631b959ec21da40c20751fec269dca
882 lines
30 KiB
C++
882 lines
30 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 "ContentEventHandler.h"
|
|
#include "IMEContentObserver.h"
|
|
#include "IMEStateManager.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsPresContext.h"
|
|
#include "mozilla/AutoRestore.h"
|
|
#include "mozilla/EditorBase.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/IMEStateManager.h"
|
|
#include "mozilla/MiscEvents.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/TextComposition.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/dom/TabParent.h"
|
|
|
|
#ifdef XP_MACOSX
|
|
// Some defiens will be conflict with OSX SDK
|
|
#define TextRange _TextRange
|
|
#define TextRangeArray _TextRangeArray
|
|
#define Comment _Comment
|
|
#endif
|
|
|
|
#include "nsPluginInstanceOwner.h"
|
|
|
|
#ifdef XP_MACOSX
|
|
#undef TextRange
|
|
#undef TextRangeArray
|
|
#undef Comment
|
|
#endif
|
|
|
|
using namespace mozilla::widget;
|
|
|
|
namespace mozilla {
|
|
|
|
#define IDEOGRAPHIC_SPACE (NS_LITERAL_STRING(u"\x3000"))
|
|
|
|
/******************************************************************************
|
|
* TextComposition
|
|
******************************************************************************/
|
|
|
|
bool TextComposition::sHandlingSelectionEvent = false;
|
|
|
|
TextComposition::TextComposition(nsPresContext* aPresContext,
|
|
nsINode* aNode,
|
|
TabParent* aTabParent,
|
|
WidgetCompositionEvent* aCompositionEvent)
|
|
: mPresContext(aPresContext)
|
|
, mNode(aNode)
|
|
, mTabParent(aTabParent)
|
|
, mNativeContext(aCompositionEvent->mNativeIMEContext)
|
|
, mCompositionStartOffset(0)
|
|
, mTargetClauseOffsetInComposition(0)
|
|
, mCompositionStartOffsetInTextNode(UINT32_MAX)
|
|
, mCompositionLengthInTextNode(UINT32_MAX)
|
|
, mIsSynthesizedForTests(aCompositionEvent->mFlags.mIsSynthesizedForTests)
|
|
, mIsComposing(false)
|
|
, mIsEditorHandlingEvent(false)
|
|
, mIsRequestingCommit(false)
|
|
, mIsRequestingCancel(false)
|
|
, mRequestedToCommitOrCancel(false)
|
|
, mHasReceivedCommitEvent(false)
|
|
, mWasNativeCompositionEndEventDiscarded(false)
|
|
, mAllowControlCharacters(
|
|
Preferences::GetBool("dom.compositionevent.allow_control_characters",
|
|
false))
|
|
, mWasCompositionStringEmpty(true)
|
|
{
|
|
MOZ_ASSERT(aCompositionEvent->mNativeIMEContext.IsValid());
|
|
}
|
|
|
|
void
|
|
TextComposition::Destroy()
|
|
{
|
|
mPresContext = nullptr;
|
|
mNode = nullptr;
|
|
mTabParent = 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.
|
|
}
|
|
|
|
bool
|
|
TextComposition::IsValidStateForComposition(nsIWidget* aWidget) const
|
|
{
|
|
return !Destroyed() && aWidget && !aWidget->Destroyed() &&
|
|
mPresContext->GetPresShell() &&
|
|
!mPresContext->GetPresShell()->IsDestroying();
|
|
}
|
|
|
|
bool
|
|
TextComposition::MaybeDispatchCompositionUpdate(
|
|
const WidgetCompositionEvent* aCompositionEvent)
|
|
{
|
|
MOZ_RELEASE_ASSERT(!mTabParent);
|
|
|
|
if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
|
|
return false;
|
|
}
|
|
|
|
if (mLastData == aCompositionEvent->mData) {
|
|
return true;
|
|
}
|
|
CloneAndDispatchAs(aCompositionEvent, eCompositionUpdate);
|
|
return IsValidStateForComposition(aCompositionEvent->mWidget);
|
|
}
|
|
|
|
BaseEventFlags
|
|
TextComposition::CloneAndDispatchAs(
|
|
const WidgetCompositionEvent* aCompositionEvent,
|
|
EventMessage aMessage,
|
|
nsEventStatus* aStatus,
|
|
EventDispatchingCallback* aCallBack)
|
|
{
|
|
MOZ_RELEASE_ASSERT(!mTabParent);
|
|
|
|
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.mTime = aCompositionEvent->mTime;
|
|
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)
|
|
{
|
|
nsPluginInstanceOwner::GeneratePluginEvent(aOriginalEvent,
|
|
aDispatchEvent);
|
|
|
|
EventDispatcher::Dispatch(mNode, mPresContext,
|
|
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 (mTabParent) {
|
|
// The composition event should be discarded in the child process too.
|
|
Unused << mTabParent->SendCompositionEvent(*aCompositionEvent);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
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 TabParent, composition should be in the
|
|
// remote process.
|
|
if (mTabParent) {
|
|
Unused << mTabParent->SendCompositionEvent(*aCompositionEvent);
|
|
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");
|
|
bool removePlaceholderCharacter =
|
|
Preferences::GetBool("intl.ime.remove_placeholder_character_at_commit",
|
|
false);
|
|
if (removePlaceholderCharacter && 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.
|
|
if (dispatchDOMTextEvent &&
|
|
aCompositionEvent->mMessage != eCompositionChange &&
|
|
!mIsComposing && 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) {
|
|
aCompositionEvent->mFlags =
|
|
CloneAndDispatchAs(aCompositionEvent, eCompositionChange,
|
|
aStatus, aCallBack);
|
|
} else {
|
|
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,
|
|
TabParent* aTabParent,
|
|
WidgetSelectionEvent* aSelectionEvent)
|
|
{
|
|
// If the content is a container of TabParent, composition should be in the
|
|
// remote process.
|
|
if (aTabParent) {
|
|
Unused << aTabParent->SendSelectionEvent(*aSelectionEvent);
|
|
aSelectionEvent->StopPropagation();
|
|
return;
|
|
}
|
|
|
|
ContentEventHandler handler(aPresContext);
|
|
AutoRestore<bool> saveHandlingSelectionEvent(sHandlingSelectionEvent);
|
|
sHandlingSelectionEvent = true;
|
|
// 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 selectedTextEvent(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()) {
|
|
selectedTextEvent.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");
|
|
selectedTextEvent.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->IsManaging(this)) {
|
|
doQuerySelection = false;
|
|
contentObserver->HandleQueryContentEvent(&selectedTextEvent);
|
|
}
|
|
// 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(&selectedTextEvent);
|
|
}
|
|
|
|
if (NS_WARN_IF(!selectedTextEvent.mSucceeded)) {
|
|
return 0; // XXX Is this okay?
|
|
}
|
|
return selectedTextEvent.mReply.mOffset;
|
|
}
|
|
|
|
void
|
|
TextComposition::OnCompositionEventDispatched(
|
|
const WidgetCompositionEvent* aCompositionEvent)
|
|
{
|
|
MOZ_RELEASE_ASSERT(!mTabParent);
|
|
|
|
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->IsManaging(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)
|
|
{
|
|
// 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);
|
|
|
|
{
|
|
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, EmptyString(),
|
|
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, mTabParent);
|
|
}
|
|
|
|
void
|
|
TextComposition::EditorWillHandleCompositionChangeEvent(
|
|
const WidgetCompositionEvent* aCompositionChangeEvent)
|
|
{
|
|
mIsComposing = aCompositionChangeEvent->IsComposing();
|
|
mRanges = aCompositionChangeEvent->mRanges;
|
|
mIsEditorHandlingEvent = 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(!mTabParent);
|
|
|
|
MOZ_ASSERT(!mIsEditorHandlingEvent,
|
|
"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;
|
|
mIsEditorHandlingEvent = false;
|
|
}
|
|
|
|
void
|
|
TextComposition::StartHandlingComposition(EditorBase* aEditorBase)
|
|
{
|
|
MOZ_RELEASE_ASSERT(!mTabParent);
|
|
|
|
MOZ_ASSERT(!HasEditor(), "There is a handling editor already");
|
|
mEditorBaseWeak = do_GetWeakReference(static_cast<nsIEditor*>(aEditorBase));
|
|
}
|
|
|
|
void
|
|
TextComposition::EndHandlingComposition(EditorBase* aEditorBase)
|
|
{
|
|
MOZ_RELEASE_ASSERT(!mTabParent);
|
|
|
|
#ifdef DEBUG
|
|
RefPtr<EditorBase> editorBase = GetEditorBase();
|
|
MOZ_ASSERT(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();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* TextComposition::CompositionEventDispatcher
|
|
******************************************************************************/
|
|
|
|
TextComposition::CompositionEventDispatcher::CompositionEventDispatcher(
|
|
TextComposition* aComposition,
|
|
nsINode* aEventTarget,
|
|
EventMessage aEventMessage,
|
|
const nsAString& aData,
|
|
bool aIsSynthesizedEvent)
|
|
: Runnable("TextComposition::CompositionEventDispatcher")
|
|
, mTextComposition(aComposition)
|
|
, 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;
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
switch (mEventMessage) {
|
|
case eCompositionStart: {
|
|
WidgetCompositionEvent compStart(true, eCompositionStart, widget);
|
|
compStart.mNativeIMEContext = mTextComposition->mNativeContext;
|
|
WidgetQueryContentEvent selectedText(true, eQuerySelectedText, widget);
|
|
ContentEventHandler handler(presContext);
|
|
handler.OnQuerySelectedText(&selectedText);
|
|
NS_ASSERTION(selectedText.mSucceeded, "Failed to get selected text");
|
|
compStart.mData = selectedText.mReply.mString;
|
|
compStart.mFlags.mIsSynthesizedForTests =
|
|
mTextComposition->IsSynthesizedForTests();
|
|
IMEStateManager::DispatchCompositionEvent(mEventTarget, presContext,
|
|
&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(mEventTarget, presContext,
|
|
&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 (index_type i = Length(); i > 0; --i) {
|
|
nsINode* node = ElementAt(i - 1)->GetEventTargetNode();
|
|
if (node && nsContentUtils::ContentIsDescendantOf(node, aContent)) {
|
|
return ElementAt(i - 1);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace mozilla
|