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