diff options
Diffstat (limited to 'layout/generic/TextOverflow.h')
| -rw-r--r-- | layout/generic/TextOverflow.h | 259 |
1 files changed, 259 insertions, 0 deletions
diff --git a/layout/generic/TextOverflow.h b/layout/generic/TextOverflow.h new file mode 100644 index 0000000000..835b35be19 --- /dev/null +++ b/layout/generic/TextOverflow.h @@ -0,0 +1,259 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */ +/* 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 TextOverflow_h_ +#define TextOverflow_h_ + +#include "nsDisplayList.h" +#include "nsTHashtable.h" +#include "mozilla/Likely.h" +#include "mozilla/WritingModes.h" +#include <algorithm> + +class nsIScrollableFrame; +class nsLineBox; + +namespace mozilla { +namespace css { + +/** + * A class for rendering CSS3 text-overflow. + * Usage: + * 1. allocate an object using WillProcessLines + * 2. then call ProcessLine for each line you are building display lists for + */ +class TextOverflow { + public: + /** + * Allocate an object for text-overflow processing. + * @return nullptr if no processing is necessary. The caller owns the object. + */ + static TextOverflow* WillProcessLines(nsDisplayListBuilder* aBuilder, + nsIFrame* aBlockFrame); + /** + * Analyze the display lists for text overflow and what kind of item is at + * the content edges. Add display items for text-overflow markers as needed + * and remove or clip items that would overlap a marker. + */ + void ProcessLine(const nsDisplayListSet& aLists, nsLineBox* aLine); + + /** + * Get the resulting text-overflow markers (the list may be empty). + * @return a DisplayList containing any text-overflow markers. + */ + nsDisplayList& GetMarkers() { return mMarkerList; } + + /** + * @return true if aBlockFrmae has text-overflow:clip on both sides. + */ + static bool HasClippedOverflow(nsIFrame* aBlockFrame); + /** + * @return true if aBlockFrame needs analysis for text overflow. + */ + static bool CanHaveTextOverflow(nsDisplayListBuilder* aBuilder, + nsIFrame* aBlockFrame); + + typedef nsTHashtable<nsPtrHashKey<nsIFrame> > FrameHashtable; + + protected: + TextOverflow(nsDisplayListBuilder* aBuilder, + nsIFrame* aBlockFrame); + + typedef mozilla::WritingMode WritingMode; + typedef mozilla::LogicalRect LogicalRect; + + struct AlignmentEdges { + AlignmentEdges() : mAssigned(false) {} + void Accumulate(WritingMode aWM, const LogicalRect& aRect) + { + if (MOZ_LIKELY(mAssigned)) { + mIStart = std::min(mIStart, aRect.IStart(aWM)); + mIEnd = std::max(mIEnd, aRect.IEnd(aWM)); + } else { + mIStart = aRect.IStart(aWM); + mIEnd = aRect.IEnd(aWM); + mAssigned = true; + } + } + nscoord ISize() { return mIEnd - mIStart; } + nscoord mIStart; + nscoord mIEnd; + bool mAssigned; + }; + + struct InnerClipEdges { + InnerClipEdges() : mAssignedIStart(false), mAssignedIEnd(false) {} + void AccumulateIStart(WritingMode aWM, const LogicalRect& aRect) + { + if (MOZ_LIKELY(mAssignedIStart)) { + mIStart = std::max(mIStart, aRect.IStart(aWM)); + } else { + mIStart = aRect.IStart(aWM); + mAssignedIStart = true; + } + } + void AccumulateIEnd(WritingMode aWM, const LogicalRect& aRect) + { + if (MOZ_LIKELY(mAssignedIEnd)) { + mIEnd = std::min(mIEnd, aRect.IEnd(aWM)); + } else { + mIEnd = aRect.IEnd(aWM); + mAssignedIEnd = true; + } + } + nscoord mIStart; + nscoord mIEnd; + bool mAssignedIStart; + bool mAssignedIEnd; + }; + + LogicalRect + GetLogicalScrollableOverflowRectRelativeToBlock(nsIFrame* aFrame) const + { + return LogicalRect(mBlockWM, + aFrame->GetScrollableOverflowRect() + + aFrame->GetOffsetTo(mBlock), + mBlockSize); + } + + /** + * Examines frames on the line to determine whether we should draw a left + * and/or right marker, and if so, which frames should be completely hidden + * and the bounds of what will be displayed between the markers. + * @param aLine the line we're processing + * @param aFramesToHide frames that should have their display items removed + * @param aAlignmentEdges the outermost edges of all text and atomic + * inline-level frames that are inside the area between the markers + */ + void ExamineLineFrames(nsLineBox* aLine, + FrameHashtable* aFramesToHide, + AlignmentEdges* aAlignmentEdges); + + /** + * LineHasOverflowingText calls this to analyze edges, both the block's + * content edges and the hypothetical marker edges aligned at the block edges. + * @param aFrame the descendant frame of mBlock that we're analyzing + * @param aContentArea the block's content area + * @param aInsideMarkersArea the rectangle between the markers + * @param aFramesToHide frames that should have their display items removed + * @param aAlignmentEdges the outermost edges of all text and atomic + * inline-level frames that are inside the area between the markers + * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic + * inline-level frame is visible between the marker edges + * @param aClippedMarkerEdges the innermost edges of all text and atomic + * inline-level frames that are clipped by the current marker width + */ + void ExamineFrameSubtree(nsIFrame* aFrame, + const LogicalRect& aContentArea, + const LogicalRect& aInsideMarkersArea, + FrameHashtable* aFramesToHide, + AlignmentEdges* aAlignmentEdges, + bool* aFoundVisibleTextOrAtomic, + InnerClipEdges* aClippedMarkerEdges); + + /** + * ExamineFrameSubtree calls this to analyze a frame against the hypothetical + * marker edges (aInsideMarkersArea) for text frames and atomic inline-level + * elements. A text frame adds its extent inside aInsideMarkersArea where + * grapheme clusters are fully visible. An atomic adds its border box if + * it's fully inside aInsideMarkersArea, otherwise the frame is added to + * aFramesToHide. + * @param aFrame the descendant frame of mBlock that we're analyzing + * @param aFrameType aFrame's frame type + * @param aInsideMarkersArea the rectangle between the markers + * @param aFramesToHide frames that should have their display items removed + * @param aAlignmentEdges the outermost edges of all text and atomic + * inline-level frames that are inside the area between the markers + * inside aInsideMarkersArea + * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic + * inline-level frame is visible between the marker edges + * @param aClippedMarkerEdges the innermost edges of all text and atomic + * inline-level frames that are clipped by the current marker width + */ + void AnalyzeMarkerEdges(nsIFrame* aFrame, + const nsIAtom* aFrameType, + const LogicalRect& aInsideMarkersArea, + FrameHashtable* aFramesToHide, + AlignmentEdges* aAlignmentEdges, + bool* aFoundVisibleTextOrAtomic, + InnerClipEdges* aClippedMarkerEdges); + + /** + * Clip or remove items given the final marker edges. ("clip" here just means + * assigning mVisIStartEdge/mVisIEndEdge for any nsCharClipDisplayItem that + * needs it; see nsDisplayList.h for a description of that item). + * @param aFramesToHide remove display items for these frames + * @param aInsideMarkersArea is the area inside the markers + */ + void PruneDisplayListContents(nsDisplayList* aList, + const FrameHashtable& aFramesToHide, + const LogicalRect& aInsideMarkersArea); + + /** + * ProcessLine calls this to create display items for the markers and insert + * them into mMarkerList. + * @param aLine the line we're processing + * @param aCreateIStart if true, create a marker on the inline start side + * @param aCreateIEnd if true, create a marker on the inline end side + * @param aInsideMarkersArea is the area inside the markers + */ + void CreateMarkers(const nsLineBox* aLine, + bool aCreateIStart, bool aCreateIEnd, + const LogicalRect& aInsideMarkersArea); + + LogicalRect mContentArea; + nsDisplayListBuilder* mBuilder; + nsIFrame* mBlock; + nsIScrollableFrame* mScrollableFrame; + nsDisplayList mMarkerList; + nsSize mBlockSize; + WritingMode mBlockWM; + bool mCanHaveInlineAxisScrollbar; + bool mAdjustForPixelSnapping; + + class Marker { + public: + void Init(const nsStyleTextOverflowSide& aStyle) { + mInitialized = false; + mISize = 0; + mStyle = &aStyle; + } + + /** + * Setup the marker string and calculate its size, if not done already. + */ + void SetupString(nsIFrame* aFrame); + + bool IsNeeded() const { + return mHasOverflow; + } + void Reset() { + mHasOverflow = false; + } + + // The current width of the marker, the range is [0 .. mIntrinsicISize]. + nscoord mISize; + // The intrinsic width of the marker. + nscoord mIntrinsicISize; + // The style for this side. + const nsStyleTextOverflowSide* mStyle; + // True if there is visible overflowing inline content on this side. + bool mHasOverflow; + // True if mMarkerString and mWidth have been setup from style. + bool mInitialized; + // True if the style is text-overflow:clip on this side and the marker + // won't cause the line to become empty. + bool mActive; + }; + + Marker mIStart; // the inline start marker + Marker mIEnd; // the inline end marker +}; + +} // namespace css +} // namespace mozilla + +#endif /* !defined(TextOverflow_h_) */ |