diff -r 000000000000 -r 6474c204b198 editor/libeditor/html/nsWSRunObject.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/editor/libeditor/html/nsWSRunObject.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,414 @@ +/* -*- 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 *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 *aStartNode, + int32_t *aStartOffset, + nsCOMPtr *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 *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 *aInOutParent, + int32_t *aInOutOffset, + nsCOMPtr *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 *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 *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 *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 mStartNode; // node where ws run starts + nsCOMPtr 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 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 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 *aPriorNode); + nsresult GetPreviousWSNode(nsIDOMNode *aStartNode, + int32_t aOffset, + nsIDOMNode *aBlockParent, + nsCOMPtr *aPriorNode); + nsresult GetPreviousWSNode(::DOMPoint aPoint, + nsIDOMNode *aBlockParent, + nsCOMPtr *aPriorNode); + nsresult GetNextWSNode(nsIDOMNode *aStartNode, + nsIDOMNode *aBlockParent, + nsCOMPtr *aNextNode); + nsresult GetNextWSNode(nsIDOMNode *aStartNode, + int32_t aOffset, + nsIDOMNode *aBlockParent, + nsCOMPtr *aNextNode); + nsresult GetNextWSNode(::DOMPoint aPoint, + nsIDOMNode *aBlockParent, + nsCOMPtr *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 *outStartNode, int32_t *outStartOffset, + nsCOMPtr *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 *aBlock, + BlockBoundary aBoundary); + nsresult Scrub(); + + // member variables --------------------------------------------------------- + + nsCOMPtr 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 mStartNode; // node/offset where ws starts + int32_t mStartOffset; // ... + WSType mStartReason; // reason why ws starts (eText, eOtherBlock, etc) + nsCOMPtr mStartReasonNode;// the node that implicated by start reason + + nsCOMPtr mEndNode; // node/offset where ws ends + int32_t mEndOffset; // ... + WSType mEndReason; // reason why ws ends (eText, eOtherBlock, etc) + nsCOMPtr mEndReasonNode; // the node that implicated by end reason + + nsCOMPtr mFirstNBSPNode; // location of first nbsp in ws run, if any + int32_t mFirstNBSPOffset; // ... + + nsCOMPtr mLastNBSPNode; // location of last nbsp in ws run, if any + int32_t mLastNBSPOffset; // ... + + nsCOMArray 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 +