/** * This file is part of the html renderer for KDE. * * Copyright (C) 2003, 2006 Apple Computer, Inc. * * 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., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include "config.h" #include "RootInlineBox.h" #include "BidiResolver.h" #include "Document.h" #include "EllipsisBox.h" #include "Frame.h" #include "GraphicsContext.h" #include "HitTestResult.h" #include "RenderArena.h" #include "RenderBlock.h" using namespace std; namespace WebCore { typedef WTF::HashMap EllipsisBoxMap; static EllipsisBoxMap* gEllipsisBoxMap = 0; void* RootInlineBox::Overflow::operator new(size_t sz, RenderArena* renderArena) throw() { return renderArena->allocate(sz); } void RootInlineBox::Overflow::operator delete(void* ptr, size_t sz) { // Stash size where destroy can find it. *(size_t *)ptr = sz; } void RootInlineBox::Overflow::destroy(RenderArena* renderArena) { delete this; // Recover the size left there for us by operator delete and free the memory. renderArena->free(*(size_t *)this, this); } void RootInlineBox::destroy(RenderArena* arena) { if (m_overflow) m_overflow->destroy(arena); detachEllipsisBox(arena); InlineFlowBox::destroy(arena); } void RootInlineBox::detachEllipsisBox(RenderArena* arena) { if (m_hasEllipsisBox) { EllipsisBoxMap::iterator it = gEllipsisBoxMap->find(this); it->second->setParent(0); it->second->destroy(arena); gEllipsisBoxMap->remove(it); m_hasEllipsisBox = false; } } void RootInlineBox::clearTruncation() { if (m_hasEllipsisBox) { detachEllipsisBox(m_object->renderArena()); InlineFlowBox::clearTruncation(); } } bool RootInlineBox::canAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth) { // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room. int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge; if (width() - delta < ellipsisWidth) return false; // Next iterate over all the line boxes on the line. If we find a replaced element that intersects // then we refuse to accommodate the ellipsis. Otherwise we're ok. return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth); } void RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr, bool ltr, int blockEdge, int ellipsisWidth, InlineBox* markupBox) { // Create an ellipsis box. EllipsisBox* ellipsisBox = new (m_object->renderArena()) EllipsisBox(m_object, ellipsisStr, this, ellipsisWidth - (markupBox ? markupBox->width() : 0), yPos(), height(), baseline(), !prevRootBox(), markupBox); if (!gEllipsisBoxMap) gEllipsisBoxMap = new EllipsisBoxMap(); gEllipsisBoxMap->add(this, ellipsisBox); m_hasEllipsisBox = true; if (ltr && (xPos() + width() + ellipsisWidth) <= blockEdge) { ellipsisBox->m_x = xPos() + width(); return; } // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL) // of that glyph. Mark all of the objects that intersect the ellipsis box as not painting (as being // truncated). bool foundBox = false; ellipsisBox->m_x = placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox); } int RootInlineBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox) { int result = InlineFlowBox::placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox); if (result == -1) result = ltr ? blockEdge - ellipsisWidth : blockEdge; return result; } void RootInlineBox::paintEllipsisBox(RenderObject::PaintInfo& paintInfo, int tx, int ty) const { if (m_hasEllipsisBox && object()->shouldPaintWithinRoot(paintInfo) && object()->style()->visibility() == VISIBLE && paintInfo.phase == PaintPhaseForeground) ellipsisBox()->paint(paintInfo, tx, ty); } #if PLATFORM(MAC) void RootInlineBox::addHighlightOverflow() { // Highlight acts as a selection inflation. FloatRect rootRect(0, selectionTop(), width(), selectionHeight()); IntRect inflatedRect = enclosingIntRect(object()->document()->frame()->customHighlightLineRect(object()->style()->highlight(), rootRect, object()->node())); setHorizontalOverflowPositions(min(leftOverflow(), inflatedRect.x()), max(rightOverflow(), inflatedRect.right())); setVerticalOverflowPositions(min(topOverflow(), inflatedRect.y()), max(bottomOverflow(), inflatedRect.bottom())); } void RootInlineBox::paintCustomHighlight(RenderObject::PaintInfo& paintInfo, int tx, int ty, const AtomicString& highlightType) { if (!object()->shouldPaintWithinRoot(paintInfo) || object()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground) return; // Get the inflated rect so that we can properly hit test. FloatRect rootRect(tx + xPos(), ty + selectionTop(), width(), selectionHeight()); FloatRect inflatedRect = object()->document()->frame()->customHighlightLineRect(highlightType, rootRect, object()->node()); if (inflatedRect.intersects(paintInfo.rect)) object()->document()->frame()->paintCustomHighlight(highlightType, rootRect, rootRect, false, true, object()->node()); } #endif void RootInlineBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty) { InlineFlowBox::paint(paintInfo, tx, ty); paintEllipsisBox(paintInfo, tx, ty); #if PLATFORM(MAC) RenderStyle* styleToUse = object()->style(m_firstLine); if (styleToUse->highlight() != nullAtom && !paintInfo.context->paintingDisabled()) paintCustomHighlight(paintInfo, tx, ty, styleToUse->highlight()); #endif } bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty) { if (m_hasEllipsisBox && object()->style()->visibility() == VISIBLE) { if (ellipsisBox()->nodeAtPoint(request, result, x, y, tx, ty)) { object()->updateHitTestResult(result, IntPoint(x - tx, y - ty)); return true; } } return InlineFlowBox::nodeAtPoint(request, result, x, y, tx, ty); } void RootInlineBox::adjustPosition(int dx, int dy) { InlineFlowBox::adjustPosition(dx, dy); if (m_overflow) { m_overflow->m_topOverflow += dy; m_overflow->m_bottomOverflow += dy; m_overflow->m_selectionTop += dy; m_overflow->m_selectionBottom += dy; } m_blockHeight += dy; } void RootInlineBox::childRemoved(InlineBox* box) { if (box->object() == m_lineBreakObj) setLineBreakInfo(0, 0, BidiStatus()); for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == box->object(); prev = prev->prevRootBox()) { prev->setLineBreakInfo(0, 0, BidiStatus()); prev->markDirty(); } } GapRects RootInlineBox::fillLineSelectionGap(int selTop, int selHeight, RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty, const RenderObject::PaintInfo* paintInfo) { RenderObject::SelectionState lineState = selectionState(); bool leftGap, rightGap; block()->getHorizontalSelectionGapInfo(lineState, leftGap, rightGap); GapRects result; InlineBox* firstBox = firstSelectedBox(); InlineBox* lastBox = lastSelectedBox(); if (leftGap) result.uniteLeft(block()->fillLeftSelectionGap(firstBox->parent()->object(), firstBox->xPos(), selTop, selHeight, rootBlock, blockX, blockY, tx, ty, paintInfo)); if (rightGap) result.uniteRight(block()->fillRightSelectionGap(lastBox->parent()->object(), lastBox->xPos() + lastBox->width(), selTop, selHeight, rootBlock, blockX, blockY, tx, ty, paintInfo)); if (firstBox && firstBox != lastBox) { // Now fill in any gaps on the line that occurred between two selected elements. int lastX = firstBox->xPos() + firstBox->width(); for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) { if (box->selectionState() != RenderObject::SelectionNone) { result.uniteCenter(block()->fillHorizontalSelectionGap(box->parent()->object(), lastX + tx, selTop + ty, box->xPos() - lastX, selHeight, paintInfo)); lastX = box->xPos() + box->width(); } if (box == lastBox) break; } } return result; } void RootInlineBox::setHasSelectedChildren(bool b) { if (m_hasSelectedChildren == b) return; m_hasSelectedChildren = b; } RenderObject::SelectionState RootInlineBox::selectionState() { // Walk over all of the selected boxes. RenderObject::SelectionState state = RenderObject::SelectionNone; for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) { RenderObject::SelectionState boxState = box->selectionState(); if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd) || (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart)) state = RenderObject::SelectionBoth; else if (state == RenderObject::SelectionNone || ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) && (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside))) state = boxState; if (state == RenderObject::SelectionBoth) break; } return state; } InlineBox* RootInlineBox::firstSelectedBox() { for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) { if (box->selectionState() != RenderObject::SelectionNone) return box; } return 0; } InlineBox* RootInlineBox::lastSelectedBox() { for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) { if (box->selectionState() != RenderObject::SelectionNone) return box; } return 0; } int RootInlineBox::selectionTop() { int selectionTop = m_overflow ? m_overflow->m_selectionTop : m_y; if (!prevRootBox()) return selectionTop; int prevBottom = prevRootBox()->selectionBottom(); if (prevBottom < selectionTop && block()->containsFloats()) { // This line has actually been moved further down, probably from a large line-height, but possibly because the // line was forced to clear floats. If so, let's check the offsets, and only be willing to use the previous // line's bottom overflow if the offsets are greater on both sides. int prevLeft = block()->leftOffset(prevBottom); int prevRight = block()->rightOffset(prevBottom); int newLeft = block()->leftOffset(selectionTop); int newRight = block()->rightOffset(selectionTop); if (prevLeft > newLeft || prevRight < newRight) return selectionTop; } return prevBottom; } RenderBlock* RootInlineBox::block() const { return static_cast(m_object); } bool isEditableLeaf(InlineBox* leaf) { return leaf && leaf->object() && leaf->object()->element() && leaf->object()->element()->isContentEditable(); } InlineBox* RootInlineBox::closestLeafChildForXPos(int x, bool onlyEditableLeaves) { InlineBox* firstLeaf = firstLeafChildAfterBox(); InlineBox* lastLeaf = lastLeafChildBeforeBox(); if (firstLeaf == lastLeaf && (!onlyEditableLeaves || isEditableLeaf(firstLeaf))) return firstLeaf; // Avoid returning a list marker when possible. if (x <= firstLeaf->m_x && !firstLeaf->object()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf))) // The x coordinate is less or equal to left edge of the firstLeaf. // Return it. return firstLeaf; if (x >= lastLeaf->m_x + lastLeaf->m_width && !lastLeaf->object()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf))) // The x coordinate is greater or equal to right edge of the lastLeaf. // Return it. return lastLeaf; InlineBox* closestLeaf = lastLeaf; for (InlineBox* leaf = firstLeaf; leaf && leaf != lastLeaf; leaf = leaf->nextLeafChild()) { if (!leaf->object()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) { int leafX = leaf->m_x; closestLeaf = leaf; if (x < leafX + leaf->m_width) // The x coordinate is less than the right edge of the box. // Return it. return leaf; } } return closestLeaf; } BidiStatus RootInlineBox::lineBreakBidiStatus() const { return BidiStatus(m_lineBreakBidiStatusEor, m_lineBreakBidiStatusLastStrong, m_lineBreakBidiStatusLast, m_lineBreakContext); } void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status) { m_lineBreakObj = obj; m_lineBreakPos = breakPos; m_lineBreakBidiStatusEor = status.eor; m_lineBreakBidiStatusLastStrong = status.lastStrong; m_lineBreakBidiStatusLast = status.last; m_lineBreakContext = status.context; } EllipsisBox* RootInlineBox::ellipsisBox() const { if (!m_hasEllipsisBox) return false; return gEllipsisBoxMap->get(this); } void RootInlineBox::setVerticalOverflowPositions(int top, int bottom) { if (!m_overflow) { if (top == m_y && bottom == m_y + m_height) return; m_overflow = new (m_object->renderArena()) Overflow(this); } m_overflow->m_topOverflow = top; m_overflow->m_bottomOverflow = bottom; } } // namespace WebCore