Source/WebCore/rendering/InlineBox.h

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  *
  19  */
  20
  21 #ifndef InlineBox_h
  22 #define InlineBox_h
  23
  24 #include "RenderBoxModelObject.h"
  25 #include "TextDirection.h"
  26
  27 namespace WebCore {
  28
  29 class HitTestRequest;
  30 class HitTestResult;
  31 class RootInlineBox;
  32
  33 // InlineBox represents a rectangle that occurs on a line.  It corresponds to
  34 // some RenderObject (i.e., it represents a portion of that RenderObject).
  35 class InlineBox {
  36     WTF_MAKE_FAST_ALLOCATED;
  37 public:
  38     virtual ~InlineBox();
  39
  40     void assertNotDeleted() const;
  41
  42     virtual void deleteLine() = 0;
  43     virtual void extractLine() = 0;
  44     virtual void attachLine() = 0;
  45
  46     virtual bool isLineBreak() const { return renderer().isLineBreak(); }
  47
  48     virtual void adjustPosition(float dx, float dy);
  49     void adjustLogicalPosition(float deltaLogicalLeft, float deltaLogicalTop)
  50     {
  51         if (isHorizontal())
  52             adjustPosition(deltaLogicalLeft, deltaLogicalTop);
  53         else
  54             adjustPosition(deltaLogicalTop, deltaLogicalLeft);
  55     }
  56     void adjustLineDirectionPosition(float delta)
  57     {
  58         if (isHorizontal())
  59             adjustPosition(delta, 0);
  60         else
  61             adjustPosition(0, delta);
  62     }
  63     void adjustBlockDirectionPosition(float delta)
  64     {
  65         if (isHorizontal())
  66             adjustPosition(0, delta);
  67         else
  68             adjustPosition(delta, 0);
  69     }
  70
  71     virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom) = 0;
  72     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom) = 0;
  73
  74 #ifndef NDEBUG
  75     void showTreeForThis() const;
  76     void showLineTreeForThis() const;
  77
  78     virtual void showBox(int = 0) const;
  79     virtual void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0, int = 0) const;
  80     virtual const char* boxName() const;
  81 #endif
  82
  83     bool behavesLikeText() const { return m_bitfields.behavesLikeText(); }
  84     void setBehavesLikeText(bool behavesLikeText) { m_bitfields.setBehavesLikeText(behavesLikeText); }
  85
  86     virtual bool isInlineElementBox() const { return false; }
  87     virtual bool isInlineFlowBox() const { return false; }
  88     virtual bool isInlineTextBox() const { return false; }
  89     virtual bool isRootInlineBox() const { return false; }
  90     virtual bool isSVGInlineTextBox() const { return false; }
  91     virtual bool isSVGInlineFlowBox() const { return false; }
  92     virtual bool isSVGRootInlineBox() const { return false; }
  93
  94     bool hasVirtualLogicalHeight() const { return m_bitfields.hasVirtualLogicalHeight(); }
  95     void setHasVirtualLogicalHeight() { m_bitfields.setHasVirtualLogicalHeight(true); }
  96     virtual float virtualLogicalHeight() const
  97     {
  98         ASSERT_NOT_REACHED();
  99         return 0;
 100     }
 101
 102     bool isHorizontal() const { return m_bitfields.isHorizontal(); }
 103     void setIsHorizontal(bool isHorizontal) { m_bitfields.setIsHorizontal(isHorizontal); }
 104
 105     virtual FloatRect calculateBoundaries() const
 106     {
 107         ASSERT_NOT_REACHED();
 108         return FloatRect();
 109     }
 110
 111     bool isConstructed() { return m_bitfields.constructed(); }
 112     virtual void setConstructed() { m_bitfields.setConstructed(true); }
 113
 114     void setExtracted(bool extracted = true) { m_bitfields.setExtracted(extracted); }
 115
 116     void setIsFirstLine(bool firstLine) { m_bitfields.setFirstLine(firstLine); }
 117     bool isFirstLine() const { return m_bitfields.firstLine(); }
 118
 119     void removeFromParent();
 120
 121     InlineBox* nextOnLine() const { return m_next; }
 122     InlineBox* prevOnLine() const { return m_prev; }
 123     void setNextOnLine(InlineBox* next)
 124     {
 125         ASSERT(m_parent || !next);
 126         m_next = next;
 127     }
 128     void setPrevOnLine(InlineBox* prev)
 129     {
 130         ASSERT(m_parent || !prev);
 131         m_prev = prev;
 132     }
 133     bool nextOnLineExists() const;
 134     bool previousOnLineExists() const;
 135
 136     virtual bool isLeaf() const { return true; }
 137
 138     InlineBox* nextLeafChild() const;
 139     InlineBox* prevLeafChild() const;
 140
 141     // Helper functions for editing and hit-testing code.
 142     // FIXME: These two functions should be moved to RenderedPosition once the code to convert between
 143     // Position and inline box, offset pair is moved to RenderedPosition.
 144     InlineBox* nextLeafChildIgnoringLineBreak() const;
 145     InlineBox* prevLeafChildIgnoringLineBreak() const;
 146
 147     // FIXME: Hide this once all callers are using tighter types.
 148     RenderObject& renderer() const { return m_renderer; }
 149
 150     InlineFlowBox* parent() const
 151     {
 152         assertNotDeleted();
 153         ASSERT_WITH_SECURITY_IMPLICATION(!m_hasBadParent);
 154         return m_parent;
 155     }
 156     void setParent(InlineFlowBox* par) { m_parent = par; }
 157
 158     const RootInlineBox& root() const;
 159     RootInlineBox& root();
 160
 161     // x() is the left side of the box in the containing block's coordinate system.
 162     void setX(float x) { m_topLeft.setX(x); }
 163     float x() const { return m_topLeft.x(); }
 164     float left() const { return m_topLeft.x(); }
 165
 166     // y() is the top side of the box in the containing block's coordinate system.
 167     void setY(float y) { m_topLeft.setY(y); }
 168     float y() const { return m_topLeft.y(); }
 169     float top() const { return m_topLeft.y(); }
 170
 171     const FloatPoint& topLeft() const { return m_topLeft; }
 172
 173     float width() const { return isHorizontal() ? logicalWidth() : logicalHeight(); }
 174     float height() const { return isHorizontal() ? logicalHeight() : logicalWidth(); }
 175     FloatSize size() const { return FloatSize(width(), height()); }
 176     float right() const { return left() + width(); }
 177     float bottom() const { return top() + height(); }
 178
 179     // The logicalLeft position is the left edge of the line box in a horizontal line and the top edge in a vertical line.
 180     float logicalLeft() const { return isHorizontal() ? m_topLeft.x() : m_topLeft.y(); }
 181     float logicalRight() const { return logicalLeft() + logicalWidth(); }
 182     void setLogicalLeft(float left)
 183     {
 184         if (isHorizontal())
 185             setX(left);
 186         else
 187             setY(left);
 188     }
 189     int pixelSnappedLogicalLeft() const { return logicalLeft(); }
 190     int pixelSnappedLogicalRight() const { return ceilf(logicalRight()); }
 191     int pixelSnappedLogicalTop() const { return logicalTop(); }
 192     int pixelSnappedLogicalBottom() const { return ceilf(logicalBottom()); }
 193
 194     // The logicalTop[ position is the top edge of the line box in a horizontal line and the left edge in a vertical line.
 195     float logicalTop() const { return isHorizontal() ? m_topLeft.y() : m_topLeft.x(); }
 196     float logicalBottom() const { return logicalTop() + logicalHeight(); }
 197     void setLogicalTop(float top)
 198     {
 199         if (isHorizontal())
 200             setY(top);
 201         else
 202             setX(top);
 203     }
 204
 205     // The logical width is our extent in the line's overall inline direction, i.e., width for horizontal text and height for vertical text.
 206     void setLogicalWidth(float w) { m_logicalWidth = w; }
 207     float logicalWidth() const { return m_logicalWidth; }
 208
 209     // The logical height is our extent in the block flow direction, i.e., height for horizontal text and width for vertical text.
 210     float logicalHeight() const;
 211
 212     FloatRect logicalFrameRect() const { return isHorizontal() ? FloatRect(m_topLeft.x(), m_topLeft.y(), m_logicalWidth, logicalHeight()) : FloatRect(m_topLeft.y(), m_topLeft.x(), m_logicalWidth, logicalHeight()); }
 213
 214     virtual int baselinePosition(FontBaseline baselineType) const;
 215     virtual LayoutUnit lineHeight() const;
 216
 217     virtual int caretMinOffset() const;
 218     virtual int caretMaxOffset() const;
 219
 220     unsigned char bidiLevel() const { return m_bitfields.bidiEmbeddingLevel(); }
 221     void setBidiLevel(unsigned char level) { m_bitfields.setBidiEmbeddingLevel(level); }
 222     TextDirection direction() const { return bidiLevel() % 2 ? RTL : LTR; }
 223     bool isLeftToRightDirection() const { return direction() == LTR; }
 224     int caretLeftmostOffset() const { return isLeftToRightDirection() ? caretMinOffset() : caretMaxOffset(); }
 225     int caretRightmostOffset() const { return isLeftToRightDirection() ? caretMaxOffset() : caretMinOffset(); }
 226
 227     virtual void clearTruncation() { }
 228
 229     bool isDirty() const { return m_bitfields.dirty(); }
 230     virtual void markDirty(bool dirty = true) { m_bitfields.setDirty(dirty); }
 231
 232     virtual void dirtyLineBoxes();
 233
 234     virtual RenderObject::SelectionState selectionState();
 235
 236     virtual bool canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth) const;
 237     // visibleLeftEdge, visibleRightEdge are in the parent's coordinate system.
 238     virtual float placeEllipsisBox(bool ltr, float visibleLeftEdge, float visibleRightEdge, float ellipsisWidth, float &truncatedWidth, bool&);
 239
 240 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
 241     void setHasBadParent();
 242     void invalidateParentChildList();
 243 #endif
 244
 245     int expansion() const { return m_bitfields.expansion(); }
 246
 247     bool visibleToHitTesting() const { return renderer().style().visibility() == VISIBLE && renderer().style().pointerEvents() != PE_NONE; }
 248
 249     const RenderStyle& lineStyle() const { return m_bitfields.firstLine() ? renderer().firstLineStyle() : renderer().style(); }
 250
 251     EVerticalAlign verticalAlign() const { return lineStyle().verticalAlign(); }
 252
 253     // Use with caution! The type is not checked!
 254     RenderBoxModelObject* boxModelObject() const
 255     {
 256         if (!m_renderer.isText())
 257             return &toRenderBoxModelObject(m_renderer);
 258         return 0;
 259     }
 260
 261     FloatPoint locationIncludingFlipping();
 262     void flipForWritingMode(FloatRect&);
 263     FloatPoint flipForWritingMode(const FloatPoint&);
 264     void flipForWritingMode(LayoutRect&);
 265     LayoutPoint flipForWritingMode(const LayoutPoint&);
 266
 267     bool knownToHaveNoOverflow() const { return m_bitfields.knownToHaveNoOverflow(); }
 268     void clearKnownToHaveNoOverflow();
 269
 270     bool dirOverride() const { return m_bitfields.dirOverride(); }
 271     void setDirOverride(bool dirOverride) { m_bitfields.setDirOverride(dirOverride); }
 272
 273 private:
 274     InlineBox* m_next; // The next element on the same line as us.
 275     InlineBox* m_prev; // The previous element on the same line as us.
 276
 277     InlineFlowBox* m_parent; // The box that contains us.
 278
 279     RenderObject& m_renderer;
 280
 281 public:
 282     FloatPoint m_topLeft;
 283     float m_logicalWidth;
 284
 285 #define ADD_BOOLEAN_BITFIELD(name, Name) \
 286     private:\
 287     unsigned m_##name : 1;\
 288     public:\
 289     bool name() const { return m_##name; }\
 290     void set##Name(bool name) { m_##name = name; }\
 291
 292     class InlineBoxBitfields {
 293     public:
 294         explicit InlineBoxBitfields(bool firstLine = false, bool constructed = false, bool dirty = false, bool extracted = false, bool isHorizontal = true)
 295             : m_firstLine(firstLine)
 296             , m_constructed(constructed)
 297             , m_bidiEmbeddingLevel(0)
 298             , m_dirty(dirty)
 299             , m_extracted(extracted)
 300             , m_hasVirtualLogicalHeight(false)
 301             , m_isHorizontal(isHorizontal)
 302             , m_endsWithBreak(false)
 303             , m_hasSelectedChildrenOrCanHaveLeadingExpansion(false)
 304             , m_knownToHaveNoOverflow(true)
 305             , m_hasEllipsisBoxOrHyphen(false)
 306             , m_dirOverride(false)
 307             , m_behavesLikeText(false)
 308             , m_determinedIfNextOnLineExists(false)
 309             , m_nextOnLineExists(false)
 310             , m_expansion(0)
 311         {
 312         }
 313
 314         // Some of these bits are actually for subclasses and moved here to compact the structures.
 315         // for this class
 316         ADD_BOOLEAN_BITFIELD(firstLine, FirstLine);
 317         ADD_BOOLEAN_BITFIELD(constructed, Constructed);
 318
 319     private:
 320         unsigned m_bidiEmbeddingLevel : 6; // The maximium bidi level is 62: http://unicode.org/reports/tr9/#Explicit_Levels_and_Directions
 321
 322     public:
 323         unsigned char bidiEmbeddingLevel() const { return m_bidiEmbeddingLevel; }
 324         void setBidiEmbeddingLevel(unsigned char bidiEmbeddingLevel) { m_bidiEmbeddingLevel = bidiEmbeddingLevel; }
 325
 326         ADD_BOOLEAN_BITFIELD(dirty, Dirty);
 327         ADD_BOOLEAN_BITFIELD(extracted, Extracted);
 328         ADD_BOOLEAN_BITFIELD(hasVirtualLogicalHeight, HasVirtualLogicalHeight);
 329         ADD_BOOLEAN_BITFIELD(isHorizontal, IsHorizontal);
 330         // for RootInlineBox
 331         ADD_BOOLEAN_BITFIELD(endsWithBreak, EndsWithBreak); // Whether the line ends with a <br>.
 332         // shared between RootInlineBox and InlineTextBox
 333         ADD_BOOLEAN_BITFIELD(hasSelectedChildrenOrCanHaveLeadingExpansion, HasSelectedChildrenOrCanHaveLeadingExpansion);
 334         ADD_BOOLEAN_BITFIELD(knownToHaveNoOverflow, KnownToHaveNoOverflow);
 335         ADD_BOOLEAN_BITFIELD(hasEllipsisBoxOrHyphen, HasEllipsisBoxOrHyphen);
 336         // for InlineTextBox
 337         ADD_BOOLEAN_BITFIELD(dirOverride, DirOverride);
 338         ADD_BOOLEAN_BITFIELD(behavesLikeText, BehavesLikeText); // Whether or not this object represents text with a non-zero height. Includes non-image list markers, text boxes, br.
 339
 340     private:
 341         mutable unsigned m_determinedIfNextOnLineExists : 1;
 342
 343     public:
 344         bool determinedIfNextOnLineExists() const { return m_determinedIfNextOnLineExists; }
 345         void setDeterminedIfNextOnLineExists(bool determinedIfNextOnLineExists) const { m_determinedIfNextOnLineExists = determinedIfNextOnLineExists; }
 346
 347     private:
 348         mutable unsigned m_nextOnLineExists : 1;
 349
 350     public:
 351         bool nextOnLineExists() const { return m_nextOnLineExists; }
 352         void setNextOnLineExists(bool nextOnLineExists) const { m_nextOnLineExists = nextOnLineExists; }
 353
 354     private:
 355         signed m_expansion : 12; // for justified text
 356
 357     public:
 358         signed expansion() const { return m_expansion; }
 359         void setExpansion(signed expansion) { m_expansion = expansion; }
 360     };
 361 #undef ADD_BOOLEAN_BITFIELD
 362
 363 private:
 364     InlineBoxBitfields m_bitfields;
 365
 366 protected:
 367     explicit InlineBox(RenderObject& renderer)
 368         : m_next(nullptr)
 369         , m_prev(nullptr)
 370         , m_parent(nullptr)
 371         , m_renderer(renderer)
 372         , m_logicalWidth(0)
 373 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
 374         , m_deletionSentinel(deletionSentinelNotDeletedValue)
 375         , m_hasBadParent(false)
 376 #endif
 377     {
 378     }
 379
 380     InlineBox(RenderObject& renderer, FloatPoint topLeft, float logicalWidth, bool firstLine, bool constructed,
 381               bool dirty, bool extracted, bool isHorizontal, InlineBox* next, InlineBox* prev, InlineFlowBox* parent)
 382         : m_next(next)
 383         , m_prev(prev)
 384         , m_parent(parent)
 385         , m_renderer(renderer)
 386         , m_topLeft(topLeft)
 387         , m_logicalWidth(logicalWidth)
 388         , m_bitfields(firstLine, constructed, dirty, extracted, isHorizontal)
 389 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
 390         , m_deletionSentinel(deletionSentinelNotDeletedValue)
 391         , m_hasBadParent(false)
 392 #endif
 393     {
 394     }
 395
 396     // For RootInlineBox
 397     bool endsWithBreak() const { return m_bitfields.endsWithBreak(); }
 398     void setEndsWithBreak(bool endsWithBreak) { m_bitfields.setEndsWithBreak(endsWithBreak); }
 399     bool hasEllipsisBox() const { return m_bitfields.hasEllipsisBoxOrHyphen(); }
 400     bool hasSelectedChildren() const { return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); }
 401     void setHasSelectedChildren(bool hasSelectedChildren) { m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion(hasSelectedChildren); }
 402     void setHasEllipsisBox(bool hasEllipsisBox) { m_bitfields.setHasEllipsisBoxOrHyphen(hasEllipsisBox); }
 403
 404     // For InlineTextBox
 405     bool hasHyphen() const { return m_bitfields.hasEllipsisBoxOrHyphen(); }
 406     void setHasHyphen(bool hasHyphen) { m_bitfields.setHasEllipsisBoxOrHyphen(hasHyphen); }
 407     bool canHaveLeadingExpansion() const { return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); }
 408     void setCanHaveLeadingExpansion(bool canHaveLeadingExpansion) { m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion(canHaveLeadingExpansion); }
 409     int expansion() { return m_bitfields.expansion(); }
 410     void setExpansion(int expansion) { m_bitfields.setExpansion(expansion); }
 411
 412     // For InlineFlowBox and InlineTextBox
 413     bool extracted() const { return m_bitfields.extracted(); }
 414
 415 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
 416 private:
 417     static const unsigned deletionSentinelNotDeletedValue = 0xF0F0F0F0U;
 418     static const unsigned deletionSentinelDeletedValue = 0xF0DEADF0U;
 419     unsigned m_deletionSentinel;
 420     bool m_hasBadParent;
 421 #endif
 422 };
 423
 424 #define INLINE_BOX_OBJECT_TYPE_CASTS(ToValueTypeName, predicate) \
 425     TYPE_CASTS_BASE(ToValueTypeName, InlineBox, object, object->predicate, object.predicate)
 426
 427 #if ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
 428
 429 inline InlineBox::~InlineBox()
 430 {
 431 }
 432
 433 inline void InlineBox::assertNotDeleted() const
 434 {
 435 }
 436
 437 #endif
 438
 439 } // namespace WebCore
 440
 441 #ifndef NDEBUG
 442 // Outside the WebCore namespace for ease of invocation from gdb.
 443 void showTree(const WebCore::InlineBox*);
 444 void showLineTree(const WebCore::InlineBox*);
 445 #endif
 446
 447 #endif // InlineBox_h