extensions/spellcheck/src/mozInlineSpellChecker.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Inline Spellchecker
  16  *
  17  * The Initial Developer of the Original Code is Mozdev Group, Inc.
  18  * Portions created by the Initial Developer are Copyright (C) 2004
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s): Neil Deakin (neil@mozdevgroup.com)
  22  *                 Scott MacGregor (mscott@mozilla.org)
  23  *                 Brett Wilson <brettw@gmail.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #ifndef __mozinlinespellchecker_h__
  40 #define __mozinlinespellchecker_h__
  41
  42 #include "nsAutoPtr.h"
  43 #include "nsIDOMRange.h"
  44 #include "nsIEditorSpellCheck.h"
  45 #include "nsIEditActionListener.h"
  46 #include "nsIInlineSpellChecker.h"
  47 #include "nsITextServicesDocument.h"
  48 #include "nsIDOMTreeWalker.h"
  49 #include "nsWeakReference.h"
  50 #include "nsIEditor.h"
  51 #include "nsIDOMFocusListener.h"
  52 #include "nsIDOMMouseListener.h"
  53 #include "nsIDOMKeyListener.h"
  54 #include "nsWeakReference.h"
  55 #include "mozISpellI18NUtil.h"
  56
  57 class nsIDOMDocumentRange;
  58 class nsIDOMMouseEventListener;
  59 class mozInlineSpellWordUtil;
  60 class mozInlineSpellChecker;
  61 class mozInlineSpellResume;
  62
  63 class mozInlineSpellStatus
  64 {
  65 public:
  66   mozInlineSpellStatus(mozInlineSpellChecker* aSpellChecker);
  67
  68   nsresult InitForEditorChange(PRInt32 aAction,
  69                                nsIDOMNode* aAnchorNode, PRInt32 aAnchorOffset,
  70                                nsIDOMNode* aPreviousNode, PRInt32 aPreviousOffset,
  71                                nsIDOMNode* aStartNode, PRInt32 aStartOffset,
  72                                nsIDOMNode* aEndNode, PRInt32 aEndOffset);
  73   nsresult InitForNavigation(PRBool aForceCheck, PRInt32 aNewPositionOffset,
  74                              nsIDOMNode* aOldAnchorNode, PRInt32 aOldAnchorOffset,
  75                              nsIDOMNode* aNewAnchorNode, PRInt32 aNewAnchorOffset,
  76                              PRBool* aContinue);
  77   nsresult InitForSelection();
  78   nsresult InitForRange(nsIDOMRange* aRange);
  79
  80   nsresult FinishInitOnEvent(mozInlineSpellWordUtil& aWordUtil);
  81
  82   nsRefPtr<mozInlineSpellChecker> mSpellChecker;
  83
  84   // The total number of words checked in this sequence, using this tally tells
  85   // us when to stop. This count is preserved as we continue checking in new
  86   // messages.
  87   PRInt32 mWordCount;
  88
  89   // what happened?
  90   enum Operation { eOpChange,       // for SpellCheckAfterChange except kOpDeleteSelection
  91                    eOpChangeDelete, // for SpellCheckAfterChange kOpDeleteSelection
  92                    eOpNavigation,   // for HandleNavigationEvent
  93                    eOpSelection,    // re-check all misspelled words
  94                    eOpResume };     // for resuming a previously started check
  95   Operation mOp;
  96
  97   // Used for events where we have already computed the range to use. It can
  98   // also be NULL in these cases where we need to check the entire range.
  99   nsCOMPtr<nsIDOMRange> mRange;
 100
 101   // If we happen to know something was inserted, this is that range.
 102   // Can be NULL (this only allows an optimization, so not setting doesn't hurt)
 103   nsCOMPtr<nsIDOMRange> mCreatedRange;
 104
 105   // Contains the range computed for the current word. Can be NULL.
 106   nsCOMPtr<nsIDOMRange> mNoCheckRange;
 107
 108   // Indicates the position of the cursor for the event (so we can compute
 109   // mNoCheckRange). It can be NULL if we don't care about the cursor position
 110   // (such as for the intial check of everything).
 111   //
 112   // For mOp == eOpNavigation, this is the NEW position of the cursor
 113   nsCOMPtr<nsIDOMRange> mAnchorRange;
 114
 115   // -----
 116   // The following members are only for navigation events and are only
 117   // stored for FinishNavigationEvent to initialize the other members.
 118   // -----
 119
 120   // this is the OLD position of the cursor
 121   nsCOMPtr<nsIDOMRange> mOldNavigationAnchorRange;
 122
 123   // Set when we should force checking the current word. See
 124   // mozInlineSpellChecker::HandleNavigationEvent for a description of why we
 125   // have this.
 126   PRBool mForceNavigationWordCheck;
 127
 128   // Contains the offset passed in to HandleNavigationEvent
 129   PRInt32 mNewNavigationPositionOffset;
 130
 131 protected:
 132   nsresult FinishNavigationEvent(mozInlineSpellWordUtil& aWordUtil);
 133
 134   nsresult FillNoCheckRangeFromAnchor(mozInlineSpellWordUtil& aWordUtil);
 135
 136   nsresult GetDocumentRange(nsIDOMDocumentRange** aDocRange);
 137   nsresult PositionToCollapsedRange(nsIDOMDocumentRange* aDocRange,
 138                                     nsIDOMNode* aNode, PRInt32 aOffset,
 139                                     nsIDOMRange** aRange);
 140 };
 141
 142 class mozInlineSpellChecker : public nsIInlineSpellChecker, nsIEditActionListener, nsIDOMFocusListener, nsIDOMMouseListener, nsIDOMKeyListener,
 143                                      nsSupportsWeakReference
 144 {
 145 private:
 146   friend class mozInlineSpellStatus;
 147
 148   // Access with CanEnableInlineSpellChecking
 149   enum SpellCheckingState { SpellCheck_Uninitialized = -1,
 150                             SpellCheck_NotAvailable = 0,
 151                             SpellCheck_Available = 1};
 152   static SpellCheckingState gCanEnableSpellChecking;
 153
 154   nsWeakPtr mEditor;
 155   nsCOMPtr<nsIEditorSpellCheck> mSpellCheck;
 156   nsCOMPtr<nsITextServicesDocument> mTextServicesDocument;
 157   nsCOMPtr<nsIDOMTreeWalker> mTreeWalker;
 158   nsCOMPtr<mozISpellI18NUtil> mConverter;
 159
 160   PRInt32 mNumWordsInSpellSelection;
 161   PRInt32 mMaxNumWordsInSpellSelection;
 162
 163   // How many misspellings we can add at once. This is often less than the max
 164   // total number of misspellings. When you have a large textarea prepopulated
 165   // with text with many misspellings, we can hit this limit. By making it
 166   // lower than the total number of misspelled words, new text typed by the
 167   // user can also have spellchecking in it.
 168   PRInt32 mMaxMisspellingsPerCheck;
 169
 170   // we need to keep track of the current text position in the document
 171   // so we can spell check the old word when the user clicks around the document.
 172   nsCOMPtr<nsIDOMNode> mCurrentSelectionAnchorNode;
 173   PRInt32              mCurrentSelectionOffset;
 174
 175   // Set when we have spellchecked after the last edit operation. See the
 176   // commment at the top of the .cpp file for more info.
 177   PRBool mNeedsCheckAfterNavigation;
 178
 179   // TODO: these should be defined somewhere so that they don't have to be copied
 180   // from editor!
 181   enum OperationID
 182   {
 183     kOpIgnore = -1,
 184     kOpNone = 0,
 185     kOpUndo,
 186     kOpRedo,
 187     kOpInsertNode,
 188     kOpCreateNode,
 189     kOpDeleteNode,
 190     kOpSplitNode,
 191     kOpJoinNode,
 192     kOpDeleteSelection,
 193
 194     kOpInsertBreak    = 1000,
 195     kOpInsertText     = 1001,
 196     kOpInsertIMEText  = 1002,
 197     kOpDeleteText     = 1003,
 198
 199     kOpMakeList            = 3001,
 200     kOpIndent              = 3002,
 201     kOpOutdent             = 3003,
 202     kOpAlign               = 3004,
 203     kOpMakeBasicBlock      = 3005,
 204     kOpRemoveList          = 3006,
 205     kOpMakeDefListItem     = 3007,
 206     kOpInsertElement       = 3008,
 207     kOpInsertQuotation     = 3009,
 208     kOpSetTextProperty     = 3010,
 209     kOpRemoveTextProperty  = 3011,
 210     kOpHTMLPaste           = 3012,
 211     kOpLoadHTML            = 3013,
 212     kOpResetTextProperties = 3014,
 213     kOpSetAbsolutePosition = 3015,
 214     kOpRemoveAbsolutePosition = 3016,
 215     kOpDecreaseZIndex      = 3017,
 216     kOpIncreaseZIndex      = 3018
 217   };
 218
 219 public:
 220
 221   NS_DECL_ISUPPORTS
 222   NS_DECL_NSIEDITACTIONLISTENER
 223   NS_DECL_NSIINLINESPELLCHECKER
 224
 225   // returns true if it looks likely that we can enable real-time spell checking
 226   static PRBool CanEnableInlineSpellChecking();
 227
 228   /*BEGIN implementations of focus event handler interface*/
 229   NS_IMETHOD Focus(nsIDOMEvent* aEvent);
 230   NS_IMETHOD Blur(nsIDOMEvent* aEvent);
 231   /*END implementations of focus event handler interface*/
 232
 233   /*BEGIN implementations of mouseevent handler interface*/
 234   NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
 235   NS_IMETHOD MouseDown(nsIDOMEvent* aMouseEvent);
 236   NS_IMETHOD MouseUp(nsIDOMEvent* aMouseEvent);
 237   NS_IMETHOD MouseClick(nsIDOMEvent* aMouseEvent);
 238   NS_IMETHOD MouseDblClick(nsIDOMEvent* aMouseEvent);
 239   NS_IMETHOD MouseOver(nsIDOMEvent* aMouseEvent);
 240   NS_IMETHOD MouseOut(nsIDOMEvent* aMouseEvent);
 241   /*END implementations of mouseevent handler interface*/
 242
 243   /* BEGIN interfaces in to the keylistener  interface. */
 244   NS_IMETHOD KeyDown(nsIDOMEvent* aKeyEvent);
 245   NS_IMETHOD KeyUp(nsIDOMEvent* aKeyEvent);
 246   NS_IMETHOD KeyPress(nsIDOMEvent* aKeyEvent);
 247   /* END interfaces from nsIDOMKeyListener */
 248
 249   mozInlineSpellChecker();
 250   virtual ~mozInlineSpellChecker();
 251
 252   // spell checks all of the words between two nodes
 253   nsresult SpellCheckBetweenNodes(nsIDOMNode *aStartNode,
 254                                   PRInt32 aStartOffset,
 255                                   nsIDOMNode *aEndNode,
 256                                   PRInt32 aEndOffset);
 257
 258   // examines the dom node in question and returns true if the inline spell
 259   // checker should skip the node (i.e. the text is inside of a block quote
 260   // or an e-mail signature...)
 261   nsresult SkipSpellCheckForNode(nsIEditor* aEditor,
 262                                  nsIDOMNode *aNode, PRBool * aCheckSpelling);
 263
 264   nsresult SpellCheckAfterChange(nsIDOMNode* aCursorNode, PRInt32 aCursorOffset,
 265                                  nsIDOMNode* aPreviousNode, PRInt32 aPreviousOffset,
 266                                  nsISelection* aSpellCheckSelection);
 267
 268   // spell check the text contained within aRange, potentially scheduling
 269   // another check in the future if the time threshold is reached
 270   nsresult ScheduleSpellCheck(const mozInlineSpellStatus& aStatus);
 271
 272   nsresult DoSpellCheckSelection(mozInlineSpellWordUtil& aWordUtil,
 273                                  nsISelection* aSpellCheckSelection,
 274                                  mozInlineSpellStatus* aStatus);
 275   nsresult DoSpellCheck(mozInlineSpellWordUtil& aWordUtil,
 276                         nsISelection *aSpellCheckSelection,
 277                         mozInlineSpellStatus* aStatus,
 278                         PRBool* aDoneChecking);
 279
 280   // helper routine to determine if a point is inside of a the passed in selection.
 281   nsresult IsPointInSelection(nsISelection *aSelection,
 282                               nsIDOMNode *aNode,
 283                               PRInt32 aOffset,
 284                               nsIDOMRange **aRange);
 285
 286   nsresult CleanupRangesInSelection(nsISelection *aSelection);
 287
 288   nsresult RemoveRange(nsISelection *aSpellCheckSelection, nsIDOMRange * aRange);
 289   nsresult AddRange(nsISelection *aSpellCheckSelection, nsIDOMRange * aRange);
 290   PRBool   SpellCheckSelectionIsFull() { return mNumWordsInSpellSelection >= mMaxNumWordsInSpellSelection; }
 291
 292   nsresult MakeSpellCheckRange(nsIDOMNode* aStartNode, PRInt32 aStartOffset,
 293                                nsIDOMNode* aEndNode, PRInt32 aEndOffset,
 294                                nsIDOMRange** aRange);
 295
 296   // DOM and editor event registration helper routines
 297   nsresult RegisterEventListeners();
 298   nsresult UnregisterEventListeners();
 299   nsresult HandleNavigationEvent(nsIDOMEvent * aEvent, PRBool aForceWordSpellCheck, PRInt32 aNewPositionOffset = 0);
 300
 301   nsresult GetSpellCheckSelection(nsISelection ** aSpellCheckSelection);
 302   nsresult SaveCurrentSelectionPosition();
 303
 304   nsresult ResumeCheck(mozInlineSpellStatus* aStatus);
 305 };
 306
 307 #endif /* __mozinlinespellchecker_h__ */