bool
TextComposition::MaybeDispatchCompositionUpdate(
const WidgetCompositionEvent* aCompositionEvent)
{
if (!IsValidStateForComposition(aCompositionEvent->widget)) {
return false;
}
if (mLastData == aCompositionEvent->mData) {
return true;
}
CloneAndDispatchAs(aCompositionEvent, NS_COMPOSITION_UPDATE);
return IsValidStateForComposition(aCompositionEvent->widget);
}
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();
}
}
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;
}
bool
TextComposition::MaybeDispatchCompositionUpdate(
const WidgetCompositionEvent* aCompositionEvent)
{
MOZ_RELEASE_ASSERT(!mTabParent);
if (!IsValidStateForComposition(aCompositionEvent->widget)) {
return false;
}
if (mLastData == aCompositionEvent->mData) {
return true;
}
CloneAndDispatchAs(aCompositionEvent, eCompositionUpdate);
return IsValidStateForComposition(aCompositionEvent->widget);
}
BaseEventFlags
TextComposition::CloneAndDispatchAs(
const WidgetCompositionEvent* aCompositionEvent,
uint32_t aMessage,
nsEventStatus* aStatus,
EventDispatchingCallback* aCallBack)
{
MOZ_ASSERT(IsValidStateForComposition(aCompositionEvent->widget),
"Should be called only when it's safe to dispatch an event");
WidgetCompositionEvent compositionEvent(aCompositionEvent->mFlags.mIsTrusted,
aMessage, aCompositionEvent->widget);
compositionEvent.time = aCompositionEvent->time;
compositionEvent.timeStamp = aCompositionEvent->timeStamp;
compositionEvent.mData = aCompositionEvent->mData;
compositionEvent.mFlags.mIsSynthesizedForTests =
aCompositionEvent->mFlags.mIsSynthesizedForTests;
nsEventStatus dummyStatus = nsEventStatus_eConsumeNoDefault;
nsEventStatus* status = aStatus ? aStatus : &dummyStatus;
if (aMessage == NS_COMPOSITION_UPDATE) {
mLastData = compositionEvent.mData;
}
EventDispatcher::Dispatch(mNode, mPresContext,
&compositionEvent, nullptr, status, aCallBack);
return compositionEvent.mFlags;
}
bool
TextComposition::MaybeDispatchCompositionUpdate(
const WidgetCompositionEvent* aCompositionEvent)
{
MOZ_RELEASE_ASSERT(!mTabParent);
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) {
return true;
}
CloneAndDispatchAs(aCompositionEvent, eCompositionUpdate);
return IsValidStateForComposition(aCompositionEvent->mWidget);
}
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. (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);
}
void
TextComposition::DispatchCompositionEvent(
WidgetCompositionEvent* aCompositionEvent,
nsEventStatus* aStatus,
EventDispatchingCallback* aCallBack,
bool aIsSynthesized)
{
if (!mAllowControlCharacters) {
RemoveControlCharactersFrom(aCompositionEvent->mData,
aCompositionEvent->mRanges);
}
if (aCompositionEvent->message == NS_COMPOSITION_COMMIT_AS_IS) {
NS_ASSERTION(!aCompositionEvent->mRanges,
"mRanges of NS_COMPOSITION_COMMIT_AS_IS should be null");
aCompositionEvent->mRanges = nullptr;
NS_ASSERTION(aCompositionEvent->mData.IsEmpty(),
"mData of NS_COMPOSITION_COMMIT_AS_IS should be empty string");
if (mLastData == IDEOGRAPHIC_SPACE) {
// If the last data is an ideographic space (FullWidth space), it must be
// a placeholder character of some Chinese IME. So, committing with
// this data must not be expected by users. Let's use empty string.
aCompositionEvent->mData.Truncate();
} else {
aCompositionEvent->mData = mLastData;
}
} else if (aCompositionEvent->message == NS_COMPOSITION_COMMIT) {
NS_ASSERTION(!aCompositionEvent->mRanges,
"mRanges of NS_COMPOSITION_COMMIT should be null");
aCompositionEvent->mRanges = nullptr;
}
if (!IsValidStateForComposition(aCompositionEvent->widget)) {
*aStatus = nsEventStatus_eConsumeNoDefault;
return;
}
// 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;
}
// 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->message) {
case NS_COMPOSITION_END:
case NS_COMPOSITION_CHANGE:
case NS_COMPOSITION_COMMIT_AS_IS:
case NS_COMPOSITION_COMMIT:
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 NS_COMPOSITION_CHANGE 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->message != NS_COMPOSITION_CHANGE &&
!mIsComposing && mLastData == aCompositionEvent->mData) {
dispatchEvent = dispatchDOMTextEvent = false;
}
// widget may dispatch redundant NS_COMPOSITION_CHANGE event
// which modifies neither composition string, clauses nor caret
// position. In such case, we shouldn't dispatch DOM events.
if (dispatchDOMTextEvent &&
aCompositionEvent->message == NS_COMPOSITION_CHANGE &&
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 NS_COMPOSITION_CHANGE 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->message != NS_COMPOSITION_CHANGE) {
aCompositionEvent->mFlags =
CloneAndDispatchAs(aCompositionEvent, NS_COMPOSITION_CHANGE,
aStatus, aCallBack);
} else {
EventDispatcher::Dispatch(mNode, mPresContext,
aCompositionEvent, nullptr, aStatus, aCallBack);
}
} else {
*aStatus = nsEventStatus_eConsumeNoDefault;
}
if (!IsValidStateForComposition(aCompositionEvent->widget)) {
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->message != NS_COMPOSITION_END) {
CloneAndDispatchAs(aCompositionEvent, NS_COMPOSITION_END);
}
MOZ_ASSERT(!mIsComposing, "Why is the editor still composing?");
MOZ_ASSERT(!HasEditor(), "Why does the editor still keep to hold this?");
}
// Notify composition update to widget if possible
NotityUpdateComposition(aCompositionEvent);
}