bool RenderReplaced::shouldPaint(PaintInfo& paintInfo, const LayoutPoint& paintOffset) { if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseMask && paintInfo.phase != PaintPhaseClippingMask) return false; if (!paintInfo.shouldPaintWithinRoot(this)) return false; // if we're invisible or haven't received a layout yet, then just bail. if (style()->visibility() != VISIBLE) return false; LayoutPoint adjustedPaintOffset = paintOffset + location(); // Early exit if the element touches the edges. LayoutUnit top = adjustedPaintOffset.y() + visualOverflowRect().y(); LayoutUnit bottom = adjustedPaintOffset.y() + visualOverflowRect().maxY(); if (isSelected() && inlineBoxWrapper()) { LayoutUnit selTop = paintOffset.y() + inlineBoxWrapper()->root().selectionTop(); LayoutUnit selBottom = paintOffset.y() + selTop + inlineBoxWrapper()->root().selectionHeight(); top = std::min(selTop, top); bottom = std::max(selBottom, bottom); } if (adjustedPaintOffset.x() + visualOverflowRect().x() >= paintInfo.rect.maxX() || adjustedPaintOffset.x() + visualOverflowRect().maxX() <= paintInfo.rect.x()) return false; if (top >= paintInfo.rect.maxY() || bottom <= paintInfo.rect.y()) return false; return true; }
void LayoutListMarker::setSelectionState(SelectionState state) { // The selection state for our containing block hierarchy is updated by the base class call. LayoutBox::setSelectionState(state); if (inlineBoxWrapper() && canUpdateSelectionOnRootLineBoxes()) inlineBoxWrapper()->root().setHasSelectedChildren(state != SelectionNone); }
void RenderReplaced::setSelectionState(SelectionState state) { // The selection state for our containing block hierarchy is updated by the base class call. RenderBox::setSelectionState(state); if (inlineBoxWrapper() && canUpdateSelectionOnRootLineBoxes()) if (RootInlineBox* root = inlineBoxWrapper()->root()) root->setHasSelectedChildren(isSelected()); }
LayoutRect RenderReplaced::localSelectionRect(bool checkWhetherSelected) const { if (checkWhetherSelected && !isSelected()) return LayoutRect(); if (!inlineBoxWrapper()) // We're a block-level replaced element. Just return our own dimensions. return LayoutRect(LayoutPoint(), size()); RootInlineBox& root = inlineBoxWrapper()->root(); LayoutUnit newLogicalTop = root.selectionTop() - inlineBoxWrapper()->logicalTop(); return LayoutRect(0, newLogicalTop, width(), root.selectionHeight()); }
LayoutRect LayoutListMarker::localSelectionRect() const { InlineBox* box = inlineBoxWrapper(); if (!box) return LayoutRect(LayoutPoint(), size()); RootInlineBox& root = inlineBoxWrapper()->root(); const ComputedStyle* blockStyle = root.block().style(); LayoutUnit newLogicalTop = blockStyle->isFlippedBlocksWritingMode() ? inlineBoxWrapper()->logicalBottom() - root.selectionBottom() : root.selectionTop() - inlineBoxWrapper()->logicalTop(); return blockStyle->isHorizontalWritingMode() ? LayoutRect(0, newLogicalTop, size().width(), root.selectionHeight()) : LayoutRect(newLogicalTop, 0, root.selectionHeight(), size().height()); }
LayoutRect RenderReplaced::localSelectionRect(bool checkWhetherSelected) const { if (checkWhetherSelected && !isSelected()) return LayoutRect(); if (!inlineBoxWrapper()) // We're a block-level replaced element. Just return our own dimensions. return LayoutRect(LayoutPoint(), size()); RootInlineBox& root = inlineBoxWrapper()->root(); LayoutUnit newLogicalTop = root.block().style()->slowIsFlippedBlocksWritingMode() ? inlineBoxWrapper()->logicalBottom() - root.selectionBottom() : root.selectionTop() - inlineBoxWrapper()->logicalTop(); if (root.block().style()->isHorizontalWritingMode()) return LayoutRect(0, newLogicalTop, width(), root.selectionHeight()); return LayoutRect(newLogicalTop, 0, root.selectionHeight(), height()); }
LayoutRect LayoutListMarker::selectionRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer) const { ASSERT(!needsLayout()); if (selectionState() == SelectionNone || !inlineBoxWrapper()) return LayoutRect(); RootInlineBox& root = inlineBoxWrapper()->root(); LayoutRect rect(0, root.selectionTop() - location().y(), size().width(), root.selectionHeight()); mapToVisibleRectInAncestorSpace(paintInvalidationContainer, rect, nullptr); // FIXME: groupedMapping() leaks the squashing abstraction. if (paintInvalidationContainer->layer()->groupedMapping()) PaintLayer::mapRectToPaintBackingCoordinates(paintInvalidationContainer, rect); return rect; }
PositionWithAffinity LayoutReplaced::positionForPoint(const LayoutPoint& point) { // FIXME: This code is buggy if the replaced element is relative positioned. InlineBox* box = inlineBoxWrapper(); RootInlineBox* rootBox = box ? &box->root() : 0; LayoutUnit top = rootBox ? rootBox->selectionTop() : logicalTop(); LayoutUnit bottom = rootBox ? rootBox->selectionBottom() : logicalBottom(); LayoutUnit blockDirectionPosition = isHorizontalWritingMode() ? point.y() + location().y() : point.x() + location().x(); LayoutUnit lineDirectionPosition = isHorizontalWritingMode() ? point.x() + location().x() : point.y() + location().y(); if (blockDirectionPosition < top) return createPositionWithAffinity(caretMinOffset()); // coordinates are above if (blockDirectionPosition >= bottom) return createPositionWithAffinity(caretMaxOffset()); // coordinates are below if (node()) { if (lineDirectionPosition <= logicalLeft() + (logicalWidth() / 2)) return createPositionWithAffinity(0); return createPositionWithAffinity(1); } return LayoutBox::positionForPoint(point); }
VisiblePosition RenderReplaced::positionForPoint(const IntPoint& point) { InlineBox* box = inlineBoxWrapper(); if (!box) return createVisiblePosition(0, DOWNSTREAM); // FIXME: This code is buggy if the replaced element is relative positioned. RootInlineBox* root = box->root(); int top = root->topOverflow(); int bottom = root->nextRootBox() ? root->nextRootBox()->topOverflow() : root->bottomOverflow(); if (point.y() + y() < top) return createVisiblePosition(caretMinOffset(), DOWNSTREAM); // coordinates are above if (point.y() + y() >= bottom) return createVisiblePosition(caretMaxOffset(), DOWNSTREAM); // coordinates are below if (node()) { if (point.x() <= width() / 2) return createVisiblePosition(0, DOWNSTREAM); return createVisiblePosition(1, DOWNSTREAM); } return RenderBox::positionForPoint(point); }
LayoutRect LayoutReplaced::localSelectionRect() const { if (selectionState() == SelectionNone) return LayoutRect(); if (!inlineBoxWrapper()) { // We're a block-level replaced element. Just return our own dimensions. return LayoutRect(LayoutPoint(), size()); } RootInlineBox& root = inlineBoxWrapper()->root(); LayoutUnit newLogicalTop = root.block().style()->isFlippedBlocksWritingMode() ? inlineBoxWrapper()->logicalBottom() - root.selectionBottom() : root.selectionTop() - inlineBoxWrapper()->logicalTop(); if (root.block().style()->isHorizontalWritingMode()) return LayoutRect(0, newLogicalTop, size().width(), root.selectionHeight()); return LayoutRect(newLogicalTop, 0, root.selectionHeight(), size().height()); }
VisiblePosition RenderReplaced::positionForPoint(const LayoutPoint& point, const RenderRegion* region) { // FIXME: This code is buggy if the replaced element is relative positioned. InlineBox* box = inlineBoxWrapper(); const RootInlineBox* rootBox = box ? &box->root() : 0; LayoutUnit top = rootBox ? rootBox->selectionTop() : logicalTop(); LayoutUnit bottom = rootBox ? rootBox->selectionBottom() : logicalBottom(); LayoutUnit blockDirectionPosition = isHorizontalWritingMode() ? point.y() + y() : point.x() + x(); LayoutUnit lineDirectionPosition = isHorizontalWritingMode() ? point.x() + x() : point.y() + y(); if (blockDirectionPosition < top) return createVisiblePosition(caretMinOffset(), DOWNSTREAM); // coordinates are above if (blockDirectionPosition >= bottom) return createVisiblePosition(caretMaxOffset(), DOWNSTREAM); // coordinates are below if (element()) { if (lineDirectionPosition <= logicalLeft() + (logicalWidth() / 2)) return createVisiblePosition(0, DOWNSTREAM); return createVisiblePosition(1, DOWNSTREAM); } return RenderBox::positionForPoint(point, region); }
VisiblePosition RenderReplaced::positionForPoint(const IntPoint& point) { InlineBox* box = inlineBoxWrapper(); if (!box) return createVisiblePosition(0, DOWNSTREAM); // FIXME: This code is buggy if the replaced element is relative positioned. RootInlineBox* root = box->root(); int top = root->selectionTop(); int bottom = root->selectionBottom(); int blockDirectionPosition = box->isHorizontal() ? point.y() + y() : point.x() + x(); int lineDirectionPosition = box->isHorizontal() ? point.x() + x() : point.y() + y(); if (blockDirectionPosition < top) return createVisiblePosition(caretMinOffset(), DOWNSTREAM); // coordinates are above if (blockDirectionPosition >= bottom) return createVisiblePosition(caretMaxOffset(), DOWNSTREAM); // coordinates are below if (node()) { if (lineDirectionPosition <= box->logicalLeft() + (box->logicalWidth() / 2)) return createVisiblePosition(0, DOWNSTREAM); return createVisiblePosition(1, DOWNSTREAM); } return RenderBox::positionForPoint(point); }
VisiblePosition RenderReplaced::positionForCoordinates(int x, int y) { InlineBox* box = inlineBoxWrapper(); if (!box) return VisiblePosition(element(), 0, DOWNSTREAM); // FIXME: This code is buggy if the replaced element is relative positioned. RootInlineBox* root = box->root(); int top = root->topOverflow(); int bottom = root->nextRootBox() ? root->nextRootBox()->topOverflow() : root->bottomOverflow(); if (y + yPos() < top) return VisiblePosition(element(), caretMinOffset(), DOWNSTREAM); // coordinates are above if (y + yPos() >= bottom) return VisiblePosition(element(), caretMaxOffset(), DOWNSTREAM); // coordinates are below if (element()) { if (x <= width() / 2) return VisiblePosition(element(), 0, DOWNSTREAM); return VisiblePosition(element(), 1, DOWNSTREAM); } return RenderBox::positionForCoordinates(x, y); }
void RenderReplaced::setSelectionState(SelectionState state) { // The selection state for our containing block hierarchy is updated by the base class call. RenderBox::setSelectionState(state); if (!inlineBoxWrapper()) return; // We only include the space below the baseline in our layer's cached paint invalidation rect if the // image is selected. Since the selection state has changed update the rect. if (hasLayer()) setPreviousPaintInvalidationRect(boundsRectForPaintInvalidation(containerForPaintInvalidation())); if (canUpdateSelectionOnRootLineBoxes()) inlineBoxWrapper()->root().setHasSelectedChildren(isSelected()); }
void RenderListMarker::setSelectionState(SelectionState state) { m_selectionState = state; if (InlineBox* box = inlineBoxWrapper()) if (RootInlineBox* root = box->root()) root->setHasSelectedChildren(state != SelectionNone); containingBlock()->setSelectionState(state); }
IntRect RenderListMarker::selectionRect(bool clipToVisibleContent) { ASSERT(!needsLayout()); if (selectionState() == SelectionNone || !inlineBoxWrapper()) return IntRect(); RootInlineBox* root = inlineBoxWrapper()->root(); IntRect rect(0, root->selectionTop() - yPos(), width(), root->selectionHeight()); if (clipToVisibleContent) computeAbsoluteRepaintRect(rect); else { int absx, absy; absolutePosition(absx, absy); rect.move(absx, absy); } return rect; }
void LayoutReplaced::setSelectionState(SelectionState state) { // The selection state for our containing block hierarchy is updated by the // base class call. LayoutBox::setSelectionState(state); if (!inlineBoxWrapper()) return; // We only include the space below the baseline in our layer's cached paint // invalidation rect if the image is selected. Since the selection state has // changed update the rect. if (hasLayer()) { LayoutRect rect = localVisualRect(); PaintLayer::mapRectToPaintInvalidationBacking( *this, containerForPaintInvalidation(), rect); setPreviousVisualRect(rect); } if (canUpdateSelectionOnRootLineBoxes()) inlineBoxWrapper()->root().setHasSelectedChildren(state != SelectionNone); }
bool RenderReplaced::shouldPaint(PaintInfo& paintInfo, const LayoutPoint& paintOffset) { LayoutPoint adjustedPaintOffset = paintOffset + location(); // Early exit if the element touches the edges. LayoutUnit top = adjustedPaintOffset.y() + visualOverflowRect().y(); LayoutUnit bottom = adjustedPaintOffset.y() + visualOverflowRect().maxY(); if (isSelected() && inlineBoxWrapper()) { LayoutUnit selTop = paintOffset.y() + inlineBoxWrapper()->root().selectionTop(); LayoutUnit selBottom = paintOffset.y() + selTop + inlineBoxWrapper()->root().selectionHeight(); top = std::min(selTop, top); bottom = std::max(selBottom, bottom); } if (adjustedPaintOffset.x() + visualOverflowRect().x() >= paintInfo.rect.maxX() || adjustedPaintOffset.x() + visualOverflowRect().maxX() <= paintInfo.rect.x()) return false; if (top >= paintInfo.rect.maxY() || bottom <= paintInfo.rect.y()) return false; return true; }
PositionWithAffinity RenderReplaced::positionForPoint(const LayoutPoint& point) { // FIXME: This code is buggy if the replaced element is relative positioned. InlineBox* box = inlineBoxWrapper(); RootInlineBox* rootBox = box ? &box->root() : 0; LayoutUnit top = rootBox ? rootBox->selectionTop() : logicalTop(); LayoutUnit bottom = rootBox ? rootBox->selectionBottom() : logicalBottom(); LayoutUnit blockDirectionPosition = point.y() + y(); if (blockDirectionPosition < top) return createPositionWithAffinity(caretMinOffset(), DOWNSTREAM); // coordinates are above if (blockDirectionPosition >= bottom) return createPositionWithAffinity(caretMaxOffset(), DOWNSTREAM); // coordinates are below return RenderBox::positionForPoint(point); }