LCOV - app.info - objdir/dist/include/nsRange.h

LCOV - code coverage report
| Current view: | directory - objdir/dist/include - nsRange.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 21 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 8 | 0 | 0.0 %

           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 mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : /*
          39                 :  * Implementation of the DOM nsIDOMRange object.
          40                 :  */
          41                 :
          42                 : #ifndef nsRange_h___
          43                 : #define nsRange_h___
          44                 :
          45                 : #include "nsIDOMRange.h"
          46                 : #include "nsCOMPtr.h"
          47                 : #include "nsIDOMDocumentFragment.h"
          48                 : #include "nsIContent.h"
          49                 : #include "nsIDOMNode.h"
          50                 : #include "prmon.h"
          51                 : #include "nsStubMutationObserver.h"
          52                 :
          53                 : class nsRange : public nsIDOMRange,
          54                 :                 public nsStubMutationObserver
          55                 : {
          56                 : public:
          57               0 :   nsRange()
          58                 :     : mRoot(nsnull)
          59                 :     , mStartOffset(0)
          60                 :     , mEndOffset(0)
          61                 :     , mIsPositioned(false)
          62                 :     , mIsDetached(false)
          63                 :     , mMaySpanAnonymousSubtrees(false)
          64               0 :     , mInSelection(false)
          65               0 :   {}
          66                 :   virtual ~nsRange();
          67                 :
          68                 :   static nsresult CreateRange(nsIDOMNode* aStartParent, PRInt32 aStartOffset,
          69                 :                               nsIDOMNode* aEndParent, PRInt32 aEndOffset,
          70                 :                               nsRange** aRange);
          71                 :   static nsresult CreateRange(nsIDOMNode* aStartParent, PRInt32 aStartOffset,
          72                 :                               nsIDOMNode* aEndParent, PRInt32 aEndOffset,
          73                 :                               nsIDOMRange** aRange);
          74                 :
          75                 :   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
          76                 :   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsRange, nsIDOMRange)
          77                 :
          78                 :   // nsIDOMRange interface
          79                 :   NS_DECL_NSIDOMRANGE
          80                 :
          81                 :   nsINode* GetRoot() const
          82                 :   {
          83                 :     return mRoot;
          84                 :   }
          85                 :
          86               0 :   nsINode* GetStartParent() const
          87                 :   {
          88               0 :     return mStartParent;
          89                 :   }
          90                 :
          91               0 :   nsINode* GetEndParent() const
          92                 :   {
          93               0 :     return mEndParent;
          94                 :   }
          95                 :
          96               0 :   PRInt32 StartOffset() const
          97                 :   {
          98               0 :     return mStartOffset;
          99                 :   }
         100                 :
         101               0 :   PRInt32 EndOffset() const
         102                 :   {
         103               0 :     return mEndOffset;
         104                 :   }
         105                 :
         106                 :   bool IsPositioned() const
         107                 :   {
         108                 :     return mIsPositioned;
         109                 :   }
         110                 :
         111                 :   bool IsDetached() const
         112                 :   {
         113                 :     return mIsDetached;
         114                 :   }
         115                 :
         116               0 :   bool Collapsed() const
         117                 :   {
         118               0 :     return mIsPositioned && mStartParent == mEndParent &&
         119               0 :            mStartOffset == mEndOffset;
         120                 :   }
         121                 :
         122               0 :   void SetMaySpanAnonymousSubtrees(bool aMaySpanAnonymousSubtrees)
         123                 :   {
         124               0 :     mMaySpanAnonymousSubtrees = aMaySpanAnonymousSubtrees;
         125               0 :   }
         126                 :
         127                 :   /**
         128                 :    * Return true iff this range is part of at least one Selection object
         129                 :    * and isn't detached.
         130                 :    */
         131                 :   bool IsInSelection() const
         132                 :   {
         133                 :     return mInSelection;
         134                 :   }
         135                 :
         136                 :   /**
         137                 :    * Called when the range is added/removed from a Selection.
         138                 :    */
         139                 :   void SetInSelection(bool aInSelection)
         140                 :   {
         141                 :     if (mInSelection == aInSelection || mIsDetached) {
         142                 :       return;
         143                 :     }
         144                 :     mInSelection = aInSelection;
         145                 :     nsINode* commonAncestor = GetCommonAncestor();
         146                 :     NS_ASSERTION(commonAncestor, "unexpected disconnected nodes");
         147                 :     if (mInSelection) {
         148                 :       RegisterCommonAncestor(commonAncestor);
         149                 :     } else {
         150                 :       UnregisterCommonAncestor(commonAncestor);
         151                 :     }
         152                 :   }
         153                 :
         154                 :   nsINode* GetCommonAncestor() const;
         155                 :   void Reset();
         156                 :   nsresult SetStart(nsINode* aParent, PRInt32 aOffset);
         157                 :   nsresult SetEnd(nsINode* aParent, PRInt32 aOffset);
         158                 :   nsresult CloneRange(nsRange** aNewRange) const;
         159                 :
         160               0 :   nsresult Set(nsINode* aStartParent, PRInt32 aStartOffset,
         161                 :                nsINode* aEndParent, PRInt32 aEndOffset)
         162                 :   {
         163                 :     // If this starts being hot, we may be able to optimize this a bit,
         164                 :     // but for now just set start and end separately.
         165               0 :     nsresult rv = SetStart(aStartParent, aStartOffset);
         166               0 :     NS_ENSURE_SUCCESS(rv, rv);
         167                 :
         168               0 :     return SetEnd(aEndParent, aEndOffset);
         169                 :   }
         170                 :
         171                 :   NS_IMETHOD GetUsedFontFaces(nsIDOMFontFaceList** aResult);
         172                 :
         173                 :   // nsIMutationObserver methods
         174                 :   NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
         175                 :   NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
         176                 :   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
         177                 :   NS_DECL_NSIMUTATIONOBSERVER_PARENTCHAINCHANGED
         178                 :   NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
         179                 :
         180                 : private:
         181                 :   // no copy's or assigns
         182                 :   nsRange(const nsRange&);
         183                 :   nsRange& operator=(const nsRange&);
         184                 :
         185                 :   /**
         186                 :    * Cut or delete the range's contents.
         187                 :    *
         188                 :    * @param aFragment nsIDOMDocumentFragment containing the nodes.
         189                 :    *                  May be null to indicate the caller doesn't want a fragment.
         190                 :    */
         191                 :   nsresult CutContents(nsIDOMDocumentFragment** frag);
         192                 :
         193                 :   static nsresult CloneParentsBetween(nsIDOMNode *aAncestor,
         194                 :                                       nsIDOMNode *aNode,
         195                 :                                       nsIDOMNode **aClosestAncestor,
         196                 :                                       nsIDOMNode **aFarthestAncestor);
         197                 :
         198                 : public:
         199                 : /******************************************************************************
         200                 :  *  Utility routine to detect if a content node starts before a range and/or
         201                 :  *  ends after a range.  If neither it is contained inside the range.
         202                 :  *
         203                 :  *  XXX - callers responsibility to ensure node in same doc as range!
         204                 :  *
         205                 :  *****************************************************************************/
         206                 :   static nsresult CompareNodeToRange(nsINode* aNode, nsRange* aRange,
         207                 :                                      bool *outNodeBefore,
         208                 :                                      bool *outNodeAfter);
         209                 :
         210                 :   static bool IsNodeSelected(nsINode* aNode, PRUint32 aStartOffset,
         211                 :                              PRUint32 aEndOffset);
         212                 :
         213                 :   typedef nsTHashtable<nsPtrHashKey<nsRange> > RangeHashTable;
         214                 : protected:
         215                 :   void RegisterCommonAncestor(nsINode* aNode);
         216                 :   void UnregisterCommonAncestor(nsINode* aNode);
         217                 :   nsINode* IsValidBoundary(nsINode* aNode);
         218                 :
         219                 :   // CharacterDataChanged set aNotInsertedYet to true to disable an assertion
         220                 :   // and suppress re-registering a range common ancestor node since
         221                 :   // the new text node of a splitText hasn't been inserted yet.
         222                 :   // CharacterDataChanged does the re-registering when needed.
         223                 :   void DoSetRange(nsINode* aStartN, PRInt32 aStartOffset,
         224                 :                   nsINode* aEndN, PRInt32 aEndOffset,
         225                 :                   nsINode* aRoot, bool aNotInsertedYet = false);
         226                 :
         227                 :   /**
         228                 :    * For a range for which IsInSelection() is true, return the common
         229                 :    * ancestor for the range.  This method uses the selection bits and
         230                 :    * nsGkAtoms::range property on the nodes to quickly find the ancestor.
         231                 :    * That is, it's a faster version of GetCommonAncestor that only works
         232                 :    * for ranges in a Selection.  The method will assert and the behavior
         233                 :    * is undefined if called on a range where IsInSelection() is false.
         234                 :    */
         235                 :   nsINode* GetRegisteredCommonAncestor();
         236                 :
         237                 :   struct NS_STACK_CLASS AutoInvalidateSelection
         238                 :   {
         239                 :     AutoInvalidateSelection(nsRange* aRange) : mRange(aRange)
         240                 :     {
         241                 : #ifdef DEBUG
         242                 :       mWasInSelection = mRange->IsInSelection();
         243                 : #endif
         244                 :       if (!mRange->IsInSelection() || mIsNested) {
         245                 :         return;
         246                 :       }
         247                 :       mIsNested = true;
         248                 :       NS_ASSERTION(!mRange->IsDetached(), "detached range in selection");
         249                 :       mCommonAncestor = mRange->GetRegisteredCommonAncestor();
         250                 :     }
         251                 :     ~AutoInvalidateSelection();
         252                 :     nsRange* mRange;
         253                 :     nsRefPtr<nsINode> mCommonAncestor;
         254                 : #ifdef DEBUG
         255                 :     bool mWasInSelection;
         256                 : #endif
         257                 :     static bool mIsNested;
         258                 :   };
         259                 :
         260                 :   nsCOMPtr<nsINode> mRoot;
         261                 :   nsCOMPtr<nsINode> mStartParent;
         262                 :   nsCOMPtr<nsINode> mEndParent;
         263                 :   PRInt32 mStartOffset;
         264                 :   PRInt32 mEndOffset;
         265                 :
         266                 :   bool mIsPositioned;
         267                 :   bool mIsDetached;
         268                 :   bool mMaySpanAnonymousSubtrees;
         269                 :   bool mInSelection;
         270                 : };
         271                 :
         272                 : #endif /* nsRange_h___ */

Generated by: LCOV version 1.7