src/third_party/WebKit/Source/core/rendering/InlineBox.cpp

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2007 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 #include "config.h"
  21 #include "core/rendering/InlineBox.h"
  22
  23 #include "core/paint/BlockPainter.h"
  24 #include "core/rendering/InlineFlowBox.h"
  25 #include "core/rendering/PaintInfo.h"
  26 #include "core/rendering/RenderBlockFlow.h"
  27 #include "core/rendering/RenderObjectInlines.h"
  28 #include "core/rendering/RootInlineBox.h"
  29 #include "platform/Partitions.h"
  30 #include "platform/fonts/FontMetrics.h"
  31
  32 #ifndef NDEBUG
  33 #include <stdio.h>
  34 #endif
  35
  36 namespace blink {
  37
  38 struct SameSizeAsInlineBox {
  39     virtual ~SameSizeAsInlineBox() { }
  40     void* a[4];
  41     FloatPoint b;
  42     float c;
  43     uint32_t d : 32;
  44 #if ENABLE(ASSERT)
  45     bool f;
  46 #endif
  47 };
  48
  49 COMPILE_ASSERT(sizeof(InlineBox) == sizeof(SameSizeAsInlineBox), InlineBox_size_guard);
  50
  51 #if ENABLE(ASSERT)
  52
  53 InlineBox::~InlineBox()
  54 {
  55     if (!m_hasBadParent && m_parent)
  56         m_parent->setHasBadChildList();
  57 }
  58
  59 #endif
  60
  61 void InlineBox::remove(MarkLineBoxes markLineBoxes)
  62 {
  63     if (parent())
  64         parent()->removeChild(this, markLineBoxes);
  65 }
  66
  67 void* InlineBox::operator new(size_t sz)
  68 {
  69     return partitionAlloc(Partitions::getRenderingPartition(), sz);
  70 }
  71
  72 void InlineBox::operator delete(void* ptr)
  73 {
  74     partitionFree(ptr);
  75 }
  76
  77 #ifndef NDEBUG
  78 const char* InlineBox::boxName() const
  79 {
  80     return "InlineBox";
  81 }
  82
  83 void InlineBox::showTreeForThis() const
  84 {
  85     renderer().showTreeForThis();
  86 }
  87
  88 void InlineBox::showLineTreeForThis() const
  89 {
  90     renderer().containingBlock()->showLineTreeAndMark(this, "*");
  91 }
  92
  93 void InlineBox::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj, int depth) const
  94 {
  95     int printedCharacters = 0;
  96     if (this == markedBox1)
  97         printedCharacters += fprintf(stderr, "%s", markedLabel1);
  98     if (this == markedBox2)
  99         printedCharacters += fprintf(stderr, "%s", markedLabel2);
 100     if (&renderer() == obj)
 101         printedCharacters += fprintf(stderr, "*");
 102     for (; printedCharacters < depth * 2; printedCharacters++)
 103         fputc(' ', stderr);
 104
 105     showBox(printedCharacters);
 106 }
 107
 108 void InlineBox::showBox(int printedCharacters) const
 109 {
 110     printedCharacters += fprintf(stderr, "%s\t%p", boxName(), this);
 111     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
 112         fputc(' ', stderr);
 113     fprintf(stderr, "\t%s %p {pos=%g,%g size=%g,%g} baseline=%i/%i\n",
 114         renderer().renderName(), &renderer(), x(), y(), width(), height(),
 115         baselinePosition(AlphabeticBaseline),
 116         baselinePosition(IdeographicBaseline));
 117 }
 118 #endif
 119
 120 float InlineBox::logicalHeight() const
 121 {
 122     if (hasVirtualLogicalHeight())
 123         return virtualLogicalHeight();
 124
 125     if (renderer().isText())
 126         return m_bitfields.isText() ? renderer().style(isFirstLineStyle())->fontMetrics().height() : 0;
 127     if (renderer().isBox() && parent())
 128         return isHorizontal() ? toRenderBox(renderer()).height().toFloat() : toRenderBox(renderer()).width().toFloat();
 129
 130     ASSERT(isInlineFlowBox());
 131     RenderBoxModelObject* flowObject = boxModelObject();
 132     const FontMetrics& fontMetrics = renderer().style(isFirstLineStyle())->fontMetrics();
 133     float result = fontMetrics.height();
 134     if (parent())
 135         result += flowObject->borderAndPaddingLogicalHeight();
 136     return result;
 137 }
 138
 139 int InlineBox::baselinePosition(FontBaseline baselineType) const
 140 {
 141     return boxModelObject()->baselinePosition(baselineType, m_bitfields.firstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 142 }
 143
 144 LayoutUnit InlineBox::lineHeight() const
 145 {
 146     return boxModelObject()->lineHeight(m_bitfields.firstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 147 }
 148
 149 int InlineBox::caretMinOffset() const
 150 {
 151     return renderer().caretMinOffset();
 152 }
 153
 154 int InlineBox::caretMaxOffset() const
 155 {
 156     return renderer().caretMaxOffset();
 157 }
 158
 159 void InlineBox::dirtyLineBoxes()
 160 {
 161     markDirty();
 162     for (InlineFlowBox* curr = parent(); curr && !curr->isDirty(); curr = curr->parent())
 163         curr->markDirty();
 164 }
 165
 166 void InlineBox::deleteLine()
 167 {
 168     if (!m_bitfields.extracted() && renderer().isBox())
 169         toRenderBox(renderer()).setInlineBoxWrapper(0);
 170     destroy();
 171 }
 172
 173 void InlineBox::extractLine()
 174 {
 175     m_bitfields.setExtracted(true);
 176     if (renderer().isBox())
 177         toRenderBox(renderer()).setInlineBoxWrapper(0);
 178 }
 179
 180 void InlineBox::attachLine()
 181 {
 182     m_bitfields.setExtracted(false);
 183     if (renderer().isBox())
 184         toRenderBox(renderer()).setInlineBoxWrapper(this);
 185 }
 186
 187 void InlineBox::adjustPosition(float dx, float dy)
 188 {
 189     m_topLeft.move(dx, dy);
 190
 191     if (renderer().isReplaced())
 192         toRenderBox(renderer()).move(dx, dy);
 193 }
 194
 195 void InlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
 196 {
 197     BlockPainter::paintInlineBox(*this, paintInfo, paintOffset);
 198 }
 199
 200 bool InlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
 201 {
 202     // Hit test all phases of replaced elements atomically, as though the replaced element established its
 203     // own stacking context.  (See Appendix E.2, section 6.4 on inline block/table elements in the CSS2.1
 204     // specification.)
 205     LayoutPoint childPoint = accumulatedOffset;
 206     if (parent()->renderer().style()->isFlippedBlocksWritingMode()) // Faster than calling containingBlock().
 207         childPoint = renderer().containingBlock()->flipForWritingModeForChild(&toRenderBox(renderer()), childPoint);
 208
 209     return renderer().hitTest(request, result, locationInContainer, childPoint);
 210 }
 211
 212 const RootInlineBox& InlineBox::root() const
 213 {
 214     if (m_parent)
 215         return m_parent->root();
 216     ASSERT(isRootInlineBox());
 217     return static_cast<const RootInlineBox&>(*this);
 218 }
 219
 220 RootInlineBox& InlineBox::root()
 221 {
 222     if (m_parent)
 223         return m_parent->root();
 224     ASSERT(isRootInlineBox());
 225     return static_cast<RootInlineBox&>(*this);
 226 }
 227
 228 bool InlineBox::nextOnLineExists() const
 229 {
 230     if (!m_bitfields.determinedIfNextOnLineExists()) {
 231         m_bitfields.setDeterminedIfNextOnLineExists(true);
 232
 233         if (!parent())
 234             m_bitfields.setNextOnLineExists(false);
 235         else if (nextOnLine())
 236             m_bitfields.setNextOnLineExists(true);
 237         else
 238             m_bitfields.setNextOnLineExists(parent()->nextOnLineExists());
 239     }
 240     return m_bitfields.nextOnLineExists();
 241 }
 242
 243 InlineBox* InlineBox::nextLeafChild() const
 244 {
 245     InlineBox* leaf = 0;
 246     for (InlineBox* box = nextOnLine(); box && !leaf; box = box->nextOnLine())
 247         leaf = box->isLeaf() ? box : toInlineFlowBox(box)->firstLeafChild();
 248     if (!leaf && parent())
 249         leaf = parent()->nextLeafChild();
 250     return leaf;
 251 }
 252
 253 InlineBox* InlineBox::prevLeafChild() const
 254 {
 255     InlineBox* leaf = 0;
 256     for (InlineBox* box = prevOnLine(); box && !leaf; box = box->prevOnLine())
 257         leaf = box->isLeaf() ? box : toInlineFlowBox(box)->lastLeafChild();
 258     if (!leaf && parent())
 259         leaf = parent()->prevLeafChild();
 260     return leaf;
 261 }
 262
 263 InlineBox* InlineBox::nextLeafChildIgnoringLineBreak() const
 264 {
 265     InlineBox* leaf = nextLeafChild();
 266     if (leaf && leaf->isLineBreak())
 267         return 0;
 268     return leaf;
 269 }
 270
 271 InlineBox* InlineBox::prevLeafChildIgnoringLineBreak() const
 272 {
 273     InlineBox* leaf = prevLeafChild();
 274     if (leaf && leaf->isLineBreak())
 275         return 0;
 276     return leaf;
 277 }
 278
 279 RenderObject::SelectionState InlineBox::selectionState() const
 280 {
 281     return renderer().selectionState();
 282 }
 283
 284 bool InlineBox::canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth) const
 285 {
 286     // Non-replaced elements can always accommodate an ellipsis.
 287     if (!renderer().isReplaced())
 288         return true;
 289
 290     IntRect boxRect(left(), 0, m_logicalWidth, 10);
 291     IntRect ellipsisRect(ltr ? blockEdge - ellipsisWidth : blockEdge, 0, ellipsisWidth, 10);
 292     return !(boxRect.intersects(ellipsisRect));
 293 }
 294
 295 float InlineBox::placeEllipsisBox(bool, float, float, float, float& truncatedWidth, bool&)
 296 {
 297     // Use -1 to mean "we didn't set the position."
 298     truncatedWidth += logicalWidth();
 299     return -1;
 300 }
 301
 302 void InlineBox::clearKnownToHaveNoOverflow()
 303 {
 304     m_bitfields.setKnownToHaveNoOverflow(false);
 305     if (parent() && parent()->knownToHaveNoOverflow())
 306         parent()->clearKnownToHaveNoOverflow();
 307 }
 308
 309 FloatPoint InlineBox::locationIncludingFlipping()
 310 {
 311     if (!renderer().style()->isFlippedBlocksWritingMode())
 312         return FloatPoint(x(), y());
 313     RenderBlockFlow& block = root().block();
 314     if (block.style()->isHorizontalWritingMode())
 315         return FloatPoint(x(), block.height() - height() - y());
 316
 317     return FloatPoint(block.width() - width() - x(), y());
 318 }
 319
 320 void InlineBox::flipForWritingMode(FloatRect& rect)
 321 {
 322     if (!renderer().style()->isFlippedBlocksWritingMode())
 323         return;
 324     root().block().flipForWritingMode(rect);
 325 }
 326
 327 FloatPoint InlineBox::flipForWritingMode(const FloatPoint& point)
 328 {
 329     if (!renderer().style()->isFlippedBlocksWritingMode())
 330         return point;
 331     return root().block().flipForWritingMode(point);
 332 }
 333
 334 void InlineBox::flipForWritingMode(LayoutRect& rect)
 335 {
 336     if (!renderer().style()->isFlippedBlocksWritingMode())
 337         return;
 338     root().block().flipForWritingMode(rect);
 339 }
 340
 341 LayoutPoint InlineBox::flipForWritingMode(const LayoutPoint& point)
 342 {
 343     if (!renderer().style()->isFlippedBlocksWritingMode())
 344         return point;
 345     return root().block().flipForWritingMode(point);
 346 }
 347
 348 } // namespace blink
 349
 350 #ifndef NDEBUG
 351
 352 void showTree(const blink::InlineBox* b)
 353 {
 354     if (b)
 355         b->showTreeForThis();
 356 }
 357
 358 void showLineTree(const blink::InlineBox* b)
 359 {
 360     if (b)
 361         b->showLineTreeForThis();
 362 }
 363
 364 #endif