The Tor Browser: editor/libeditor/html/nsWSRunObject.h@6474c204b198 (annotated)

editor/libeditor/html/nsWSRunObject.h@6474c204b198 (annotated)

editor/libeditor/html/nsWSRunObject.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 __wsrunobject_h__
 #define __wsrunobject_h__
 #include "nsCOMArray.h"
 #include "nsCOMPtr.h"
 #include "nsIContent.h"
 #include "nsIDOMNode.h"
 #include "nsIEditor.h"
 #include "nsINode.h"
 #include "nscore.h"
 class nsHTMLEditor;
 class nsIDOMDocument;
 class nsIDOMNode;
 struct DOMPoint;
 // class nsWSRunObject represents the entire whitespace situation
 // around a given point.  It collects up a list of nodes that contain
 // whitespace and categorizes in up to 3 different WSFragments (detailed
 // below).  Each WSFragment is a collection of whitespace that is
 // either all insignificant, or that is significant.  A WSFragment could
 // consist of insignificant whitespace because it is after a block
 // boundary or after a break.  Or it could be insignificant because it
 // is before a block.  Or it could be significant because it is
 // surrounded by text, or starts and ends with nbsps, etc.
 // Throughout I refer to LeadingWS, NormalWS, TrailingWS.  LeadingWS & TrailingWS
 // are runs of ascii ws that are insignificant (do not render) because they
 // are adjacent to block boundaries, or after a break.  NormalWS is ws that
 // does cause soem rendering.  Note that not all the ws in a NormalWS run need
 // render.  For example, two ascii spaces surrounded by text on both sides
 // will only render as one space (in non-preformatted stlye html), yet both
 // spaces count as NormalWS.  Together, they render as the one visible space.
 /**
  * A type-safe bitfield indicating various types of whitespace or other things.
  * Used as a member variable in nsWSRunObject and WSFragment.
  *
  * XXX: If this idea is useful in other places, we should generalize it using a
  * template.
  */
 class WSType {
 public:
   enum Enum {
     none       = 0,
     leadingWS  = 1,      // leading insignificant ws, ie, after block or br
     trailingWS = 1 << 1, // trailing insignificant ws, ie, before block
     normalWS   = 1 << 2, // normal significant ws, ie, after text, image, ...
     text       = 1 << 3, // indicates regular (non-ws) text
     special    = 1 << 4, // indicates an inline non-container, like image
     br         = 1 << 5, // indicates a br node
     otherBlock = 1 << 6, // indicates a block other than one ws run is in
     thisBlock  = 1 << 7, // indicates the block ws run is in
     block      = otherBlock | thisBlock // block found
   };
   /**
    * Implicit constructor, because the enums are logically just WSTypes
    * themselves, and are only a separate type because there's no other obvious
    * way to name specific WSType values.
    */
   WSType(const Enum& aEnum = none) : mEnum(aEnum) {}
   // operator==, &, and | need to access mEnum
   friend bool operator==(const WSType& aLeft, const WSType& aRight);
   friend const WSType operator&(const WSType& aLeft, const WSType& aRight);
   friend const WSType operator|(const WSType& aLeft, const WSType& aRight);
   WSType& operator=(const WSType& aOther) {
     // This handles self-assignment fine
     mEnum = aOther.mEnum;
     return *this;
   }
   WSType& operator&=(const WSType& aOther) {
     mEnum &= aOther.mEnum;
     return *this;
   }
   WSType& operator|=(const WSType& aOther) {
     mEnum |= aOther.mEnum;
     return *this;
   }
 private:
   uint16_t mEnum;
   void bool_conversion_helper() {}
 public:
   // Allow boolean conversion with no numeric conversion
   typedef void (WSType::*bool_type)();
   operator bool_type() const
   {
     return mEnum ? &WSType::bool_conversion_helper : nullptr;
   }
 };
 /**
  * These are declared as global functions so "WSType::Enum == WSType" et al.
  * will work using the implicit constructor.
  */
 inline bool operator==(const WSType& aLeft, const WSType& aRight)
 {
   return aLeft.mEnum == aRight.mEnum;
 }
 inline bool operator!=(const WSType& aLeft, const WSType& aRight)
 {
   return !(aLeft == aRight);
 }
 inline const WSType operator&(const WSType& aLeft, const WSType& aRight)
 {
   WSType ret;
   ret.mEnum = aLeft.mEnum & aRight.mEnum;
   return ret;
 }
 inline const WSType operator|(const WSType& aLeft, const WSType& aRight)
 {
   WSType ret;
   ret.mEnum = aLeft.mEnum | aRight.mEnum;
   return ret;
 }
 /**
  * Make sure that & and | of WSType::Enum creates a WSType instead of an int,
  * because operators between WSType and int shouldn't work
  */
 inline const WSType operator&(const WSType::Enum& aLeft,
                               const WSType::Enum& aRight)
 {
   return WSType(aLeft) & WSType(aRight);
 }
 inline const WSType operator|(const WSType::Enum& aLeft,
                               const WSType::Enum& aRight)
 {
   return WSType(aLeft) | WSType(aRight);
 }
 class MOZ_STACK_CLASS nsWSRunObject
 {
   public:
     // public enums ---------------------------------------------------------
     enum BlockBoundary
     {
       kBeforeBlock,
       kBlockStart,
       kBlockEnd,
       kAfterBlock
     };
     enum {eBefore = 1};
     enum {eAfter  = 1 << 1};
     enum {eBoth   = eBefore | eAfter};
     // constructor / destructor -----------------------------------------------
     nsWSRunObject(nsHTMLEditor *aEd, nsIDOMNode *aNode, int32_t aOffset);
     ~nsWSRunObject();
     // public methods ---------------------------------------------------------
     // ScrubBlockBoundary removes any non-visible whitespace at the specified
     // location relative to a block node.
     static nsresult ScrubBlockBoundary(nsHTMLEditor *aHTMLEd,
                                        nsCOMPtr<nsIDOMNode> *aBlock,
                                        BlockBoundary aBoundary,
                                        int32_t *aOffset = 0);
     // PrepareToJoinBlocks fixes up ws at the end of aLeftParent and the
     // beginning of aRightParent in preperation for them to be joined.
     // example of fixup: trailingws in aLeftParent needs to be removed.
     static nsresult PrepareToJoinBlocks(nsHTMLEditor *aEd,
                                         nsIDOMNode *aLeftParent,
                                         nsIDOMNode *aRightParent);
     // PrepareToDeleteRange fixes up ws before {aStartNode,aStartOffset}
     // and after {aEndNode,aEndOffset} in preperation for content
     // in that range to be deleted.  Note that the nodes and offsets
     // are adjusted in response to any dom changes we make while
     // adjusting ws.
     // example of fixup: trailingws before {aStartNode,aStartOffset}
     //                   needs to be removed.
     static nsresult PrepareToDeleteRange(nsHTMLEditor *aHTMLEd,
                                          nsCOMPtr<nsIDOMNode> *aStartNode,
                                          int32_t *aStartOffset,
                                          nsCOMPtr<nsIDOMNode> *aEndNode,
                                          int32_t *aEndOffset);
     // PrepareToDeleteNode fixes up ws before and after aNode in preperation
     // for aNode to be deleted.
     // example of fixup: trailingws before aNode needs to be removed.
     static nsresult PrepareToDeleteNode(nsHTMLEditor *aHTMLEd,
                                         nsIDOMNode *aNode);
     // PrepareToSplitAcrossBlocks fixes up ws before and after
     // {aSplitNode,aSplitOffset} in preperation for a block
     // parent to be split.  Note that the aSplitNode and aSplitOffset
     // are adjusted in response to any dom changes we make while
     // adjusting ws.
     // example of fixup: normalws before {aSplitNode,aSplitOffset}
     //                   needs to end with nbsp.
     static nsresult PrepareToSplitAcrossBlocks(nsHTMLEditor *aHTMLEd,
                                                nsCOMPtr<nsIDOMNode> *aSplitNode,
                                                int32_t *aSplitOffset);
     // InsertBreak inserts a br node at {aInOutParent,aInOutOffset}
     // and makes any needed adjustments to ws around that point.
     // example of fixup: normalws after {aInOutParent,aInOutOffset}
     //                   needs to begin with nbsp.
     nsresult InsertBreak(nsCOMPtr<nsIDOMNode> *aInOutParent,
                          int32_t *aInOutOffset,
                          nsCOMPtr<nsIDOMNode> *outBRNode,
                          nsIEditor::EDirection aSelect);
     // InsertText inserts a string at {aInOutParent,aInOutOffset}
     // and makes any needed adjustments to ws around that point.
     // example of fixup: trailingws before {aInOutParent,aInOutOffset}
     //                   needs to be removed.
     nsresult InsertText(const nsAString& aStringToInsert,
                         nsCOMPtr<nsIDOMNode> *aInOutNode,
                         int32_t *aInOutOffset,
                         nsIDOMDocument *aDoc);
     // DeleteWSBackward deletes a single visible piece of ws before
     // the ws point (the point to create the wsRunObject, passed to
     // its constructor).  It makes any needed conversion to adjacent
     // ws to retain its significance.
     nsresult DeleteWSBackward();
     // DeleteWSForward deletes a single visible piece of ws after
     // the ws point (the point to create the wsRunObject, passed to
     // its constructor).  It makes any needed conversion to adjacent
     // ws to retain its significance.
     nsresult DeleteWSForward();
     // PriorVisibleNode returns the first piece of visible thing
     // before {aNode,aOffset}.  If there is no visible ws qualifying
     // it returns what is before the ws run.  Note that
     // {outVisNode,outVisOffset} is set to just AFTER the visible
     // object.
     void PriorVisibleNode(nsIDOMNode *aNode,
                           int32_t aOffset,
                           nsCOMPtr<nsIDOMNode> *outVisNode,
                           int32_t *outVisOffset,
                           WSType *outType);
     // NextVisibleNode returns the first piece of visible thing
     // after {aNode,aOffset}.  If there is no visible ws qualifying
     // it returns what is after the ws run.  Note that
     // {outVisNode,outVisOffset} is set to just BEFORE the visible
     // object.
     void NextVisibleNode(nsIDOMNode *aNode,
                          int32_t aOffset,
                          nsCOMPtr<nsIDOMNode> *outVisNode,
                          int32_t *outVisOffset,
                          WSType *outType);
     // AdjustWhitespace examines the ws object for nbsp's that can
     // be safely converted to regular ascii space and converts them.
     nsresult AdjustWhitespace();
   protected:
     // WSFragment struct ---------------------------------------------------------
     // WSFragment represents a single run of ws (all leadingws, or all normalws,
     // or all trailingws, or all leading+trailingws).  Note that this single run may
     // still span multiple nodes.
     struct WSFragment
     {
       nsCOMPtr<nsIDOMNode> mStartNode;  // node where ws run starts
       nsCOMPtr<nsIDOMNode> mEndNode;    // node where ws run ends
       int32_t mStartOffset;             // offset where ws run starts
       int32_t mEndOffset;               // offset where ws run ends
       // type of ws, and what is to left and right of it
       WSType mType, mLeftType, mRightType;
       // other ws runs to left or right.  may be null.
       WSFragment *mLeft, *mRight;
       WSFragment() : mStartNode(0), mEndNode(0),
                      mStartOffset(0), mEndOffset(0),
                      mType(), mLeftType(), mRightType(),
                      mLeft(0), mRight(0)
       {
       }
     };
     // WSPoint struct ------------------------------------------------------------
     // A WSPoint struct represents a unique location within the ws run.  It is
     // always within a textnode that is one of the nodes stored in the list
     // in the wsRunObject.  For convenience, the character at that point is also
     // stored in the struct.
     struct MOZ_STACK_CLASS WSPoint
     {
       nsCOMPtr<nsIContent> mTextNode;
       uint32_t mOffset;
       char16_t mChar;
       WSPoint() : mTextNode(0),mOffset(0),mChar(0) {}
       WSPoint(nsIDOMNode *aNode, int32_t aOffset, char16_t aChar) :
                      mTextNode(do_QueryInterface(aNode)),mOffset(aOffset),mChar(aChar)
       {
         if (!mTextNode->IsNodeOfType(nsINode::eDATA_NODE)) {
           // Not sure if this is needed, but it'll maintain the same
           // functionality
           mTextNode = nullptr;
         }
       }
       WSPoint(nsIContent *aTextNode, int32_t aOffset, char16_t aChar) :
                      mTextNode(aTextNode),mOffset(aOffset),mChar(aChar) {}
     };
     enum AreaRestriction
     {
       eAnywhere, eOutsideUserSelectAll
     };
     // protected methods ---------------------------------------------------------
     // tons of utility methods.
     /**
      * Return the node which we will handle white-space under. This is the
      * closest block within the DOM subtree we're editing, or if none is
      * found, the (inline) root of the editable subtree.
      */
     already_AddRefed<nsIDOMNode> GetWSBoundingParent();
     nsresult GetWSNodes();
     void     GetRuns();
     void     ClearRuns();
     void     MakeSingleWSRun(WSType aType);
     nsresult PrependNodeToList(nsIDOMNode *aNode);
     nsresult AppendNodeToList(nsIDOMNode *aNode);
     nsresult GetPreviousWSNode(nsIDOMNode *aStartNode,
                                nsIDOMNode *aBlockParent,
                                nsCOMPtr<nsIDOMNode> *aPriorNode);
     nsresult GetPreviousWSNode(nsIDOMNode *aStartNode,
                                int32_t      aOffset,
                                nsIDOMNode  *aBlockParent,
                                nsCOMPtr<nsIDOMNode> *aPriorNode);
     nsresult GetPreviousWSNode(::DOMPoint aPoint,
                                nsIDOMNode  *aBlockParent,
                                nsCOMPtr<nsIDOMNode> *aPriorNode);
     nsresult GetNextWSNode(nsIDOMNode *aStartNode,
                            nsIDOMNode *aBlockParent,
                            nsCOMPtr<nsIDOMNode> *aNextNode);
     nsresult GetNextWSNode(nsIDOMNode *aStartNode,
                            int32_t     aOffset,
                            nsIDOMNode *aBlockParent,
                            nsCOMPtr<nsIDOMNode> *aNextNode);
     nsresult GetNextWSNode(::DOMPoint aPoint,
                            nsIDOMNode  *aBlockParent,
                            nsCOMPtr<nsIDOMNode> *aNextNode);
     nsresult PrepareToDeleteRangePriv(nsWSRunObject* aEndObject);
     nsresult PrepareToSplitAcrossBlocksPriv();
     nsresult DeleteChars(nsIDOMNode *aStartNode, int32_t aStartOffset,
                          nsIDOMNode *aEndNode, int32_t aEndOffset,
                          AreaRestriction aAR = eAnywhere);
     WSPoint  GetCharAfter(nsIDOMNode *aNode, int32_t aOffset);
     WSPoint  GetCharBefore(nsIDOMNode *aNode, int32_t aOffset);
     WSPoint  GetCharAfter(const WSPoint &aPoint);
     WSPoint  GetCharBefore(const WSPoint &aPoint);
     nsresult ConvertToNBSP(WSPoint aPoint,
                            AreaRestriction aAR = eAnywhere);
     void     GetAsciiWSBounds(int16_t aDir, nsIDOMNode *aNode, int32_t aOffset,
                                 nsCOMPtr<nsIDOMNode> *outStartNode, int32_t *outStartOffset,
                                 nsCOMPtr<nsIDOMNode> *outEndNode, int32_t *outEndOffset);
     void     FindRun(nsIDOMNode *aNode, int32_t aOffset, WSFragment **outRun, bool after);
     char16_t GetCharAt(nsIContent *aTextNode, int32_t aOffset);
     WSPoint  GetWSPointAfter(nsIDOMNode *aNode, int32_t aOffset);
     WSPoint  GetWSPointBefore(nsIDOMNode *aNode, int32_t aOffset);
     nsresult CheckTrailingNBSPOfRun(WSFragment *aRun);
     nsresult CheckTrailingNBSP(WSFragment *aRun, nsIDOMNode *aNode, int32_t aOffset);
     nsresult CheckLeadingNBSP(WSFragment *aRun, nsIDOMNode *aNode, int32_t aOffset);
     static nsresult ScrubBlockBoundaryInner(nsHTMLEditor *aHTMLEd,
                                        nsCOMPtr<nsIDOMNode> *aBlock,
                                        BlockBoundary aBoundary);
     nsresult Scrub();
     // member variables ---------------------------------------------------------
     nsCOMPtr<nsIDOMNode> mNode;           // the node passed to our constructor
     int32_t mOffset;                      // the offset passed to our contructor
     // together, the above represent the point at which we are building up ws info.
     bool    mPRE;                         // true if we are in preformatted whitespace context
     nsCOMPtr<nsIDOMNode> mStartNode;      // node/offset where ws starts
     int32_t mStartOffset;                 // ...
     WSType mStartReason;                  // reason why ws starts (eText, eOtherBlock, etc)
     nsCOMPtr<nsIDOMNode> mStartReasonNode;// the node that implicated by start reason
     nsCOMPtr<nsIDOMNode> mEndNode;        // node/offset where ws ends
     int32_t mEndOffset;                   // ...
     WSType mEndReason;                    // reason why ws ends (eText, eOtherBlock, etc)
     nsCOMPtr<nsIDOMNode> mEndReasonNode;  // the node that implicated by end reason
     nsCOMPtr<nsIDOMNode> mFirstNBSPNode;  // location of first nbsp in ws run, if any
     int32_t mFirstNBSPOffset;             // ...
     nsCOMPtr<nsIDOMNode> mLastNBSPNode;   // location of last nbsp in ws run, if any
     int32_t mLastNBSPOffset;              // ...
     nsCOMArray<nsIDOMNode> mNodeArray;//the list of nodes containing ws in this run
     WSFragment *mStartRun;                // the first WSFragment in the run
     WSFragment *mEndRun;                  // the last WSFragment in the run, may be same as first
     nsHTMLEditor *mHTMLEditor;            // non-owning.
     friend class nsHTMLEditRules;  // opening this class up for pillaging
     friend class nsHTMLEditor;     // opening this class up for more pillaging
 };
 #endif

The Tor Browser / annotate

editor/libeditor/html/nsWSRunObject.h@6474c204b198 (annotated)

editor/libeditor/html/nsWSRunObject.h