author Jonathan Watt <jwatt@jwatt.org>
Tue, 19 Apr 2016 21:51:25 +0100
changeset 332041 31b3a03707447d000981a6c1aa2dc81697458fc8
parent 330673 a2d94f934b2a733fa09e8f1097ee6fe07d7a2ad1
child 336158 63073a4784cf19fb3b8006134635e2ff2dcb50ce
permissions -rw-r--r--
Bug 1265953, part 2 - Convert much of the rest of the widget code from nsAutoPtr to UniquePtr. r=mstange

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 TSFTextStore_h_
#define TSFTextStore_h_

#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsIWidget.h"
#include "nsWindowBase.h"
#include "WinUtils.h"
#include "mozilla/Attributes.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/TextEventDispatcher.h"
#include "mozilla/TextRange.h"
#include "mozilla/WindowsVersion.h"

#include <msctf.h>
#include <textstor.h>

// GUID_PROP_INPUTSCOPE is declared in inputscope.h using INIT_GUID.
// With initguid.h, we get its instance instead of extern declaration.
#include <initguid.h>
#include <tsattrs.h>
#include <inputscope.h>

// TSF InputScope, for earlier SDK 8
#define IS_SEARCH static_cast<InputScope>(50)

struct ITfThreadMgr;
struct ITfDocumentMgr;
struct ITfDisplayAttributeMgr;
struct ITfCategoryMgr;
class nsWindow;

namespace mozilla {
namespace widget {

struct MSGResult;

 * Text Services Framework text store

class TSFTextStore final : public ITextStoreACP
                         , public ITfContextOwnerCompositionSink
                         , public ITfMouseTrackerACP
public: /*IUnknown*/
  STDMETHODIMP          QueryInterface(REFIID, void**);


public: /*ITextStoreACP*/
  STDMETHODIMP UnadviseSink(IUnknown*);
                       ULONG*, LONG*);
  STDMETHODIMP GetFormattedText(LONG, LONG, IDataObject**);
  STDMETHODIMP QueryInsertEmbedded(const GUID*, const FORMATETC*, BOOL*);
  STDMETHODIMP RequestSupportedAttrs(DWORD, ULONG, const TS_ATTRID*);
  STDMETHODIMP RequestAttrsAtPosition(LONG, ULONG, const TS_ATTRID*, DWORD);
  STDMETHODIMP RequestAttrsTransitioningAtPosition(LONG, ULONG,
                                                   const TS_ATTRID*, DWORD);
  STDMETHODIMP FindNextAttrTransition(LONG, LONG, ULONG, const TS_ATTRID*,
                                      DWORD, LONG*, BOOL*, LONG*);
  STDMETHODIMP GetActiveView(TsViewCookie*);
  STDMETHODIMP GetACPFromPoint(TsViewCookie, const POINT*, DWORD, LONG*);
  STDMETHODIMP GetScreenExt(TsViewCookie, RECT*);
  STDMETHODIMP GetWnd(TsViewCookie, HWND*);
  STDMETHODIMP InsertTextAtSelection(DWORD, const WCHAR*, ULONG, LONG*, LONG*,
  STDMETHODIMP InsertEmbeddedAtSelection(DWORD, IDataObject*, LONG*, LONG*,

public: /*ITfContextOwnerCompositionSink*/
  STDMETHODIMP OnStartComposition(ITfCompositionView*, BOOL*);
  STDMETHODIMP OnUpdateComposition(ITfCompositionView*, ITfRange*);
  STDMETHODIMP OnEndComposition(ITfCompositionView*);

public: /*ITfMouseTrackerACP*/
  STDMETHODIMP AdviseMouseSink(ITfRangeACP*, ITfMouseSink*, DWORD*);
  STDMETHODIMP UnadviseMouseSink(DWORD);

  static void     Initialize(void);
  static void     Terminate(void);

  static bool     ProcessRawKeyMessage(const MSG& aMsg);
  static void     ProcessMessage(nsWindowBase* aWindow, UINT aMessage,
                                 WPARAM& aWParam, LPARAM& aLParam,
                                 MSGResult& aResult);

  static void     SetIMEOpenState(bool);
  static bool     GetIMEOpenState(void);

  static void     CommitComposition(bool aDiscard)
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);

  static void SetInputContext(nsWindowBase* aWidget,
                              const InputContext& aContext,
                              const InputContextAction& aAction);

  static nsresult OnFocusChange(bool aGotFocus,
                                nsWindowBase* aFocusedWidget,
                                const InputContext& aContext);
  static nsresult OnTextChange(const IMENotification& aIMENotification)
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
      return NS_OK;
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);
    return textStore->OnTextChangeInternal(aIMENotification);

