diff options
Diffstat (limited to 'widget/IMEData.h')
| -rw-r--r-- | widget/IMEData.h | 882 |
1 files changed, 882 insertions, 0 deletions
diff --git a/widget/IMEData.h b/widget/IMEData.h new file mode 100644 index 000000000..b12497be3 --- /dev/null +++ b/widget/IMEData.h @@ -0,0 +1,882 @@ +/* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* 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/. */ + +#ifndef mozilla_widget_IMEData_h_ +#define mozilla_widget_IMEData_h_ + +#include "nsPoint.h" +#include "nsRect.h" +#include "nsStringGlue.h" + +class nsIWidget; + +namespace mozilla { + +class WritingMode; + +} // namespace mozilla + +/** + * Preference for receiving IME updates + * + * If mWantUpdates is not NOTIFY_NOTHING, nsTextStateManager will observe text + * change and/or selection change and call nsIWidget::NotifyIME() with + * NOTIFY_IME_OF_SELECTION_CHANGE and/or NOTIFY_IME_OF_TEXT_CHANGE. + * Please note that the text change observing cost is very expensive especially + * on an HTML editor has focus. + * If the IME implementation on a particular platform doesn't care about + * NOTIFY_IME_OF_SELECTION_CHANGE and/or NOTIFY_IME_OF_TEXT_CHANGE, + * they should set mWantUpdates to NOTIFY_NOTHING to avoid the cost. + * If the IME implementation needs notifications even while our process is + * deactive, it should also set NOTIFY_DURING_DEACTIVE. + */ +struct nsIMEUpdatePreference final +{ + typedef uint8_t Notifications; + + enum : Notifications + { + NOTIFY_NOTHING = 0, + NOTIFY_TEXT_CHANGE = 1 << 1, + NOTIFY_POSITION_CHANGE = 1 << 2, + // NOTIFY_MOUSE_BUTTON_EVENT_ON_CHAR is used when mouse button is pressed + // or released on a character in the focused editor. The notification is + // notified to IME as a mouse event. If it's consumed by IME, NotifyIME() + // returns NS_SUCCESS_EVENT_CONSUMED. Otherwise, it returns NS_OK if it's + // handled without any error. + NOTIFY_MOUSE_BUTTON_EVENT_ON_CHAR = 1 << 3, + // NOTE: NOTIFY_DURING_DEACTIVE isn't supported in environments where two + // or more compositions are possible. E.g., Mac and Linux (GTK). + NOTIFY_DURING_DEACTIVE = 1 << 7 + }; + + nsIMEUpdatePreference() + : mWantUpdates(NOTIFY_NOTHING) + { + } + + explicit nsIMEUpdatePreference(Notifications aWantUpdates) + : mWantUpdates(aWantUpdates) + { + } + + nsIMEUpdatePreference operator|(const nsIMEUpdatePreference& aOther) const + { + return nsIMEUpdatePreference(aOther.mWantUpdates | mWantUpdates); + } + + bool WantTextChange() const + { + return !!(mWantUpdates & NOTIFY_TEXT_CHANGE); + } + + bool WantPositionChanged() const + { + return !!(mWantUpdates & NOTIFY_POSITION_CHANGE); + } + + bool WantChanges() const + { + return WantTextChange(); + } + + bool WantMouseButtonEventOnChar() const + { + return !!(mWantUpdates & NOTIFY_MOUSE_BUTTON_EVENT_ON_CHAR); + } + + bool WantDuringDeactive() const + { + return !!(mWantUpdates & NOTIFY_DURING_DEACTIVE); + } + + Notifications mWantUpdates; +}; + +/** + * Contains IMEStatus plus information about the current + * input context that the IME can use as hints if desired. + */ + +namespace mozilla { +namespace widget { + +struct IMEState final +{ + /** + * IME enabled states, the mEnabled value of + * SetInputContext()/GetInputContext() should be one value of following + * values. + * + * WARNING: If you change these values, you also need to edit: + * nsIDOMWindowUtils.idl + * nsContentUtils::GetWidgetStatusFromIMEStatus + */ + enum Enabled + { + /** + * 'Disabled' means the user cannot use IME. So, the IME open state should + * be 'closed' during 'disabled'. + */ + DISABLED, + /** + * 'Enabled' means the user can use IME. + */ + ENABLED, + /** + * 'Password' state is a special case for the password editors. + * E.g., on mac, the password editors should disable the non-Roman + * keyboard layouts at getting focus. Thus, the password editor may have + * special rules on some platforms. + */ + PASSWORD, + /** + * This state is used when a plugin is focused. + * When a plug-in is focused content, we should send native events + * directly. Because we don't process some native events, but they may + * be needed by the plug-in. + */ + PLUGIN, + /** + * 'Unknown' is useful when you cache this enum. So, this shouldn't be + * used with nsIWidget::SetInputContext(). + */ + UNKNOWN + }; + Enabled mEnabled; + + /** + * IME open states the mOpen value of SetInputContext() should be one value of + * OPEN, CLOSE or DONT_CHANGE_OPEN_STATE. GetInputContext() should return + * OPEN, CLOSE or OPEN_STATE_NOT_SUPPORTED. + */ + enum Open + { + /** + * 'Unsupported' means the platform cannot return actual IME open state. + * This value is used only by GetInputContext(). + */ + OPEN_STATE_NOT_SUPPORTED, + /** + * 'Don't change' means the widget shouldn't change IME open state when + * SetInputContext() is called. + */ + DONT_CHANGE_OPEN_STATE = OPEN_STATE_NOT_SUPPORTED, + /** + * 'Open' means that IME should compose in its primary language (or latest + * input mode except direct ASCII character input mode). Even if IME is + * opened by this value, users should be able to close IME by theirselves. + * Web contents can specify this value by |ime-mode: active;|. + */ + OPEN, + /** + * 'Closed' means that IME shouldn't handle key events (or should handle + * as ASCII character inputs on mobile device). Even if IME is closed by + * this value, users should be able to open IME by theirselves. + * Web contents can specify this value by |ime-mode: inactive;|. + */ + CLOSED + }; + Open mOpen; + + IMEState() + : mEnabled(ENABLED) + , mOpen(DONT_CHANGE_OPEN_STATE) + { + } + + explicit IMEState(Enabled aEnabled, Open aOpen = DONT_CHANGE_OPEN_STATE) + : mEnabled(aEnabled) + , mOpen(aOpen) + { + } + + // Returns true if the user can input characters. + // This means that a plain text editor, an HTML editor, a password editor or + // a plain text editor whose ime-mode is "disabled". + bool IsEditable() const + { + return mEnabled == ENABLED || mEnabled == PASSWORD; + } + // Returns true if the user might be able to input characters. + // This means that a plain text editor, an HTML editor, a password editor, + // a plain text editor whose ime-mode is "disabled" or a windowless plugin + // has focus. + bool MaybeEditable() const + { + return IsEditable() || mEnabled == PLUGIN; + } +}; + +// NS_ONLY_ONE_NATIVE_IME_CONTEXT is a special value of native IME context. +// If there can be only one IME composition in a process, this can be used. +#define NS_ONLY_ONE_NATIVE_IME_CONTEXT \ + (reinterpret_cast<void*>(static_cast<intptr_t>(-1))) + +struct NativeIMEContext final +{ + // Pointer to native IME context. Typically this is the result of + // nsIWidget::GetNativeData(NS_RAW_NATIVE_IME_CONTEXT) in the parent process. + // See also NS_ONLY_ONE_NATIVE_IME_CONTEXT. + uintptr_t mRawNativeIMEContext; + // Process ID of the origin of mNativeIMEContext. + uint64_t mOriginProcessID; + + NativeIMEContext() + { + Init(nullptr); + } + + explicit NativeIMEContext(nsIWidget* aWidget) + { + Init(aWidget); + } + + bool IsValid() const + { + return mRawNativeIMEContext && + mOriginProcessID != static_cast<uintptr_t>(-1); + } + + void Init(nsIWidget* aWidget); + void InitWithRawNativeIMEContext(const void* aRawNativeIMEContext) + { + InitWithRawNativeIMEContext(const_cast<void*>(aRawNativeIMEContext)); + } + void InitWithRawNativeIMEContext(void* aRawNativeIMEContext); + + bool operator==(const NativeIMEContext& aOther) const + { + return mRawNativeIMEContext == aOther.mRawNativeIMEContext && + mOriginProcessID == aOther.mOriginProcessID; + } + bool operator!=(const NativeIMEContext& aOther) const + { + return !(*this == aOther); + } +}; + +struct InputContext final +{ + InputContext() + : mOrigin(XRE_IsParentProcess() ? ORIGIN_MAIN : ORIGIN_CONTENT) + , mMayBeIMEUnaware(false) + { + } + + bool IsPasswordEditor() const + { + return mHTMLInputType.LowerCaseEqualsLiteral("password"); + } + + IMEState mIMEState; + + /* The type of the input if the input is a html input field */ + nsString mHTMLInputType; + + /* The type of the inputmode */ + nsString mHTMLInputInputmode; + + /* A hint for the action that is performed when the input is submitted */ + nsString mActionHint; + + /** + * mOrigin indicates whether this focus event refers to main or remote + * content. + */ + enum Origin + { + // Adjusting focus of content on the main process + ORIGIN_MAIN, + // Adjusting focus of content in a remote process + ORIGIN_CONTENT + }; + Origin mOrigin; + + /* True if the webapp may be unaware of IME events such as input event or + * composiion events. This enables a key-events-only mode on Android for + * compatibility with webapps relying on key listeners. */ + bool mMayBeIMEUnaware; + + bool IsOriginMainProcess() const + { + return mOrigin == ORIGIN_MAIN; + } + + bool IsOriginContentProcess() const + { + return mOrigin == ORIGIN_CONTENT; + } + + bool IsOriginCurrentProcess() const + { + if (XRE_IsParentProcess()) { + return IsOriginMainProcess(); + } + return IsOriginContentProcess(); + } +}; + +struct InputContextAction final +{ + /** + * mCause indicates what action causes calling nsIWidget::SetInputContext(). + * It must be one of following values. + */ + enum Cause + { + // The cause is unknown but originated from content. Focus might have been + // changed by content script. + CAUSE_UNKNOWN, + // The cause is unknown but originated from chrome. Focus might have been + // changed by chrome script. + CAUSE_UNKNOWN_CHROME, + // The cause is user's keyboard operation. + CAUSE_KEY, + // The cause is user's mouse operation. + CAUSE_MOUSE, + // The cause is user's touch operation (implies mouse) + CAUSE_TOUCH + }; + Cause mCause; + + /** + * mFocusChange indicates what happened for focus. + */ + enum FocusChange + { + FOCUS_NOT_CHANGED, + // A content got focus. + GOT_FOCUS, + // Focused content lost focus. + LOST_FOCUS, + // Menu got pseudo focus that means focused content isn't changed but + // keyboard events will be handled by menu. + MENU_GOT_PSEUDO_FOCUS, + // Menu lost pseudo focus that means focused content will handle keyboard + // events. + MENU_LOST_PSEUDO_FOCUS + }; + FocusChange mFocusChange; + + bool ContentGotFocusByTrustedCause() const + { + return (mFocusChange == GOT_FOCUS && + mCause != CAUSE_UNKNOWN); + } + + bool UserMightRequestOpenVKB() const + { + return (mFocusChange == FOCUS_NOT_CHANGED && + (mCause == CAUSE_MOUSE || mCause == CAUSE_TOUCH)); + } + + static bool IsUserAction(Cause aCause) + { + switch (aCause) { + case CAUSE_KEY: + case CAUSE_MOUSE: + case CAUSE_TOUCH: + return true; + default: + return false; + } + } + + InputContextAction() + : mCause(CAUSE_UNKNOWN) + , mFocusChange(FOCUS_NOT_CHANGED) + { + } + + explicit InputContextAction(Cause aCause, + FocusChange aFocusChange = FOCUS_NOT_CHANGED) + : mCause(aCause) + , mFocusChange(aFocusChange) + { + } +}; + +// IMEMessage is shared by IMEStateManager and TextComposition. +// Update values in GeckoEditable.java if you make changes here. +// XXX Negative values are used in Android... +typedef int8_t IMEMessageType; +enum IMEMessage : IMEMessageType +{ + // This is used by IMENotification internally. This means that the instance + // hasn't been initialized yet. + NOTIFY_IME_OF_NOTHING, + // An editable content is getting focus + NOTIFY_IME_OF_FOCUS, + // An editable content is losing focus + NOTIFY_IME_OF_BLUR, + // Selection in the focused editable content is changed + NOTIFY_IME_OF_SELECTION_CHANGE, + // Text in the focused editable content is changed + NOTIFY_IME_OF_TEXT_CHANGE, + // Notified when a dispatched composition event is handled by the + // contents. This must be notified after the other notifications. + // Note that if a remote process has focus, this is notified only once when + // all dispatched events are handled completely. So, the receiver shouldn't + // count number of received this notification for comparing with the number + // of dispatched events. + // NOTE: If a composition event causes moving focus from the focused editor, + // this notification may not be notified as usual. Even in such case, + // NOTIFY_IME_OF_BLUR is always sent. So, notification listeners + // should tread the blur notification as including this if there is + // pending composition events. + NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED, + // Position or size of focused element may be changed. + NOTIFY_IME_OF_POSITION_CHANGE, + // Mouse button event is fired on a character in focused editor + NOTIFY_IME_OF_MOUSE_BUTTON_EVENT, + // Request to commit current composition to IME + // (some platforms may not support) + REQUEST_TO_COMMIT_COMPOSITION, + // Request to cancel current composition to IME + // (some platforms may not support) + REQUEST_TO_CANCEL_COMPOSITION +}; + +// FYI: Implemented in nsBaseWidget.cpp +const char* ToChar(IMEMessage aIMEMessage); + +struct IMENotification final +{ + IMENotification() + : mMessage(NOTIFY_IME_OF_NOTHING) + { + } + + IMENotification(const IMENotification& aOther) + : mMessage(NOTIFY_IME_OF_NOTHING) + { + Assign(aOther); + } + + ~IMENotification() + { + Clear(); + } + + MOZ_IMPLICIT IMENotification(IMEMessage aMessage) + : mMessage(aMessage) + { + switch (aMessage) { + case NOTIFY_IME_OF_SELECTION_CHANGE: + mSelectionChangeData.mString = new nsString(); + mSelectionChangeData.Clear(); + break; + case NOTIFY_IME_OF_TEXT_CHANGE: + mTextChangeData.Clear(); + break; + case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT: + mMouseButtonEventData.mEventMessage = eVoidEvent; + mMouseButtonEventData.mOffset = UINT32_MAX; + mMouseButtonEventData.mCursorPos.Set(nsIntPoint(0, 0)); + mMouseButtonEventData.mCharRect.Set(nsIntRect(0, 0, 0, 0)); + mMouseButtonEventData.mButton = -1; + mMouseButtonEventData.mButtons = 0; + mMouseButtonEventData.mModifiers = 0; + break; + default: + break; + } + } + + void Assign(const IMENotification& aOther) + { + bool changingMessage = mMessage != aOther.mMessage; + if (changingMessage) { + Clear(); + mMessage = aOther.mMessage; + } + switch (mMessage) { + case NOTIFY_IME_OF_SELECTION_CHANGE: + if (changingMessage) { + mSelectionChangeData.mString = new nsString(); + } + mSelectionChangeData.Assign(aOther.mSelectionChangeData); + break; + case NOTIFY_IME_OF_TEXT_CHANGE: + mTextChangeData = aOther.mTextChangeData; + break; + case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT: + mMouseButtonEventData = aOther.mMouseButtonEventData; + break; + default: + break; + } + } + + IMENotification& operator=(const IMENotification& aOther) + { + Assign(aOther); + return *this; + } + + void Clear() + { + if (mMessage == NOTIFY_IME_OF_SELECTION_CHANGE) { + MOZ_ASSERT(mSelectionChangeData.mString); + delete mSelectionChangeData.mString; + mSelectionChangeData.mString = nullptr; + } + mMessage = NOTIFY_IME_OF_NOTHING; + } + + bool HasNotification() const + { + return mMessage != NOTIFY_IME_OF_NOTHING; + } + + void MergeWith(const IMENotification& aNotification) + { + switch (mMessage) { + case NOTIFY_IME_OF_NOTHING: + MOZ_ASSERT(aNotification.mMessage != NOTIFY_IME_OF_NOTHING); + Assign(aNotification); + break; + case NOTIFY_IME_OF_SELECTION_CHANGE: + MOZ_ASSERT(aNotification.mMessage == NOTIFY_IME_OF_SELECTION_CHANGE); + mSelectionChangeData.Assign(aNotification.mSelectionChangeData); + break; + case NOTIFY_IME_OF_TEXT_CHANGE: + MOZ_ASSERT(aNotification.mMessage == NOTIFY_IME_OF_TEXT_CHANGE); + mTextChangeData += aNotification.mTextChangeData; + break; + case NOTIFY_IME_OF_POSITION_CHANGE: + case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED: + MOZ_ASSERT(aNotification.mMessage == mMessage); + break; + default: + MOZ_CRASH("Merging notification isn't supported"); + break; + } + } + + IMEMessage mMessage; + + struct Point + { + int32_t mX; + int32_t mY; + + void Set(const nsIntPoint& aPoint) + { + mX = aPoint.x; + mY = aPoint.y; + } + nsIntPoint AsIntPoint() const + { + return nsIntPoint(mX, mY); + } + }; + + struct Rect + { + int32_t mX; + int32_t mY; + int32_t mWidth; + int32_t mHeight; + + void Set(const nsIntRect& aRect) + { + mX = aRect.x; + mY = aRect.y; + mWidth = aRect.width; + mHeight = aRect.height; + } + nsIntRect AsIntRect() const + { + return nsIntRect(mX, mY, mWidth, mHeight); + } + }; + + // NOTIFY_IME_OF_SELECTION_CHANGE specific data + struct SelectionChangeDataBase + { + // Selection range. + uint32_t mOffset; + + // Selected string + nsString* mString; + + // Writing mode at the selection. + uint8_t mWritingMode; + + bool mReversed; + bool mCausedByComposition; + bool mCausedBySelectionEvent; + bool mOccurredDuringComposition; + + void SetWritingMode(const WritingMode& aWritingMode); + WritingMode GetWritingMode() const; + + uint32_t StartOffset() const + { + return mOffset + (mReversed ? Length() : 0); + } + uint32_t EndOffset() const + { + return mOffset + (mReversed ? 0 : Length()); + } + const nsString& String() const + { + return *mString; + } + uint32_t Length() const + { + return mString->Length(); + } + bool IsInInt32Range() const + { + return mOffset + Length() <= INT32_MAX; + } + bool IsCollapsed() const + { + return mString->IsEmpty(); + } + void ClearSelectionData() + { + mOffset = UINT32_MAX; + mString->Truncate(); + mWritingMode = 0; + mReversed = false; + } + void Clear() + { + ClearSelectionData(); + mCausedByComposition = false; + mCausedBySelectionEvent = false; + mOccurredDuringComposition = false; + } + bool IsValid() const + { + return mOffset != UINT32_MAX; + } + void Assign(const SelectionChangeDataBase& aOther) + { + mOffset = aOther.mOffset; + *mString = aOther.String(); + mWritingMode = aOther.mWritingMode; + mReversed = aOther.mReversed; + AssignReason(aOther.mCausedByComposition, + aOther.mCausedBySelectionEvent, + aOther.mOccurredDuringComposition); + } + void AssignReason(bool aCausedByComposition, + bool aCausedBySelectionEvent, + bool aOccurredDuringComposition) + { + mCausedByComposition = aCausedByComposition; + mCausedBySelectionEvent = aCausedBySelectionEvent; + mOccurredDuringComposition = aOccurredDuringComposition; + } + }; + + // SelectionChangeDataBase cannot have constructors because it's used in + // the union. Therefore, SelectionChangeData should only implement + // constructors. In other words, add other members to + // SelectionChangeDataBase. + struct SelectionChangeData final : public SelectionChangeDataBase + { + SelectionChangeData() + { + mString = &mStringInstance; + Clear(); + } + explicit SelectionChangeData(const SelectionChangeDataBase& aOther) + { + mString = &mStringInstance; + Assign(aOther); + } + SelectionChangeData(const SelectionChangeData& aOther) + { + mString = &mStringInstance; + Assign(aOther); + } + SelectionChangeData& operator=(const SelectionChangeDataBase& aOther) + { + mString = &mStringInstance; + Assign(aOther); + return *this; + } + SelectionChangeData& operator=(const SelectionChangeData& aOther) + { + mString = &mStringInstance; + Assign(aOther); + return *this; + } + + private: + // When SelectionChangeData is used outside of union, it shouldn't create + // nsString instance in the heap as far as possible. + nsString mStringInstance; + }; + + struct TextChangeDataBase + { + // mStartOffset is the start offset of modified or removed text in + // original content and inserted text in new content. + uint32_t mStartOffset; + // mRemovalEndOffset is the end offset of modified or removed text in + // original content. If the value is same as mStartOffset, no text hasn't + // been removed yet. + uint32_t mRemovedEndOffset; + // mAddedEndOffset is the end offset of inserted text or same as + // mStartOffset if just removed. The vlaue is offset in the new content. + uint32_t mAddedEndOffset; + + // Note that TextChangeDataBase may be the result of merging two or more + // changes especially in e10s mode. + + // mCausedOnlyByComposition is true only when *all* merged changes are + // caused by composition. + bool mCausedOnlyByComposition; + // mIncludingChangesDuringComposition is true if at least one change which + // is not caused by composition occurred during the last composition. + // Note that if after the last composition is finished and there are some + // changes not caused by composition, this is set to false. + bool mIncludingChangesDuringComposition; + // mIncludingChangesWithoutComposition is true if there is at least one + // change which did occur when there wasn't a composition ongoing. + bool mIncludingChangesWithoutComposition; + + uint32_t OldLength() const + { + MOZ_ASSERT(IsValid()); + return mRemovedEndOffset - mStartOffset; + } + uint32_t NewLength() const + { + MOZ_ASSERT(IsValid()); + return mAddedEndOffset - mStartOffset; + } + + // Positive if text is added. Negative if text is removed. + int64_t Difference() const + { + return mAddedEndOffset - mRemovedEndOffset; + } + + bool IsInInt32Range() const + { + MOZ_ASSERT(IsValid()); + return mStartOffset <= INT32_MAX && + mRemovedEndOffset <= INT32_MAX && + mAddedEndOffset <= INT32_MAX; + } + + bool IsValid() const + { + return !(mStartOffset == UINT32_MAX && + !mRemovedEndOffset && !mAddedEndOffset); + } + + void Clear() + { + mStartOffset = UINT32_MAX; + mRemovedEndOffset = mAddedEndOffset = 0; + } + + void MergeWith(const TextChangeDataBase& aOther); + TextChangeDataBase& operator+=(const TextChangeDataBase& aOther) + { + MergeWith(aOther); + return *this; + } + +#ifdef DEBUG + void Test(); +#endif // #ifdef DEBUG + }; + + // TextChangeDataBase cannot have constructors because they are used in union. + // Therefore, TextChangeData should only implement constructor. In other + // words, add other members to TextChangeDataBase. + struct TextChangeData : public TextChangeDataBase + { + TextChangeData() { Clear(); } + + TextChangeData(uint32_t aStartOffset, + uint32_t aRemovedEndOffset, + uint32_t aAddedEndOffset, + bool aCausedByComposition, + bool aOccurredDuringComposition) + { + MOZ_ASSERT(aRemovedEndOffset >= aStartOffset, + "removed end offset must not be smaller than start offset"); + MOZ_ASSERT(aAddedEndOffset >= aStartOffset, + "added end offset must not be smaller than start offset"); + mStartOffset = aStartOffset; + mRemovedEndOffset = aRemovedEndOffset; + mAddedEndOffset = aAddedEndOffset; + mCausedOnlyByComposition = aCausedByComposition; + mIncludingChangesDuringComposition = + !aCausedByComposition && aOccurredDuringComposition; + mIncludingChangesWithoutComposition = + !aCausedByComposition && !aOccurredDuringComposition; + } + }; + + struct MouseButtonEventData + { + // The value of WidgetEvent::mMessage + EventMessage mEventMessage; + // Character offset from the start of the focused editor under the cursor + uint32_t mOffset; + // Cursor position in pixels relative to the widget + Point mCursorPos; + // Character rect in pixels under the cursor relative to the widget + Rect mCharRect; + // The value of WidgetMouseEventBase::button and buttons + int16_t mButton; + int16_t mButtons; + // The value of WidgetInputEvent::modifiers + Modifiers mModifiers; + }; + + union + { + // NOTIFY_IME_OF_SELECTION_CHANGE specific data + SelectionChangeDataBase mSelectionChangeData; + + // NOTIFY_IME_OF_TEXT_CHANGE specific data + TextChangeDataBase mTextChangeData; + + // NOTIFY_IME_OF_MOUSE_BUTTON_EVENT specific data + MouseButtonEventData mMouseButtonEventData; + }; + + void SetData(const SelectionChangeDataBase& aSelectionChangeData) + { + MOZ_RELEASE_ASSERT(mMessage == NOTIFY_IME_OF_SELECTION_CHANGE); + mSelectionChangeData.Assign(aSelectionChangeData); + } + + void SetData(const TextChangeDataBase& aTextChangeData) + { + MOZ_RELEASE_ASSERT(mMessage == NOTIFY_IME_OF_TEXT_CHANGE); + mTextChangeData = aTextChangeData; + } +}; + +struct CandidateWindowPosition +{ + // Upper left corner of the candidate window if mExcludeRect is false. + // Otherwise, the position currently interested. E.g., caret position. + LayoutDeviceIntPoint mPoint; + // Rect which shouldn't be overlapped with the candidate window. + // This is valid only when mExcludeRect is true. + LayoutDeviceIntRect mRect; + // See explanation of mPoint and mRect. + bool mExcludeRect; +}; + +} // namespace widget +} // namespace mozilla + +#endif // #ifndef mozilla_widget_IMEData_h_ |