bool RenderLineBoxList::hitTest(RenderBoxModelObject* renderer, const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty, HitTestAction hitTestAction) const { if (hitTestAction != HitTestForeground) return false; ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could hit test like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return false; // We can check the first box and last box and avoid hit testing if we don't // contain the point. This is a quick short-circuit that we can take to avoid walking any lines. // FIXME: This check is flawed in the following extremely obscure way: // if some line in the middle has a huge overflow, it might actually extend below the last line. if ((y >= ty + lastLineBox()->root()->bottomVisibleOverflow()) || (y < ty + firstLineBox()->root()->topVisibleOverflow())) return false; // See if our root lines contain the point. If so, then we hit test // them further. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = lastLineBox(); curr; curr = curr->prevLineBox()) { if (y >= ty + curr->root()->topVisibleOverflow() && y < ty + curr->root()->bottomVisibleOverflow()) { bool inside = curr->nodeAtPoint(request, result, x, y, tx, ty); if (inside) { renderer->updateHitTestResult(result, IntPoint(x - tx, y - ty)); return true; } } } return false; }
bool RenderFlow::hitTestLines(NodeInfo& i, int x, int y, int tx, int ty, HitTestAction hitTestAction) { (void) hitTestAction; /* if (hitTestAction != HitTestForeground) // ### port hitTest return false; */ if (!firstLineBox()) return false; // We can check the first box and last box and avoid hit testing if we don't // contain the point. This is a quick short-circuit that we can take to avoid walking any lines. // FIXME: This check is flawed in two extremely obscure ways. // (1) If some line in the middle has a huge overflow, it might actually extend below the last line. // (2) The overflow from an inline block on a line is not reported to the line. if ((y >= ty + lastLineBox()->root()->bottomOverflow()) || (y < ty + firstLineBox()->root()->topOverflow())) return false; // See if our root lines contain the point. If so, then we hit test // them further. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = lastLineBox(); curr; curr = curr->prevFlowBox()) { if (y >= ty + curr->root()->topOverflow() && y < ty + curr->root()->bottomOverflow()) { bool inside = curr->nodeAtPoint(i, x, y, tx, ty); if (inside) { setInnerNode(i); return true; } } } return false; }
bool LineBoxList::hitTest(LayoutBoxModelObject* renderer, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction) const { if (hitTestAction != HitTestForeground) return false; ASSERT(renderer->isLayoutBlock() || (renderer->isLayoutInline() && renderer->hasLayer())); // The only way an inline could hit test like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return false; LayoutPoint point = locationInContainer.point(); LayoutRect rect(firstLineBox()->isHorizontal() ? IntRect(point.x(), point.y() - locationInContainer.topPadding(), 1, locationInContainer.topPadding() + locationInContainer.bottomPadding() + 1) : IntRect(point.x() - locationInContainer.leftPadding(), point.y(), locationInContainer.rightPadding() + locationInContainer.leftPadding() + 1, 1)); if (!anyLineIntersectsRect(renderer, rect, accumulatedOffset)) return false; // See if our root lines contain the point. If so, then we hit test // them further. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = lastLineBox(); curr; curr = curr->prevLineBox()) { RootInlineBox& root = curr->root(); if (rangeIntersectsRect(renderer, curr->logicalTopVisualOverflow(root.lineTop()), curr->logicalBottomVisualOverflow(root.lineBottom()), rect, accumulatedOffset)) { bool inside = curr->nodeAtPoint(result, locationInContainer, accumulatedOffset, root.lineTop(), root.lineBottom()); if (inside) { renderer->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset)); return true; } } } return false; }
void LineBoxListPainter::paint(const LayoutBoxModelObject& layoutObject, const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const { ASSERT(!shouldPaintSelfOutline(paintInfo.phase) && !shouldPaintDescendantOutlines(paintInfo.phase)); // Only paint during the foreground/selection phases. if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseTextClip && paintInfo.phase != PaintPhaseMask) return; ASSERT(layoutObject.isLayoutBlock() || (layoutObject.isLayoutInline() && layoutObject.hasLayer())); // The only way an inline could paint like this is if it has a layer. if (paintInfo.phase == PaintPhaseForeground && paintInfo.isPrinting()) addPDFURLRectsForInlineChildrenRecursively(layoutObject, paintInfo, paintOffset); // If we have no lines then we have no work to do. if (!m_lineBoxList.firstLineBox()) return; if (!m_lineBoxList.anyLineIntersectsRect(LineLayoutBoxModel(const_cast<LayoutBoxModelObject*>(&layoutObject)), paintInfo.cullRect(), paintOffset)) return; PaintInfo info(paintInfo); // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = m_lineBoxList.firstLineBox(); curr; curr = curr->nextLineBox()) { if (m_lineBoxList.lineIntersectsDirtyRect(LineLayoutBoxModel(const_cast<LayoutBoxModelObject*>(&layoutObject)), curr, info.cullRect(), paintOffset)) { RootInlineBox& root = curr->root(); curr->paint(info, paintOffset, root.lineTop(), root.lineBottom()); } } }
void LineBoxListPainter::paint(LayoutBoxModelObject* layoutObject, const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const { ASSERT(paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines); // Only paint during the foreground/selection phases. if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseTextClip && paintInfo.phase != PaintPhaseMask) return; ASSERT(layoutObject->isLayoutBlock() || (layoutObject->isLayoutInline() && layoutObject->hasLayer())); // The only way an inline could paint like this is if it has a layer. // FIXME: When Skia supports annotation rect covering (https://code.google.com/p/skia/issues/detail?id=3872), // these rects may be covered line box drawings. Then we may need a dedicated paint phase. if (paintInfo.phase == PaintPhaseForeground && paintInfo.isPrinting()) addPDFURLRectsForInlineChildrenRecursively(layoutObject, paintInfo, paintOffset); // If we have no lines then we have no work to do. if (!m_lineBoxList.firstLineBox()) return; if (!m_lineBoxList.anyLineIntersectsRect(LineLayoutBoxModel(layoutObject), LayoutRect(paintInfo.rect), paintOffset)) return; PaintInfo info(paintInfo); // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = m_lineBoxList.firstLineBox(); curr; curr = curr->nextLineBox()) { if (m_lineBoxList.lineIntersectsDirtyRect(LineLayoutBoxModel(layoutObject), curr, info, paintOffset)) { RootInlineBox& root = curr->root(); curr->paint(info, paintOffset, root.lineTop(), root.lineBottom()); } } }
void InlinePainter::paintOutline(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) { RenderStyle* styleToUse = m_renderInline.style(); if (!styleToUse->hasOutline()) return; LayoutRect bounds; if (RuntimeEnabledFeatures::slimmingPaintEnabled()) { // FIXME: Use tighter bounds. RenderBlock* cb = m_renderInline.containingBlock(); bounds = cb->visualOverflowRect(); bounds.moveBy(paintOffset); } RenderDrawingRecorder recorder(paintInfo.context, m_renderInline, paintInfo.phase, bounds); if (recorder.canUseCachedDrawing()) return; if (styleToUse->outlineStyleIsAuto()) { if (RenderTheme::theme().shouldDrawDefaultFocusRing(&m_renderInline)) { // Only paint the focus ring by hand if the theme isn't able to draw the focus ring. ObjectPainter(m_renderInline).paintFocusRing(paintInfo, paintOffset, styleToUse); } return; } if (styleToUse->outlineStyle() == BNONE) return; Vector<LayoutRect> rects; rects.append(LayoutRect()); for (InlineFlowBox* curr = m_renderInline.firstLineBox(); curr; curr = curr->nextLineBox()) { RootInlineBox& root = curr->root(); LayoutUnit top = std::max<LayoutUnit>(root.lineTop(), curr->logicalTop()); LayoutUnit bottom = std::min<LayoutUnit>(root.lineBottom(), curr->logicalBottom()); rects.append(LayoutRect(curr->x(), top, curr->logicalWidth(), bottom - top)); } rects.append(LayoutRect()); Color outlineColor = m_renderInline.resolveColor(styleToUse, CSSPropertyOutlineColor); bool useTransparencyLayer = outlineColor.hasAlpha(); GraphicsContext* graphicsContext = paintInfo.context; if (useTransparencyLayer) { graphicsContext->beginTransparencyLayer(static_cast<float>(outlineColor.alpha()) / 255); outlineColor = Color(outlineColor.red(), outlineColor.green(), outlineColor.blue()); } for (unsigned i = 1; i < rects.size() - 1; i++) paintOutlineForLine(graphicsContext, paintOffset, rects.at(i - 1), rects.at(i), rects.at(i + 1), outlineColor); if (useTransparencyLayer) graphicsContext->endLayer(); }
void InlinePainter::paintOutline(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) { const ComputedStyle& styleToUse = m_layoutInline.styleRef(); if (!styleToUse.hasOutline()) return; if (styleToUse.outlineStyleIsAuto()) { if (!LayoutTheme::theme().shouldDrawDefaultFocusRing(&m_layoutInline)) return; if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*paintInfo.context, m_layoutInline, paintInfo.phase)) return; Vector<LayoutRect> focusRingRects; m_layoutInline.addOutlineRects(focusRingRects, paintOffset); LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutInline, paintInfo.phase, outlinePaintRect(focusRingRects, LayoutPoint())); // Only paint the focus ring by hand if the theme isn't able to draw the focus ring. ObjectPainter(m_layoutInline).paintFocusRing(paintInfo, styleToUse, focusRingRects); return; } if (styleToUse.outlineStyle() == BNONE) return; GraphicsContext* graphicsContext = paintInfo.context; if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(*graphicsContext, m_layoutInline, paintInfo.phase)) return; Vector<LayoutRect> rects; rects.append(LayoutRect()); for (InlineFlowBox* curr = m_layoutInline.firstLineBox(); curr; curr = curr->nextLineBox()) { RootInlineBox& root = curr->root(); LayoutUnit top = std::max<LayoutUnit>(root.lineTop(), curr->logicalTop()); LayoutUnit bottom = std::min<LayoutUnit>(root.lineBottom(), curr->logicalBottom()); rects.append(LayoutRect(curr->x(), top, curr->logicalWidth(), bottom - top)); } rects.append(LayoutRect()); Color outlineColor = m_layoutInline.resolveColor(styleToUse, CSSPropertyOutlineColor); bool useTransparencyLayer = outlineColor.hasAlpha(); LayoutObjectDrawingRecorder recorder(*graphicsContext, m_layoutInline, paintInfo.phase, outlinePaintRect(rects, paintOffset)); if (useTransparencyLayer) { graphicsContext->beginLayer(static_cast<float>(outlineColor.alpha()) / 255); outlineColor = Color(outlineColor.red(), outlineColor.green(), outlineColor.blue()); } for (unsigned i = 1; i < rects.size() - 1; i++) paintOutlineForLine(graphicsContext, paintOffset, rects.at(i - 1), rects.at(i), rects.at(i + 1), outlineColor); if (useTransparencyLayer) graphicsContext->endLayer(); }
void RenderFlow::paintLines(PaintInfo& i, int _tx, int _ty) { // Only paint during the foreground/selection phases. if (i.phase != PaintActionForeground && i.phase != PaintActionSelection && i.phase != PaintActionOutline) return; if (!firstLineBox()) return; // We can check the first box and last box and avoid painting if we don't // intersect. This is a quick short-circuit that we can take to avoid walking any lines. // FIXME: This check is flawed in two extremely obscure ways. // (1) If some line in the middle has a huge overflow, it might actually extend below the last line. // (2) The overflow from an inline block on a line is not reported to the line. int maxOutlineSize = maximalOutlineSize(i.phase); int yPos = firstLineBox()->root()->topOverflow() - maxOutlineSize; int h = maxOutlineSize + lastLineBox()->root()->bottomOverflow() - yPos; yPos += _ty; if ((yPos >= i.r.y() + i.r.height()) || (yPos + h <= i.r.y())) return; for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextFlowBox()) { yPos = curr->root()->topOverflow() - maxOutlineSize; h = curr->root()->bottomOverflow() + maxOutlineSize - yPos; yPos += _ty; if ((yPos < i.r.y() + i.r.height()) && (yPos + h > i.r.y())) curr->paint(i, _tx, _ty); } if (i.phase == PaintActionOutline && i.outlineObjects) { QValueList<RenderFlow *>::iterator it;; for( it = (*i.outlineObjects).begin(); it != (*i.outlineObjects).end(); ++it ) if ((*it)->isRenderInline()) static_cast<RenderInline*>(*it)->paintOutlines(i.p, _tx, _ty); i.outlineObjects->clear(); } }
void RenderLineBoxList::paint(RenderBoxModelObject* renderer, PaintInfo& paintInfo, const LayoutPoint& paintOffset) const { // Only paint during the foreground/selection phases. if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip && paintInfo.phase != PaintPhaseMask) return; ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; if (!anyLineIntersectsRect(renderer, paintInfo.rect, paintOffset)) return; PaintInfo info(paintInfo); ListHashSet<RenderInline*> outlineObjects; info.setOutlineObjects(&outlineObjects); // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { if (lineIntersectsDirtyRect(renderer, curr, info, paintOffset)) { RootInlineBox& root = curr->root(); curr->paint(info, paintOffset, root.lineTop(), root.lineBottom()); } } if (info.phase == PaintPhaseOutline || info.phase == PaintPhaseSelfOutline || info.phase == PaintPhaseChildOutlines) { ListHashSet<RenderInline*>::iterator end = info.outlineObjects()->end(); for (ListHashSet<RenderInline*>::iterator it = info.outlineObjects()->begin(); it != end; ++it) { RenderInline* flow = *it; flow->paintOutline(info, paintOffset); } info.outlineObjects()->clear(); } }
void RenderLineBoxList::paint(RenderBoxModelObject* renderer, PaintInfo& paintInfo, const LayoutPoint& paintOffset, Vector<RenderBox*>& layers) const { ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; if (!anyLineIntersectsRect(renderer, paintInfo.rect, paintOffset)) return; PaintInfo info(paintInfo); // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { if (lineIntersectsDirtyRect(renderer, curr, info, paintOffset)) { RootInlineBox& root = curr->root(); curr->paint(info, paintOffset, root.lineTop(), root.lineBottom(), layers); } } }
void RenderFlow::paintLines(PaintInfo& i, int _tx, int _ty) { // Only paint during the foreground/selection phases. if (i.phase != PaintActionForeground && i.phase != PaintActionSelection && i.phase != PaintActionOutline) return; bool inlineFlow = isInlineFlow(); if (inlineFlow) KHTMLAssert(m_layer); // The only way a compact/run-in/inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; // We can check the first box and last box and avoid painting if we don't // intersect. This is a quick short-circuit that we can take to avoid walking any lines. // FIXME: This check is flawed in two extremely obscure ways. // (1) If some line in the middle has a huge overflow, it might actually extend below the last line. // (2) The overflow from an inline block on a line is not reported to the line. int yPos = firstLineBox()->root()->selectionTop() - maximalOutlineSize(i.phase); int h = maximalOutlineSize(i.phase) + lastLineBox()->root()->selectionTop() + lastLineBox()->root()->selectionHeight() - yPos; yPos += _ty; if ((yPos >= i.r.y() + i.r.height()) || (yPos + h <= i.r.y())) return; // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. bool isPrinting = (i.p->device()->devType() == QInternal::Printer); for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextFlowBox()) { if (isPrinting) { // FIXME: This is a feeble effort to avoid splitting a line across two pages. // It is utterly inadequate, and this should not be done at paint time at all. // The whole way objects break across pages needs to be redone. RenderCanvas* c = canvas(); // Try to avoid splitting a line vertically, but only if it's less than the height // of the entire page. if (curr->root()->bottomOverflow() - curr->root()->topOverflow() <= c->printRect().height()) { if (_ty + curr->root()->bottomOverflow() > c->printRect().y() + c->printRect().height()) { if (_ty + curr->root()->topOverflow() < c->truncatedAt()) c->setBestTruncatedAt(_ty + curr->root()->topOverflow(), this); // If we were able to truncate, don't paint. if (_ty + curr->root()->topOverflow() >= c->truncatedAt()) break; } } } int top = kMin(curr->root()->topOverflow(), curr->root()->selectionTop()) - maximalOutlineSize(i.phase); int bottom = kMax(curr->root()->selectionTop() + curr->root()->selectionHeight(), curr->root()->bottomOverflow()) + maximalOutlineSize(i.phase); h = bottom - top; yPos = _ty + top; if ((yPos < i.r.y() + i.r.height()) && (yPos + h > i.r.y())) curr->paint(i, _tx, _ty); } if (i.phase == PaintActionOutline && i.outlineObjects) { // FIXME: Will the order in which we added objects to the dictionary be preserved? Probably not. // This means the paint order of outlines will be wrong, although this is a minor issue. QPtrDictIterator<RenderFlow> objects(*i.outlineObjects); for (objects.toFirst(); objects.current(); ++objects) { #ifdef APPLE_CHANGES if (objects.current()->style()->outlineStyleIsAuto()) objects.current()->paintFocusRing(i.p, _tx, _ty); else #endif objects.current()->paintOutlines(i.p, _tx, _ty); } i.outlineObjects->clear(); } }
void RenderLineBoxList::readyWRATHWidgets(PaintedWidgetsOfWRATHHandle &handle, RenderBoxModelObject *renderer, PaintInfoOfWRATH &paintInfo, int tx, int ty) { RenderLineBoxList_WRATHWidgets *d; d=RenderLineBoxList_WRATHWidgets::object(renderer, handle); ContextOfWRATH::AutoPushNode autoPushRoot(paintInfo.wrath_context, d->m_root_node); /* this just.. sucks. WebKit builds a list of RenderInline objects that it will draw outlines. It is not clear if and how that list changes, so we punt and make all them handle non-visible and only those that are found in the list are then made visible. */ d->m_handles.hideEachObject(); d->m_outlineHandles.hideEachObject(); // Only paint during the foreground/selection phases. if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip && paintInfo.phase != PaintPhaseMask) return; ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; RenderView* v = renderer->view(); bool usePrintRect = !v->printRect().isEmpty(); int outlineSize = renderer->maximalOutlineSize(paintInfo.phase); if (!anyLineIntersectsRect(renderer, paintInfo.rect, tx, ty, usePrintRect, outlineSize)) return; PaintInfoOfWRATH info(paintInfo); ListHashSet<RenderInline*> outlineObjects; info.outlineObjects = &outlineObjects; for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { if (usePrintRect) { RootInlineBox* root = curr->root(); int topForPaginationCheck = curr->logicalTopVisualOverflow(root->lineTop()); int bottomForPaginationCheck = curr->logicalLeftVisualOverflow(); if (!curr->parent()) { // We're a root box. Use lineTop and lineBottom as well here. topForPaginationCheck = min(topForPaginationCheck, root->lineTop()); bottomForPaginationCheck = max(bottomForPaginationCheck, root->lineBottom()); } if (bottomForPaginationCheck - topForPaginationCheck <= v->printRect().height()) { if (ty + bottomForPaginationCheck > v->printRect().maxY()) { if (RootInlineBox* nextRootBox = curr->root()->nextRootBox()) bottomForPaginationCheck = min(bottomForPaginationCheck, min(nextRootBox->logicalTopVisualOverflow(), nextRootBox->lineTop())); } if (ty + bottomForPaginationCheck > v->printRect().maxY()) { if (ty + topForPaginationCheck < v->truncatedAt()) v->setBestTruncatedAt(ty + topForPaginationCheck, renderer); // If we were able to truncate, don't paint. if (ty + topForPaginationCheck >= v->truncatedAt()) break; } } } if (lineIntersectsDirtyRect(renderer, curr, info, tx, ty)) { RootInlineBox* root = curr->root(); PaintedWidgetsOfWRATHHandleT<InlineBox> &currHandle(d->m_handles.getHandle(curr)); currHandle.visible(true); curr->readyWRATHWidgets(currHandle, info, tx, ty, root->lineTop(), root->lineBottom()); } } if (info.phase == PaintPhaseOutline || info.phase == PaintPhaseSelfOutline || info.phase == PaintPhaseChildOutlines) { ListHashSet<RenderInline*>::iterator end = info.outlineObjects->end(); for (ListHashSet<RenderInline*>::iterator it = info.outlineObjects->begin(); it != end; ++it) { RenderInline* flow = *it; PaintedWidgetsOfWRATHHandle &handle(d->m_outlineHandles.getHandle(flow)); handle.visible(true); flow->readyWRATHWidgetOutline(handle, info.wrath_context, tx, ty); } info.outlineObjects->clear(); } d->m_handles.removeNonVisibleHandles(); d->m_outlineHandles.removeNonVisibleHandles(); }
void RenderLineBoxList::paint(RenderBoxModelObject* renderer, PaintInfo& paintInfo, const LayoutPoint& paintOffset) const { ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; // FIXME: Paint-time pagination is obsolete and is now only used by embedded WebViews inside AppKit // NSViews. Do not add any more code for this. RenderView& v = renderer->view(); bool usePrintRect = !v.printRect().isEmpty(); if (!anyLineIntersectsRect(renderer, paintInfo.rect, paintOffset, usePrintRect)) return; PaintInfo info(paintInfo); ListHashSet<RenderInline*> outlineObjects; info.outlineObjects = &outlineObjects; // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { if (usePrintRect) { // FIXME: This is the deprecated pagination model that is still needed // for embedded views inside AppKit. AppKit is incapable of paginating vertical // text pages, so we don't have to deal with vertical lines at all here. const RootInlineBox& rootBox = curr->root(); LayoutUnit topForPaginationCheck = curr->logicalTopVisualOverflow(rootBox.lineTop()); LayoutUnit bottomForPaginationCheck = curr->logicalLeftVisualOverflow(); if (!curr->parent()) { // We're a root box. Use lineTop and lineBottom as well here. topForPaginationCheck = std::min(topForPaginationCheck, rootBox.lineTop()); bottomForPaginationCheck = std::max(bottomForPaginationCheck, rootBox.lineBottom()); } if (bottomForPaginationCheck - topForPaginationCheck <= v.printRect().height()) { if (paintOffset.y() + bottomForPaginationCheck > v.printRect().maxY()) { if (RootInlineBox* nextRootBox = rootBox.nextRootBox()) bottomForPaginationCheck = std::min(bottomForPaginationCheck, std::min<LayoutUnit>(nextRootBox->logicalTopVisualOverflow(), nextRootBox->lineTop())); } if (paintOffset.y() + bottomForPaginationCheck > v.printRect().maxY()) { if (paintOffset.y() + topForPaginationCheck < v.truncatedAt()) v.setBestTruncatedAt(paintOffset.y() + topForPaginationCheck, renderer); // If we were able to truncate, don't paint. if (paintOffset.y() + topForPaginationCheck >= v.truncatedAt()) break; } } } if (lineIntersectsDirtyRect(renderer, curr, info, paintOffset)) { const RootInlineBox& rootBox = curr->root(); curr->paint(info, paintOffset, rootBox.lineTop(), rootBox.lineBottom()); } } if (info.phase == PaintPhaseOutline || info.phase == PaintPhaseSelfOutline || info.phase == PaintPhaseChildOutlines) { ListHashSet<RenderInline*>::iterator end = info.outlineObjects->end(); for (ListHashSet<RenderInline*>::iterator it = info.outlineObjects->begin(); it != end; ++it) { RenderInline* flow = *it; flow->paintOutline(info, paintOffset); } info.outlineObjects->clear(); } }
void RenderLineBoxList::dirtyLinesFromChangedChild(RenderObject* container, RenderObject* child) { if (!container->parent() || (container->isRenderBlock() && (container->selfNeedsLayout() || !container->isBlockFlow()))) return; // If we have no first line box, then just bail early. if (!firstLineBox()) { // For an empty inline, go ahead and propagate the check up to our parent, unless the parent // is already dirty. if (container->isInline() && !container->parent()->selfNeedsLayout()) container->parent()->dirtyLinesFromChangedChild(container); return; } // Try to figure out which line box we belong in. First try to find a previous // line box by examining our siblings. If we didn't find a line box, then use our // parent's first line box. RootInlineBox* box = 0; RenderObject* curr = 0; for (curr = child->previousSibling(); curr; curr = curr->previousSibling()) { if (curr->isFloatingOrPositioned()) continue; if (curr->isReplaced()) { InlineBox* wrapper = toRenderBox(curr)->inlineBoxWrapper(); if (wrapper) box = wrapper->root(); } else if (curr->isText()) { InlineTextBox* textBox = toRenderText(curr)->lastTextBox(); if (textBox) box = textBox->root(); } else if (curr->isRenderInline()) { InlineFlowBox* flowBox = toRenderInline(curr)->lastLineBox(); if (flowBox) box = flowBox->root(); } if (box) break; } if (!box) box = firstLineBox()->root(); // If we found a line box, then dirty it. if (box) { RootInlineBox* adjacentBox; box->markDirty(); // dirty the adjacent lines that might be affected // NOTE: we dirty the previous line because RootInlineBox objects cache // the address of the first object on the next line after a BR, which we may be // invalidating here. For more info, see how RenderBlock::layoutInlineChildren // calls setLineBreakInfo with the result of findNextLineBreak. findNextLineBreak, // despite the name, actually returns the first RenderObject after the BR. // <rdar://problem/3849947> "Typing after pasting line does not appear until after window resize." adjacentBox = box->prevRootBox(); if (adjacentBox) adjacentBox->markDirty(); if (child->isBR() || (curr && curr->isBR())) { adjacentBox = box->nextRootBox(); if (adjacentBox) adjacentBox->markDirty(); } } }
void RenderLineBoxList::paint(RenderBoxModelObject* renderer, RenderObject::PaintInfo& paintInfo, int tx, int ty) const { // Only paint during the foreground/selection phases.(只有画前景和选择才会跑到这里) if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip && paintInfo.phase != PaintPhaseMask) return; ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer. // If we have no lines then we have no work to do. if (!firstLineBox()) return; // We can check the first box and last box and avoid painting if we don't // intersect. This is a quick short-circuit that we can take to avoid walking any lines. // FIXME: This check is flawed in the following extremely obscure way: // if some line in the middle has a huge overflow, it might actually extend below the last line. int yPos = firstLineBox()->topVisibleOverflow() - renderer->maximalOutlineSize(paintInfo.phase); int h = renderer->maximalOutlineSize(paintInfo.phase) + lastLineBox()->bottomVisibleOverflow() - yPos; // 要画的inline块(从第一行到最后一行的)整个高度 yPos += ty; // 起始高度 if (yPos >= paintInfo.rect.bottom() || yPos + h <= paintInfo.rect.y()) return; RenderObject::PaintInfo info(paintInfo); ListHashSet<RenderInline*> outlineObjects; info.outlineObjects = &outlineObjects; // See if our root lines intersect with the dirty rect. If so, then we paint // them. Note that boxes can easily overlap, so we can't make any assumptions // based off positions of our first line box or our last line box. RenderView* v = renderer->view(); bool usePrintRect = !v->printRect().isEmpty(); for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) { // 开始对每行进行绘制 if (usePrintRect) { // FIXME: This is a feeble effort to avoid splitting a line across two pages. // It is utterly inadequate, and this should not be done at paint time at all. // The whole way objects break across pages needs to be redone. // Try to avoid splitting a line vertically, but only if it's less than the height // of the entire page. if (curr->bottomVisibleOverflow() - curr->topVisibleOverflow() <= v->printRect().height()) { if (ty + curr->bottomVisibleOverflow() > v->printRect().bottom()) { if (ty + curr->topVisibleOverflow() < v->truncatedAt()) v->setBestTruncatedAt(ty + curr->root()->topVisibleOverflow(), renderer); // If we were able to truncate, don't paint. if (ty + curr->topVisibleOverflow() >= v->truncatedAt()) break; } } } int top = min(curr->topVisibleOverflow(), curr->root()->selectionTop()) - renderer->maximalOutlineSize(info.phase); // 高点 int bottom = curr->bottomVisibleOverflow() + renderer->maximalOutlineSize(info.phase); // 底点 h = bottom - top; // 高度 yPos = ty + top; // 开始绘制点 v->setMinimumColumnHeight(h); if (yPos < info.rect.bottom() && yPos + h > info.rect.y()) curr->paint(info, tx, ty); // 开始绘制该行 } if (info.phase == PaintPhaseOutline || info.phase == PaintPhaseSelfOutline || info.phase == PaintPhaseChildOutlines) { ListHashSet<RenderInline*>::iterator end = info.outlineObjects->end(); for (ListHashSet<RenderInline*>::iterator it = info.outlineObjects->begin(); it != end; ++it) { RenderInline* flow = *it; flow->paintOutline(info.context, tx, ty); } info.outlineObjects->clear(); } }