  static nsresult OnSelectionChange(const IMENotification& aIMENotification)
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
      return NS_OK;
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);
    return textStore->OnSelectionChangeInternal(aIMENotification);

  static nsresult OnLayoutChange()
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
      return NS_OK;
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);
    return textStore->OnLayoutChangeInternal();

  static nsresult OnUpdateComposition()
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
      return NS_OK;
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);
    return textStore->OnUpdateCompositionInternal();

  static nsresult OnMouseButtonEvent(const IMENotification& aIMENotification)
    NS_ASSERTION(IsInTSFMode(), "Not in TSF mode, shouldn't be called");
    if (!sEnabledTextStore) {
      return NS_OK;
    RefPtr<TSFTextStore> textStore(sEnabledTextStore);
    return textStore->OnMouseButtonEventInternal(aIMENotification);

  static nsIMEUpdatePreference GetIMEUpdatePreference();

  // Returns the address of the pointer so that the TSF automatic test can
  // replace the system object with a custom implementation for testing.
  // XXX TSF doesn't work now.  Should we remove it?
  static void* GetNativeData(uint32_t aDataType)
    switch (aDataType) {
        Initialize(); // Apply any previous changes
        return static_cast<void*>(&sThreadMgr);
        return static_cast<void*>(&sCategoryMgr);
        return static_cast<void*>(&sDisplayAttrMgr);
        return nullptr;

  static ITfMessagePump* GetMessagePump()
    return sMessagePump;

  static void* GetThreadManager()
    return static_cast<void*>(sThreadMgr);

  static bool ThinksHavingFocus()
    return (sEnabledTextStore && sEnabledTextStore->mContext);

  static bool IsInTSFMode()
    return sThreadMgr != nullptr;

  static bool IsComposing()
    return (sEnabledTextStore && sEnabledTextStore->mComposition.IsComposing());

  static bool IsComposingOn(nsWindowBase* aWidget)
    return (IsComposing() && sEnabledTextStore->mWidget == aWidget);

  static bool IsIMM_IME();

#ifdef DEBUG
  // Returns true when keyboard layout has IME (TIP).
  static bool     CurrentKeyboardLayoutHasIME();
#endif // #ifdef DEBUG


  static bool CreateAndSetFocus(nsWindowBase* aFocusedWidget,
                                const InputContext& aContext);
  static void MarkContextAsKeyboardDisabled(ITfContext* aContext);
  static void MarkContextAsEmpty(ITfContext* aContext);

  bool     Init(nsWindowBase* aWidget);
  bool     Destroy();

  bool     IsReadLock(DWORD aLock) const
    return (TS_LF_READ == (aLock & TS_LF_READ));
  bool     IsReadWriteLock(DWORD aLock) const
    return (TS_LF_READWRITE == (aLock & TS_LF_READWRITE));
  bool     IsReadLocked() const { return IsReadLock(mLock); }
  bool     IsReadWriteLocked() const { return IsReadWriteLock(mLock); }

  // This is called immediately after a call of OnLockGranted() of mSink.
  // Note that mLock isn't cleared yet when this is called.
  void     DidLockGranted();

  bool     GetScreenExtInternal(RECT& aScreenExt);
  // If aDispatchCompositionChangeEvent is true, this method will dispatch
  // compositionchange event if this is called during IME composing.
  // aDispatchCompositionChangeEvent should be true only when this is called
  // from SetSelection.  Because otherwise, the compositionchange event should
  // not be sent from here.
  HRESULT  SetSelectionInternal(const TS_SELECTION_ACP*,
                                bool aDispatchCompositionChangeEvent = false);
  bool     InsertTextAtSelectionInternal(const nsAString& aInsertStr,
                                         TS_TEXTCHANGE* aTextChange);
  void     CommitCompositionInternal(bool);
  nsresult OnTextChangeInternal(const IMENotification& aIMENotification);
  nsresult OnSelectionChangeInternal(const IMENotification& aIMENotification);
  nsresult OnMouseButtonEventInternal(const IMENotification& aIMENotification);
  HRESULT  GetDisplayAttribute(ITfProperty* aProperty,
                               ITfRange* aRange,
                               TF_DISPLAYATTRIBUTE* aResult);
  HRESULT  RestartCompositionIfNecessary(ITfRange* pRangeNew = nullptr);
  HRESULT  RestartComposition(ITfCompositionView* aCompositionView,
                              ITfRange* aNewRange);

  // Following methods record composing action(s) to mPendingActions.
  // They will be flushed FlushPendingActions().
  HRESULT  RecordCompositionStartAction(ITfCompositionView* aCompositionView,
                                        ITfRange* aRange,
                                        bool aPreserveSelection);
  HRESULT  RecordCompositionStartAction(ITfCompositionView* aComposition,
                                        LONG aStart,
                                        LONG aLength,
                                        bool aPreserveSelection);
  HRESULT  RecordCompositionUpdateAction();
  HRESULT  RecordCompositionEndAction();

  // DispatchEvent() dispatches the event and if it may not be handled
  // synchronously, this makes the instance not notify TSF of pending
  // notifications until next notification from content.
  void     DispatchEvent(WidgetGUIEvent& aEvent);
  void     OnLayoutInformationAvaliable();

  // FlushPendingActions() performs pending actions recorded in mPendingActions
  // and clear it.
  void     FlushPendingActions();
  // MaybeFlushPendingNotifications() performs pending notifications to TSF.
  void     MaybeFlushPendingNotifications();

  nsresult OnLayoutChangeInternal();
  nsresult OnUpdateCompositionInternal();

  void     NotifyTSFOfTextChange(const TS_TEXTCHANGE& aTextChange);
  void     NotifyTSFOfSelectionChange();
  bool     NotifyTSFOfLayoutChange();
  void     NotifyTSFOfLayoutChangeAgain();

  HRESULT  HandleRequestAttrs(DWORD aFlags,
                              ULONG aFilterCount,
                              const TS_ATTRID* aFilterAttrs);
  void     SetInputScope(const nsString& aHTMLInputType,
                         const nsString& aHTMLInputInputmode);

  // Creates native caret over our caret.  This method only works on desktop
  // application.  Otherwise, this does nothing.
  void     CreateNativeCaret();
  // Destroys native caret if there is.
  void     MaybeDestroyNativeCaret();

  // Holds the pointer to our current win32 widget
  RefPtr<nsWindowBase>       mWidget;
  // mDispatcher is a helper class to dispatch composition events.
  RefPtr<TextEventDispatcher> mDispatcher;
  // Document manager for the currently focused editor
  RefPtr<ITfDocumentMgr>     mDocumentMgr;
  // Edit cookie associated with the current editing context
  DWORD                        mEditCookie;
  // Editing context at the bottom of mDocumentMgr's context stack
  RefPtr<ITfContext>         mContext;
  // Currently installed notification sink
  RefPtr<ITextStoreACPSink>  mSink;
  // TS_AS_* mask of what events to notify
  DWORD                        mSinkMask;
  // 0 if not locked, otherwise TS_LF_* indicating the current lock
  DWORD                        mLock;
  // 0 if no lock is queued, otherwise TS_LF_* indicating the queue lock
  DWORD                        mLockQueued;

  class Composition final
    // nullptr if no composition is active, otherwise the current composition
    RefPtr<ITfCompositionView> mView;

    // Current copy of the active composition string. Only mString is
    // changed during a InsertTextAtSelection call if we have a composition.
    // mString acts as a buffer until OnUpdateComposition is called
    // and mString is flushed to editor through eCompositionChange.
    // This way all changes are updated in batches to avoid
    // inconsistencies/artifacts.
    nsString mString;

    // The start of the current active composition, in ACP offsets
    LONG mStart;

    bool IsComposing() const
      return (mView != nullptr);

    LONG EndOffset() const
      return mStart + static_cast<LONG>(mString.Length());

    // Start() and End() updates the members for emulating the latest state.
    // Unless flush the pending actions, this data never matches the actual
    // content.
    void Start(ITfCompositionView* aCompositionView,
               LONG aCompositionStartOffset,
               const nsAString& aCompositionString);
    void End();
  // While the document is locked, we cannot dispatch any events which cause
  // DOM events since the DOM events' handlers may modify the locked document.
  // However, even while the document is locked, TSF may queries us.
  // For that, TSFTextStore modifies mComposition even while the document is
  // locked.  With mComposition, query methods can returns the text content
  // information.
  Composition mComposition;

  class Selection
    Selection() : mDirty(true) {}

    bool IsDirty() const { return mDirty; };
    void MarkDirty() { mDirty = true; }

      return mACP;

    void SetSelection(const TS_SELECTION_ACP& aSelection)
      mDirty = false;
      mACP = aSelection;
      // Selection end must be active in our editor.
      if (mACP.style.ase != TS_AE_START) {
        mACP.style.ase = TS_AE_END;
      // We're not support interim char selection for now.
      // XXX Probably, this is necessary for supporting South Asian languages.
      mACP.style.fInterimChar = FALSE;

    void SetSelection(uint32_t aStart,
                      uint32_t aLength,
                      bool aReversed,
                      WritingMode aWritingMode)
      mDirty = false;
      mACP.acpStart = static_cast<LONG>(aStart);
      mACP.acpEnd = static_cast<LONG>(aStart + aLength);
      mACP.style.ase = aReversed ? TS_AE_START : TS_AE_END;
      mACP.style.fInterimChar = FALSE;
      mWritingMode = aWritingMode;

    bool IsCollapsed() const
      return (mACP.acpStart == mACP.acpEnd);

    void CollapseAt(uint32_t aOffset)
      // XXX This does not update the selection's mWritingMode.
      // If it is ever used to "collapse" to an entirely new location,
      // we may need to fix that.
      mDirty = false;
      mACP.acpStart = mACP.acpEnd = static_cast<LONG>(aOffset);
      mACP.style.ase = TS_AE_END;
      mACP.style.fInterimChar = FALSE;

    LONG MinOffset() const
      LONG min = std::min(mACP.acpStart, mACP.acpEnd);
      MOZ_ASSERT(min >= 0);
      return min;

    LONG MaxOffset() const
      LONG max = std::max(mACP.acpStart, mACP.acpEnd);
      MOZ_ASSERT(max >= 0);
      return max;

    LONG StartOffset() const
      MOZ_ASSERT(mACP.acpStart >= 0);
      return mACP.acpStart;

    LONG EndOffset() const
      MOZ_ASSERT(mACP.acpEnd >= 0);
      return mACP.acpEnd;

    LONG Length() const
      MOZ_ASSERT(mACP.acpEnd >= mACP.acpStart);
      return std::abs(mACP.acpEnd - mACP.acpStart);

    bool IsReversed() const
      return (mACP.style.ase == TS_AE_START);

    TsActiveSelEnd ActiveSelEnd() const
      return mACP.style.ase;

    bool IsInterimChar() const
      return (mACP.style.fInterimChar != FALSE);

    WritingMode GetWritingMode() const
      return mWritingMode;

    WritingMode mWritingMode;
    bool mDirty;
  // Don't access mSelection directly except at calling MarkDirty().
  // Use CurrentSelection() instead.  This is marked as dirty when the
  // selection or content is changed without document lock.
  Selection mSelection;

  // Get "current selection".  If the document is locked, this initializes
  // mSelection with the selection at the first call during a lock and returns
  // it.  However, mSelection is NOT modified immediately.  When pending
  // changes are flushed at unlocking the document, cached mSelection is
  // modified.  Note that this is also called by LockedContent().
  Selection& CurrentSelection();

  struct PendingAction final
    enum ActionType : uint8_t
    ActionType mType;
    // For compositionstart and selectionset
    LONG mSelectionStart;
    LONG mSelectionLength;
    // For compositionstart, compositionupdate and compositionend
    nsString mData;
    // For compositionupdate
    RefPtr<TextRangeArray> mRanges;
    // For selectionset
    bool mSelectionReversed;
    // For compositionupdate
    bool mIncomplete;
    // For compositionstart
    bool mAdjustSelection;
  // Items of mPendingActions are appended when TSF tells us to need to dispatch
  // DOM composition events.  However, we cannot dispatch while the document is
  // locked because it can cause modifying the locked document.  So, the pending
  // actions should be performed when document lock is unlocked.
  nsTArray<PendingAction> mPendingActions;

  PendingAction* LastOrNewPendingCompositionUpdate()
    if (!mPendingActions.IsEmpty()) {
      PendingAction& lastAction = mPendingActions.LastElement();
      if (lastAction.mType == PendingAction::COMPOSITION_UPDATE) {
        return &lastAction;
    PendingAction* newAction = mPendingActions.AppendElement();
    newAction->mType = PendingAction::COMPOSITION_UPDATE;
    newAction->mRanges = new TextRangeArray();
    newAction->mIncomplete = true;
    return newAction;

   * WasTextInsertedWithoutCompositionAt() checks if text was inserted without
   * composition immediately before (e.g., see InsertTextAtSelectionInternal()).
   * @param aStart              The inserted offset you expected.
   * @param aLength             The inserted text length you expected.
   * @return                    true if the last pending actions are
   *                            COMPOSITION_START and COMPOSITION_END and
   *                            aStart and aLength match their information.
  bool WasTextInsertedWithoutCompositionAt(LONG aStart, LONG aLength) const
    if (mPendingActions.Length() < 2) {
      return false;
    const PendingAction& pendingLastAction = mPendingActions.LastElement();
    if (pendingLastAction.mType != PendingAction::COMPOSITION_END ||
        pendingLastAction.mData.Length() != aLength) {
      return false;
    const PendingAction& pendingPreLastAction =
      mPendingActions[mPendingActions.Length() - 2];
    return pendingPreLastAction.mType == PendingAction::COMPOSITION_START &&
           pendingPreLastAction.mSelectionStart == aStart;

  bool IsPendingCompositionUpdateIncomplete() const
    if (mPendingActions.IsEmpty()) {
      return false;
    const PendingAction& lastAction = mPendingActions.LastElement();
    return lastAction.mType == PendingAction::COMPOSITION_UPDATE &&

  void CompleteLastActionIfStillIncomplete()
    if (!IsPendingCompositionUpdateIncomplete()) {

  // When On*Composition() is called without document lock, we need to flush
  // the recorded actions at quitting the method.
  // AutoPendingActionAndContentFlusher class is usedful for it.  
  class MOZ_STACK_CLASS AutoPendingActionAndContentFlusher final
    AutoPendingActionAndContentFlusher(TSFTextStore* aTextStore)
      : mTextStore(aTextStore)
      if (!mTextStore->IsReadWriteLocked()) {
        mTextStore->mIsRecordingActionsWithoutLock = true;

      if (!mTextStore->mIsRecordingActionsWithoutLock) {
      mTextStore->mIsRecordingActionsWithoutLock = false;

    AutoPendingActionAndContentFlusher() {}

    RefPtr<TSFTextStore> mTextStore;

  class Content final
    Content(TSFTextStore::Composition& aComposition,
            TSFTextStore::Selection& aSelection) :
      mComposition(aComposition), mSelection(aSelection)

    void Clear()
      mInitialized = false;

    bool IsInitialized() const { return mInitialized; }

    void Init(const nsAString& aText)
      mText = aText;
      if (mComposition.IsComposing()) {
        mLastCompositionString = mComposition.mString;
      } else {
      mMinTextModifiedOffset = NOT_MODIFIED;
      mInitialized = true;

    void OnLayoutChanged()
      mMinTextModifiedOffset = NOT_MODIFIED;

    const nsDependentSubstring GetSelectedText() const;
    const nsDependentSubstring GetSubstring(uint32_t aStart,
                                            uint32_t aLength) const;
    void ReplaceSelectedTextWith(const nsAString& aString);
    void ReplaceTextWith(LONG aStart, LONG aLength, const nsAString& aString);

    void StartComposition(ITfCompositionView* aCompositionView,
                          const PendingAction& aCompStart,
                          bool aPreserveSelection);
     * RestoreCommittedComposition() restores the committed string as
     * composing string.  If InsertTextAtSelection() or something is called
     * before a call of OnStartComposition(), there is a pending
     * compositionstart and a pending compositionend.  In this case, we
     * need to cancel the pending compositionend and continue the composition.
     * @param aCompositionView          The composition view.
     * @param aPendingCompositionStart  The pending compositionstart which
     *                                  started the committed composition.
     * @param aCanceledCompositionEnd   The pending compositionend which is
     *                                  canceled for restarting the composition.
    void RestoreCommittedComposition(
                         ITfCompositionView* aCompositionView,
                         const PendingAction& aPendingCompositionStart,
                         const PendingAction& aCanceledCompositionEnd);
    void EndComposition(const PendingAction& aCompEnd);

    const nsString& Text() const
      return mText;
    const nsString& LastCompositionString() const
      return mLastCompositionString;
    uint32_t MinTextModifiedOffset() const
      return mMinTextModifiedOffset;

    // Returns true if layout of the character at the aOffset has not been
    // calculated.
    bool IsLayoutChangedAfter(uint32_t aOffset) const
      return mInitialized && (mMinTextModifiedOffset < aOffset);
    // Returns true if layout of the content has been changed, i.e., the new
    // layout has not been calculated.
    bool IsLayoutChanged() const
      return mInitialized && (mMinTextModifiedOffset != NOT_MODIFIED);
    // Returns minimum offset of modified text range.
    uint32_t MinOffsetOfLayoutChanged() const
      return mInitialized ? mMinTextModifiedOffset : NOT_MODIFIED;

    TSFTextStore::Composition& Composition() { return mComposition; }
    TSFTextStore::Selection& Selection() { return mSelection; }

    nsString mText;
    // mLastCompositionString stores the composition string when the document
    // is locked. This is necessary to compute mMinTextModifiedOffset.
    nsString mLastCompositionString;
    TSFTextStore::Composition& mComposition;
    TSFTextStore::Selection& mSelection;

    // The minimum offset of modified part of the text.
    enum : uint32_t
    uint32_t mMinTextModifiedOffset;

    bool mInitialized;
  // mLockedContent starts to cache content of the document at first query of
  // the content during a document lock.  This is abandoned after document is
  // unlocked and dispatched events are handled.  This is initialized by
  // LockedContent() automatically.  So, don't access this member directly
  // except at calling Clear(), IsInitialized(), IsLayoutChangedAfter() or
  // IsLayoutChanged().
  Content mLockedContent;

  Content& LockedContent();

  // While the documet is locked, this returns the text stored by
  // mLockedContent.  Otherwise, return the current text content.
  bool GetCurrentText(nsAString& aTextContent);

  class MouseTracker final
    static const DWORD kInvalidCookie = static_cast<DWORD>(-1);


    HRESULT Init(TSFTextStore* aTextStore);
    HRESULT AdviseSink(TSFTextStore* aTextStore,
                       ITfRangeACP* aTextRange, ITfMouseSink* aMouseSink);
    void UnadviseSink();

    bool IsUsing() const { return mSink != nullptr; }
    bool InRange(uint32_t aOffset) const
      if (NS_WARN_IF(mStart < 0) ||
          NS_WARN_IF(mLength <= 0)) {
        return false;
      return aOffset >= static_cast<uint32_t>(mStart) &&
             aOffset < static_cast<uint32_t>(mStart + mLength);
    DWORD Cookie() const { return mCookie; }
    bool OnMouseButtonEvent(ULONG aEdge, ULONG aQuadrant, DWORD aButtonStatus);
    LONG RangeStart() const { return mStart; }
    RefPtr<ITfMouseSink> mSink;
    LONG mStart;
    LONG mLength;
    DWORD mCookie;
  // mMouseTrackers is an array to store each information of installed
  // ITfMouseSink instance.
  nsTArray<MouseTracker> mMouseTrackers;

  // The input scopes for this context, defaults to IS_DEFAULT.
  nsTArray<InputScope>         mInputScopes;

  // Support retrieving attributes.
  // TODO: We should support RightToLeft, perhaps.
    // Used for result of GetRequestedAttrIndex()
    eNotSupported = -1,

    // Supported attributes
    eInputScope = 0,

    // Count of the supported attributes
  bool mRequestedAttrs[NUM_OF_SUPPORTED_ATTRS];

  int32_t GetRequestedAttrIndex(const TS_ATTRID& aAttrID);
  TS_ATTRID GetAttrID(int32_t aIndex);

  bool mRequestedAttrValues;

  // If edit actions are being recorded without document lock, this is true.
  // Otherwise, false.
  bool                         mIsRecordingActionsWithoutLock;
  // During recording actions, we shouldn't call mSink->OnSelectionChange()
  // because it may cause TSF request new lock.  This is a problem if the
  // selection change is caused by a call of On*Composition() without document
  // lock since RequestLock() tries to flush the pending actions again (which
  // are flushing).  Therefore, OnSelectionChangeInternal() sets this true
  // during recoding actions and then, RequestLock() will call
  // mSink->OnSelectionChange() after mLock becomes 0.
  bool                         mPendingOnSelectionChange;
  // If GetTextExt() or GetACPFromPoint() is called and the layout hasn't been
  // calculated yet, these methods return TS_E_NOLAYOUT.  At that time,
  // mHasReturnedNoLayoutError is set to true.
  bool                         mHasReturnedNoLayoutError;
  // Before calling ITextStoreACPSink::OnLayoutChange() and
  // ITfContextOwnerServices::OnLayoutChange(), mWaitingQueryLayout is set to
  // true.  This is set to  false when GetTextExt() or GetACPFromPoint() is
  // called.
  bool                         mWaitingQueryLayout;
  // During the documet is locked, we shouldn't destroy the instance.
  // If this is true, the instance will be destroyed after unlocked.
  bool                         mPendingDestroy;
  // If this is false, MaybeFlushPendingNotifications() will clear the
  // mLockedContent.
  bool                         mDeferClearingLockedContent;
  // While there is native caret, this is true.  Otherwise, false.
  bool                         mNativeCaretIsCreated;
  // While the instance is dispatching events, the event may not be handled
  // synchronously in e10s mode.  So, in such case, in strictly speaking,
  // we shouldn't query layout information.  However, TS_E_NOLAYOUT bugs of
  // ITextStoreAPC::GetTextExt() blocks us to behave ideally.
  // For preventing it to be called, we should put off notifying TSF of
  // anything until layout information becomes available.
  bool                         mDeferNotifyingTSF;
  // While the document is locked, committing composition always fails since
  // TSF needs another document lock for modifying the composition, selection
  // and etc.  So, committing composition should be performed after the
  // document is unlocked.
  bool                         mDeferCommittingComposition;
  bool                         mDeferCancellingComposition;
  // Immediately after a call of Destroy(), mDestroyed becomes true.  If this
  // is true, the instance shouldn't grant any requests from the TIP anymore.
  bool                         mDestroyed;

  // TSF thread manager object for the current application
  static StaticRefPtr<ITfThreadMgr> sThreadMgr;
  // sMessagePump is QI'ed from sThreadMgr
  static StaticRefPtr<ITfMessagePump> sMessagePump;
  // sKeystrokeMgr is QI'ed from sThreadMgr
  static StaticRefPtr<ITfKeystrokeMgr> sKeystrokeMgr;
  // TSF display attribute manager
  static StaticRefPtr<ITfDisplayAttributeMgr> sDisplayAttrMgr;
  // TSF category manager
  static StaticRefPtr<ITfCategoryMgr> sCategoryMgr;

  // Current text store which is managing a keyboard enabled editor (i.e.,
  // editable editor).  Currently only ONE TSFTextStore instance is ever used,
  // although Create is called when an editor is focused and Destroy called
  // when the focused editor is blurred.
  static StaticRefPtr<TSFTextStore> sEnabledTextStore;

  // For IME (keyboard) disabled state:
  static StaticRefPtr<ITfDocumentMgr> sDisabledDocumentMgr;
  static StaticRefPtr<ITfContext> sDisabledContext;

  static StaticRefPtr<ITfInputProcessorProfiles> sInputProcessorProfiles;

  // TSF client ID for the current application
  static DWORD sClientId;

  // Enables/Disables hack for specific TIP.
  static bool sCreateNativeCaretForATOK;
  static bool sDoNotReturnNoLayoutErrorToMSSimplifiedTIP;
  static bool sDoNotReturnNoLayoutErrorToMSTraditionalTIP;
  static bool sDoNotReturnNoLayoutErrorToFreeChangJie;
  static bool sDoNotReturnNoLayoutErrorToEasyChangjei;
  static bool sDoNotReturnNoLayoutErrorToMSJapaneseIMEAtFirstChar;
  static bool sDoNotReturnNoLayoutErrorToMSJapaneseIMEAtCaret;
  static bool sHackQueryInsertForMSSimplifiedTIP;
  static bool sHackQueryInsertForMSTraditionalTIP;

} // namespace widget
} // namespace mozilla

#endif // #ifndef TSFTextStore_h_