summaryrefslogtreecommitdiffstats
path: root/extensions/spellcheck/src/mozInlineSpellChecker.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /extensions/spellcheck/src/mozInlineSpellChecker.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'extensions/spellcheck/src/mozInlineSpellChecker.h')
-rw-r--r--extensions/spellcheck/src/mozInlineSpellChecker.h272
1 files changed, 272 insertions, 0 deletions
diff --git a/extensions/spellcheck/src/mozInlineSpellChecker.h b/extensions/spellcheck/src/mozInlineSpellChecker.h
new file mode 100644
index 000000000..86d91c2c0
--- /dev/null
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.h
@@ -0,0 +1,272 @@
+/* -*- 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 __mozinlinespellchecker_h__
+#define __mozinlinespellchecker_h__
+
+#include "mozilla/EditorBase.h"
+#include "nsRange.h"
+#include "nsIEditorSpellCheck.h"
+#include "nsIEditActionListener.h"
+#include "nsIInlineSpellChecker.h"
+#include "nsIDOMTreeWalker.h"
+#include "nsWeakReference.h"
+#include "nsIDOMEventListener.h"
+#include "nsWeakReference.h"
+#include "mozISpellI18NUtil.h"
+#include "nsCycleCollectionParticipant.h"
+
+// X.h defines KeyPress
+#ifdef KeyPress
+#undef KeyPress
+#endif
+
+class mozInlineSpellWordUtil;
+class mozInlineSpellChecker;
+class mozInlineSpellResume;
+class InitEditorSpellCheckCallback;
+class UpdateCurrentDictionaryCallback;
+class mozInlineSpellResume;
+
+class mozInlineSpellStatus
+{
+public:
+ explicit mozInlineSpellStatus(mozInlineSpellChecker* aSpellChecker);
+
+ nsresult InitForEditorChange(EditAction aAction,
+ nsIDOMNode* aAnchorNode, int32_t aAnchorOffset,
+ nsIDOMNode* aPreviousNode, int32_t aPreviousOffset,
+ nsIDOMNode* aStartNode, int32_t aStartOffset,
+ nsIDOMNode* aEndNode, int32_t aEndOffset);
+ nsresult InitForNavigation(bool aForceCheck, int32_t aNewPositionOffset,
+ nsIDOMNode* aOldAnchorNode, int32_t aOldAnchorOffset,
+ nsIDOMNode* aNewAnchorNode, int32_t aNewAnchorOffset,
+ bool* aContinue);
+ nsresult InitForSelection();
+ nsresult InitForRange(nsRange* aRange);
+
+ nsresult FinishInitOnEvent(mozInlineSpellWordUtil& aWordUtil);
+
+ // Return true if we plan to spell-check everything
+ bool IsFullSpellCheck() const {
+ return mOp == eOpChange && !mRange;
+ }
+
+ RefPtr<mozInlineSpellChecker> mSpellChecker;
+
+ // The total number of words checked in this sequence, using this tally tells
+ // us when to stop. This count is preserved as we continue checking in new
+ // messages.
+ int32_t mWordCount;
+
+ // what happened?
+ enum Operation { eOpChange, // for SpellCheckAfterChange except deleteSelection
+ eOpChangeDelete, // for SpellCheckAfterChange deleteSelection
+ eOpNavigation, // for HandleNavigationEvent
+ eOpSelection, // re-check all misspelled words
+ eOpResume }; // for resuming a previously started check
+ Operation mOp;
+
+ // Used for events where we have already computed the range to use. It can
+ // also be nullptr in these cases where we need to check the entire range.
+ RefPtr<nsRange> mRange;
+
+ // If we happen to know something was inserted, this is that range.
+ // Can be nullptr (this only allows an optimization, so not setting doesn't hurt)
+ RefPtr<nsRange> mCreatedRange;
+
+ // Contains the range computed for the current word. Can be nullptr.
+ RefPtr<nsRange> mNoCheckRange;
+
+ // Indicates the position of the cursor for the event (so we can compute
+ // mNoCheckRange). It can be nullptr if we don't care about the cursor position
+ // (such as for the intial check of everything).
+ //
+ // For mOp == eOpNavigation, this is the NEW position of the cursor
+ nsCOMPtr<nsIDOMRange> mAnchorRange;
+
+ // -----
+ // The following members are only for navigation events and are only
+ // stored for FinishNavigationEvent to initialize the other members.
+ // -----
+
+ // this is the OLD position of the cursor
+ nsCOMPtr<nsIDOMRange> mOldNavigationAnchorRange;
+
+ // Set when we should force checking the current word. See
+ // mozInlineSpellChecker::HandleNavigationEvent for a description of why we
+ // have this.
+ bool mForceNavigationWordCheck;
+
+ // Contains the offset passed in to HandleNavigationEvent
+ int32_t mNewNavigationPositionOffset;
+
+protected:
+ nsresult FinishNavigationEvent(mozInlineSpellWordUtil& aWordUtil);
+
+ nsresult FillNoCheckRangeFromAnchor(mozInlineSpellWordUtil& aWordUtil);
+
+ nsresult GetDocument(nsIDOMDocument** aDocument);
+ nsresult PositionToCollapsedRange(nsIDOMDocument* aDocument,
+ nsIDOMNode* aNode, int32_t aOffset,
+ nsIDOMRange** aRange);
+};
+
+class mozInlineSpellChecker final : public nsIInlineSpellChecker,
+ public nsIEditActionListener,
+ public nsIDOMEventListener,
+ public nsSupportsWeakReference
+{
+private:
+ friend class mozInlineSpellStatus;
+ friend class InitEditorSpellCheckCallback;
+ friend class UpdateCurrentDictionaryCallback;
+ friend class AutoChangeNumPendingSpellChecks;
+ friend class mozInlineSpellResume;
+
+ // Access with CanEnableInlineSpellChecking
+ enum SpellCheckingState { SpellCheck_Uninitialized = -1,
+ SpellCheck_NotAvailable = 0,
+ SpellCheck_Available = 1};
+ static SpellCheckingState gCanEnableSpellChecking;
+
+ nsWeakPtr mEditor;
+ nsCOMPtr<nsIEditorSpellCheck> mSpellCheck;
+ nsCOMPtr<nsIEditorSpellCheck> mPendingSpellCheck;
+ nsCOMPtr<nsIDOMTreeWalker> mTreeWalker;
+ nsCOMPtr<mozISpellI18NUtil> mConverter;
+
+ int32_t mNumWordsInSpellSelection;
+ int32_t mMaxNumWordsInSpellSelection;
+
+ // How many misspellings we can add at once. This is often less than the max
+ // total number of misspellings. When you have a large textarea prepopulated
+ // with text with many misspellings, we can hit this limit. By making it
+ // lower than the total number of misspelled words, new text typed by the
+ // user can also have spellchecking in it.
+ int32_t mMaxMisspellingsPerCheck;
+
+ // we need to keep track of the current text position in the document
+ // so we can spell check the old word when the user clicks around the document.
+ nsCOMPtr<nsIDOMNode> mCurrentSelectionAnchorNode;
+ int32_t mCurrentSelectionOffset;
+
+ // Tracks the number of pending spell checks *and* async operations that may
+ // lead to spell checks, like updating the current dictionary. This is
+ // necessary so that observers can know when to wait for spell check to
+ // complete.
+ int32_t mNumPendingSpellChecks;
+
+ // The number of calls to UpdateCurrentDictionary that haven't finished yet.
+ int32_t mNumPendingUpdateCurrentDictionary;
+
+ // This number is incremented each time the spell checker is disabled so that
+ // pending scheduled spell checks and UpdateCurrentDictionary calls can be
+ // ignored when they finish.
+ uint32_t mDisabledAsyncToken;
+
+ // When mPendingSpellCheck is non-null, this is the callback passed when
+ // it was initialized.
+ RefPtr<InitEditorSpellCheckCallback> mPendingInitEditorSpellCheckCallback;
+
+ // Set when we have spellchecked after the last edit operation. See the
+ // commment at the top of the .cpp file for more info.
+ bool mNeedsCheckAfterNavigation;
+
+ // Set when we have a pending mozInlineSpellResume which will check
+ // the whole document.
+ bool mFullSpellCheckScheduled;
+
+ // Maintains state during the asynchronous UpdateCurrentDictionary call.
+ nsString mPreviousDictionary;
+
+public:
+
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_NSIEDITACTIONLISTENER
+ NS_DECL_NSIINLINESPELLCHECKER
+ NS_DECL_NSIDOMEVENTLISTENER
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(mozInlineSpellChecker, nsIDOMEventListener)
+
+ // returns true if there are any spell checking dictionaries available
+ static bool CanEnableInlineSpellChecking();
+ // update the cached value whenever the list of available dictionaries changes
+ static void UpdateCanEnableInlineSpellChecking();
+
+ nsresult Blur(nsIDOMEvent* aEvent);
+ nsresult MouseClick(nsIDOMEvent* aMouseEvent);
+ nsresult KeyPress(nsIDOMEvent* aKeyEvent);
+
+ mozInlineSpellChecker();
+
+ // spell checks all of the words between two nodes
+ nsresult SpellCheckBetweenNodes(nsIDOMNode *aStartNode,
+ int32_t aStartOffset,
+ nsIDOMNode *aEndNode,
+ int32_t aEndOffset);
+
+ // examines the dom node in question and returns true if the inline spell
+ // checker should skip the node (i.e. the text is inside of a block quote
+ // or an e-mail signature...)
+ bool ShouldSpellCheckNode(nsIEditor* aEditor, nsINode *aNode);
+
+ nsresult SpellCheckAfterChange(nsIDOMNode* aCursorNode, int32_t aCursorOffset,
+ nsIDOMNode* aPreviousNode, int32_t aPreviousOffset,
+ nsISelection* aSpellCheckSelection);
+
+ // spell check the text contained within aRange, potentially scheduling
+ // another check in the future if the time threshold is reached
+ nsresult ScheduleSpellCheck(const mozInlineSpellStatus& aStatus);
+
+ nsresult DoSpellCheckSelection(mozInlineSpellWordUtil& aWordUtil,
+ mozilla::dom::Selection* aSpellCheckSelection,
+ mozInlineSpellStatus* aStatus);
+ nsresult DoSpellCheck(mozInlineSpellWordUtil& aWordUtil,
+ mozilla::dom::Selection *aSpellCheckSelection,
+ mozInlineSpellStatus* aStatus,
+ bool* aDoneChecking);
+
+ // helper routine to determine if a point is inside of the passed in selection.
+ nsresult IsPointInSelection(nsISelection *aSelection,
+ nsIDOMNode *aNode,
+ int32_t aOffset,
+ nsIDOMRange **aRange);
+
+ nsresult CleanupRangesInSelection(mozilla::dom::Selection *aSelection);
+
+ nsresult RemoveRange(mozilla::dom::Selection *aSpellCheckSelection,
+ nsRange *aRange);
+ nsresult AddRange(nsISelection *aSpellCheckSelection, nsIDOMRange * aRange);
+ bool SpellCheckSelectionIsFull() { return mNumWordsInSpellSelection >= mMaxNumWordsInSpellSelection; }
+
+ nsresult MakeSpellCheckRange(nsIDOMNode* aStartNode, int32_t aStartOffset,
+ nsIDOMNode* aEndNode, int32_t aEndOffset,
+ nsRange** aRange);
+
+ // DOM and editor event registration helper routines
+ nsresult RegisterEventListeners();
+ nsresult UnregisterEventListeners();
+ nsresult HandleNavigationEvent(bool aForceWordSpellCheck, int32_t aNewPositionOffset = 0);
+
+ nsresult GetSpellCheckSelection(nsISelection ** aSpellCheckSelection);
+ nsresult SaveCurrentSelectionPosition();
+
+ nsresult ResumeCheck(mozInlineSpellStatus* aStatus);
+
+protected:
+ virtual ~mozInlineSpellChecker();
+
+ // called when async nsIEditorSpellCheck methods complete
+ nsresult EditorSpellCheckInited();
+ nsresult CurrentDictionaryUpdated();
+
+ // track the number of pending spell checks and async operations that may lead
+ // to spell checks, notifying observers accordingly
+ void ChangeNumPendingSpellChecks(int32_t aDelta,
+ nsIEditor* aEditor = nullptr);
+ void NotifyObservers(const char* aTopic, nsIEditor* aEditor);
+};
+
+#endif /* __mozinlinespellchecker_h__ */