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 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(); } }