| /* |
| * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. |
| * All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #ifndef InlineBox_h |
| #define InlineBox_h |
| |
| #include "core/CoreExport.h" |
| #include "core/layout/api/LineLayoutBoxModel.h" |
| #include "core/layout/api/LineLayoutItem.h" |
| #include "core/layout/api/SelectionState.h" |
| #include "platform/graphics/paint/DisplayItemClient.h" |
| #include "platform/text/TextDirection.h" |
| |
| namespace blink { |
| |
| class HitTestRequest; |
| class HitTestResult; |
| class LayoutObject; |
| class RootInlineBox; |
| |
| enum MarkLineBoxes { MarkLineBoxesDirty, DontMarkLineBoxes }; |
| |
| // InlineBox represents a rectangle that occurs on a line. It corresponds to |
| // some LayoutObject (i.e., it represents a portion of that LayoutObject). |
| class CORE_EXPORT InlineBox : public DisplayItemClient { |
| WTF_MAKE_NONCOPYABLE(InlineBox); |
| |
| public: |
| InlineBox(LineLayoutItem obj) |
| : m_next(nullptr), |
| m_prev(nullptr), |
| m_parent(nullptr), |
| m_lineLayoutItem(obj), |
| m_logicalWidth() |
| #if ENABLE(ASSERT) |
| , |
| m_hasBadParent(false) |
| #endif |
| { |
| } |
| |
| InlineBox(LineLayoutItem item, |
| LayoutPoint topLeft, |
| LayoutUnit logicalWidth, |
| bool firstLine, |
| bool constructed, |
| bool dirty, |
| bool extracted, |
| bool isHorizontal, |
| InlineBox* next, |
| InlineBox* prev, |
| InlineFlowBox* parent) |
| : m_bitfields(firstLine, constructed, dirty, extracted, isHorizontal), |
| m_next(next), |
| m_prev(prev), |
| m_parent(parent), |
| m_lineLayoutItem(item), |
| m_topLeft(topLeft), |
| m_logicalWidth(logicalWidth) |
| #if ENABLE(ASSERT) |
| , |
| m_hasBadParent(false) |
| #endif |
| { |
| } |
| |
| virtual ~InlineBox(); |
| |
| virtual void destroy(); |
| |
| virtual void deleteLine(); |
| virtual void extractLine(); |
| virtual void attachLine(); |
| |
| virtual bool isLineBreak() const { return false; } |
| |
| // These methods are called when the caller wants to move the position of |
| // InlineBox without full layout of it. The implementation should update the |
| // position of the whole subtree (e.g. position of descendants and overflow |
| // etc. should also be moved accordingly). |
| virtual void move(const LayoutSize& delta); |
| DISABLE_CFI_PERF void moveInLogicalDirection( |
| const LayoutSize& deltaInLogicalDirection) { |
| move(isHorizontal() ? deltaInLogicalDirection |
| : deltaInLogicalDirection.transposedSize()); |
| } |
| void moveInInlineDirection(LayoutUnit delta) { |
| moveInLogicalDirection(LayoutSize(delta, LayoutUnit())); |
| } |
| void moveInBlockDirection(LayoutUnit delta) { |
| moveInLogicalDirection(LayoutSize(LayoutUnit(), delta)); |
| } |
| |
| virtual void paint(const PaintInfo&, |
| const LayoutPoint&, |
| LayoutUnit lineTop, |
| LayoutUnit lineBottom) const; |
| virtual bool nodeAtPoint(HitTestResult&, |
| const HitTestLocation& locationInContainer, |
| const LayoutPoint& accumulatedOffset, |
| LayoutUnit lineTop, |
| LayoutUnit lineBottom); |
| |
| // InlineBoxes are allocated out of the rendering partition. |
| void* operator new(size_t); |
| void operator delete(void*); |
| |
| #ifndef NDEBUG |
| void showTreeForThis() const; |
| void showLineTreeForThis() const; |
| |
| virtual void showBox(int = 0) const; |
| virtual void showLineTreeAndMark(const InlineBox* = nullptr, |
| const char* = nullptr, |
| const InlineBox* = nullptr, |
| const char* = nullptr, |
| const LayoutObject* = nullptr, |
| int = 0) const; |
| #endif |
| |
| virtual const char* boxName() const; |
| |
| // DisplayItemClient methods |
| String debugName() const override; |
| LayoutRect visualRect() const override; |
| |
| bool isText() const { return m_bitfields.isText(); } |
| void setIsText(bool isText) { m_bitfields.setIsText(isText); } |
| |
| virtual bool isInlineFlowBox() const { return false; } |
| virtual bool isInlineTextBox() const { return false; } |
| virtual bool isRootInlineBox() const { return false; } |
| |
| virtual bool isSVGInlineTextBox() const { return false; } |
| virtual bool isSVGInlineFlowBox() const { return false; } |
| virtual bool isSVGRootInlineBox() const { return false; } |
| |
| bool hasVirtualLogicalHeight() const { |
| return m_bitfields.hasVirtualLogicalHeight(); |
| } |
| void setHasVirtualLogicalHeight() { |
| m_bitfields.setHasVirtualLogicalHeight(true); |
| } |
| virtual LayoutUnit virtualLogicalHeight() const { |
| ASSERT_NOT_REACHED(); |
| return LayoutUnit(); |
| } |
| |
| bool isHorizontal() const { return m_bitfields.isHorizontal(); } |
| void setIsHorizontal(bool isHorizontal) { |
| m_bitfields.setIsHorizontal(isHorizontal); |
| } |
| |
| virtual LayoutRect calculateBoundaries() const { |
| ASSERT_NOT_REACHED(); |
| return LayoutRect(); |
| } |
| |
| bool isConstructed() { return m_bitfields.constructed(); } |
| virtual void setConstructed() { m_bitfields.setConstructed(true); } |
| |
| void setExtracted(bool extracted = true) { |
| m_bitfields.setExtracted(extracted); |
| } |
| |
| void setFirstLineStyleBit(bool firstLine) { |
| m_bitfields.setFirstLine(firstLine); |
| } |
| bool isFirstLineStyle() const { return m_bitfields.firstLine(); } |
| |
| void remove(MarkLineBoxes = MarkLineBoxesDirty); |
| |
| InlineBox* nextOnLine() const { return m_next; } |
| InlineBox* prevOnLine() const { return m_prev; } |
| void setNextOnLine(InlineBox* next) { |
| ASSERT(m_parent || !next); |
| m_next = next; |
| } |
| void setPrevOnLine(InlineBox* prev) { |
| ASSERT(m_parent || !prev); |
| m_prev = prev; |
| } |
| bool nextOnLineExists() const; |
| |
| virtual bool isLeaf() const { return true; } |
| |
| InlineBox* nextLeafChild() const; |
| InlineBox* prevLeafChild() const; |
| |
| // Helper functions for editing and hit-testing code. |
| // FIXME: These two functions should be moved to RenderedPosition once the |
| // code to convert between Position and inline box, offset pair is moved to |
| // RenderedPosition. |
| InlineBox* nextLeafChildIgnoringLineBreak() const; |
| InlineBox* prevLeafChildIgnoringLineBreak() const; |
| |
| LineLayoutItem getLineLayoutItem() const { return m_lineLayoutItem; } |
| |
| InlineFlowBox* parent() const { |
| ASSERT(!m_hasBadParent); |
| return m_parent; |
| } |
| void setParent(InlineFlowBox* par) { m_parent = par; } |
| |
| const RootInlineBox& root() const; |
| RootInlineBox& root(); |
| |
| // x() is the left side of the box in the containing block's coordinate |
| // system. |
| void setX(LayoutUnit x) { m_topLeft.setX(x); } |
| LayoutUnit x() const { return m_topLeft.x(); } |
| LayoutUnit left() const { return m_topLeft.x(); } |
| |
| // y() is the top side of the box in the containing block's coordinate system. |
| void setY(LayoutUnit y) { m_topLeft.setY(y); } |
| LayoutUnit y() const { return m_topLeft.y(); } |
| LayoutUnit top() const { return m_topLeft.y(); } |
| |
| const LayoutPoint& topLeft() const { return m_topLeft; } |
| |
| LayoutUnit width() const { |
| return isHorizontal() ? logicalWidth() : logicalHeight(); |
| } |
| LayoutUnit height() const { |
| return isHorizontal() ? logicalHeight() : logicalWidth(); |
| } |
| LayoutSize size() const { return LayoutSize(width(), height()); } |
| LayoutUnit right() const { return left() + width(); } |
| LayoutUnit bottom() const { return top() + height(); } |
| |
| // The logicalLeft position is the left edge of the line box in a horizontal |
| // line and the top edge in a vertical line. |
| LayoutUnit logicalLeft() const { |
| return isHorizontal() ? m_topLeft.x() : m_topLeft.y(); |
| } |
| LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); } |
| void setLogicalLeft(LayoutUnit left) { |
| if (isHorizontal()) |
| setX(left); |
| else |
| setY(left); |
| } |
| int pixelSnappedLogicalLeft() const { return logicalLeft().toInt(); } |
| int pixelSnappedLogicalRight() const { return logicalRight().ceil(); } |
| int pixelSnappedLogicalTop() const { return logicalTop().toInt(); } |
| int pixelSnappedLogicalBottom() const { return logicalBottom().ceil(); } |
| |
| // The logicalTop[ position is the top edge of the line box in a horizontal |
| // line and the left edge in a vertical line. |
| LayoutUnit logicalTop() const { |
| return isHorizontal() ? m_topLeft.y() : m_topLeft.x(); |
| } |
| LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); } |
| void setLogicalTop(LayoutUnit top) { |
| if (isHorizontal()) |
| setY(top); |
| else |
| setX(top); |
| } |
| |
| // The logical width is our extent in the line's overall inline direction, |
| // i.e., width for horizontal text and height for vertical text. |
| void setLogicalWidth(LayoutUnit w) { m_logicalWidth = w; } |
| LayoutUnit logicalWidth() const { return m_logicalWidth; } |
| |
| // The logical height is our extent in the block flow direction, i.e., height |
| // for horizontal text and width for vertical text. |
| LayoutUnit logicalHeight() const; |
| |
| LayoutRect logicalFrameRect() const { |
| return isHorizontal() ? LayoutRect(m_topLeft.x(), m_topLeft.y(), |
| m_logicalWidth, logicalHeight()) |
| : LayoutRect(m_topLeft.y(), m_topLeft.x(), |
| m_logicalWidth, logicalHeight()); |
| } |
| |
| virtual int baselinePosition(FontBaseline baselineType) const; |
| virtual LayoutUnit lineHeight() const; |
| |
| virtual int caretMinOffset() const; |
| virtual int caretMaxOffset() const; |
| |
| unsigned char bidiLevel() const { return m_bitfields.bidiEmbeddingLevel(); } |
| void setBidiLevel(unsigned char level) { |
| m_bitfields.setBidiEmbeddingLevel(level); |
| } |
| TextDirection direction() const { return bidiLevel() % 2 ? RTL : LTR; } |
| bool isLeftToRightDirection() const { return direction() == LTR; } |
| int caretLeftmostOffset() const { |
| return isLeftToRightDirection() ? caretMinOffset() : caretMaxOffset(); |
| } |
| int caretRightmostOffset() const { |
| return isLeftToRightDirection() ? caretMaxOffset() : caretMinOffset(); |
| } |
| |
| virtual void clearTruncation() {} |
| |
| bool isDirty() const { return m_bitfields.dirty(); } |
| virtual void markDirty() { m_bitfields.setDirty(true); } |
| |
| virtual void dirtyLineBoxes(); |
| |
| virtual SelectionState getSelectionState() const; |
| |
| virtual bool canAccommodateEllipsis(bool ltr, |
| int blockEdge, |
| int ellipsisWidth) const; |
| // visibleLeftEdge, visibleRightEdge are in the parent's coordinate system. |
| virtual LayoutUnit placeEllipsisBox(bool ltr, |
| LayoutUnit visibleLeftEdge, |
| LayoutUnit visibleRightEdge, |
| LayoutUnit ellipsisWidth, |
| LayoutUnit& truncatedWidth, |
| bool&); |
| |
| #if ENABLE(ASSERT) |
| void setHasBadParent(); |
| #endif |
| |
| int expansion() const { return m_bitfields.expansion(); } |
| |
| bool visibleToHitTestRequest(const HitTestRequest& request) const { |
| return getLineLayoutItem().visibleToHitTestRequest(request); |
| } |
| |
| // Anonymous inline: https://drafts.csswg.org/css2/visuren.html#anonymous |
| bool isAnonymousInline() const { |
| return getLineLayoutItem().isText() && getLineLayoutItem().parent() && |
| getLineLayoutItem().parent().isBox(); |
| } |
| EVerticalAlign verticalAlign() const { |
| return isAnonymousInline() ? ComputedStyle::initialVerticalAlign() |
| : getLineLayoutItem() |
| .style(m_bitfields.firstLine()) |
| ->verticalAlign(); |
| } |
| |
| // Use with caution! The type is not checked! |
| LineLayoutBoxModel boxModelObject() const { |
| if (!getLineLayoutItem().isText()) |
| return LineLayoutBoxModel(m_lineLayoutItem); |
| return LineLayoutBoxModel(nullptr); |
| } |
| |
| LayoutPoint locationIncludingFlipping() const; |
| |
| // Converts from a rect in the logical space of the InlineBox to one in the |
| // physical space of the containing block. The logical space of an InlineBox |
| // may be transposed for vertical text and flipped for right-to-left text. |
| void logicalRectToPhysicalRect(LayoutRect&) const; |
| |
| // TODO(szager): The Rect versions should return a rect, not modify the |
| // argument. |
| void flipForWritingMode(FloatRect&) const; |
| FloatPoint flipForWritingMode(const FloatPoint&) const; |
| void flipForWritingMode(LayoutRect&) const; |
| LayoutPoint flipForWritingMode(const LayoutPoint&) const; |
| |
| bool knownToHaveNoOverflow() const { |
| return m_bitfields.knownToHaveNoOverflow(); |
| } |
| void clearKnownToHaveNoOverflow(); |
| |
| bool dirOverride() const { return m_bitfields.dirOverride(); } |
| void setDirOverride(bool dirOverride) { |
| m_bitfields.setDirOverride(dirOverride); |
| } |
| |
| // Set all LineLayoutItems in the inline box subtree should do full paint |
| // invalidation. |
| void setShouldDoFullPaintInvalidationRecursively(); |
| |
| #define ADD_BOOLEAN_BITFIELD(name, Name) \ |
| private: \ |
| unsigned m_##name : 1; \ |
| \ |
| public: \ |
| bool name() const { return m_##name; } \ |
| void set##Name(bool name) { m_##name = name; } |
| |
| class InlineBoxBitfields { |
| DISALLOW_NEW(); |
| |
| public: |
| InlineBoxBitfields(bool firstLine = false, |
| bool constructed = false, |
| bool dirty = false, |
| bool extracted = false, |
| bool isHorizontal = true) |
| : m_firstLine(firstLine), |
| m_constructed(constructed), |
| m_bidiEmbeddingLevel(0), |
| m_dirty(dirty), |
| m_extracted(extracted), |
| m_hasVirtualLogicalHeight(false), |
| m_isHorizontal(isHorizontal), |
| m_endsWithBreak(false), |
| m_hasSelectedChildrenOrCanHaveLeadingExpansion(false), |
| m_knownToHaveNoOverflow(true), |
| m_hasEllipsisBoxOrHyphen(false), |
| m_dirOverride(false), |
| m_isText(false), |
| m_determinedIfNextOnLineExists(false), |
| m_nextOnLineExists(false), |
| m_expansion(0) {} |
| |
| // Some of these bits are actually for subclasses and moved here to compact |
| // the structures. |
| // for this class |
| ADD_BOOLEAN_BITFIELD(firstLine, FirstLine); |
| ADD_BOOLEAN_BITFIELD(constructed, Constructed); |
| |
| private: |
| // The maximium bidi level is 62: |
| // http://unicode.org/reports/tr9/#Explicit_Levels_and_Directions |
| unsigned m_bidiEmbeddingLevel : 6; |
| |
| public: |
| unsigned char bidiEmbeddingLevel() const { return m_bidiEmbeddingLevel; } |
| void setBidiEmbeddingLevel(unsigned char bidiEmbeddingLevel) { |
| m_bidiEmbeddingLevel = bidiEmbeddingLevel; |
| } |
| |
| ADD_BOOLEAN_BITFIELD(dirty, Dirty); |
| ADD_BOOLEAN_BITFIELD(extracted, Extracted); |
| ADD_BOOLEAN_BITFIELD(hasVirtualLogicalHeight, HasVirtualLogicalHeight); |
| ADD_BOOLEAN_BITFIELD(isHorizontal, IsHorizontal); |
| // for RootInlineBox |
| ADD_BOOLEAN_BITFIELD(endsWithBreak, |
| EndsWithBreak); // Whether the line ends with a <br>. |
| // shared between RootInlineBox and InlineTextBox |
| ADD_BOOLEAN_BITFIELD(hasSelectedChildrenOrCanHaveLeadingExpansion, |
| HasSelectedChildrenOrCanHaveLeadingExpansion); |
| |
| // This boolean will never be set if there is potential for overflow, but it |
| // will be eagerly cleared in the opposite case. As such, it's a |
| // conservative tracking of the absence of overflow. |
| // |
| // For whether we have overflow, callers should use m_overflow on |
| // InlineFlowBox. |
| ADD_BOOLEAN_BITFIELD(knownToHaveNoOverflow, KnownToHaveNoOverflow); |
| ADD_BOOLEAN_BITFIELD(hasEllipsisBoxOrHyphen, HasEllipsisBoxOrHyphen); |
| // for InlineTextBox |
| ADD_BOOLEAN_BITFIELD(dirOverride, DirOverride); |
| // Whether or not this object represents text with a non-zero height. |
| // Includes non-image list markers, text boxes. |
| ADD_BOOLEAN_BITFIELD(isText, IsText); |
| |
| private: |
| mutable unsigned m_determinedIfNextOnLineExists : 1; |
| |
| public: |
| bool determinedIfNextOnLineExists() const { |
| return m_determinedIfNextOnLineExists; |
| } |
| void setDeterminedIfNextOnLineExists( |
| bool determinedIfNextOnLineExists) const { |
| m_determinedIfNextOnLineExists = determinedIfNextOnLineExists; |
| } |
| |
| private: |
| mutable unsigned m_nextOnLineExists : 1; |
| |
| public: |
| bool nextOnLineExists() const { return m_nextOnLineExists; } |
| void setNextOnLineExists(bool nextOnLineExists) const { |
| m_nextOnLineExists = nextOnLineExists; |
| } |
| |
| private: |
| unsigned m_expansion : 12; // for justified text |
| |
| public: |
| signed expansion() const { return m_expansion; } |
| void setExpansion(signed expansion) { m_expansion = expansion; } |
| }; |
| #undef ADD_BOOLEAN_BITFIELD |
| |
| private: |
| // Converts the given (top-left) position from the logical space of the |
| // InlineBox to the physical space of the containing block. The size indicates |
| // the size of the box whose point is being flipped. |
| LayoutPoint logicalPositionToPhysicalPoint(const LayoutPoint&, |
| const LayoutSize&) const; |
| |
| void setLineLayoutItemShouldDoFullPaintInvalidationIfNeeded(); |
| |
| InlineBoxBitfields m_bitfields; |
| |
| InlineBox* m_next; // The next element on the same line as us. |
| InlineBox* m_prev; // The previous element on the same line as us. |
| |
| InlineFlowBox* m_parent; // The box that contains us. |
| LineLayoutItem m_lineLayoutItem; |
| |
| protected: |
| // For RootInlineBox |
| bool endsWithBreak() const { return m_bitfields.endsWithBreak(); } |
| void setEndsWithBreak(bool endsWithBreak) { |
| m_bitfields.setEndsWithBreak(endsWithBreak); |
| } |
| bool hasEllipsisBox() const { return m_bitfields.hasEllipsisBoxOrHyphen(); } |
| bool hasSelectedChildren() const { |
| return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); |
| } |
| void setHasSelectedChildren(bool hasSelectedChildren) { |
| m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion( |
| hasSelectedChildren); |
| } |
| void setHasEllipsisBox(bool hasEllipsisBox) { |
| m_bitfields.setHasEllipsisBoxOrHyphen(hasEllipsisBox); |
| } |
| |
| // For InlineTextBox |
| bool hasHyphen() const { return m_bitfields.hasEllipsisBoxOrHyphen(); } |
| void setHasHyphen(bool hasHyphen) { |
| m_bitfields.setHasEllipsisBoxOrHyphen(hasHyphen); |
| } |
| bool canHaveLeadingExpansion() const { |
| return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); |
| } |
| void setCanHaveLeadingExpansion(bool canHaveLeadingExpansion) { |
| m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion( |
| canHaveLeadingExpansion); |
| } |
| signed expansion() { return m_bitfields.expansion(); } |
| void setExpansion(signed expansion) { m_bitfields.setExpansion(expansion); } |
| |
| // For InlineFlowBox and InlineTextBox |
| bool extracted() const { return m_bitfields.extracted(); } |
| |
| LayoutPoint m_topLeft; |
| LayoutUnit m_logicalWidth; |
| |
| private: |
| #if ENABLE(ASSERT) |
| bool m_hasBadParent; |
| #endif |
| }; |
| |
| #if !ENABLE(ASSERT) |
| inline InlineBox::~InlineBox() {} |
| #endif |
| |
| #if ENABLE(ASSERT) |
| inline void InlineBox::setHasBadParent() { |
| m_hasBadParent = true; |
| } |
| #endif |
| |
| #define DEFINE_INLINE_BOX_TYPE_CASTS(typeName) \ |
| DEFINE_TYPE_CASTS(typeName, InlineBox, box, box->is##typeName(), \ |
| box.is##typeName()) |
| |
| // Allow equality comparisons of InlineBox's by reference or pointer, |
| // interchangeably. |
| DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(InlineBox) |
| |
| } // namespace blink |
| |
| #ifndef NDEBUG |
| // Outside the WebCore namespace for ease of invocation from gdb. |
| void showTree(const blink::InlineBox*); |
| void showLineTree(const blink::InlineBox*); |
| #endif |
| |
| #endif // InlineBox_h |