/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ // vim:cindent:ts=2:et:sw=2: /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* utility functions for drawing borders and backgrounds */ #include <ctime> #include "gfx2DGlue.h" #include "mozilla/ArrayUtils.h" #include "mozilla/DebugOnly.h" #include "mozilla/gfx/2D.h" #include "mozilla/gfx/Helpers.h" #include "mozilla/gfx/PathHelpers.h" #include "mozilla/HashFunctions.h" #include "mozilla/MathAlgorithms.h" #include "BorderConsts.h" #include "nsISVGChildFrame.h" #include "nsStyleConsts.h" #include "nsPresContext.h" #include "nsIFrame.h" #include "nsPoint.h" #include "nsRect.h" #include "nsIPresShell.h" #include "nsFrameManager.h" #include "nsStyleContext.h" #include "nsGkAtoms.h" #include "nsCSSAnonBoxes.h" #include "nsIContent.h" #include "nsIDocumentInlines.h" #include "nsIScrollableFrame.h" #include "imgIRequest.h" #include "imgIContainer.h" #include "ImageOps.h" #include "nsCSSRendering.h" #include "nsCSSColorUtils.h" #include "nsITheme.h" #include "nsThemeConstants.h" #include "nsLayoutUtils.h" #include "nsBlockFrame.h" #include "gfxContext.h" #include "nsRenderingContext.h" #include "nsStyleStructInlines.h" #include "nsCSSFrameConstructor.h" #include "nsCSSProps.h" #include "nsContentUtils.h" #include "nsSVGEffects.h" #include "nsSVGIntegrationUtils.h" #include "gfxDrawable.h" #include "GeckoProfiler.h" #include "nsCSSRenderingBorders.h" #include "mozilla/css/ImageLoader.h" #include "ImageContainer.h" #include "mozilla/Telemetry.h" #include "gfxUtils.h" #include "gfxGradientCache.h" #include "nsInlineFrame.h" #include "nsRubyTextContainerFrame.h" #include <algorithm> using namespace mozilla; using namespace mozilla::css; using namespace mozilla::gfx; using namespace mozilla::image; using mozilla::CSSSizeOrRatio; static int gFrameTreeLockCount = 0; // To avoid storing this data on nsInlineFrame (bloat) and to avoid // recalculating this for each frame in a continuation (perf), hold // a cache of various coordinate information that we need in order // to paint inline backgrounds. struct InlineBackgroundData { InlineBackgroundData() : mFrame(nullptr), mLineContainer(nullptr) { } ~InlineBackgroundData() { } void Reset() { mBoundingBox.SetRect(0,0,0,0); mContinuationPoint = mLineContinuationPoint = mUnbrokenMeasure = 0; mFrame = mLineContainer = nullptr; mPIStartBorderData.Reset(); } /** * Return a continuous rect for (an inline) aFrame relative to the * continuation that draws the left-most part of the background. * This is used when painting backgrounds. */ nsRect GetContinuousRect(nsIFrame* aFrame) { MOZ_ASSERT(static_cast<nsInlineFrame*>(do_QueryFrame(aFrame))); SetFrame(aFrame); nscoord pos; // an x coordinate if writing-mode is horizontal; // y coordinate if vertical if (mBidiEnabled) { pos = mLineContinuationPoint; // Scan continuations on the same line as aFrame and accumulate the widths // of frames that are to the left (if this is an LTR block) or right // (if it's RTL) of the current one. bool isRtlBlock = (mLineContainer->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL); nscoord curOffset = mVertical ? aFrame->GetOffsetTo(mLineContainer).y : aFrame->GetOffsetTo(mLineContainer).x; // If the continuation is fluid we know inlineFrame is not on the same line. // If it's not fluid, we need to test further to be sure. nsIFrame* inlineFrame = aFrame->GetPrevContinuation(); while (inlineFrame && !inlineFrame->GetNextInFlow() && AreOnSameLine(aFrame, inlineFrame)) { nscoord frameOffset = mVertical ? inlineFrame->GetOffsetTo(mLineContainer).y : inlineFrame->GetOffsetTo(mLineContainer).x; if (isRtlBlock == (frameOffset >= curOffset)) { pos += mVertical ? inlineFrame->GetSize().height : inlineFrame->GetSize().width; } inlineFrame = inlineFrame->GetPrevContinuation(); } inlineFrame = aFrame->GetNextContinuation(); while (inlineFrame && !inlineFrame->GetPrevInFlow() && AreOnSameLine(aFrame, inlineFrame)) { nscoord frameOffset = mVertical ? inlineFrame->GetOffsetTo(mLineContainer).y : inlineFrame->GetOffsetTo(mLineContainer).x; if (isRtlBlock == (frameOffset >= curOffset)) { pos += mVertical ? inlineFrame->GetSize().height : inlineFrame->GetSize().width; } inlineFrame = inlineFrame->GetNextContinuation(); } if (isRtlBlock) { // aFrame itself is also to the right of its left edge, so add its width. pos += mVertical ? aFrame->GetSize().height : aFrame->GetSize().width; // pos is now the distance from the left [top] edge of aFrame to the right [bottom] edge // of the unbroken content. Change it to indicate the distance from the // left [top] edge of the unbroken content to the left [top] edge of aFrame. pos = mUnbrokenMeasure - pos; } } else { pos = mContinuationPoint; } // Assume background-origin: border and return a rect with offsets // relative to (0,0). If we have a different background-origin, // then our rect should be deflated appropriately by our caller. return mVertical ? nsRect(0, -pos, mFrame->GetSize().width, mUnbrokenMeasure) : nsRect(-pos, 0, mUnbrokenMeasure, mFrame->GetSize().height); } /** * Return a continuous rect for (an inline) aFrame relative to the * continuation that should draw the left[top]-border. This is used when painting * borders and clipping backgrounds. This may NOT be the same continuous rect * as for drawing backgrounds; the continuation with the left[top]-border might be * somewhere in the middle of that rect (e.g. BIDI), in those cases we need * the reverse background order starting at the left[top]-border continuation. */ nsRect GetBorderContinuousRect(nsIFrame* aFrame, nsRect aBorderArea) { // Calling GetContinuousRect(aFrame) here may lead to Reset/Init which // resets our mPIStartBorderData so we save it ... PhysicalInlineStartBorderData saved(mPIStartBorderData); nsRect joinedBorderArea = GetContinuousRect(aFrame); if (!saved.mIsValid || saved.mFrame != mPIStartBorderData.mFrame) { if (aFrame == mPIStartBorderData.mFrame) { if (mVertical) { mPIStartBorderData.SetCoord(joinedBorderArea.y); } else { mPIStartBorderData.SetCoord(joinedBorderArea.x); } } else if (mPIStartBorderData.mFrame) { if (mVertical) { mPIStartBorderData.SetCoord(GetContinuousRect(mPIStartBorderData.mFrame).y); } else { mPIStartBorderData.SetCoord(GetContinuousRect(mPIStartBorderData.mFrame).x); } } } else { // ... and restore it when possible. mPIStartBorderData.mCoord = saved.mCoord; } if (mVertical) { if (joinedBorderArea.y > mPIStartBorderData.mCoord) { joinedBorderArea.y = -(mUnbrokenMeasure + joinedBorderArea.y - aBorderArea.height); } else { joinedBorderArea.y -= mPIStartBorderData.mCoord; } } else { if (joinedBorderArea.x > mPIStartBorderData.mCoord) { joinedBorderArea.x = -(mUnbrokenMeasure + joinedBorderArea.x - aBorderArea.width); } else { joinedBorderArea.x -= mPIStartBorderData.mCoord; } } return joinedBorderArea; } nsRect GetBoundingRect(nsIFrame* aFrame) { SetFrame(aFrame); // Move the offsets relative to (0,0) which puts the bounding box into // our coordinate system rather than our parent's. We do this by // moving it the back distance from us to the bounding box. // This also assumes background-origin: border, so our caller will // need to deflate us if needed. nsRect boundingBox(mBoundingBox); nsPoint point = mFrame->GetPosition(); boundingBox.MoveBy(-point.x, -point.y); return boundingBox; } protected: // This is a coordinate on the inline axis, but is not a true logical inline- // coord because it is always measured from left to right (if horizontal) or // from top to bottom (if vertical), ignoring any bidi RTL directionality. // We'll call this "physical inline start", or PIStart for short. struct PhysicalInlineStartBorderData { nsIFrame* mFrame; // the continuation that may have a left-border nscoord mCoord; // cached GetContinuousRect(mFrame).x or .y bool mIsValid; // true if mCoord is valid void Reset() { mFrame = nullptr; mIsValid = false; } void SetCoord(nscoord aCoord) { mCoord = aCoord; mIsValid = true; } }; nsIFrame* mFrame; nsIFrame* mLineContainer; nsRect mBoundingBox; nscoord mContinuationPoint; nscoord mUnbrokenMeasure; nscoord mLineContinuationPoint; PhysicalInlineStartBorderData mPIStartBorderData; bool mBidiEnabled; bool mVertical; void SetFrame(nsIFrame* aFrame) { NS_PRECONDITION(aFrame, "Need a frame"); NS_ASSERTION(gFrameTreeLockCount > 0, "Can't call this when frame tree is not locked"); if (aFrame == mFrame) { return; } nsIFrame *prevContinuation = GetPrevContinuation(aFrame); if (!prevContinuation || mFrame != prevContinuation) { // Ok, we've got the wrong frame. We have to start from scratch. Reset(); Init(aFrame); return; } // Get our last frame's size and add its width to our continuation // point before we cache the new frame. mContinuationPoint += mVertical ? mFrame->GetSize().height : mFrame->GetSize().width; // If this a new line, update mLineContinuationPoint. if (mBidiEnabled && (aFrame->GetPrevInFlow() || !AreOnSameLine(mFrame, aFrame))) { mLineContinuationPoint = mContinuationPoint; } mFrame = aFrame; } nsIFrame* GetPrevContinuation(nsIFrame* aFrame) { nsIFrame* prevCont = aFrame->GetPrevContinuation(); if (!prevCont && (aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) { nsIFrame* block = aFrame->Properties().Get(nsIFrame::IBSplitPrevSibling()); if (block) { // The {ib} properties are only stored on first continuations NS_ASSERTION(!block->GetPrevContinuation(), "Incorrect value for IBSplitPrevSibling"); prevCont = block->Properties().Get(nsIFrame::IBSplitPrevSibling()); NS_ASSERTION(prevCont, "How did that happen?"); } } return prevCont; } nsIFrame* GetNextContinuation(nsIFrame* aFrame) { nsIFrame* nextCont = aFrame->GetNextContinuation(); if (!nextCont && (aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) { // The {ib} properties are only stored on first continuations aFrame = aFrame->FirstContinuation(); nsIFrame* block = aFrame->Properties().Get(nsIFrame::IBSplitSibling()); if (block) { nextCont = block->Properties().Get(nsIFrame::IBSplitSibling()); NS_ASSERTION(nextCont, "How did that happen?"); } } return nextCont; } void Init(nsIFrame* aFrame) { mPIStartBorderData.Reset(); mBidiEnabled = aFrame->PresContext()->BidiEnabled(); if (mBidiEnabled) { // Find the line container frame mLineContainer = aFrame; while (mLineContainer && mLineContainer->IsFrameOfType(nsIFrame::eLineParticipant)) { mLineContainer = mLineContainer->GetParent(); } MOZ_ASSERT(mLineContainer, "Cannot find line containing frame."); MOZ_ASSERT(mLineContainer != aFrame, "line container frame " "should be an ancestor of the target frame."); } mVertical = aFrame->GetWritingMode().IsVertical(); // Start with the previous flow frame as our continuation point // is the total of the widths of the previous frames. nsIFrame* inlineFrame = GetPrevContinuation(aFrame); while (inlineFrame) { if (!mPIStartBorderData.mFrame && !(mVertical ? inlineFrame->GetSkipSides().Top() : inlineFrame->GetSkipSides().Left())) { mPIStartBorderData.mFrame = inlineFrame; } nsRect rect = inlineFrame->GetRect(); mContinuationPoint += mVertical ? rect.height : rect.width; if (mBidiEnabled && !AreOnSameLine(aFrame, inlineFrame)) { mLineContinuationPoint += mVertical ? rect.height : rect.width; } mUnbrokenMeasure += mVertical ? rect.height : rect.width; mBoundingBox.UnionRect(mBoundingBox, rect); inlineFrame = GetPrevContinuation(inlineFrame); } // Next add this frame and subsequent frames to the bounding box and // unbroken width. inlineFrame = aFrame; while (inlineFrame) { if (!mPIStartBorderData.mFrame && !(mVertical ? inlineFrame->GetSkipSides().Top() : inlineFrame->GetSkipSides().Left())) { mPIStartBorderData.mFrame = inlineFrame; } nsRect rect = inlineFrame->GetRect(); mUnbrokenMeasure += mVertical ? rect.height : rect.width; mBoundingBox.UnionRect(mBoundingBox, rect); inlineFrame = GetNextContinuation(inlineFrame); } mFrame = aFrame; } bool AreOnSameLine(nsIFrame* aFrame1, nsIFrame* aFrame2) { if (nsBlockFrame* blockFrame = do_QueryFrame(mLineContainer)) { bool isValid1, isValid2; nsBlockInFlowLineIterator it1(blockFrame, aFrame1, &isValid1); nsBlockInFlowLineIterator it2(blockFrame, aFrame2, &isValid2); return isValid1 && isValid2 && // Make sure aFrame1 and aFrame2 are in the same continuation of // blockFrame. it1.GetContainer() == it2.GetContainer() && // And on the same line in it it1.GetLine() == it2.GetLine(); } if (nsRubyTextContainerFrame* rtcFrame = do_QueryFrame(mLineContainer)) { nsBlockFrame* block = nsLayoutUtils::FindNearestBlockAncestor(rtcFrame); // Ruby text container can only hold one line of text, so if they // are in the same continuation, they are in the same line. Since // ruby text containers are bidi isolate, they are never split for // bidi reordering, which means being in different continuation // indicates being in different lines. for (nsIFrame* frame = rtcFrame->FirstContinuation(); frame; frame = frame->GetNextContinuation()) { bool isDescendant1 = nsLayoutUtils::IsProperAncestorFrame(frame, aFrame1, block); bool isDescendant2 = nsLayoutUtils::IsProperAncestorFrame(frame, aFrame2, block); if (isDescendant1 && isDescendant2) { return true; } if (isDescendant1 || isDescendant2) { return false; } } MOZ_ASSERT_UNREACHABLE("None of the frames is a descendant of this rtc?"); } MOZ_ASSERT_UNREACHABLE("Do we have any other type of line container?"); return false; } }; // A resolved color stop, with a specific position along the gradient line and // a color. struct ColorStop { ColorStop(): mPosition(0), mIsMidpoint(false) {} ColorStop(double aPosition, bool aIsMidPoint, const Color& aColor) : mPosition(aPosition), mIsMidpoint(aIsMidPoint), mColor(aColor) {} double mPosition; // along the gradient line; 0=start, 1=end bool mIsMidpoint; Color mColor; }; /* Local functions */ static DrawResult DrawBorderImage(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aBorderArea, const nsStyleBorder& aStyleBorder, const nsRect& aDirtyRect, Sides aSkipSides, PaintBorderFlags aFlags); static nscolor MakeBevelColor(mozilla::css::Side whichSide, uint8_t style, nscolor aBackgroundColor, nscolor aBorderColor); static InlineBackgroundData* gInlineBGData = nullptr; // Initialize any static variables used by nsCSSRendering. void nsCSSRendering::Init() { NS_ASSERTION(!gInlineBGData, "Init called twice"); gInlineBGData = new InlineBackgroundData(); } // Clean up any global variables used by nsCSSRendering. void nsCSSRendering::Shutdown() { delete gInlineBGData; gInlineBGData = nullptr; } /** * Make a bevel color */ static nscolor MakeBevelColor(mozilla::css::Side whichSide, uint8_t style, nscolor aBackgroundColor, nscolor aBorderColor) { nscolor colors[2]; nscolor theColor; // Given a background color and a border color // calculate the color used for the shading NS_GetSpecial3DColors(colors, aBackgroundColor, aBorderColor); if ((style == NS_STYLE_BORDER_STYLE_OUTSET) || (style == NS_STYLE_BORDER_STYLE_RIDGE)) { // Flip colors for these two border styles switch (whichSide) { case NS_SIDE_BOTTOM: whichSide = NS_SIDE_TOP; break; case NS_SIDE_RIGHT: whichSide = NS_SIDE_LEFT; break; case NS_SIDE_TOP: whichSide = NS_SIDE_BOTTOM; break; case NS_SIDE_LEFT: whichSide = NS_SIDE_RIGHT; break; } } switch (whichSide) { case NS_SIDE_BOTTOM: theColor = colors[1]; break; case NS_SIDE_RIGHT: theColor = colors[1]; break; case NS_SIDE_TOP: theColor = colors[0]; break; case NS_SIDE_LEFT: default: theColor = colors[0]; break; } return theColor; } static bool GetRadii(nsIFrame* aForFrame, const nsStyleBorder& aBorder, const nsRect& aOrigBorderArea, const nsRect& aBorderArea, nscoord aRadii[8]) { bool haveRoundedCorners; nsSize sz = aBorderArea.Size(); nsSize frameSize = aForFrame->GetSize(); if (&aBorder == aForFrame->StyleBorder() && frameSize == aOrigBorderArea.Size()) { haveRoundedCorners = aForFrame->GetBorderRadii(sz, sz, Sides(), aRadii); } else { haveRoundedCorners = nsIFrame::ComputeBorderRadii(aBorder.mBorderRadius, frameSize, sz, Sides(), aRadii); } return haveRoundedCorners; } static bool GetRadii(nsIFrame* aForFrame, const nsStyleBorder& aBorder, const nsRect& aOrigBorderArea, const nsRect& aBorderArea, RectCornerRadii* aBgRadii) { nscoord radii[8]; bool haveRoundedCorners = GetRadii(aForFrame, aBorder, aOrigBorderArea, aBorderArea, radii); if (haveRoundedCorners) { auto d2a = aForFrame->PresContext()->AppUnitsPerDevPixel(); nsCSSRendering::ComputePixelRadii(radii, d2a, aBgRadii); } return haveRoundedCorners; } static nsRect JoinBoxesForVerticalSlice(nsIFrame* aFrame, const nsRect& aBorderArea) { // Inflate vertically as if our continuations were laid out vertically // adjacent. Note that we don't touch the width. nsRect borderArea = aBorderArea; nscoord h = 0; nsIFrame* f = aFrame->GetNextContinuation(); for (; f; f = f->GetNextContinuation()) { MOZ_ASSERT(!(f->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT), "anonymous ib-split block shouldn't have border/background"); h += f->GetRect().height; } borderArea.height += h; h = 0; f = aFrame->GetPrevContinuation(); for (; f; f = f->GetPrevContinuation()) { MOZ_ASSERT(!(f->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT), "anonymous ib-split block shouldn't have border/background"); h += f->GetRect().height; } borderArea.y -= h; borderArea.height += h; return borderArea; } /** * Inflate aBorderArea which is relative to aFrame's origin to calculate * a hypothetical non-split frame area for all the continuations. * See "Joining Boxes for 'slice'" in * http://dev.w3.org/csswg/css-break/#break-decoration */ enum InlineBoxOrder { eForBorder, eForBackground }; static nsRect JoinBoxesForSlice(nsIFrame* aFrame, const nsRect& aBorderArea, InlineBoxOrder aOrder) { if (static_cast<nsInlineFrame*>(do_QueryFrame(aFrame))) { return (aOrder == eForBorder ? gInlineBGData->GetBorderContinuousRect(aFrame, aBorderArea) : gInlineBGData->GetContinuousRect(aFrame)) + aBorderArea.TopLeft(); } return JoinBoxesForVerticalSlice(aFrame, aBorderArea); } static bool IsBoxDecorationSlice(const nsStyleBorder& aStyleBorder) { return aStyleBorder.mBoxDecorationBreak == StyleBoxDecorationBreak::Slice; } static nsRect BoxDecorationRectForBorder(nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides, const nsStyleBorder* aStyleBorder = nullptr) { if (!aStyleBorder) { aStyleBorder = aFrame->StyleBorder(); } // If aSkipSides.IsEmpty() then there are no continuations, or it's // a ::first-letter that wants all border sides on the first continuation. return ::IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty() ? ::JoinBoxesForSlice(aFrame, aBorderArea, eForBorder) : aBorderArea; } static nsRect BoxDecorationRectForBackground(nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides, const nsStyleBorder* aStyleBorder = nullptr) { if (!aStyleBorder) { aStyleBorder = aFrame->StyleBorder(); } // If aSkipSides.IsEmpty() then there are no continuations, or it's // a ::first-letter that wants all border sides on the first continuation. return ::IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty() ? ::JoinBoxesForSlice(aFrame, aBorderArea, eForBackground) : aBorderArea; } //---------------------------------------------------------------------- // Thebes Border Rendering Code Start /* * Compute the float-pixel radii that should be used for drawing * this border/outline, given the various input bits. */ /* static */ void nsCSSRendering::ComputePixelRadii(const nscoord *aAppUnitsRadii, nscoord aAppUnitsPerPixel, RectCornerRadii *oBorderRadii) { Float radii[8]; NS_FOR_CSS_HALF_CORNERS(corner) radii[corner] = Float(aAppUnitsRadii[corner]) / aAppUnitsPerPixel; (*oBorderRadii)[C_TL] = Size(radii[NS_CORNER_TOP_LEFT_X], radii[NS_CORNER_TOP_LEFT_Y]); (*oBorderRadii)[C_TR] = Size(radii[NS_CORNER_TOP_RIGHT_X], radii[NS_CORNER_TOP_RIGHT_Y]); (*oBorderRadii)[C_BR] = Size(radii[NS_CORNER_BOTTOM_RIGHT_X], radii[NS_CORNER_BOTTOM_RIGHT_Y]); (*oBorderRadii)[C_BL] = Size(radii[NS_CORNER_BOTTOM_LEFT_X], radii[NS_CORNER_BOTTOM_LEFT_Y]); } DrawResult nsCSSRendering::PaintBorder(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, nsStyleContext* aStyleContext, PaintBorderFlags aFlags, Sides aSkipSides) { PROFILER_LABEL("nsCSSRendering", "PaintBorder", js::ProfileEntry::Category::GRAPHICS); nsStyleContext *styleIfVisited = aStyleContext->GetStyleIfVisited(); const nsStyleBorder *styleBorder = aStyleContext->StyleBorder(); // Don't check RelevantLinkVisited here, since we want to take the // same amount of time whether or not it's true. if (!styleIfVisited) { return PaintBorderWithStyleBorder(aPresContext, aRenderingContext, aForFrame, aDirtyRect, aBorderArea, *styleBorder, aStyleContext, aFlags, aSkipSides); } nsStyleBorder newStyleBorder(*styleBorder); NS_FOR_CSS_SIDES(side) { nscolor color = aStyleContext->GetVisitedDependentColor( nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_color)[side]); newStyleBorder.mBorderColor[side] = StyleComplexColor::FromColor(color); } DrawResult result = PaintBorderWithStyleBorder(aPresContext, aRenderingContext, aForFrame, aDirtyRect, aBorderArea, newStyleBorder, aStyleContext, aFlags, aSkipSides); return result; } DrawResult nsCSSRendering::PaintBorderWithStyleBorder(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleBorder& aStyleBorder, nsStyleContext* aStyleContext, PaintBorderFlags aFlags, Sides aSkipSides) { DrawTarget& aDrawTarget = *aRenderingContext.GetDrawTarget(); PrintAsStringNewline("++ PaintBorder"); // Check to see if we have an appearance defined. If so, we let the theme // renderer draw the border. DO not get the data from aForFrame, since the passed in style context // may be different! Always use |aStyleContext|! const nsStyleDisplay* displayData = aStyleContext->StyleDisplay(); if (displayData->mAppearance) { nsITheme *theme = aPresContext->GetTheme(); if (theme && theme->ThemeSupportsWidget(aPresContext, aForFrame, displayData->mAppearance)) { return DrawResult::SUCCESS; // Let the theme handle it. } } if (aStyleBorder.IsBorderImageLoaded()) { return DrawBorderImage(aPresContext, aRenderingContext, aForFrame, aBorderArea, aStyleBorder, aDirtyRect, aSkipSides, aFlags); } DrawResult result = DrawResult::SUCCESS; // If we had a border-image, but it wasn't loaded, then we should return // DrawResult::NOT_READY; we'll want to try again if we do a paint with sync // decoding enabled. if (aStyleBorder.mBorderImageSource.GetType() != eStyleImageType_Null) { result = DrawResult::NOT_READY; } // Get our style context's color struct. const nsStyleColor* ourColor = aStyleContext->StyleColor(); // In NavQuirks mode we want to use the parent's context as a starting point // for determining the background color. bool quirks = aPresContext->CompatibilityMode() == eCompatibility_NavQuirks; nsIFrame* bgFrame = FindNonTransparentBackgroundFrame(aForFrame, quirks); nsStyleContext* bgContext = bgFrame->StyleContext(); nscolor bgColor = bgContext->GetVisitedDependentColor(eCSSProperty_background_color); nsMargin border = aStyleBorder.GetComputedBorder(); if (0 == border.left && 0 == border.right && 0 == border.top && 0 == border.bottom) { // Empty border area return result; } // Compute the outermost boundary of the area that might be painted. // Same coordinate space as aBorderArea & aBGClipRect. nsRect joinedBorderArea = ::BoxDecorationRectForBorder(aForFrame, aBorderArea, aSkipSides, &aStyleBorder); RectCornerRadii bgRadii; ::GetRadii(aForFrame, aStyleBorder, aBorderArea, joinedBorderArea, &bgRadii); PrintAsFormatString(" joinedBorderArea: %d %d %d %d\n", joinedBorderArea.x, joinedBorderArea.y, joinedBorderArea.width, joinedBorderArea.height); // start drawing bool needToPopClip = false; if (::IsBoxDecorationSlice(aStyleBorder)) { if (joinedBorderArea.IsEqualEdges(aBorderArea)) { // No need for a clip, just skip the sides we don't want. border.ApplySkipSides(aSkipSides); } else { // We're drawing borders around the joined continuation boxes so we need // to clip that to the slice that we want for this frame. aDrawTarget.PushClipRect( NSRectToSnappedRect(aBorderArea, aForFrame->PresContext()->AppUnitsPerDevPixel(), aDrawTarget)); needToPopClip = true; } } else { MOZ_ASSERT(joinedBorderArea.IsEqualEdges(aBorderArea), "Should use aBorderArea for box-decoration-break:clone"); MOZ_ASSERT(aForFrame->GetSkipSides().IsEmpty() || IS_TRUE_OVERFLOW_CONTAINER(aForFrame), "Should not skip sides for box-decoration-break:clone except " "::first-letter/line continuations or other frame types that " "don't have borders but those shouldn't reach this point. " "Overflow containers do reach this point though."); border.ApplySkipSides(aSkipSides); } // Convert to dev pixels. nscoord twipsPerPixel = aPresContext->DevPixelsToAppUnits(1); Rect joinedBorderAreaPx = NSRectToRect(joinedBorderArea, twipsPerPixel); Float borderWidths[4] = { Float(border.top / twipsPerPixel), Float(border.right / twipsPerPixel), Float(border.bottom / twipsPerPixel), Float(border.left / twipsPerPixel) }; Rect dirtyRect = NSRectToRect(aDirtyRect, twipsPerPixel); uint8_t borderStyles[4]; nscolor borderColors[4]; nsBorderColors *compositeColors[4]; // pull out styles, colors, composite colors NS_FOR_CSS_SIDES (i) { borderStyles[i] = aStyleBorder.GetBorderStyle(i); borderColors[i] = ourColor->CalcComplexColor(aStyleBorder.mBorderColor[i]); aStyleBorder.GetCompositeColors(i, &compositeColors[i]); } PrintAsFormatString(" borderStyles: %d %d %d %d\n", borderStyles[0], borderStyles[1], borderStyles[2], borderStyles[3]); //PrintAsFormatString ("bgRadii: %f %f %f %f\n", bgRadii[0], bgRadii[1], bgRadii[2], bgRadii[3]); #if 0 // this will draw a transparent red backround underneath the border area ColorPattern color(ToDeviceColor(Color(1.f, 0.f, 0.f, 0.5f))); aDrawTarget.FillRect(joinedBorderAreaPx, color); #endif nsIDocument* document = nullptr; nsIContent* content = aForFrame->GetContent(); if (content) { document = content->OwnerDoc(); } nsCSSBorderRenderer br(aPresContext, document, &aDrawTarget, dirtyRect, joinedBorderAreaPx, borderStyles, borderWidths, bgRadii, borderColors, compositeColors, bgColor); br.DrawBorders(); if (needToPopClip) { aDrawTarget.PopClip(); } PrintAsStringNewline(); return result; } static nsRect GetOutlineInnerRect(nsIFrame* aFrame) { nsRect* savedOutlineInnerRect = aFrame->Properties().Get(nsIFrame::OutlineInnerRectProperty()); if (savedOutlineInnerRect) return *savedOutlineInnerRect; NS_NOTREACHED("we should have saved a frame property"); return nsRect(nsPoint(0, 0), aFrame->GetSize()); } void nsCSSRendering::PaintOutline(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, nsStyleContext* aStyleContext) { nscoord twipsRadii[8]; // Get our style context's color struct. const nsStyleOutline* ourOutline = aStyleContext->StyleOutline(); MOZ_ASSERT(ourOutline != NS_STYLE_BORDER_STYLE_NONE, "shouldn't have created nsDisplayOutline item"); uint8_t outlineStyle = ourOutline->mOutlineStyle; nscoord width = ourOutline->GetOutlineWidth(); if (width == 0 && outlineStyle != NS_STYLE_BORDER_STYLE_AUTO) { // Empty outline return; } nsIFrame* bgFrame = nsCSSRendering::FindNonTransparentBackgroundFrame (aForFrame, false); nsStyleContext* bgContext = bgFrame->StyleContext(); nscolor bgColor = bgContext->GetVisitedDependentColor(eCSSProperty_background_color); nsRect innerRect; if ( #ifdef MOZ_XUL aStyleContext->GetPseudoType() == CSSPseudoElementType::XULTree #else false #endif ) { innerRect = aBorderArea; } else { innerRect = GetOutlineInnerRect(aForFrame) + aBorderArea.TopLeft(); } nscoord offset = ourOutline->mOutlineOffset; innerRect.Inflate(offset, offset); // If the dirty rect is completely inside the border area (e.g., only the // content is being painted), then we can skip out now // XXX this isn't exactly true for rounded borders, where the inside curves may // encroach into the content area. A safer calculation would be to // shorten insideRect by the radius one each side before performing this test. if (innerRect.Contains(aDirtyRect)) return; nsRect outerRect = innerRect; outerRect.Inflate(width, width); // get the radius for our outline nsIFrame::ComputeBorderRadii(ourOutline->mOutlineRadius, aBorderArea.Size(), outerRect.Size(), Sides(), twipsRadii); // Get our conversion values nscoord twipsPerPixel = aPresContext->DevPixelsToAppUnits(1); // get the outer rectangles Rect oRect(NSRectToRect(outerRect, twipsPerPixel)); // convert the radii nsMargin outlineMargin(width, width, width, width); RectCornerRadii outlineRadii; ComputePixelRadii(twipsRadii, twipsPerPixel, &outlineRadii); if (outlineStyle == NS_STYLE_BORDER_STYLE_AUTO) { if (nsLayoutUtils::IsOutlineStyleAutoEnabled()) { nsITheme* theme = aPresContext->GetTheme(); if (theme && theme->ThemeSupportsWidget(aPresContext, aForFrame, NS_THEME_FOCUS_OUTLINE)) { theme->DrawWidgetBackground(&aRenderingContext, aForFrame, NS_THEME_FOCUS_OUTLINE, innerRect, aDirtyRect); return; } } if (width == 0) { return; // empty outline } // http://dev.w3.org/csswg/css-ui/#outline // "User agents may treat 'auto' as 'solid'." outlineStyle = NS_STYLE_BORDER_STYLE_SOLID; } uint8_t outlineStyles[4] = { outlineStyle, outlineStyle, outlineStyle, outlineStyle }; // This handles treating the initial color as 'currentColor'; if we // ever want 'invert' back we'll need to do a bit of work here too. nscolor outlineColor = aStyleContext->GetVisitedDependentColor(eCSSProperty_outline_color); nscolor outlineColors[4] = { outlineColor, outlineColor, outlineColor, outlineColor }; // convert the border widths Float outlineWidths[4] = { Float(width / twipsPerPixel), Float(width / twipsPerPixel), Float(width / twipsPerPixel), Float(width / twipsPerPixel) }; Rect dirtyRect = NSRectToRect(aDirtyRect, twipsPerPixel); nsIDocument* document = nullptr; nsIContent* content = aForFrame->GetContent(); if (content) { document = content->OwnerDoc(); } // start drawing nsCSSBorderRenderer br(aPresContext, document, aRenderingContext.GetDrawTarget(), dirtyRect, oRect, outlineStyles, outlineWidths, outlineRadii, outlineColors, nullptr, bgColor); br.DrawBorders(); PrintAsStringNewline(); } void nsCSSRendering::PaintFocus(nsPresContext* aPresContext, DrawTarget* aDrawTarget, const nsRect& aFocusRect, nscolor aColor) { nscoord oneCSSPixel = nsPresContext::CSSPixelsToAppUnits(1); nscoord oneDevPixel = aPresContext->DevPixelsToAppUnits(1); Rect focusRect(NSRectToRect(aFocusRect, oneDevPixel)); RectCornerRadii focusRadii; { nscoord twipsRadii[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; ComputePixelRadii(twipsRadii, oneDevPixel, &focusRadii); } Float focusWidths[4] = { Float(oneCSSPixel / oneDevPixel), Float(oneCSSPixel / oneDevPixel), Float(oneCSSPixel / oneDevPixel), Float(oneCSSPixel / oneDevPixel) }; uint8_t focusStyles[4] = { NS_STYLE_BORDER_STYLE_DOTTED, NS_STYLE_BORDER_STYLE_DOTTED, NS_STYLE_BORDER_STYLE_DOTTED, NS_STYLE_BORDER_STYLE_DOTTED }; nscolor focusColors[4] = { aColor, aColor, aColor, aColor }; // Because this renders a dotted border, the background color // should not be used. Therefore, we provide a value that will // be blatantly wrong if it ever does get used. (If this becomes // something that CSS can style, this function will then have access // to a style context and can use the same logic that PaintBorder // and PaintOutline do.) nsCSSBorderRenderer br(aPresContext, nullptr, aDrawTarget, focusRect, focusRect, focusStyles, focusWidths, focusRadii, focusColors, nullptr, NS_RGB(255, 0, 0)); br.DrawBorders(); PrintAsStringNewline(); } // Thebes Border Rendering Code End //---------------------------------------------------------------------- //---------------------------------------------------------------------- /** * Helper for ComputeObjectAnchorPoint; parameters are the same as for * that function, except they're for a single coordinate / a single size * dimension. (so, x/width vs. y/height) */ static void ComputeObjectAnchorCoord(const Position::Coord& aCoord, const nscoord aOriginBounds, const nscoord aImageSize, nscoord* aTopLeftCoord, nscoord* aAnchorPointCoord) { *aAnchorPointCoord = aCoord.mLength; *aTopLeftCoord = aCoord.mLength; if (aCoord.mHasPercent) { // Adjust aTopLeftCoord by the specified % of the extra space. nscoord extraSpace = aOriginBounds - aImageSize; *aTopLeftCoord += NSToCoordRound(aCoord.mPercent * extraSpace); // The anchor-point doesn't care about our image's size; just the size // of the region we're rendering into. *aAnchorPointCoord += NSToCoordRound(aCoord.mPercent * aOriginBounds); } } void nsImageRenderer::ComputeObjectAnchorPoint( const Position& aPos, const nsSize& aOriginBounds, const nsSize& aImageSize, nsPoint* aTopLeft, nsPoint* aAnchorPoint) { ComputeObjectAnchorCoord(aPos.mXPosition, aOriginBounds.width, aImageSize.width, &aTopLeft->x, &aAnchorPoint->x); ComputeObjectAnchorCoord(aPos.mYPosition, aOriginBounds.height, aImageSize.height, &aTopLeft->y, &aAnchorPoint->y); } nsIFrame* nsCSSRendering::FindNonTransparentBackgroundFrame(nsIFrame* aFrame, bool aStartAtParent /*= false*/) { NS_ASSERTION(aFrame, "Cannot find NonTransparentBackgroundFrame in a null frame"); nsIFrame* frame = nullptr; if (aStartAtParent) { frame = nsLayoutUtils::GetParentOrPlaceholderFor(aFrame); } if (!frame) { frame = aFrame; } while (frame) { // No need to call GetVisitedDependentColor because it always uses // this alpha component anyway. if (NS_GET_A(frame->StyleBackground()->mBackgroundColor) > 0) break; if (frame->IsThemed()) break; nsIFrame* parent = nsLayoutUtils::GetParentOrPlaceholderFor(frame); if (!parent) break; frame = parent; } return frame; } // Returns true if aFrame is a canvas frame. // We need to treat the viewport as canvas because, even though // it does not actually paint a background, we need to get the right // background style so we correctly detect transparent documents. bool nsCSSRendering::IsCanvasFrame(nsIFrame* aFrame) { nsIAtom* frameType = aFrame->GetType(); return frameType == nsGkAtoms::canvasFrame || frameType == nsGkAtoms::rootFrame || frameType == nsGkAtoms::pageContentFrame || frameType == nsGkAtoms::viewportFrame; } nsIFrame* nsCSSRendering::FindBackgroundStyleFrame(nsIFrame* aForFrame) { const nsStyleBackground* result = aForFrame->StyleBackground(); // Check if we need to do propagation from BODY rather than HTML. if (!result->IsTransparent()) { return aForFrame; } nsIContent* content = aForFrame->GetContent(); // The root element content can't be null. We wouldn't know what // frame to create for aFrame. // Use |OwnerDoc| so it works during destruction. if (!content) { return aForFrame; } nsIDocument* document = content->OwnerDoc(); dom::Element* bodyContent = document->GetBodyElement(); // We need to null check the body node (bug 118829) since // there are cases, thanks to the fix for bug 5569, where we // will reflow a document with no body. In particular, if a // SCRIPT element in the head blocks the parser and then has a // SCRIPT that does "document.location.href = 'foo'", then // nsParser::Terminate will call |DidBuildModel| methods // through to the content sink, which will call |StartLayout| // and thus |Initialize| on the pres shell. See bug 119351 // for the ugly details. if (!bodyContent) { return aForFrame; } nsIFrame *bodyFrame = bodyContent->GetPrimaryFrame(); if (!bodyFrame) { return aForFrame; } return nsLayoutUtils::GetStyleFrame(bodyFrame); } /** * |FindBackground| finds the correct style data to use to paint the * background. It is responsible for handling the following two * statements in section 14.2 of CSS2: * * The background of the box generated by the root element covers the * entire canvas. * * For HTML documents, however, we recommend that authors specify the * background for the BODY element rather than the HTML element. User * agents should observe the following precedence rules to fill in the * background: if the value of the 'background' property for the HTML * element is different from 'transparent' then use it, else use the * value of the 'background' property for the BODY element. If the * resulting value is 'transparent', the rendering is undefined. * * Thus, in our implementation, it is responsible for ensuring that: * + we paint the correct background on the |nsCanvasFrame|, * |nsRootBoxFrame|, or |nsPageFrame|, * + we don't paint the background on the root element, and * + we don't paint the background on the BODY element in *some* cases, * and for SGML-based HTML documents only. * * |FindBackground| returns true if a background should be painted, and * the resulting style context to use for the background information * will be filled in to |aBackground|. */ nsStyleContext* nsCSSRendering::FindRootFrameBackground(nsIFrame* aForFrame) { return FindBackgroundStyleFrame(aForFrame)->StyleContext(); } inline bool FindElementBackground(nsIFrame* aForFrame, nsIFrame* aRootElementFrame, nsStyleContext** aBackgroundSC) { if (aForFrame == aRootElementFrame) { // We must have propagated our background to the viewport or canvas. Abort. return false; } *aBackgroundSC = aForFrame->StyleContext(); // Return true unless the frame is for a BODY element whose background // was propagated to the viewport. nsIContent* content = aForFrame->GetContent(); if (!content || content->NodeInfo()->NameAtom() != nsGkAtoms::body) return true; // not frame for a "body" element // It could be a non-HTML "body" element but that's OK, we'd fail the // bodyContent check below if (aForFrame->StyleContext()->GetPseudo()) return true; // A pseudo-element frame. // We should only look at the <html> background if we're in an HTML document nsIDocument* document = content->OwnerDoc(); dom::Element* bodyContent = document->GetBodyElement(); if (bodyContent != content) return true; // this wasn't the background that was propagated // This can be called even when there's no root element yet, during frame // construction, via nsLayoutUtils::FrameHasTransparency and // nsContainerFrame::SyncFrameViewProperties. if (!aRootElementFrame) return true; const nsStyleBackground* htmlBG = aRootElementFrame->StyleBackground(); return !htmlBG->IsTransparent(); } bool nsCSSRendering::FindBackground(nsIFrame* aForFrame, nsStyleContext** aBackgroundSC) { nsIFrame* rootElementFrame = aForFrame->PresContext()->PresShell()->FrameConstructor()->GetRootElementStyleFrame(); if (IsCanvasFrame(aForFrame)) { *aBackgroundSC = FindCanvasBackground(aForFrame, rootElementFrame); return true; } else { return FindElementBackground(aForFrame, rootElementFrame, aBackgroundSC); } } void nsCSSRendering::BeginFrameTreesLocked() { ++gFrameTreeLockCount; } void nsCSSRendering::EndFrameTreesLocked() { NS_ASSERTION(gFrameTreeLockCount > 0, "Unbalanced EndFrameTreeLocked"); --gFrameTreeLockCount; if (gFrameTreeLockCount == 0) { gInlineBGData->Reset(); } } void nsCSSRendering::PaintBoxShadowOuter(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aFrameArea, const nsRect& aDirtyRect, float aOpacity) { DrawTarget& aDrawTarget = *aRenderingContext.GetDrawTarget(); nsCSSShadowArray* shadows = aForFrame->StyleEffects()->mBoxShadow; if (!shadows) return; bool hasBorderRadius; bool nativeTheme; // mutually exclusive with hasBorderRadius const nsStyleDisplay* styleDisplay = aForFrame->StyleDisplay(); nsITheme::Transparency transparency; if (aForFrame->IsThemed(styleDisplay, &transparency)) { // We don't respect border-radius for native-themed widgets hasBorderRadius = false; // For opaque (rectangular) theme widgets we can take the generic // border-box path with border-radius disabled. nativeTheme = transparency != nsITheme::eOpaque; } else { nativeTheme = false; hasBorderRadius = true; // we'll update this below } nsRect frameRect = nativeTheme ? aForFrame->GetVisualOverflowRectRelativeToSelf() + aFrameArea.TopLeft() : aFrameArea; Sides skipSides = aForFrame->GetSkipSides(); frameRect = ::BoxDecorationRectForBorder(aForFrame, frameRect, skipSides); // Get any border radius, since box-shadow must also have rounded corners if // the frame does. RectCornerRadii borderRadii; const nscoord twipsPerPixel = aPresContext->DevPixelsToAppUnits(1); if (hasBorderRadius) { nscoord twipsRadii[8]; NS_ASSERTION(aFrameArea.Size() == aForFrame->VisualBorderRectRelativeToSelf().Size(), "unexpected size"); nsSize sz = frameRect.Size(); hasBorderRadius = aForFrame->GetBorderRadii(sz, sz, Sides(), twipsRadii); if (hasBorderRadius) { ComputePixelRadii(twipsRadii, twipsPerPixel, &borderRadii); } } // We don't show anything that intersects with the frame we're blurring on. So tell the // blurrer not to do unnecessary work there. gfxRect skipGfxRect = ThebesRect(NSRectToRect(frameRect, twipsPerPixel)); skipGfxRect.Round(); bool useSkipGfxRect = true; if (nativeTheme) { // Optimize non-leaf native-themed frames by skipping computing pixels // in the padding-box. We assume the padding-box is going to be painted // opaquely for non-leaf frames. // XXX this may not be a safe assumption; we should make this go away // by optimizing box-shadow drawing more for the cases where we don't have a skip-rect. useSkipGfxRect = !aForFrame->IsLeaf(); nsRect paddingRect = aForFrame->GetPaddingRect() - aForFrame->GetPosition() + aFrameArea.TopLeft(); skipGfxRect = nsLayoutUtils::RectToGfxRect(paddingRect, twipsPerPixel); } else if (hasBorderRadius) { skipGfxRect.Deflate(gfxMargin( std::max(borderRadii[C_TL].height, borderRadii[C_TR].height), 0, std::max(borderRadii[C_BL].height, borderRadii[C_BR].height), 0)); } gfxContext* renderContext = aRenderingContext.ThebesContext(); for (uint32_t i = shadows->Length(); i > 0; --i) { nsCSSShadowItem* shadowItem = shadows->ShadowAt(i - 1); if (shadowItem->mInset) continue; nsRect shadowRect = frameRect; shadowRect.MoveBy(shadowItem->mXOffset, shadowItem->mYOffset); if (!nativeTheme) { shadowRect.Inflate(shadowItem->mSpread, shadowItem->mSpread); } // shadowRect won't include the blur, so make an extra rect here that includes the blur // for use in the even-odd rule below. nsRect shadowRectPlusBlur = shadowRect; nscoord blurRadius = shadowItem->mRadius; shadowRectPlusBlur.Inflate( nsContextBoxBlur::GetBlurRadiusMargin(blurRadius, twipsPerPixel)); Rect shadowGfxRectPlusBlur = NSRectToRect(shadowRectPlusBlur, twipsPerPixel); shadowGfxRectPlusBlur.RoundOut(); MaybeSnapToDevicePixels(shadowGfxRectPlusBlur, aDrawTarget, true); // Set the shadow color; if not specified, use the foreground color nscolor shadowColor; if (shadowItem->mHasColor) shadowColor = shadowItem->mColor; else shadowColor = aForFrame->StyleColor()->mColor; Color gfxShadowColor(Color::FromABGR(shadowColor)); gfxShadowColor.a *= aOpacity; if (nativeTheme) { nsContextBoxBlur blurringArea; // When getting the widget shape from the native theme, we're going // to draw the widget into the shadow surface to create a mask. // We need to ensure that there actually *is* a shadow surface // and that we're not going to draw directly into renderContext. gfxContext* shadowContext = blurringArea.Init(shadowRect, shadowItem->mSpread, blurRadius, twipsPerPixel, renderContext, aDirtyRect, useSkipGfxRect ? &skipGfxRect : nullptr, nsContextBoxBlur::FORCE_MASK); if (!shadowContext) continue; MOZ_ASSERT(shadowContext == blurringArea.GetContext()); renderContext->Save(); renderContext->SetColor(gfxShadowColor); // Draw the shape of the frame so it can be blurred. Recall how nsContextBoxBlur // doesn't make any temporary surfaces if blur is 0 and it just returns the original // surface? If we have no blur, we're painting this fill on the actual content surface // (renderContext == shadowContext) which is why we set up the color and clip // before doing this. // We don't clip the border-box from the shadow, nor any other box. // We assume that the native theme is going to paint over the shadow. // Draw the widget shape gfxContextMatrixAutoSaveRestore save(shadowContext); gfxPoint devPixelOffset = nsLayoutUtils::PointToGfxPoint(nsPoint(shadowItem->mXOffset, shadowItem->mYOffset), aPresContext->AppUnitsPerDevPixel()); shadowContext->SetMatrix( shadowContext->CurrentMatrix().Translate(devPixelOffset)); nsRect nativeRect = aDirtyRect; nativeRect.MoveBy(-nsPoint(shadowItem->mXOffset, shadowItem->mYOffset)); nativeRect.IntersectRect(frameRect, nativeRect); nsRenderingContext wrapperCtx(shadowContext); aPresContext->GetTheme()->DrawWidgetBackground(&wrapperCtx, aForFrame, styleDisplay->mAppearance, aFrameArea, nativeRect); blurringArea.DoPaint(); renderContext->Restore(); } else { renderContext->Save(); { Rect innerClipRect = NSRectToRect(frameRect, twipsPerPixel); if (!MaybeSnapToDevicePixels(innerClipRect, aDrawTarget, true)) { innerClipRect.Round(); } // Clip out the interior of the frame's border edge so that the shadow // is only painted outside that area. RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder(FillRule::FILL_EVEN_ODD); AppendRectToPath(builder, shadowGfxRectPlusBlur); if (hasBorderRadius) { AppendRoundedRectToPath(builder, innerClipRect, borderRadii); } else { AppendRectToPath(builder, innerClipRect); } RefPtr<Path> path = builder->Finish(); renderContext->Clip(path); } // Clip the shadow so that we only get the part that applies to aForFrame. nsRect fragmentClip = shadowRectPlusBlur; if (!skipSides.IsEmpty()) { if (skipSides.Left()) { nscoord xmost = fragmentClip.XMost(); fragmentClip.x = aFrameArea.x; fragmentClip.width = xmost - fragmentClip.x; } if (skipSides.Right()) { nscoord xmost = fragmentClip.XMost(); nscoord overflow = xmost - aFrameArea.XMost(); if (overflow > 0) { fragmentClip.width -= overflow; } } if (skipSides.Top()) { nscoord ymost = fragmentClip.YMost(); fragmentClip.y = aFrameArea.y; fragmentClip.height = ymost - fragmentClip.y; } if (skipSides.Bottom()) { nscoord ymost = fragmentClip.YMost(); nscoord overflow = ymost - aFrameArea.YMost(); if (overflow > 0) { fragmentClip.height -= overflow; } } } fragmentClip = fragmentClip.Intersect(aDirtyRect); renderContext-> Clip(NSRectToSnappedRect(fragmentClip, aForFrame->PresContext()->AppUnitsPerDevPixel(), aDrawTarget)); RectCornerRadii clipRectRadii; if (hasBorderRadius) { Float spreadDistance = shadowItem->mSpread / twipsPerPixel; Float borderSizes[4]; borderSizes[NS_SIDE_LEFT] = spreadDistance; borderSizes[NS_SIDE_TOP] = spreadDistance; borderSizes[NS_SIDE_RIGHT] = spreadDistance; borderSizes[NS_SIDE_BOTTOM] = spreadDistance; nsCSSBorderRenderer::ComputeOuterRadii(borderRadii, borderSizes, &clipRectRadii); } nsContextBoxBlur::BlurRectangle(renderContext, shadowRect, twipsPerPixel, hasBorderRadius ? &clipRectRadii : nullptr, blurRadius, gfxShadowColor, aDirtyRect, skipGfxRect); renderContext->Restore(); } } } void nsCSSRendering::PaintBoxShadowInner(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aFrameArea) { nsCSSShadowArray* shadows = aForFrame->StyleEffects()->mBoxShadow; if (!shadows) return; if (aForFrame->IsThemed() && aForFrame->GetContent() && !nsContentUtils::IsChromeDoc(aForFrame->GetContent()->GetUncomposedDoc())) { // There's no way of getting hold of a shape corresponding to a // "padding-box" for native-themed widgets, so just don't draw // inner box-shadows for them. But we allow chrome to paint inner // box shadows since chrome can be aware of the platform theme. return; } NS_ASSERTION(aForFrame->GetType() == nsGkAtoms::fieldSetFrame || aFrameArea.Size() == aForFrame->GetSize(), "unexpected size"); Sides skipSides = aForFrame->GetSkipSides(); nsRect frameRect = ::BoxDecorationRectForBorder(aForFrame, aFrameArea, skipSides); nsRect paddingRect = frameRect; nsMargin border = aForFrame->GetUsedBorder(); paddingRect.Deflate(border); // Get any border radius, since box-shadow must also have rounded corners // if the frame does. nscoord twipsRadii[8]; nsSize sz = frameRect.Size(); bool hasBorderRadius = aForFrame->GetBorderRadii(sz, sz, Sides(), twipsRadii); const nscoord twipsPerPixel = aPresContext->DevPixelsToAppUnits(1); RectCornerRadii innerRadii; if (hasBorderRadius) { RectCornerRadii borderRadii; ComputePixelRadii(twipsRadii, twipsPerPixel, &borderRadii); Float borderSizes[4] = { Float(border.top / twipsPerPixel), Float(border.right / twipsPerPixel), Float(border.bottom / twipsPerPixel), Float(border.left / twipsPerPixel) }; nsCSSBorderRenderer::ComputeInnerRadii(borderRadii, borderSizes, &innerRadii); } for (uint32_t i = shadows->Length(); i > 0; --i) { nsCSSShadowItem* shadowItem = shadows->ShadowAt(i - 1); if (!shadowItem->mInset) continue; // shadowPaintRect: the area to paint on the temp surface // shadowClipRect: the area on the temporary surface within shadowPaintRect // that we will NOT paint in nscoord blurRadius = shadowItem->mRadius; nsMargin blurMargin = nsContextBoxBlur::GetBlurRadiusMargin(blurRadius, twipsPerPixel); nsRect shadowPaintRect = paddingRect; shadowPaintRect.Inflate(blurMargin); Rect shadowPaintGfxRect = NSRectToRect(shadowPaintRect, twipsPerPixel); shadowPaintGfxRect.RoundOut(); // Round the spread radius to device pixels (by truncation). // This mostly matches what we do for borders, except that we don't round // up values between zero and one device pixels to one device pixel. // This way of rounding is symmetric around zero, which makes sense for // the spread radius. int32_t spreadDistance = shadowItem->mSpread / twipsPerPixel; nscoord spreadDistanceAppUnits = aPresContext->DevPixelsToAppUnits(spreadDistance); nsRect shadowClipRect = paddingRect; shadowClipRect.MoveBy(shadowItem->mXOffset, shadowItem->mYOffset); shadowClipRect.Deflate(spreadDistanceAppUnits, spreadDistanceAppUnits); Rect shadowClipGfxRect = NSRectToRect(shadowClipRect, twipsPerPixel); shadowClipGfxRect.Round(); RectCornerRadii clipRectRadii; if (hasBorderRadius) { // Calculate the radii the inner clipping rect will have Float borderSizes[4] = {0, 0, 0, 0}; // See PaintBoxShadowOuter and bug 514670 if (innerRadii[C_TL].width > 0 || innerRadii[C_BL].width > 0) { borderSizes[NS_SIDE_LEFT] = spreadDistance; } if (innerRadii[C_TL].height > 0 || innerRadii[C_TR].height > 0) { borderSizes[NS_SIDE_TOP] = spreadDistance; } if (innerRadii[C_TR].width > 0 || innerRadii[C_BR].width > 0) { borderSizes[NS_SIDE_RIGHT] = spreadDistance; } if (innerRadii[C_BL].height > 0 || innerRadii[C_BR].height > 0) { borderSizes[NS_SIDE_BOTTOM] = spreadDistance; } nsCSSBorderRenderer::ComputeInnerRadii(innerRadii, borderSizes, &clipRectRadii); } // Set the "skip rect" to the area within the frame that we don't paint in, // including after blurring. nsRect skipRect = shadowClipRect; skipRect.Deflate(blurMargin); gfxRect skipGfxRect = nsLayoutUtils::RectToGfxRect(skipRect, twipsPerPixel); if (hasBorderRadius) { skipGfxRect.Deflate(gfxMargin( std::max(clipRectRadii[C_TL].height, clipRectRadii[C_TR].height), 0, std::max(clipRectRadii[C_BL].height, clipRectRadii[C_BR].height), 0)); } // When there's a blur radius, gfxAlphaBoxBlur leaves the skiprect area // unchanged. And by construction the gfxSkipRect is not touched by the // rendered shadow (even after blurring), so those pixels must be completely // transparent in the shadow, so drawing them changes nothing. gfxContext* renderContext = aRenderingContext.ThebesContext(); DrawTarget* drawTarget = renderContext->GetDrawTarget(); nsContextBoxBlur blurringArea; // Clip the context to the area of the frame's padding rect, so no part of the // shadow is painted outside. Also cut out anything beyond where the inset shadow // will be. Rect shadowGfxRect = NSRectToRect(paddingRect, twipsPerPixel); shadowGfxRect.Round(); // Set the shadow color; if not specified, use the foreground color Color shadowColor = Color::FromABGR(shadowItem->mHasColor ? shadowItem->mColor : aForFrame->StyleColor()->mColor); renderContext->Save(); // This clips the outside border radius. // clipRectRadii is the border radius inside the inset shadow. if (hasBorderRadius) { RefPtr<Path> roundedRect = MakePathForRoundedRect(*drawTarget, shadowGfxRect, innerRadii); renderContext->Clip(roundedRect); } else { renderContext->Clip(shadowGfxRect); } nsContextBoxBlur insetBoxBlur; gfxRect destRect = nsLayoutUtils::RectToGfxRect(shadowPaintRect, twipsPerPixel); Point shadowOffset(shadowItem->mXOffset / twipsPerPixel, shadowItem->mYOffset / twipsPerPixel); insetBoxBlur.InsetBoxBlur(renderContext, ToRect(destRect), shadowClipGfxRect, shadowColor, blurRadius, spreadDistanceAppUnits, twipsPerPixel, hasBorderRadius, clipRectRadii, ToRect(skipGfxRect), shadowOffset); renderContext->Restore(); } } /* static */ nsCSSRendering::PaintBGParams nsCSSRendering::PaintBGParams::ForAllLayers(nsPresContext& aPresCtx, nsRenderingContext& aRenderingCtx, const nsRect& aDirtyRect, const nsRect& aBorderArea, nsIFrame *aFrame, uint32_t aPaintFlags) { MOZ_ASSERT(aFrame); PaintBGParams result(aPresCtx, aRenderingCtx, aDirtyRect, aBorderArea, aFrame, aPaintFlags, -1, CompositionOp::OP_OVER); return result; } /* static */ nsCSSRendering::PaintBGParams nsCSSRendering::PaintBGParams::ForSingleLayer(nsPresContext& aPresCtx, nsRenderingContext& aRenderingCtx, const nsRect& aDirtyRect, const nsRect& aBorderArea, nsIFrame *aFrame, uint32_t aPaintFlags, int32_t aLayer, CompositionOp aCompositionOp) { MOZ_ASSERT(aFrame && (aLayer != -1)); PaintBGParams result(aPresCtx, aRenderingCtx, aDirtyRect, aBorderArea, aFrame, aPaintFlags, aLayer, aCompositionOp); return result; } DrawResult nsCSSRendering::PaintBackground(const PaintBGParams& aParams) { PROFILER_LABEL("nsCSSRendering", "PaintBackground", js::ProfileEntry::Category::GRAPHICS); NS_PRECONDITION(aParams.frame, "Frame is expected to be provided to PaintBackground"); nsStyleContext *sc; if (!FindBackground(aParams.frame, &sc)) { // We don't want to bail out if moz-appearance is set on a root // node. If it has a parent content node, bail because it's not // a root, otherwise keep going in order to let the theme stuff // draw the background. The canvas really should be drawing the // bg, but there's no way to hook that up via css. if (!aParams.frame->StyleDisplay()->mAppearance) { return DrawResult::SUCCESS; } nsIContent* content = aParams.frame->GetContent(); if (!content || content->GetParent()) { return DrawResult::SUCCESS; } sc = aParams.frame->StyleContext(); } return PaintBackgroundWithSC(aParams, sc, *aParams.frame->StyleBorder()); } static bool IsOpaqueBorderEdge(const nsStyleBorder& aBorder, mozilla::css::Side aSide) { if (aBorder.GetComputedBorder().Side(aSide) == 0) return true; switch (aBorder.GetBorderStyle(aSide)) { case NS_STYLE_BORDER_STYLE_SOLID: case NS_STYLE_BORDER_STYLE_GROOVE: case NS_STYLE_BORDER_STYLE_RIDGE: case NS_STYLE_BORDER_STYLE_INSET: case NS_STYLE_BORDER_STYLE_OUTSET: break; default: return false; } // If we're using a border image, assume it's not fully opaque, // because we may not even have the image loaded at this point, and // even if we did, checking whether the relevant tile is fully // opaque would be too much work. if (aBorder.mBorderImageSource.GetType() != eStyleImageType_Null) return false; StyleComplexColor color = aBorder.mBorderColor[aSide]; // We don't know the foreground color here, so if it's being used // we must assume it might be transparent. if (!color.IsNumericColor()) { return false; } return NS_GET_A(color.mColor) == 255; } /** * Returns true if all border edges are either missing or opaque. */ static bool IsOpaqueBorder(const nsStyleBorder& aBorder) { if (aBorder.mBorderColors) return false; NS_FOR_CSS_SIDES(i) { if (!IsOpaqueBorderEdge(aBorder, i)) return false; } return true; } static inline void SetupDirtyRects(const nsRect& aBGClipArea, const nsRect& aCallerDirtyRect, nscoord aAppUnitsPerPixel, /* OUT: */ nsRect* aDirtyRect, gfxRect* aDirtyRectGfx) { aDirtyRect->IntersectRect(aBGClipArea, aCallerDirtyRect); // Compute the Thebes equivalent of the dirtyRect. *aDirtyRectGfx = nsLayoutUtils::RectToGfxRect(*aDirtyRect, aAppUnitsPerPixel); NS_WARNING_ASSERTION(aDirtyRect->IsEmpty() || !aDirtyRectGfx->IsEmpty(), "converted dirty rect should not be empty"); MOZ_ASSERT(!aDirtyRect->IsEmpty() || aDirtyRectGfx->IsEmpty(), "second should be empty if first is"); } /* static */ void nsCSSRendering::GetImageLayerClip(const nsStyleImageLayers::Layer& aLayer, nsIFrame* aForFrame, const nsStyleBorder& aBorder, const nsRect& aBorderArea, const nsRect& aCallerDirtyRect, bool aWillPaintBorder, nscoord aAppUnitsPerPixel, /* out */ ImageLayerClipState* aClipState) { // Compute the outermost boundary of the area that might be painted. // Same coordinate space as aBorderArea. Sides skipSides = aForFrame->GetSkipSides(); nsRect clipBorderArea = ::BoxDecorationRectForBorder(aForFrame, aBorderArea, skipSides, &aBorder); bool haveRoundedCorners = GetRadii(aForFrame, aBorder, aBorderArea, clipBorderArea, aClipState->mRadii); uint8_t backgroundClip = aLayer.mClip; bool isSolidBorder = aWillPaintBorder && IsOpaqueBorder(aBorder); if (isSolidBorder && backgroundClip == NS_STYLE_IMAGELAYER_CLIP_BORDER) { // If we have rounded corners, we need to inflate the background // drawing area a bit to avoid seams between the border and // background. backgroundClip = haveRoundedCorners ? NS_STYLE_IMAGELAYER_CLIP_MOZ_ALMOST_PADDING : NS_STYLE_IMAGELAYER_CLIP_PADDING; } aClipState->mBGClipArea = clipBorderArea; aClipState->mHasAdditionalBGClipArea = false; aClipState->mCustomClip = false; if (aForFrame->GetType() == nsGkAtoms::scrollFrame && NS_STYLE_IMAGELAYER_ATTACHMENT_LOCAL == aLayer.mAttachment) { // As of this writing, this is still in discussion in the CSS Working Group // http://lists.w3.org/Archives/Public/www-style/2013Jul/0250.html // The rectangle for 'background-clip' scrolls with the content, // but the background is also clipped at a non-scrolling 'padding-box' // like the content. (See below.) // Therefore, only 'content-box' makes a difference here. if (backgroundClip == NS_STYLE_IMAGELAYER_CLIP_CONTENT) { nsIScrollableFrame* scrollableFrame = do_QueryFrame(aForFrame); // Clip at a rectangle attached to the scrolled content. aClipState->mHasAdditionalBGClipArea = true; aClipState->mAdditionalBGClipArea = nsRect( aClipState->mBGClipArea.TopLeft() + scrollableFrame->GetScrolledFrame()->GetPosition() // For the dir=rtl case: + scrollableFrame->GetScrollRange().TopLeft(), scrollableFrame->GetScrolledRect().Size()); nsMargin padding = aForFrame->GetUsedPadding(); // padding-bottom is ignored on scrollable frames: // https://bugzilla.mozilla.org/show_bug.cgi?id=748518 padding.bottom = 0; padding.ApplySkipSides(skipSides); aClipState->mAdditionalBGClipArea.Deflate(padding); } // Also clip at a non-scrolling, rounded-corner 'padding-box', // same as the scrolled content because of the 'overflow' property. backgroundClip = NS_STYLE_IMAGELAYER_CLIP_PADDING; } if (backgroundClip != NS_STYLE_IMAGELAYER_CLIP_BORDER && backgroundClip != NS_STYLE_IMAGELAYER_CLIP_TEXT) { nsMargin border = aForFrame->GetUsedBorder(); if (backgroundClip == NS_STYLE_IMAGELAYER_CLIP_MOZ_ALMOST_PADDING) { // Reduce |border| by 1px (device pixels) on all sides, if // possible, so that we don't get antialiasing seams between the // background and border. border.top = std::max(0, border.top - aAppUnitsPerPixel); border.right = std::max(0, border.right - aAppUnitsPerPixel); border.bottom = std::max(0, border.bottom - aAppUnitsPerPixel); border.left = std::max(0, border.left - aAppUnitsPerPixel); } else if (backgroundClip != NS_STYLE_IMAGELAYER_CLIP_PADDING) { NS_ASSERTION(backgroundClip == NS_STYLE_IMAGELAYER_CLIP_CONTENT, "unexpected background-clip"); border += aForFrame->GetUsedPadding(); } border.ApplySkipSides(skipSides); aClipState->mBGClipArea.Deflate(border); if (haveRoundedCorners) { nsIFrame::InsetBorderRadii(aClipState->mRadii, border); } } if (haveRoundedCorners) { auto d2a = aForFrame->PresContext()->AppUnitsPerDevPixel(); nsCSSRendering::ComputePixelRadii(aClipState->mRadii, d2a, &aClipState->mClippedRadii); aClipState->mHasRoundedCorners = true; } else { aClipState->mHasRoundedCorners = false; } if (!haveRoundedCorners && aClipState->mHasAdditionalBGClipArea) { // Do the intersection here to account for the fast path(?) below. aClipState->mBGClipArea = aClipState->mBGClipArea.Intersect(aClipState->mAdditionalBGClipArea); aClipState->mHasAdditionalBGClipArea = false; } SetupDirtyRects(aClipState->mBGClipArea, aCallerDirtyRect, aAppUnitsPerPixel, &aClipState->mDirtyRect, &aClipState->mDirtyRectGfx); } static void SetupImageLayerClip(nsCSSRendering::ImageLayerClipState& aClipState, gfxContext *aCtx, nscoord aAppUnitsPerPixel, gfxContextAutoSaveRestore* aAutoSR) { if (aClipState.mDirtyRectGfx.IsEmpty()) { // Our caller won't draw anything under this condition, so no need // to set more up. return; } if (aClipState.mCustomClip) { // We don't support custom clips and rounded corners, arguably a bug, but // table painting seems to depend on it. return; } DrawTarget* drawTarget = aCtx->GetDrawTarget(); // If we have rounded corners, clip all subsequent drawing to the // rounded rectangle defined by bgArea and bgRadii (we don't know // whether the rounded corners intrude on the dirtyRect or not). // Do not do this if we have a caller-provided clip rect -- // as above with bgArea, arguably a bug, but table painting seems // to depend on it. if (aClipState.mHasAdditionalBGClipArea) { gfxRect bgAreaGfx = nsLayoutUtils::RectToGfxRect( aClipState.mAdditionalBGClipArea, aAppUnitsPerPixel); bgAreaGfx.Round(); bgAreaGfx.Condition(); aAutoSR->EnsureSaved(aCtx); aCtx->NewPath(); aCtx->Rectangle(bgAreaGfx, true); aCtx->Clip(); } if (aClipState.mHasRoundedCorners) { Rect bgAreaGfx = NSRectToRect(aClipState.mBGClipArea, aAppUnitsPerPixel); bgAreaGfx.Round(); if (bgAreaGfx.IsEmpty()) { // I think it's become possible to hit this since // http://hg.mozilla.org/mozilla-central/rev/50e934e4979b landed. NS_WARNING("converted background area should not be empty"); // Make our caller not do anything. aClipState.mDirtyRectGfx.SizeTo(gfxSize(0.0, 0.0)); return; } aAutoSR->EnsureSaved(aCtx); RefPtr<Path> roundedRect = MakePathForRoundedRect(*drawTarget, bgAreaGfx, aClipState.mClippedRadii); aCtx->Clip(roundedRect); } } static void DrawBackgroundColor(nsCSSRendering::ImageLayerClipState& aClipState, gfxContext *aCtx, nscoord aAppUnitsPerPixel) { if (aClipState.mDirtyRectGfx.IsEmpty()) { // Our caller won't draw anything under this condition, so no need // to set more up. return; } DrawTarget* drawTarget = aCtx->GetDrawTarget(); // We don't support custom clips and rounded corners, arguably a bug, but // table painting seems to depend on it. if (!aClipState.mHasRoundedCorners || aClipState.mCustomClip) { aCtx->NewPath(); aCtx->Rectangle(aClipState.mDirtyRectGfx, true); aCtx->Fill(); return; } Rect bgAreaGfx = NSRectToRect(aClipState.mBGClipArea, aAppUnitsPerPixel); bgAreaGfx.Round(); if (bgAreaGfx.IsEmpty()) { // I think it's become possible to hit this since // http://hg.mozilla.org/mozilla-central/rev/50e934e4979b landed. NS_WARNING("converted background area should not be empty"); // Make our caller not do anything. aClipState.mDirtyRectGfx.SizeTo(gfxSize(0.0, 0.0)); return; } aCtx->Save(); gfxRect dirty = ThebesRect(bgAreaGfx).Intersect(aClipState.mDirtyRectGfx); aCtx->NewPath(); aCtx->Rectangle(dirty, true); aCtx->Clip(); if (aClipState.mHasAdditionalBGClipArea) { gfxRect bgAdditionalAreaGfx = nsLayoutUtils::RectToGfxRect( aClipState.mAdditionalBGClipArea, aAppUnitsPerPixel); bgAdditionalAreaGfx.Round(); bgAdditionalAreaGfx.Condition(); aCtx->NewPath(); aCtx->Rectangle(bgAdditionalAreaGfx, true); aCtx->Clip(); } RefPtr<Path> roundedRect = MakePathForRoundedRect(*drawTarget, bgAreaGfx, aClipState.mClippedRadii); aCtx->SetPath(roundedRect); aCtx->Fill(); aCtx->Restore(); } nscolor nsCSSRendering::DetermineBackgroundColor(nsPresContext* aPresContext, nsStyleContext* aStyleContext, nsIFrame* aFrame, bool& aDrawBackgroundImage, bool& aDrawBackgroundColor) { aDrawBackgroundImage = true; aDrawBackgroundColor = true; const nsStyleVisibility* visibility = aStyleContext->StyleVisibility(); if (visibility->mColorAdjust != NS_STYLE_COLOR_ADJUST_EXACT && aFrame->HonorPrintBackgroundSettings()) { aDrawBackgroundImage = aPresContext->GetBackgroundImageDraw(); aDrawBackgroundColor = aPresContext->GetBackgroundColorDraw(); } const nsStyleBackground *bg = aStyleContext->StyleBackground(); nscolor bgColor; if (aDrawBackgroundColor) { bgColor = aStyleContext->GetVisitedDependentColor(eCSSProperty_background_color); if (NS_GET_A(bgColor) == 0) { aDrawBackgroundColor = false; } } else { // If GetBackgroundColorDraw() is false, we are still expected to // draw color in the background of any frame that's not completely // transparent, but we are expected to use white instead of whatever // color was specified. bgColor = NS_RGB(255, 255, 255); if (aDrawBackgroundImage || !bg->IsTransparent()) { aDrawBackgroundColor = true; } else { bgColor = NS_RGBA(0,0,0,0); } } // We can skip painting the background color if a background image is opaque. nsStyleImageLayers::Repeat repeat = bg->BottomLayer().mRepeat; bool xFullRepeat = repeat.mXRepeat == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || repeat.mXRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND; bool yFullRepeat = repeat.mYRepeat == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || repeat.mYRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND; if (aDrawBackgroundColor && xFullRepeat && yFullRepeat && bg->BottomLayer().mImage.IsOpaque() && bg->BottomLayer().mBlendMode == NS_STYLE_BLEND_NORMAL) { aDrawBackgroundColor = false; } return bgColor; } static gfxFloat ConvertGradientValueToPixels(const nsStyleCoord& aCoord, gfxFloat aFillLength, int32_t aAppUnitsPerPixel) { switch (aCoord.GetUnit()) { case eStyleUnit_Percent: return aCoord.GetPercentValue() * aFillLength; case eStyleUnit_Coord: return NSAppUnitsToFloatPixels(aCoord.GetCoordValue(), aAppUnitsPerPixel); case eStyleUnit_Calc: { const nsStyleCoord::Calc *calc = aCoord.GetCalcValue(); return calc->mPercent * aFillLength + NSAppUnitsToFloatPixels(calc->mLength, aAppUnitsPerPixel); } default: NS_WARNING("Unexpected coord unit"); return 0; } } // Given a box with size aBoxSize and origin (0,0), and an angle aAngle, // and a starting point for the gradient line aStart, find the endpoint of // the gradient line --- the intersection of the gradient line with a line // perpendicular to aAngle that passes through the farthest corner in the // direction aAngle. static gfxPoint ComputeGradientLineEndFromAngle(const gfxPoint& aStart, double aAngle, const gfxSize& aBoxSize) { double dx = cos(-aAngle); double dy = sin(-aAngle); gfxPoint farthestCorner(dx > 0 ? aBoxSize.width : 0, dy > 0 ? aBoxSize.height : 0); gfxPoint delta = farthestCorner - aStart; double u = delta.x*dy - delta.y*dx; return farthestCorner + gfxPoint(-u*dy, u*dx); } // Compute the start and end points of the gradient line for a linear gradient. static void ComputeLinearGradientLine(nsPresContext* aPresContext, nsStyleGradient* aGradient, const gfxSize& aBoxSize, gfxPoint* aLineStart, gfxPoint* aLineEnd) { if (aGradient->mBgPosX.GetUnit() == eStyleUnit_None) { double angle; if (aGradient->mAngle.IsAngleValue()) { angle = aGradient->mAngle.GetAngleValueInRadians(); if (!aGradient->mLegacySyntax) { angle = M_PI_2 - angle; } } else { angle = -M_PI_2; // defaults to vertical gradient starting from top } gfxPoint center(aBoxSize.width/2, aBoxSize.height/2); *aLineEnd = ComputeGradientLineEndFromAngle(center, angle, aBoxSize); *aLineStart = gfxPoint(aBoxSize.width, aBoxSize.height) - *aLineEnd; } else if (!aGradient->mLegacySyntax) { float xSign = aGradient->mBgPosX.GetPercentValue() * 2 - 1; float ySign = 1 - aGradient->mBgPosY.GetPercentValue() * 2; double angle = atan2(ySign * aBoxSize.width, xSign * aBoxSize.height); gfxPoint center(aBoxSize.width/2, aBoxSize.height/2); *aLineEnd = ComputeGradientLineEndFromAngle(center, angle, aBoxSize); *aLineStart = gfxPoint(aBoxSize.width, aBoxSize.height) - *aLineEnd; } else { int32_t appUnitsPerPixel = aPresContext->AppUnitsPerDevPixel(); *aLineStart = gfxPoint( ConvertGradientValueToPixels(aGradient->mBgPosX, aBoxSize.width, appUnitsPerPixel), ConvertGradientValueToPixels(aGradient->mBgPosY, aBoxSize.height, appUnitsPerPixel)); if (aGradient->mAngle.IsAngleValue()) { MOZ_ASSERT(aGradient->mLegacySyntax); double angle = aGradient->mAngle.GetAngleValueInRadians(); *aLineEnd = ComputeGradientLineEndFromAngle(*aLineStart, angle, aBoxSize); } else { // No angle, the line end is just the reflection of the start point // through the center of the box *aLineEnd = gfxPoint(aBoxSize.width, aBoxSize.height) - *aLineStart; } } } // Compute the start and end points of the gradient line for a radial gradient. // Also returns the horizontal and vertical radii defining the circle or // ellipse to use. static void ComputeRadialGradientLine(nsPresContext* aPresContext, nsStyleGradient* aGradient, const gfxSize& aBoxSize, gfxPoint* aLineStart, gfxPoint* aLineEnd, double* aRadiusX, double* aRadiusY) { if (aGradient->mBgPosX.GetUnit() == eStyleUnit_None) { // Default line start point is the center of the box *aLineStart = gfxPoint(aBoxSize.width/2, aBoxSize.height/2); } else { int32_t appUnitsPerPixel = aPresContext->AppUnitsPerDevPixel(); *aLineStart = gfxPoint( ConvertGradientValueToPixels(aGradient->mBgPosX, aBoxSize.width, appUnitsPerPixel), ConvertGradientValueToPixels(aGradient->mBgPosY, aBoxSize.height, appUnitsPerPixel)); } // Compute gradient shape: the x and y radii of an ellipse. double radiusX, radiusY; double leftDistance = Abs(aLineStart->x); double rightDistance = Abs(aBoxSize.width - aLineStart->x); double topDistance = Abs(aLineStart->y); double bottomDistance = Abs(aBoxSize.height - aLineStart->y); switch (aGradient->mSize) { case NS_STYLE_GRADIENT_SIZE_CLOSEST_SIDE: radiusX = std::min(leftDistance, rightDistance); radiusY = std::min(topDistance, bottomDistance); if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) { radiusX = radiusY = std::min(radiusX, radiusY); } break; case NS_STYLE_GRADIENT_SIZE_CLOSEST_CORNER: { // Compute x and y distances to nearest corner double offsetX = std::min(leftDistance, rightDistance); double offsetY = std::min(topDistance, bottomDistance); if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) { radiusX = radiusY = NS_hypot(offsetX, offsetY); } else { // maintain aspect ratio radiusX = offsetX*M_SQRT2; radiusY = offsetY*M_SQRT2; } break; } case NS_STYLE_GRADIENT_SIZE_FARTHEST_SIDE: radiusX = std::max(leftDistance, rightDistance); radiusY = std::max(topDistance, bottomDistance); if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) { radiusX = radiusY = std::max(radiusX, radiusY); } break; case NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER: { // Compute x and y distances to nearest corner double offsetX = std::max(leftDistance, rightDistance); double offsetY = std::max(topDistance, bottomDistance); if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) { radiusX = radiusY = NS_hypot(offsetX, offsetY); } else { // maintain aspect ratio radiusX = offsetX*M_SQRT2; radiusY = offsetY*M_SQRT2; } break; } case NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE: { int32_t appUnitsPerPixel = aPresContext->AppUnitsPerDevPixel(); radiusX = ConvertGradientValueToPixels(aGradient->mRadiusX, aBoxSize.width, appUnitsPerPixel); radiusY = ConvertGradientValueToPixels(aGradient->mRadiusY, aBoxSize.height, appUnitsPerPixel); break; } default: radiusX = radiusY = 0; MOZ_ASSERT(false, "unknown radial gradient sizing method"); } *aRadiusX = radiusX; *aRadiusY = radiusY; double angle; if (aGradient->mAngle.IsAngleValue()) { angle = aGradient->mAngle.GetAngleValueInRadians(); } else { // Default angle is 0deg angle = 0.0; } // The gradient line end point is where the gradient line intersects // the ellipse. *aLineEnd = *aLineStart + gfxPoint(radiusX*cos(-angle), radiusY*sin(-angle)); } // Returns aFrac*aC2 + (1 - aFrac)*C1. The interpolation is done // in RGBA color space, which is what SVG gradients and cairo // gradients expect. static Color InterpolateColor(const Color& aC1, const Color& aC2, float aFrac) { double other = 1 - aFrac; return Color(aC2.r*aFrac + aC1.r*other, aC2.g*aFrac + aC1.g*other, aC2.b*aFrac + aC1.b*other, aC2.a*aFrac + aC1.a*other); } static nscoord FindTileStart(nscoord aDirtyCoord, nscoord aTilePos, nscoord aTileDim) { NS_ASSERTION(aTileDim > 0, "Non-positive tile dimension"); double multiples = floor(double(aDirtyCoord - aTilePos)/aTileDim); return NSToCoordRound(multiples*aTileDim + aTilePos); } static gfxFloat LinearGradientStopPositionForPoint(const gfxPoint& aGradientStart, const gfxPoint& aGradientEnd, const gfxPoint& aPoint) { gfxPoint d = aGradientEnd - aGradientStart; gfxPoint p = aPoint - aGradientStart; /** * Compute a parameter t such that a line perpendicular to the * d vector, passing through aGradientStart + d*t, also * passes through aPoint. * * t is given by * (p.x - d.x*t)*d.x + (p.y - d.y*t)*d.y = 0 * * Solving for t we get * numerator = d.x*p.x + d.y*p.y * denominator = d.x^2 + d.y^2 * t = numerator/denominator * * In nsCSSRendering::PaintGradient we know the length of d * is not zero. */ double numerator = d.x * p.x + d.y * p.y; double denominator = d.x * d.x + d.y * d.y; return numerator / denominator; } static bool RectIsBeyondLinearGradientEdge(const gfxRect& aRect, const gfxMatrix& aPatternMatrix, const nsTArray<ColorStop>& aStops, const gfxPoint& aGradientStart, const gfxPoint& aGradientEnd, Color* aOutEdgeColor) { gfxFloat topLeft = LinearGradientStopPositionForPoint( aGradientStart, aGradientEnd, aPatternMatrix.Transform(aRect.TopLeft())); gfxFloat topRight = LinearGradientStopPositionForPoint( aGradientStart, aGradientEnd, aPatternMatrix.Transform(aRect.TopRight())); gfxFloat bottomLeft = LinearGradientStopPositionForPoint( aGradientStart, aGradientEnd, aPatternMatrix.Transform(aRect.BottomLeft())); gfxFloat bottomRight = LinearGradientStopPositionForPoint( aGradientStart, aGradientEnd, aPatternMatrix.Transform(aRect.BottomRight())); const ColorStop& firstStop = aStops[0]; if (topLeft < firstStop.mPosition && topRight < firstStop.mPosition && bottomLeft < firstStop.mPosition && bottomRight < firstStop.mPosition) { *aOutEdgeColor = firstStop.mColor; return true; } const ColorStop& lastStop = aStops.LastElement(); if (topLeft >= lastStop.mPosition && topRight >= lastStop.mPosition && bottomLeft >= lastStop.mPosition && bottomRight >= lastStop.mPosition) { *aOutEdgeColor = lastStop.mColor; return true; } return false; } static void ResolveMidpoints(nsTArray<ColorStop>& stops) { for (size_t x = 1; x < stops.Length() - 1;) { if (!stops[x].mIsMidpoint) { x++; continue; } Color color1 = stops[x-1].mColor; Color color2 = stops[x+1].mColor; float offset1 = stops[x-1].mPosition; float offset2 = stops[x+1].mPosition; float offset = stops[x].mPosition; // check if everything coincides. If so, ignore the midpoint. if (offset - offset1 == offset2 - offset) { stops.RemoveElementAt(x); continue; } // Check if we coincide with the left colorstop. if (offset1 == offset) { // Morph the midpoint to a regular stop with the color of the next // color stop. stops[x].mColor = color2; stops[x].mIsMidpoint = false; continue; } // Check if we coincide with the right colorstop. if (offset2 == offset) { // Morph the midpoint to a regular stop with the color of the previous // color stop. stops[x].mColor = color1; stops[x].mIsMidpoint = false; continue; } float midpoint = (offset - offset1) / (offset2 - offset1); ColorStop newStops[9]; if (midpoint > .5f) { for (size_t y = 0; y < 7; y++) { newStops[y].mPosition = offset1 + (offset - offset1) * (7 + y) / 13; } newStops[7].mPosition = offset + (offset2 - offset) / 3; newStops[8].mPosition = offset + (offset2 - offset) * 2 / 3; } else { newStops[0].mPosition = offset1 + (offset - offset1) / 3; newStops[1].mPosition = offset1 + (offset - offset1) * 2 / 3; for (size_t y = 0; y < 7; y++) { newStops[y+2].mPosition = offset + (offset2 - offset) * y / 13; } } // calculate colors for (size_t y = 0; y < 9; y++) { // Calculate the intermediate color stops per the formula of the CSS images // spec. http://dev.w3.org/csswg/css-images/#color-stop-syntax // 9 points were chosen since it is the minimum number of stops that always // give the smoothest appearace regardless of midpoint position and difference // in luminance of the end points. float relativeOffset = (newStops[y].mPosition - offset1) / (offset2 - offset1); float multiplier = powf(relativeOffset, logf(.5f) / logf(midpoint)); gfx::Float red = color1.r + multiplier * (color2.r - color1.r); gfx::Float green = color1.g + multiplier * (color2.g - color1.g); gfx::Float blue = color1.b + multiplier * (color2.b - color1.b); gfx::Float alpha = color1.a + multiplier * (color2.a - color1.a); newStops[y].mColor = Color(red, green, blue, alpha); } stops.ReplaceElementsAt(x, 1, newStops, 9); x += 9; } } static ColorStop InterpolateColorStop(const ColorStop& aFirst, const ColorStop& aSecond, double aPosition, const Color& aDefault) { MOZ_ASSERT(aFirst.mPosition <= aPosition); MOZ_ASSERT(aPosition <= aSecond.mPosition); double delta = aSecond.mPosition - aFirst.mPosition; if (delta < 1e-6) { return ColorStop(aPosition, false, aDefault); } return ColorStop(aPosition, false, InterpolateColor(aFirst.mColor, aSecond.mColor, (aPosition - aFirst.mPosition) / delta)); } // Clamp and extend the given ColorStop array in-place to fit exactly into the // range [0, 1]. static void ClampColorStops(nsTArray<ColorStop>& aStops) { MOZ_ASSERT(aStops.Length() > 0); // If all stops are outside the range, then get rid of everything and replace // with a single colour. if (aStops.Length() < 2 || aStops[0].mPosition > 1 || aStops.LastElement().mPosition < 0) { Color c = aStops[0].mPosition > 1 ? aStops[0].mColor : aStops.LastElement().mColor; aStops.Clear(); aStops.AppendElement(ColorStop(0, false, c)); return; } // Create the 0 and 1 points if they fall in the range of |aStops|, and discard // all stops outside the range [0, 1]. // XXX: If we have stops positioned at 0 or 1, we only keep the innermost of // those stops. This should be fine for the current user(s) of this function. for (size_t i = aStops.Length() - 1; i > 0; i--) { if (aStops[i - 1].mPosition < 1 && aStops[i].mPosition >= 1) { // Add a point to position 1. aStops[i] = InterpolateColorStop(aStops[i - 1], aStops[i], /* aPosition = */ 1, aStops[i - 1].mColor); // Remove all the elements whose position is greater than 1. aStops.RemoveElementsAt(i + 1, aStops.Length() - (i + 1)); } if (aStops[i - 1].mPosition <= 0 && aStops[i].mPosition > 0) { // Add a point to position 0. aStops[i - 1] = InterpolateColorStop(aStops[i - 1], aStops[i], /* aPosition = */ 0, aStops[i].mColor); // Remove all of the preceding stops -- they are all negative. aStops.RemoveElementsAt(0, i - 1); break; } } MOZ_ASSERT(aStops[0].mPosition >= -1e6); MOZ_ASSERT(aStops.LastElement().mPosition - 1 <= 1e6); // The end points won't exist yet if they don't fall in the original range of // |aStops|. Create them if needed. if (aStops[0].mPosition > 0) { aStops.InsertElementAt(0, ColorStop(0, false, aStops[0].mColor)); } if (aStops.LastElement().mPosition < 1) { aStops.AppendElement(ColorStop(1, false, aStops.LastElement().mColor)); } } void nsCSSRendering::PaintGradient(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsStyleGradient* aGradient, const nsRect& aDirtyRect, const nsRect& aDest, const nsRect& aFillArea, const nsSize& aRepeatSize, const CSSIntRect& aSrc, const nsSize& aIntrinsicSize) { PROFILER_LABEL("nsCSSRendering", "PaintGradient", js::ProfileEntry::Category::GRAPHICS); Telemetry::AutoTimer<Telemetry::GRADIENT_DURATION, Telemetry::Microsecond> gradientTimer; if (aDest.IsEmpty() || aFillArea.IsEmpty()) { return; } gfxContext *ctx = aRenderingContext.ThebesContext(); nscoord appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel(); gfxSize srcSize = gfxSize(gfxFloat(aIntrinsicSize.width)/appUnitsPerDevPixel, gfxFloat(aIntrinsicSize.height)/appUnitsPerDevPixel); bool cellContainsFill = aDest.Contains(aFillArea); // Compute "gradient line" start and end relative to the intrinsic size of // the gradient. gfxPoint lineStart, lineEnd; double radiusX = 0, radiusY = 0; // for radial gradients only if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR) { ComputeLinearGradientLine(aPresContext, aGradient, srcSize, &lineStart, &lineEnd); } else { ComputeRadialGradientLine(aPresContext, aGradient, srcSize, &lineStart, &lineEnd, &radiusX, &radiusY); } // Avoid sending Infs or Nans to downwind draw targets. if (!lineStart.IsFinite() || !lineEnd.IsFinite()) { lineStart = lineEnd = gfxPoint(0, 0); } gfxFloat lineLength = NS_hypot(lineEnd.x - lineStart.x, lineEnd.y - lineStart.y); MOZ_ASSERT(aGradient->mStops.Length() >= 2, "The parser should reject gradients with less than two stops"); // Build color stop array and compute stop positions nsTArray<ColorStop> stops; // If there is a run of stops before stop i that did not have specified // positions, then this is the index of the first stop in that run, otherwise // it's -1. int32_t firstUnsetPosition = -1; for (uint32_t i = 0; i < aGradient->mStops.Length(); ++i) { const nsStyleGradientStop& stop = aGradient->mStops[i]; double position; switch (stop.mLocation.GetUnit()) { case eStyleUnit_None: if (i == 0) { // First stop defaults to position 0.0 position = 0.0; } else if (i == aGradient->mStops.Length() - 1) { // Last stop defaults to position 1.0 position = 1.0; } else { // Other stops with no specified position get their position assigned // later by interpolation, see below. // Remeber where the run of stops with no specified position starts, // if it starts here. if (firstUnsetPosition < 0) { firstUnsetPosition = i; } stops.AppendElement(ColorStop(0, stop.mIsInterpolationHint, Color::FromABGR(stop.mColor))); continue; } break; case eStyleUnit_Percent: position = stop.mLocation.GetPercentValue(); break; case eStyleUnit_Coord: position = lineLength < 1e-6 ? 0.0 : stop.mLocation.GetCoordValue() / appUnitsPerDevPixel / lineLength; break; case eStyleUnit_Calc: nsStyleCoord::Calc *calc; calc = stop.mLocation.GetCalcValue(); position = calc->mPercent + ((lineLength < 1e-6) ? 0.0 : (NSAppUnitsToFloatPixels(calc->mLength, appUnitsPerDevPixel) / lineLength)); break; default: MOZ_ASSERT(false, "Unknown stop position type"); } if (i > 0) { // Prevent decreasing stop positions by advancing this position // to the previous stop position, if necessary position = std::max(position, stops[i - 1].mPosition); } stops.AppendElement(ColorStop(position, stop.mIsInterpolationHint, Color::FromABGR(stop.mColor))); if (firstUnsetPosition > 0) { // Interpolate positions for all stops that didn't have a specified position double p = stops[firstUnsetPosition - 1].mPosition; double d = (stops[i].mPosition - p)/(i - firstUnsetPosition + 1); for (uint32_t j = firstUnsetPosition; j < i; ++j) { p += d; stops[j].mPosition = p; } firstUnsetPosition = -1; } } // If a non-repeating linear gradient is axis-aligned and there are no gaps // between tiles, we can optimise away most of the work by converting to a // repeating linear gradient and filling the whole destination rect at once. bool forceRepeatToCoverTiles = aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR && (lineStart.x == lineEnd.x) != (lineStart.y == lineEnd.y) && aRepeatSize.width == aDest.width && aRepeatSize.height == aDest.height && !aGradient->mRepeating && !aSrc.IsEmpty() && !cellContainsFill; gfxMatrix matrix; if (forceRepeatToCoverTiles) { // Length of the source rectangle along the gradient axis. double rectLen; // The position of the start of the rectangle along the gradient. double offset; // The gradient line is "backwards". Flip the line upside down to make // things easier, and then rotate the matrix to turn everything back the // right way up. if (lineStart.x > lineEnd.x || lineStart.y > lineEnd.y) { std::swap(lineStart, lineEnd); matrix.Scale(-1, -1); } // Fit the gradient line exactly into the source rect. // aSrc is relative to aIntrinsincSize. // srcRectDev will be relative to srcSize, so in the same coordinate space // as lineStart / lineEnd. gfxRect srcRectDev = nsLayoutUtils::RectToGfxRect( CSSPixel::ToAppUnits(aSrc), appUnitsPerDevPixel); if (lineStart.x != lineEnd.x) { rectLen = srcRectDev.width; offset = (srcRectDev.x - lineStart.x) / lineLength; lineStart.x = srcRectDev.x; lineEnd.x = srcRectDev.XMost(); } else { rectLen = srcRectDev.height; offset = (srcRectDev.y - lineStart.y) / lineLength; lineStart.y = srcRectDev.y; lineEnd.y = srcRectDev.YMost(); } // Adjust gradient stop positions for the new gradient line. double scale = lineLength / rectLen; for (size_t i = 0; i < stops.Length(); i++) { stops[i].mPosition = (stops[i].mPosition - offset) * fabs(scale); } // Clamp or extrapolate gradient stops to exactly [0, 1]. ClampColorStops(stops); lineLength = rectLen; } // Special case for 'transparent' for (uint32_t i = 0; i < stops.Length(); ++i) { Color color = stops[i].mColor; if (color.r == 0 && color.g == 0 && color.b == 0 && color.a == 0) { // We have (0,0,0,0) as a color stop - this means 'transparent'. // In this case for the usually intended effect, we change the color // of the transparent stop to the color of the adjacent stop with // 0 opacity. If we are not on either edge, we add a stop on both // sides of the transparent point with the adjacent color value. // i.e.: c1 -> c1 (alpha 0) | c2 (alpha 0) -> c2 // XXX: We should probably track the use of the transparent keyword // down from the CSS parsing level to here with a flag in mStops, if // rgba(0,0,0,0) ever is an intended thing (very much a corner case). if (i > 0) { // Change stop color to adjacent-previous (color->T) color = stops[i - 1].mColor; color.a = 0; stops[i].mColor = color; if (i < stops.Length() - 1) { // We're in the middle somewhere: insert stop adjacent-next (T->color) Color color2 = stops[i + 1].mColor; color2.a = 0; if (color != color2) { // Only insert an extra stop if c1 is different than c2 in c1->T->c2 // Note: A transparent stop is never considered an interpolation hint stops.InsertElementAt(i + 1, ColorStop(stops[i].mPosition, false, color2)); i++; } } } else if (i < stops.Length() - 1) { // Change stop color to adjacent-next (T->color) color = stops[i + 1].mColor; color.a = 0; stops[i].mColor = color; } } } // Eliminate negative-position stops if the gradient is radial. double firstStop = stops[0].mPosition; if (aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR && firstStop < 0.0) { if (aGradient->mRepeating) { // Choose an instance of the repeated pattern that gives us all positive // stop-offsets. double lastStop = stops[stops.Length() - 1].mPosition; double stopDelta = lastStop - firstStop; // If all the stops are in approximately the same place then logic below // will kick in that makes us draw just the last stop color, so don't // try to do anything in that case. We certainly need to avoid // dividing by zero. if (stopDelta >= 1e-6) { double instanceCount = ceil(-firstStop/stopDelta); // Advance stops by instanceCount multiples of the period of the // repeating gradient. double offset = instanceCount*stopDelta; for (uint32_t i = 0; i < stops.Length(); i++) { stops[i].mPosition += offset; } } } else { // Move negative-position stops to position 0.0. We may also need // to set the color of the stop to the color the gradient should have // at the center of the ellipse. for (uint32_t i = 0; i < stops.Length(); i++) { double pos = stops[i].mPosition; if (pos < 0.0) { stops[i].mPosition = 0.0; // If this is the last stop, we don't need to adjust the color, // it will fill the entire area. if (i < stops.Length() - 1) { double nextPos = stops[i + 1].mPosition; // If nextPos is approximately equal to pos, then we don't // need to adjust the color of this stop because it's // not going to be displayed. // If nextPos is negative, we don't need to adjust the color of // this stop since it's not going to be displayed because // nextPos will also be moved to 0.0. if (nextPos >= 0.0 && nextPos - pos >= 1e-6) { // Compute how far the new position 0.0 is along the interval // between pos and nextPos. // XXX Color interpolation (in cairo, too) should use the // CSS 'color-interpolation' property! float frac = float((0.0 - pos)/(nextPos - pos)); stops[i].mColor = InterpolateColor(stops[i].mColor, stops[i + 1].mColor, frac); } } } } } firstStop = stops[0].mPosition; MOZ_ASSERT(firstStop >= 0.0, "Failed to fix stop offsets"); } if (aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR && !aGradient->mRepeating) { // Direct2D can only handle a particular class of radial gradients because // of the way the it specifies gradients. Setting firstStop to 0, when we // can, will help us stay on the fast path. Currently we don't do this // for repeating gradients but we could by adjusting the stop collection // to start at 0 firstStop = 0; } double lastStop = stops[stops.Length() - 1].mPosition; // Cairo gradients must have stop positions in the range [0, 1]. So, // stop positions will be normalized below by subtracting firstStop and then // multiplying by stopScale. double stopScale; double stopOrigin = firstStop; double stopEnd = lastStop; double stopDelta = lastStop - firstStop; bool zeroRadius = aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR && (radiusX < 1e-6 || radiusY < 1e-6); if (stopDelta < 1e-6 || lineLength < 1e-6 || zeroRadius) { // Stops are all at the same place. Map all stops to 0.0. // For repeating radial gradients, or for any radial gradients with // a zero radius, we need to fill with the last stop color, so just set // both radii to 0. if (aGradient->mRepeating || zeroRadius) { radiusX = radiusY = 0.0; } stopDelta = 0.0; lastStop = firstStop; } // Don't normalize non-repeating or degenerate gradients below 0..1 // This keeps the gradient line as large as the box and doesn't // lets us avoiding having to get padding correct for stops // at 0 and 1 if (!aGradient->mRepeating || stopDelta == 0.0) { stopOrigin = std::min(stopOrigin, 0.0); stopEnd = std::max(stopEnd, 1.0); } stopScale = 1.0/(stopEnd - stopOrigin); // Create the gradient pattern. RefPtr<gfxPattern> gradientPattern; gfxPoint gradientStart; gfxPoint gradientEnd; if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR) { // Compute the actual gradient line ends we need to pass to cairo after // stops have been normalized. gradientStart = lineStart + (lineEnd - lineStart)*stopOrigin; gradientEnd = lineStart + (lineEnd - lineStart)*stopEnd; gfxPoint gradientStopStart = lineStart + (lineEnd - lineStart)*firstStop; gfxPoint gradientStopEnd = lineStart + (lineEnd - lineStart)*lastStop; if (stopDelta == 0.0) { // Stops are all at the same place. For repeating gradients, this will // just paint the last stop color. We don't need to do anything. // For non-repeating gradients, this should render as two colors, one // on each "side" of the gradient line segment, which is a point. All // our stops will be at 0.0; we just need to set the direction vector // correctly. gradientEnd = gradientStart + (lineEnd - lineStart); gradientStopEnd = gradientStopStart + (lineEnd - lineStart); } gradientPattern = new gfxPattern(gradientStart.x, gradientStart.y, gradientEnd.x, gradientEnd.y); } else { NS_ASSERTION(firstStop >= 0.0, "Negative stops not allowed for radial gradients"); // To form an ellipse, we'll stretch a circle vertically, if necessary. // So our radii are based on radiusX. double innerRadius = radiusX*stopOrigin; double outerRadius = radiusX*stopEnd; if (stopDelta == 0.0) { // Stops are all at the same place. See above (except we now have // the inside vs. outside of an ellipse). outerRadius = innerRadius + 1; } gradientPattern = new gfxPattern(lineStart.x, lineStart.y, innerRadius, lineStart.x, lineStart.y, outerRadius); if (radiusX != radiusY) { // Stretch the circles into ellipses vertically by setting a transform // in the pattern. // Recall that this is the transform from user space to pattern space. // So to stretch the ellipse by factor of P vertically, we scale // user coordinates by 1/P. matrix.Translate(lineStart); matrix.Scale(1.0, radiusX/radiusY); matrix.Translate(-lineStart); } } // Use a pattern transform to take account of source and dest rects matrix.Translate(gfxPoint(aPresContext->CSSPixelsToDevPixels(aSrc.x), aPresContext->CSSPixelsToDevPixels(aSrc.y))); matrix.Scale(gfxFloat(aPresContext->CSSPixelsToAppUnits(aSrc.width))/aDest.width, gfxFloat(aPresContext->CSSPixelsToAppUnits(aSrc.height))/aDest.height); gradientPattern->SetMatrix(matrix); if (gradientPattern->CairoStatus()) return; if (stopDelta == 0.0) { // Non-repeating gradient with all stops in same place -> just add // first stop and last stop, both at position 0. // Repeating gradient with all stops in the same place, or radial // gradient with radius of 0 -> just paint the last stop color. // We use firstStop offset to keep |stops| with same units (will later normalize to 0). Color firstColor(stops[0].mColor); Color lastColor(stops.LastElement().mColor); stops.Clear(); if (!aGradient->mRepeating && !zeroRadius) { stops.AppendElement(ColorStop(firstStop, false, firstColor)); } stops.AppendElement(ColorStop(firstStop, false, lastColor)); } ResolveMidpoints(stops); bool isRepeat = aGradient->mRepeating || forceRepeatToCoverTiles; // Now set normalized color stops in pattern. // Offscreen gradient surface cache (not a tile): // On some backends (e.g. D2D), the GradientStops object holds an offscreen surface // which is a lookup table used to evaluate the gradient. This surface can use // much memory (ram and/or GPU ram) and can be expensive to create. So we cache it. // The cache key correlates 1:1 with the arguments for CreateGradientStops (also the implied backend type) // Note that GradientStop is a simple struct with a stop value (while GradientStops has the surface). nsTArray<gfx::GradientStop> rawStops(stops.Length()); rawStops.SetLength(stops.Length()); for(uint32_t i = 0; i < stops.Length(); i++) { rawStops[i].color = stops[i].mColor; rawStops[i].offset = stopScale * (stops[i].mPosition - stopOrigin); } RefPtr<mozilla::gfx::GradientStops> gs = gfxGradientCache::GetOrCreateGradientStops(ctx->GetDrawTarget(), rawStops, isRepeat ? gfx::ExtendMode::REPEAT : gfx::ExtendMode::CLAMP); gradientPattern->SetColorStops(gs); // Paint gradient tiles. This isn't terribly efficient, but doing it this // way is simple and sure to get pixel-snapping right. We could speed things // up by drawing tiles into temporary surfaces and copying those to the // destination, but after pixel-snapping tiles may not all be the same size. nsRect dirty; if (!dirty.IntersectRect(aDirtyRect, aFillArea)) return; gfxRect areaToFill = nsLayoutUtils::RectToGfxRect(aFillArea, appUnitsPerDevPixel); gfxRect dirtyAreaToFill = nsLayoutUtils::RectToGfxRect(dirty, appUnitsPerDevPixel); dirtyAreaToFill.RoundOut(); gfxMatrix ctm = ctx->CurrentMatrix(); bool isCTMPreservingAxisAlignedRectangles = ctm.PreservesAxisAlignedRectangles(); // xStart/yStart are the top-left corner of the top-left tile. nscoord xStart = FindTileStart(dirty.x, aDest.x, aRepeatSize.width); nscoord yStart = FindTileStart(dirty.y, aDest.y, aRepeatSize.height); nscoord xEnd = forceRepeatToCoverTiles ? xStart + aDest.width : dirty.XMost(); nscoord yEnd = forceRepeatToCoverTiles ? yStart + aDest.height : dirty.YMost(); // x and y are the top-left corner of the tile to draw for (nscoord y = yStart; y < yEnd; y += aRepeatSize.height) { for (nscoord x = xStart; x < xEnd; x += aRepeatSize.width) { // The coordinates of the tile gfxRect tileRect = nsLayoutUtils::RectToGfxRect( nsRect(x, y, aDest.width, aDest.height), appUnitsPerDevPixel); // The actual area to fill with this tile is the intersection of this // tile with the overall area we're supposed to be filling gfxRect fillRect = forceRepeatToCoverTiles ? areaToFill : tileRect.Intersect(areaToFill); // Try snapping the fill rect. Snap its top-left and bottom-right // independently to preserve the orientation. gfxPoint snappedFillRectTopLeft = fillRect.TopLeft(); gfxPoint snappedFillRectTopRight = fillRect.TopRight(); gfxPoint snappedFillRectBottomRight = fillRect.BottomRight(); // Snap three points instead of just two to ensure we choose the // correct orientation if there's a reflection. if (isCTMPreservingAxisAlignedRectangles && ctx->UserToDevicePixelSnapped(snappedFillRectTopLeft, true) && ctx->UserToDevicePixelSnapped(snappedFillRectBottomRight, true) && ctx->UserToDevicePixelSnapped(snappedFillRectTopRight, true)) { if (snappedFillRectTopLeft.x == snappedFillRectBottomRight.x || snappedFillRectTopLeft.y == snappedFillRectBottomRight.y) { // Nothing to draw; avoid scaling by zero and other weirdness that // could put the context in an error state. continue; } // Set the context's transform to the transform that maps fillRect to // snappedFillRect. The part of the gradient that was going to // exactly fill fillRect will fill snappedFillRect instead. gfxMatrix transform = gfxUtils::TransformRectToRect(fillRect, snappedFillRectTopLeft, snappedFillRectTopRight, snappedFillRectBottomRight); ctx->SetMatrix(transform); } ctx->NewPath(); ctx->Rectangle(fillRect); gfxRect dirtyFillRect = fillRect.Intersect(dirtyAreaToFill); gfxRect fillRectRelativeToTile = dirtyFillRect - tileRect.TopLeft(); Color edgeColor; if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR && !isRepeat && RectIsBeyondLinearGradientEdge(fillRectRelativeToTile, matrix, stops, gradientStart, gradientEnd, &edgeColor)) { ctx->SetColor(edgeColor); } else { ctx->SetMatrix( ctx->CurrentMatrix().Copy().Translate(tileRect.TopLeft())); ctx->SetPattern(gradientPattern); } ctx->Fill(); ctx->SetMatrix(ctm); } } } static CompositionOp DetermineCompositionOp(const nsCSSRendering::PaintBGParams& aParams, const nsStyleImageLayers& aLayers, uint32_t aLayerIndex) { if (aParams.layer >= 0) { // When drawing a single layer, use the specified composition op. return aParams.compositionOp; } const nsStyleImageLayers::Layer& layer = aLayers.mLayers[aLayerIndex]; // When drawing all layers, get the compositon op from each image layer. if (aParams.paintFlags & nsCSSRendering::PAINTBG_MASK_IMAGE) { // Always using OP_OVER mode while drawing the bottom mask layer. if (aLayerIndex == (aLayers.mImageCount - 1)) { return CompositionOp::OP_OVER; } return nsCSSRendering::GetGFXCompositeMode(layer.mComposite); } return nsCSSRendering::GetGFXBlendMode(layer.mBlendMode); } DrawResult nsCSSRendering::PaintBackgroundWithSC(const PaintBGParams& aParams, nsStyleContext *aBackgroundSC, const nsStyleBorder& aBorder) { NS_PRECONDITION(aParams.frame, "Frame is expected to be provided to PaintBackground"); // If we're drawing all layers, aCompositonOp is ignored, so make sure that // it was left at its default value. MOZ_ASSERT_IF(aParams.layer == -1, aParams.compositionOp == CompositionOp::OP_OVER); DrawResult result = DrawResult::SUCCESS; // Check to see if we have an appearance defined. If so, we let the theme // renderer draw the background and bail out. // XXXzw this ignores aParams.bgClipRect. const nsStyleDisplay* displayData = aParams.frame->StyleDisplay(); if (displayData->mAppearance) { nsITheme *theme = aParams.presCtx.GetTheme(); if (theme && theme->ThemeSupportsWidget(&aParams.presCtx, aParams.frame, displayData->mAppearance)) { nsRect drawing(aParams.borderArea); theme->GetWidgetOverflow(aParams.presCtx.DeviceContext(), aParams.frame, displayData->mAppearance, &drawing); drawing.IntersectRect(drawing, aParams.dirtyRect); theme->DrawWidgetBackground(&aParams.renderingCtx, aParams.frame, displayData->mAppearance, aParams.borderArea, drawing); return DrawResult::SUCCESS; } } // For canvas frames (in the CSS sense) we draw the background color using // a solid color item that gets added in nsLayoutUtils::PaintFrame, // or nsSubDocumentFrame::BuildDisplayList (bug 488242). (The solid // color may be moved into nsDisplayCanvasBackground by // nsPresShell::AddCanvasBackgroundColorItem, and painted by // nsDisplayCanvasBackground directly.) Either way we don't need to // paint the background color here. bool isCanvasFrame = IsCanvasFrame(aParams.frame); // Determine whether we are drawing background images and/or // background colors. bool drawBackgroundImage; bool drawBackgroundColor; nscolor bgColor = DetermineBackgroundColor(&aParams.presCtx, aBackgroundSC, aParams.frame, drawBackgroundImage, drawBackgroundColor); bool paintMask = (aParams.paintFlags & PAINTBG_MASK_IMAGE); const nsStyleImageLayers& layers = paintMask ? aBackgroundSC->StyleSVGReset()->mMask : aBackgroundSC->StyleBackground()->mImage; // If we're drawing a specific layer, we don't want to draw the // background color. if ((drawBackgroundColor && aParams.layer >= 0) || paintMask) { drawBackgroundColor = false; } // At this point, drawBackgroundImage and drawBackgroundColor are // true if and only if we are actually supposed to paint an image or // color into aDirtyRect, respectively. if (!drawBackgroundImage && !drawBackgroundColor) return DrawResult::SUCCESS; // Compute the outermost boundary of the area that might be painted. // Same coordinate space as aParams.borderArea & aParams.bgClipRect. Sides skipSides = aParams.frame->GetSkipSides(); nsRect paintBorderArea = ::BoxDecorationRectForBackground(aParams.frame, aParams.borderArea, skipSides, &aBorder); nsRect clipBorderArea = ::BoxDecorationRectForBorder(aParams.frame, aParams.borderArea, skipSides, &aBorder); // The 'bgClipArea' (used only by the image tiling logic, far below) // is the caller-provided aParams.bgClipRect if any, or else the area // determined by the value of 'background-clip' in // SetupCurrentBackgroundClip. (Arguably it should be the // intersection, but that breaks the table painter -- in particular, // taking the intersection breaks reftests/bugs/403249-1[ab].) gfxContext* ctx = aParams.renderingCtx.ThebesContext(); nscoord appUnitsPerPixel = aParams.presCtx.AppUnitsPerDevPixel(); ImageLayerClipState clipState; if (aParams.bgClipRect) { clipState.mBGClipArea = *aParams.bgClipRect; clipState.mCustomClip = true; clipState.mHasRoundedCorners = false; SetupDirtyRects(clipState.mBGClipArea, aParams.dirtyRect, appUnitsPerPixel, &clipState.mDirtyRect, &clipState.mDirtyRectGfx); } else { GetImageLayerClip(layers.BottomLayer(), aParams.frame, aBorder, aParams.borderArea, aParams.dirtyRect, (aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER), appUnitsPerPixel, &clipState); } // If we might be using a background color, go ahead and set it now. if (drawBackgroundColor && !isCanvasFrame) ctx->SetColor(Color::FromABGR(bgColor)); // NOTE: no Save() yet, we do that later by calling autoSR.EnsureSaved(ctx) // in the cases we need it. gfxContextAutoSaveRestore autoSR; // If there is no background image, draw a color. (If there is // neither a background image nor a color, we wouldn't have gotten // this far.) if (!drawBackgroundImage) { if (!isCanvasFrame) { DrawBackgroundColor(clipState, ctx, appUnitsPerPixel); } return DrawResult::SUCCESS; } if (layers.mImageCount < 1) { // Return if there are no background layers, all work from this point // onwards happens iteratively on these. return DrawResult::SUCCESS; } // Validate the layer range before we start iterating. int32_t startLayer = aParams.layer; int32_t nLayers = 1; if (startLayer < 0) { startLayer = (int32_t)layers.mImageCount - 1; nLayers = layers.mImageCount; } // Ensure we get invalidated for loads of the image. We need to do // this here because this might be the only code that knows about the // association of the style data with the frame. if (aBackgroundSC != aParams.frame->StyleContext()) { NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT_WITH_RANGE(i, layers, startLayer, nLayers) { aParams.frame->AssociateImage(layers.mLayers[i].mImage, &aParams.presCtx); } } // The background color is rendered over the entire dirty area, // even if the image isn't. if (drawBackgroundColor && !isCanvasFrame) { DrawBackgroundColor(clipState, ctx, appUnitsPerPixel); } if (drawBackgroundImage) { bool clipSet = false; uint8_t currentBackgroundClip = NS_STYLE_IMAGELAYER_CLIP_BORDER; NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT_WITH_RANGE(i, layers, layers.mImageCount - 1, nLayers + (layers.mImageCount - startLayer - 1)) { const nsStyleImageLayers::Layer& layer = layers.mLayers[i]; if (!aParams.bgClipRect) { if (currentBackgroundClip != layer.mClip || !clipSet) { currentBackgroundClip = layer.mClip; // If clipSet is false that means this is the bottom layer and we // already called GetImageLayerClip above and it stored its results // in clipState. if (clipSet) { autoSR.Restore(); // reset the previous one GetImageLayerClip(layer, aParams.frame, aBorder, aParams.borderArea, aParams.dirtyRect, (aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER), appUnitsPerPixel, &clipState); } SetupImageLayerClip(clipState, ctx, appUnitsPerPixel, &autoSR); clipSet = true; if (!clipBorderArea.IsEqualEdges(aParams.borderArea)) { // We're drawing the background for the joined continuation boxes // so we need to clip that to the slice that we want for this // frame. gfxRect clip = nsLayoutUtils::RectToGfxRect(aParams.borderArea, appUnitsPerPixel); autoSR.EnsureSaved(ctx); ctx->NewPath(); ctx->SnappedRectangle(clip); ctx->Clip(); } } } if ((aParams.layer < 0 || i == (uint32_t)startLayer) && !clipState.mDirtyRectGfx.IsEmpty()) { CompositionOp co = DetermineCompositionOp(aParams, layers, i); nsBackgroundLayerState state = PrepareImageLayer(&aParams.presCtx, aParams.frame, aParams.paintFlags, paintBorderArea, clipState.mBGClipArea, layer, nullptr); result &= state.mImageRenderer.PrepareResult(); if (!state.mFillArea.IsEmpty()) { if (co != CompositionOp::OP_OVER) { NS_ASSERTION(ctx->CurrentOp() == CompositionOp::OP_OVER, "It is assumed the initial op is OP_OVER, when it is " "restored later"); ctx->SetOp(co); } result &= state.mImageRenderer.DrawBackground(&aParams.presCtx, aParams.renderingCtx, state.mDestArea, state.mFillArea, state.mAnchor + paintBorderArea.TopLeft(), clipState.mDirtyRect, state.mRepeatSize); if (co != CompositionOp::OP_OVER) { ctx->SetOp(CompositionOp::OP_OVER); } } } } } return result; } nsRect nsCSSRendering::ComputeImageLayerPositioningArea(nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea, const nsStyleImageLayers::Layer& aLayer, nsIFrame** aAttachedToFrame, bool* aOutIsTransformedFixed) { // Compute background origin area relative to aBorderArea now as we may need // it to compute the effective image size for a CSS gradient. nsRect bgPositioningArea; nsIAtom* frameType = aForFrame->GetType(); nsIFrame* geometryFrame = aForFrame; if (MOZ_UNLIKELY(frameType == nsGkAtoms::scrollFrame && NS_STYLE_IMAGELAYER_ATTACHMENT_LOCAL == aLayer.mAttachment)) { nsIScrollableFrame* scrollableFrame = do_QueryFrame(aForFrame); bgPositioningArea = nsRect( scrollableFrame->GetScrolledFrame()->GetPosition() // For the dir=rtl case: + scrollableFrame->GetScrollRange().TopLeft(), scrollableFrame->GetScrolledRect().Size()); // The ScrolledRect’s size does not include the borders or scrollbars, // reverse the handling of background-origin // compared to the common case below. if (aLayer.mOrigin == NS_STYLE_IMAGELAYER_ORIGIN_BORDER) { nsMargin border = geometryFrame->GetUsedBorder(); border.ApplySkipSides(geometryFrame->GetSkipSides()); bgPositioningArea.Inflate(border); bgPositioningArea.Inflate(scrollableFrame->GetActualScrollbarSizes()); } else if (aLayer.mOrigin != NS_STYLE_IMAGELAYER_ORIGIN_PADDING) { nsMargin padding = geometryFrame->GetUsedPadding(); padding.ApplySkipSides(geometryFrame->GetSkipSides()); bgPositioningArea.Deflate(padding); NS_ASSERTION(aLayer.mOrigin == NS_STYLE_IMAGELAYER_ORIGIN_CONTENT, "unknown background-origin value"); } *aAttachedToFrame = aForFrame; return bgPositioningArea; } if (MOZ_UNLIKELY(frameType == nsGkAtoms::canvasFrame)) { geometryFrame = aForFrame->PrincipalChildList().FirstChild(); // geometryFrame might be null if this canvas is a page created // as an overflow container (e.g. the in-flow content has already // finished and this page only displays the continuations of // absolutely positioned content). if (geometryFrame) { bgPositioningArea = geometryFrame->GetRect(); } } else { bgPositioningArea = nsRect(nsPoint(0,0), aBorderArea.Size()); } // Background images are tiled over the 'background-clip' area // but the origin of the tiling is based on the 'background-origin' area // XXX: Bug 1303623 will bring in new origin value, we should iterate from // NS_STYLE_IMAGELAYER_ORIGIN_MARGIN instead of // NS_STYLE_IMAGELAYER_ORIGIN_BORDER. if (aLayer.mOrigin != NS_STYLE_IMAGELAYER_ORIGIN_BORDER && geometryFrame) { nsMargin border = geometryFrame->GetUsedBorder(); if (aLayer.mOrigin != NS_STYLE_IMAGELAYER_ORIGIN_PADDING) { border += geometryFrame->GetUsedPadding(); NS_ASSERTION(aLayer.mOrigin == NS_STYLE_IMAGELAYER_ORIGIN_CONTENT, "unknown background-origin value"); } bgPositioningArea.Deflate(border); } nsIFrame* attachedToFrame = aForFrame; if (NS_STYLE_IMAGELAYER_ATTACHMENT_FIXED == aLayer.mAttachment) { // If it's a fixed background attachment, then the image is placed // relative to the viewport, which is the area of the root frame // in a screen context or the page content frame in a print context. attachedToFrame = aPresContext->PresShell()->FrameManager()->GetRootFrame(); NS_ASSERTION(attachedToFrame, "no root frame"); nsIFrame* pageContentFrame = nullptr; if (aPresContext->IsPaginated()) { pageContentFrame = nsLayoutUtils::GetClosestFrameOfType(aForFrame, nsGkAtoms::pageContentFrame); if (pageContentFrame) { attachedToFrame = pageContentFrame; } // else this is an embedded shell and its root frame is what we want } // If the background is affected by a transform, treat is as if it // wasn't fixed. if (nsLayoutUtils::IsTransformed(aForFrame, attachedToFrame)) { attachedToFrame = aForFrame; *aOutIsTransformedFixed = true; } else { // Set the background positioning area to the viewport's area // (relative to aForFrame) bgPositioningArea = nsRect(-aForFrame->GetOffsetTo(attachedToFrame), attachedToFrame->GetSize()); if (!pageContentFrame) { // Subtract the size of scrollbars. nsIScrollableFrame* scrollableFrame = aPresContext->PresShell()->GetRootScrollFrameAsScrollable(); if (scrollableFrame) { nsMargin scrollbars = scrollableFrame->GetActualScrollbarSizes(); bgPositioningArea.Deflate(scrollbars); } } } } *aAttachedToFrame = attachedToFrame; return bgPositioningArea; } // Implementation of the formula for computation of background-repeat round // See http://dev.w3.org/csswg/css3-background/#the-background-size // This function returns the adjusted size of the background image. static nscoord ComputeRoundedSize(nscoord aCurrentSize, nscoord aPositioningSize) { float repeatCount = NS_roundf(float(aPositioningSize) / float(aCurrentSize)); if (repeatCount < 1.0f) { return aPositioningSize; } return nscoord(NS_lround(float(aPositioningSize) / repeatCount)); } // Apply the CSS image sizing algorithm as it applies to background images. // See http://www.w3.org/TR/css3-background/#the-background-size . // aIntrinsicSize is the size that the background image 'would like to be'. // It can be found by calling nsImageRenderer::ComputeIntrinsicSize. static nsSize ComputeDrawnSizeForBackground(const CSSSizeOrRatio& aIntrinsicSize, const nsSize& aBgPositioningArea, const nsStyleImageLayers::Size& aLayerSize, uint8_t aXRepeat, uint8_t aYRepeat) { nsSize imageSize; // Size is dictated by cover or contain rules. if (aLayerSize.mWidthType == nsStyleImageLayers::Size::eContain || aLayerSize.mWidthType == nsStyleImageLayers::Size::eCover) { nsImageRenderer::FitType fitType = aLayerSize.mWidthType == nsStyleImageLayers::Size::eCover ? nsImageRenderer::COVER : nsImageRenderer::CONTAIN; imageSize = nsImageRenderer::ComputeConstrainedSize(aBgPositioningArea, aIntrinsicSize.mRatio, fitType); } else { // No cover/contain constraint, use default algorithm. CSSSizeOrRatio specifiedSize; if (aLayerSize.mWidthType == nsStyleImageLayers::Size::eLengthPercentage) { specifiedSize.SetWidth( aLayerSize.ResolveWidthLengthPercentage(aBgPositioningArea)); } if (aLayerSize.mHeightType == nsStyleImageLayers::Size::eLengthPercentage) { specifiedSize.SetHeight( aLayerSize.ResolveHeightLengthPercentage(aBgPositioningArea)); } imageSize = nsImageRenderer::ComputeConcreteSize(specifiedSize, aIntrinsicSize, aBgPositioningArea); } // See https://www.w3.org/TR/css3-background/#background-size . // "If 'background-repeat' is 'round' for one (or both) dimensions, there is a second // step. The UA must scale the image in that dimension (or both dimensions) so that // it fits a whole number of times in the background positioning area." // "If 'background-repeat' is 'round' for one dimension only and if 'background-size' // is 'auto' for the other dimension, then there is a third step: that other dimension // is scaled so that the original aspect ratio is restored." bool isRepeatRoundInBothDimensions = aXRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND && aYRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND; // Calculate the rounded size only if the background-size computation // returned a correct size for the image. if (imageSize.width && aXRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND) { imageSize.width = ComputeRoundedSize(imageSize.width, aBgPositioningArea.width); if (!isRepeatRoundInBothDimensions && aLayerSize.mHeightType == nsStyleImageLayers::Size::DimensionType::eAuto) { // Restore intrinsic rato if (aIntrinsicSize.mRatio.width) { float scale = float(aIntrinsicSize.mRatio.height) / aIntrinsicSize.mRatio.width; imageSize.height = NSCoordSaturatingNonnegativeMultiply(imageSize.width, scale); } } } // Calculate the rounded size only if the background-size computation // returned a correct size for the image. if (imageSize.height && aYRepeat == NS_STYLE_IMAGELAYER_REPEAT_ROUND) { imageSize.height = ComputeRoundedSize(imageSize.height, aBgPositioningArea.height); if (!isRepeatRoundInBothDimensions && aLayerSize.mWidthType == nsStyleImageLayers::Size::DimensionType::eAuto) { // Restore intrinsic rato if (aIntrinsicSize.mRatio.height) { float scale = float(aIntrinsicSize.mRatio.width) / aIntrinsicSize.mRatio.height; imageSize.width = NSCoordSaturatingNonnegativeMultiply(imageSize.height, scale); } } } return imageSize; } /* ComputeSpacedRepeatSize * aImageDimension: the image width/height * aAvailableSpace: the background positioning area width/height * aRepeat: determine whether the image is repeated * Returns the image size plus gap size of app units for use as spacing */ static nscoord ComputeSpacedRepeatSize(nscoord aImageDimension, nscoord aAvailableSpace, bool& aRepeat) { float ratio = static_cast<float>(aAvailableSpace) / aImageDimension; if (ratio < 2.0f) { // If you can't repeat at least twice, then don't repeat. aRepeat = false; return aImageDimension; } else { aRepeat = true; return (aAvailableSpace - aImageDimension) / (NSToIntFloor(ratio) - 1); } } /* ComputeBorderSpacedRepeatSize * aImageDimension: the image width/height * aAvailableSpace: the background positioning area width/height * aSpace: the space between each image * Returns the image size plus gap size of app units for use as spacing */ static nscoord ComputeBorderSpacedRepeatSize(nscoord aImageDimension, nscoord aAvailableSpace, nscoord& aSpace) { int32_t count = aAvailableSpace / aImageDimension; aSpace = (aAvailableSpace - aImageDimension * count) / (count + 1); return aSpace + aImageDimension; } nsBackgroundLayerState nsCSSRendering::PrepareImageLayer(nsPresContext* aPresContext, nsIFrame* aForFrame, uint32_t aFlags, const nsRect& aBorderArea, const nsRect& aBGClipRect, const nsStyleImageLayers::Layer& aLayer, bool* aOutIsTransformedFixed) { /* * The properties we need to keep in mind when drawing style image * layers are: * * background-image/ mask-image * background-repeat/ mask-repeat * background-attachment * background-position/ mask-position * background-clip/ mask-clip * background-origin/ mask-origin * background-size/ mask-size * background-blend-mode * box-decoration-break * mask-mode * mask-composite * * (background-color applies to the entire element and not to individual * layers, so it is irrelevant to this method.) * * These properties have the following dependencies upon each other when * determining rendering: * * background-image/ mask-image * no dependencies * background-repeat/ mask-repeat * no dependencies * background-attachment * no dependencies * background-position/ mask-position * depends upon background-size/mask-size (for the image's scaled size) * and background-break (for the background positioning area) * background-clip/ mask-clip * no dependencies * background-origin/ mask-origin * depends upon background-attachment (only in the case where that value * is 'fixed') * background-size/ mask-size * depends upon box-decoration-break (for the background positioning area * for resolving percentages), background-image (for the image's intrinsic * size), background-repeat (if that value is 'round'), and * background-origin (for the background painting area, when * background-repeat is 'round') * background-blend-mode * no dependencies * mask-mode * no dependencies * mask-composite * no dependencies * box-decoration-break * no dependencies * * As a result of only-if dependencies we don't strictly do a topological * sort of the above properties when processing, but it's pretty close to one: * * background-clip/mask-clip (by caller) * background-image/ mask-image * box-decoration-break, background-origin/ mask origin * background-attachment (postfix for background-origin if 'fixed') * background-size/ mask-size * background-position/ mask-position * background-repeat/ mask-repeat */ uint32_t irFlags = 0; if (aFlags & nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES) { irFlags |= nsImageRenderer::FLAG_SYNC_DECODE_IMAGES; } if (aFlags & nsCSSRendering::PAINTBG_TO_WINDOW) { irFlags |= nsImageRenderer::FLAG_PAINTING_TO_WINDOW; } nsBackgroundLayerState state(aForFrame, &aLayer.mImage, irFlags); if (!state.mImageRenderer.PrepareImage()) { // There's no image or it's not ready to be painted. if (aOutIsTransformedFixed) { *aOutIsTransformedFixed = false; } return state; } // The frame to which the background is attached nsIFrame* attachedToFrame = aForFrame; // Is the background marked 'fixed', but affected by a transform? bool transformedFixed = false; // Compute background origin area relative to aBorderArea now as we may need // it to compute the effective image size for a CSS gradient. nsRect bgPositioningArea = ComputeImageLayerPositioningArea(aPresContext, aForFrame, aBorderArea, aLayer, &attachedToFrame, &transformedFixed); if (aOutIsTransformedFixed) { *aOutIsTransformedFixed = transformedFixed; } // For background-attachment:fixed backgrounds, we'll limit the area // where the background can be drawn to the viewport. nsRect bgClipRect = aBGClipRect; // Compute the anchor point. // // relative to aBorderArea.TopLeft() (which is where the top-left // of aForFrame's border-box will be rendered) nsPoint imageTopLeft; if (NS_STYLE_IMAGELAYER_ATTACHMENT_FIXED == aLayer.mAttachment && !transformedFixed) { if (aFlags & nsCSSRendering::PAINTBG_TO_WINDOW) { // Clip background-attachment:fixed backgrounds to the viewport, if we're // painting to the screen and not transformed. This avoids triggering // tiling in common cases, without affecting output since drawing is // always clipped to the viewport when we draw to the screen. (But it's // not a pure optimization since it can affect the values of pixels at the // edge of the viewport --- whether they're sampled from a putative "next // tile" or not.) bgClipRect.IntersectRect(bgClipRect, bgPositioningArea + aBorderArea.TopLeft()); } } int repeatX = aLayer.mRepeat.mXRepeat; int repeatY = aLayer.mRepeat.mYRepeat; // Scale the image as specified for background-size and background-repeat. // Also as required for proper background positioning when background-position // is defined with percentages. CSSSizeOrRatio intrinsicSize = state.mImageRenderer.ComputeIntrinsicSize(); nsSize bgPositionSize = bgPositioningArea.Size(); nsSize imageSize = ComputeDrawnSizeForBackground(intrinsicSize, bgPositionSize, aLayer.mSize, repeatX, repeatY); if (imageSize.width <= 0 || imageSize.height <= 0) return state; state.mImageRenderer.SetPreferredSize(intrinsicSize, imageSize); // Compute the position of the background now that the background's size is // determined. nsImageRenderer::ComputeObjectAnchorPoint(aLayer.mPosition, bgPositionSize, imageSize, &imageTopLeft, &state.mAnchor); state.mRepeatSize = imageSize; if (repeatX == NS_STYLE_IMAGELAYER_REPEAT_SPACE) { bool isRepeat; state.mRepeatSize.width = ComputeSpacedRepeatSize(imageSize.width, bgPositionSize.width, isRepeat); if (isRepeat) { imageTopLeft.x = 0; state.mAnchor.x = 0; } else { repeatX = NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT; } } if (repeatY == NS_STYLE_IMAGELAYER_REPEAT_SPACE) { bool isRepeat; state.mRepeatSize.height = ComputeSpacedRepeatSize(imageSize.height, bgPositionSize.height, isRepeat); if (isRepeat) { imageTopLeft.y = 0; state.mAnchor.y = 0; } else { repeatY = NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT; } } imageTopLeft += bgPositioningArea.TopLeft(); state.mAnchor += bgPositioningArea.TopLeft(); state.mDestArea = nsRect(imageTopLeft + aBorderArea.TopLeft(), imageSize); state.mFillArea = state.mDestArea; ExtendMode repeatMode = ExtendMode::CLAMP; if (repeatX == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || repeatX == NS_STYLE_IMAGELAYER_REPEAT_ROUND || repeatX == NS_STYLE_IMAGELAYER_REPEAT_SPACE) { state.mFillArea.x = bgClipRect.x; state.mFillArea.width = bgClipRect.width; repeatMode = ExtendMode::REPEAT_X; } if (repeatY == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || repeatY == NS_STYLE_IMAGELAYER_REPEAT_ROUND || repeatY == NS_STYLE_IMAGELAYER_REPEAT_SPACE) { state.mFillArea.y = bgClipRect.y; state.mFillArea.height = bgClipRect.height; /*** * We're repeating on the X axis already, * so if we have to repeat in the Y axis, * we really need to repeat in both directions. */ if (repeatMode == ExtendMode::REPEAT_X) { repeatMode = ExtendMode::REPEAT; } else { repeatMode = ExtendMode::REPEAT_Y; } } state.mImageRenderer.SetExtendMode(repeatMode); state.mImageRenderer.SetMaskOp(aLayer.mMaskMode); state.mFillArea.IntersectRect(state.mFillArea, bgClipRect); return state; } nsRect nsCSSRendering::GetBackgroundLayerRect(nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea, const nsRect& aClipRect, const nsStyleImageLayers::Layer& aLayer, uint32_t aFlags) { Sides skipSides = aForFrame->GetSkipSides(); nsRect borderArea = ::BoxDecorationRectForBackground(aForFrame, aBorderArea, skipSides); nsBackgroundLayerState state = PrepareImageLayer(aPresContext, aForFrame, aFlags, borderArea, aClipRect, aLayer); return state.mFillArea; } static DrawResult DrawBorderImage(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, nsIFrame* aForFrame, const nsRect& aBorderArea, const nsStyleBorder& aStyleBorder, const nsRect& aDirtyRect, Sides aSkipSides, PaintBorderFlags aFlags) { NS_PRECONDITION(aStyleBorder.IsBorderImageLoaded(), "drawing border image that isn't successfully loaded"); if (aDirtyRect.IsEmpty()) { return DrawResult::SUCCESS; } uint32_t irFlags = 0; if (aFlags & PaintBorderFlags::SYNC_DECODE_IMAGES) { irFlags |= nsImageRenderer::FLAG_SYNC_DECODE_IMAGES; } nsImageRenderer renderer(aForFrame, &aStyleBorder.mBorderImageSource, irFlags); // Ensure we get invalidated for loads and animations of the image. // We need to do this here because this might be the only code that // knows about the association of the style data with the frame. // XXX We shouldn't really... since if anybody is passing in a // different style, they'll potentially have the wrong size for the // border too. aForFrame->AssociateImage(aStyleBorder.mBorderImageSource, aPresContext); if (!renderer.PrepareImage()) { return renderer.PrepareResult(); } // NOTE: no Save() yet, we do that later by calling autoSR.EnsureSaved() // in case we need it. gfxContextAutoSaveRestore autoSR; // Determine the border image area, which by default corresponds to the // border box but can be modified by 'border-image-outset'. // Note that 'border-radius' do not apply to 'border-image' borders per // <http://dev.w3.org/csswg/css-backgrounds/#corner-clipping>. nsRect borderImgArea; nsMargin borderWidths(aStyleBorder.GetComputedBorder()); nsMargin imageOutset(aStyleBorder.GetImageOutset()); if (::IsBoxDecorationSlice(aStyleBorder) && !aSkipSides.IsEmpty()) { borderImgArea = ::BoxDecorationRectForBorder(aForFrame, aBorderArea, aSkipSides, &aStyleBorder); if (borderImgArea.IsEqualEdges(aBorderArea)) { // No need for a clip, just skip the sides we don't want. borderWidths.ApplySkipSides(aSkipSides); imageOutset.ApplySkipSides(aSkipSides); borderImgArea.Inflate(imageOutset); } else { // We're drawing borders around the joined continuation boxes so we need // to clip that to the slice that we want for this frame. borderImgArea.Inflate(imageOutset); imageOutset.ApplySkipSides(aSkipSides); nsRect clip = aBorderArea; clip.Inflate(imageOutset); autoSR.EnsureSaved(aRenderingContext.ThebesContext()); aRenderingContext.ThebesContext()-> Clip(NSRectToSnappedRect(clip, aForFrame->PresContext()->AppUnitsPerDevPixel(), *aRenderingContext.GetDrawTarget())); } } else { borderImgArea = aBorderArea; borderImgArea.Inflate(imageOutset); } // Calculate the image size used to compute slice points. CSSSizeOrRatio intrinsicSize = renderer.ComputeIntrinsicSize(); nsSize imageSize = nsImageRenderer::ComputeConcreteSize(CSSSizeOrRatio(), intrinsicSize, borderImgArea.Size()); renderer.SetPreferredSize(intrinsicSize, imageSize); // Compute the used values of 'border-image-slice' and 'border-image-width'; // we do them together because the latter can depend on the former. nsMargin slice; nsMargin border; NS_FOR_CSS_SIDES(s) { nsStyleCoord coord = aStyleBorder.mBorderImageSlice.Get(s); int32_t imgDimension = NS_SIDE_IS_VERTICAL(s) ? imageSize.width : imageSize.height; nscoord borderDimension = NS_SIDE_IS_VERTICAL(s) ? borderImgArea.width : borderImgArea.height; double value; switch (coord.GetUnit()) { case eStyleUnit_Percent: value = coord.GetPercentValue() * imgDimension; break; case eStyleUnit_Factor: value = nsPresContext::CSSPixelsToAppUnits( NS_lround(coord.GetFactorValue())); break; default: NS_NOTREACHED("unexpected CSS unit for image slice"); value = 0; break; } if (value < 0) value = 0; if (value > imgDimension) value = imgDimension; slice.Side(s) = value; coord = aStyleBorder.mBorderImageWidth.Get(s); switch (coord.GetUnit()) { case eStyleUnit_Coord: // absolute dimension value = coord.GetCoordValue(); break; case eStyleUnit_Percent: value = coord.GetPercentValue() * borderDimension; break; case eStyleUnit_Factor: value = coord.GetFactorValue() * borderWidths.Side(s); break; case eStyleUnit_Auto: // same as the slice value, in CSS pixels value = slice.Side(s); break; default: NS_NOTREACHED("unexpected CSS unit for border image area division"); value = 0; break; } // NSToCoordRoundWithClamp rounds towards infinity, but that's OK // because we expect value to be non-negative. MOZ_ASSERT(value >= 0); border.Side(s) = NSToCoordRoundWithClamp(value); MOZ_ASSERT(border.Side(s) >= 0); } // "If two opposite border-image-width offsets are large enough that they // overlap, their used values are proportionately reduced until they no // longer overlap." uint32_t combinedBorderWidth = uint32_t(border.left) + uint32_t(border.right); double scaleX = combinedBorderWidth > uint32_t(borderImgArea.width) ? borderImgArea.width / double(combinedBorderWidth) : 1.0; uint32_t combinedBorderHeight = uint32_t(border.top) + uint32_t(border.bottom); double scaleY = combinedBorderHeight > uint32_t(borderImgArea.height) ? borderImgArea.height / double(combinedBorderHeight) : 1.0; double scale = std::min(scaleX, scaleY); if (scale < 1.0) { border.left *= scale; border.right *= scale; border.top *= scale; border.bottom *= scale; NS_ASSERTION(border.left + border.right <= borderImgArea.width && border.top + border.bottom <= borderImgArea.height, "rounding error in width reduction???"); } // These helper tables recharacterize the 'slice' and 'width' margins // in a more convenient form: they are the x/y/width/height coords // required for various bands of the border, and they have been transformed // to be relative to the innerRect (for 'slice') or the page (for 'border'). enum { LEFT, MIDDLE, RIGHT, TOP = LEFT, BOTTOM = RIGHT }; const nscoord borderX[3] = { borderImgArea.x + 0, borderImgArea.x + border.left, borderImgArea.x + borderImgArea.width - border.right, }; const nscoord borderY[3] = { borderImgArea.y + 0, borderImgArea.y + border.top, borderImgArea.y + borderImgArea.height - border.bottom, }; const nscoord borderWidth[3] = { border.left, borderImgArea.width - border.left - border.right, border.right, }; const nscoord borderHeight[3] = { border.top, borderImgArea.height - border.top - border.bottom, border.bottom, }; const int32_t sliceX[3] = { 0, slice.left, imageSize.width - slice.right, }; const int32_t sliceY[3] = { 0, slice.top, imageSize.height - slice.bottom, }; const int32_t sliceWidth[3] = { slice.left, std::max(imageSize.width - slice.left - slice.right, 0), slice.right, }; const int32_t sliceHeight[3] = { slice.top, std::max(imageSize.height - slice.top - slice.bottom, 0), slice.bottom, }; DrawResult result = DrawResult::SUCCESS; // intrinsicSize.CanComputeConcreteSize() return false means we can not // read intrinsic size from aStyleBorder.mBorderImageSource. // In this condition, we pass imageSize(a resolved size comes from // default sizing algorithm) to renderer as the viewport size. Maybe<nsSize> svgViewportSize = intrinsicSize.CanComputeConcreteSize() ? Nothing() : Some(imageSize); bool hasIntrinsicRatio = intrinsicSize.HasRatio(); renderer.PurgeCacheForViewportChange(svgViewportSize, hasIntrinsicRatio); for (int i = LEFT; i <= RIGHT; i++) { for (int j = TOP; j <= BOTTOM; j++) { uint8_t fillStyleH, fillStyleV; nsSize unitSize; if (i == MIDDLE && j == MIDDLE) { // Discard the middle portion unless set to fill. if (NS_STYLE_BORDER_IMAGE_SLICE_NOFILL == aStyleBorder.mBorderImageFill) { continue; } NS_ASSERTION(NS_STYLE_BORDER_IMAGE_SLICE_FILL == aStyleBorder.mBorderImageFill, "Unexpected border image fill"); // css-background: // The middle image's width is scaled by the same factor as the // top image unless that factor is zero or infinity, in which // case the scaling factor of the bottom is substituted, and // failing that, the width is not scaled. The height of the // middle image is scaled by the same factor as the left image // unless that factor is zero or infinity, in which case the // scaling factor of the right image is substituted, and failing // that, the height is not scaled. gfxFloat hFactor, vFactor; if (0 < border.left && 0 < slice.left) vFactor = gfxFloat(border.left)/slice.left; else if (0 < border.right && 0 < slice.right) vFactor = gfxFloat(border.right)/slice.right; else vFactor = 1; if (0 < border.top && 0 < slice.top) hFactor = gfxFloat(border.top)/slice.top; else if (0 < border.bottom && 0 < slice.bottom) hFactor = gfxFloat(border.bottom)/slice.bottom; else hFactor = 1; unitSize.width = sliceWidth[i]*hFactor; unitSize.height = sliceHeight[j]*vFactor; fillStyleH = aStyleBorder.mBorderImageRepeatH; fillStyleV = aStyleBorder.mBorderImageRepeatV; } else if (i == MIDDLE) { // top, bottom // Sides are always stretched to the thickness of their border, // and stretched proportionately on the other axis. gfxFloat factor; if (0 < borderHeight[j] && 0 < sliceHeight[j]) factor = gfxFloat(borderHeight[j])/sliceHeight[j]; else factor = 1; unitSize.width = sliceWidth[i]*factor; unitSize.height = borderHeight[j]; fillStyleH = aStyleBorder.mBorderImageRepeatH; fillStyleV = NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH; } else if (j == MIDDLE) { // left, right gfxFloat factor; if (0 < borderWidth[i] && 0 < sliceWidth[i]) factor = gfxFloat(borderWidth[i])/sliceWidth[i]; else factor = 1; unitSize.width = borderWidth[i]; unitSize.height = sliceHeight[j]*factor; fillStyleH = NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH; fillStyleV = aStyleBorder.mBorderImageRepeatV; } else { // Corners are always stretched to fit the corner. unitSize.width = borderWidth[i]; unitSize.height = borderHeight[j]; fillStyleH = NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH; fillStyleV = NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH; } nsRect destArea(borderX[i], borderY[j], borderWidth[i], borderHeight[j]); nsRect subArea(sliceX[i], sliceY[j], sliceWidth[i], sliceHeight[j]); if (subArea.IsEmpty()) continue; nsIntRect intSubArea = subArea.ToOutsidePixels(nsPresContext::AppUnitsPerCSSPixel()); result &= renderer.DrawBorderImageComponent(aPresContext, aRenderingContext, aDirtyRect, destArea, CSSIntRect(intSubArea.x, intSubArea.y, intSubArea.width, intSubArea.height), fillStyleH, fillStyleV, unitSize, j * (RIGHT + 1) + i, svgViewportSize, hasIntrinsicRatio); } } return result; } // Begin table border-collapsing section // These functions were written to not disrupt the normal ones and yet satisfy some additional requirements // At some point, all functions should be unified to include the additional functionality that these provide static nscoord RoundIntToPixel(nscoord aValue, nscoord aTwipsPerPixel, bool aRoundDown = false) { if (aTwipsPerPixel <= 0) // We must be rendering to a device that has a resolution greater than Twips! // In that case, aValue is as accurate as it's going to get. return aValue; nscoord halfPixel = NSToCoordRound(aTwipsPerPixel / 2.0f); nscoord extra = aValue % aTwipsPerPixel; nscoord finalValue = (!aRoundDown && (extra >= halfPixel)) ? aValue + (aTwipsPerPixel - extra) : aValue - extra; return finalValue; } static nscoord RoundFloatToPixel(float aValue, nscoord aTwipsPerPixel, bool aRoundDown = false) { return RoundIntToPixel(NSToCoordRound(aValue), aTwipsPerPixel, aRoundDown); } static void SetPoly(const Rect& aRect, Point* poly) { poly[0].x = aRect.x; poly[0].y = aRect.y; poly[1].x = aRect.x + aRect.width; poly[1].y = aRect.y; poly[2].x = aRect.x + aRect.width; poly[2].y = aRect.y + aRect.height; poly[3].x = aRect.x; poly[3].y = aRect.y + aRect.height; } static void DrawDashedSegment(DrawTarget& aDrawTarget, nsRect aRect, nscoord aDashLength, nscolor aColor, int32_t aAppUnitsPerDevPixel, nscoord aTwipsPerPixel, bool aHorizontal) { ColorPattern color(ToDeviceColor(aColor)); DrawOptions drawOptions(1.f, CompositionOp::OP_OVER, AntialiasMode::NONE); StrokeOptions strokeOptions; Float dash[2]; dash[0] = Float(aDashLength) / aAppUnitsPerDevPixel; dash[1] = dash[0]; strokeOptions.mDashPattern = dash; strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); if (aHorizontal) { nsPoint left = (aRect.TopLeft() + aRect.BottomLeft()) / 2; nsPoint right = (aRect.TopRight() + aRect.BottomRight()) / 2; strokeOptions.mLineWidth = Float(aRect.height) / aAppUnitsPerDevPixel; StrokeLineWithSnapping(left, right, aAppUnitsPerDevPixel, aDrawTarget, color, strokeOptions, drawOptions); } else { nsPoint top = (aRect.TopLeft() + aRect.TopRight()) / 2; nsPoint bottom = (aRect.BottomLeft() + aRect.BottomRight()) / 2; strokeOptions.mLineWidth = Float(aRect.width) / aAppUnitsPerDevPixel; StrokeLineWithSnapping(top, bottom, aAppUnitsPerDevPixel, aDrawTarget, color, strokeOptions, drawOptions); } } static void DrawSolidBorderSegment(DrawTarget& aDrawTarget, nsRect aRect, nscolor aColor, int32_t aAppUnitsPerDevPixel, nscoord aTwipsPerPixel, uint8_t aStartBevelSide = 0, nscoord aStartBevelOffset = 0, uint8_t aEndBevelSide = 0, nscoord aEndBevelOffset = 0) { ColorPattern color(ToDeviceColor(aColor)); DrawOptions drawOptions(1.f, CompositionOp::OP_OVER, AntialiasMode::NONE); // We don't need to bevel single pixel borders if ((aRect.width == aTwipsPerPixel) || (aRect.height == aTwipsPerPixel) || ((0 == aStartBevelOffset) && (0 == aEndBevelOffset))) { // simple rectangle aDrawTarget.FillRect(NSRectToSnappedRect(aRect, aAppUnitsPerDevPixel, aDrawTarget), color, drawOptions); } else { // polygon with beveling Point poly[4]; SetPoly(NSRectToSnappedRect(aRect, aAppUnitsPerDevPixel, aDrawTarget), poly); Float startBevelOffset = NSAppUnitsToFloatPixels(aStartBevelOffset, aAppUnitsPerDevPixel); switch(aStartBevelSide) { case NS_SIDE_TOP: poly[0].x += startBevelOffset; break; case NS_SIDE_BOTTOM: poly[3].x += startBevelOffset; break; case NS_SIDE_RIGHT: poly[1].y += startBevelOffset; break; case NS_SIDE_LEFT: poly[0].y += startBevelOffset; } Float endBevelOffset = NSAppUnitsToFloatPixels(aEndBevelOffset, aAppUnitsPerDevPixel); switch(aEndBevelSide) { case NS_SIDE_TOP: poly[1].x -= endBevelOffset; break; case NS_SIDE_BOTTOM: poly[2].x -= endBevelOffset; break; case NS_SIDE_RIGHT: poly[2].y -= endBevelOffset; break; case NS_SIDE_LEFT: poly[3].y -= endBevelOffset; } RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder(); builder->MoveTo(poly[0]); builder->LineTo(poly[1]); builder->LineTo(poly[2]); builder->LineTo(poly[3]); builder->Close(); RefPtr<Path> path = builder->Finish(); aDrawTarget.Fill(path, color, drawOptions); } } static void GetDashInfo(nscoord aBorderLength, nscoord aDashLength, nscoord aTwipsPerPixel, int32_t& aNumDashSpaces, nscoord& aStartDashLength, nscoord& aEndDashLength) { aNumDashSpaces = 0; if (aStartDashLength + aDashLength + aEndDashLength >= aBorderLength) { aStartDashLength = aBorderLength; aEndDashLength = 0; } else { aNumDashSpaces = (aBorderLength - aDashLength)/ (2 * aDashLength); // round down nscoord extra = aBorderLength - aStartDashLength - aEndDashLength - (((2 * aNumDashSpaces) - 1) * aDashLength); if (extra > 0) { nscoord half = RoundIntToPixel(extra / 2, aTwipsPerPixel); aStartDashLength += half; aEndDashLength += (extra - half); } } } void nsCSSRendering::DrawTableBorderSegment(DrawTarget& aDrawTarget, uint8_t aBorderStyle, nscolor aBorderColor, const nsStyleBackground* aBGColor, const nsRect& aBorder, int32_t aAppUnitsPerDevPixel, int32_t aAppUnitsPerCSSPixel, uint8_t aStartBevelSide, nscoord aStartBevelOffset, uint8_t aEndBevelSide, nscoord aEndBevelOffset) { bool horizontal = ((NS_SIDE_TOP == aStartBevelSide) || (NS_SIDE_BOTTOM == aStartBevelSide)); nscoord twipsPerPixel = NSIntPixelsToAppUnits(1, aAppUnitsPerCSSPixel); uint8_t ridgeGroove = NS_STYLE_BORDER_STYLE_RIDGE; if ((twipsPerPixel >= aBorder.width) || (twipsPerPixel >= aBorder.height) || (NS_STYLE_BORDER_STYLE_DASHED == aBorderStyle) || (NS_STYLE_BORDER_STYLE_DOTTED == aBorderStyle)) { // no beveling for 1 pixel border, dash or dot aStartBevelOffset = 0; aEndBevelOffset = 0; } switch (aBorderStyle) { case NS_STYLE_BORDER_STYLE_NONE: case NS_STYLE_BORDER_STYLE_HIDDEN: //NS_ASSERTION(false, "style of none or hidden"); break; case NS_STYLE_BORDER_STYLE_DOTTED: case NS_STYLE_BORDER_STYLE_DASHED: { nscoord dashLength = (NS_STYLE_BORDER_STYLE_DASHED == aBorderStyle) ? DASH_LENGTH : DOT_LENGTH; // make the dash length proportional to the border thickness dashLength *= (horizontal) ? aBorder.height : aBorder.width; // make the min dash length for the ends 1/2 the dash length nscoord minDashLength = (NS_STYLE_BORDER_STYLE_DASHED == aBorderStyle) ? RoundFloatToPixel(((float)dashLength) / 2.0f, twipsPerPixel) : dashLength; minDashLength = std::max(minDashLength, twipsPerPixel); nscoord numDashSpaces = 0; nscoord startDashLength = minDashLength; nscoord endDashLength = minDashLength; if (horizontal) { GetDashInfo(aBorder.width, dashLength, twipsPerPixel, numDashSpaces, startDashLength, endDashLength); nsRect rect(aBorder.x, aBorder.y, startDashLength, aBorder.height); DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel); rect.x += startDashLength + dashLength; rect.width = aBorder.width - (startDashLength + endDashLength + dashLength); DrawDashedSegment(aDrawTarget, rect, dashLength, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, horizontal); rect.x += rect.width; rect.width = endDashLength; DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel); } else { GetDashInfo(aBorder.height, dashLength, twipsPerPixel, numDashSpaces, startDashLength, endDashLength); nsRect rect(aBorder.x, aBorder.y, aBorder.width, startDashLength); DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel); rect.y += rect.height + dashLength; rect.height = aBorder.height - (startDashLength + endDashLength + dashLength); DrawDashedSegment(aDrawTarget, rect, dashLength, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, horizontal); rect.y += rect.height; rect.height = endDashLength; DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel); } } break; case NS_STYLE_BORDER_STYLE_GROOVE: ridgeGroove = NS_STYLE_BORDER_STYLE_GROOVE; // and fall through to ridge MOZ_FALLTHROUGH; case NS_STYLE_BORDER_STYLE_RIDGE: if ((horizontal && (twipsPerPixel >= aBorder.height)) || (!horizontal && (twipsPerPixel >= aBorder.width))) { // a one pixel border DrawSolidBorderSegment(aDrawTarget, aBorder, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, aStartBevelOffset, aEndBevelSide, aEndBevelOffset); } else { nscoord startBevel = (aStartBevelOffset > 0) ? RoundFloatToPixel(0.5f * (float)aStartBevelOffset, twipsPerPixel, true) : 0; nscoord endBevel = (aEndBevelOffset > 0) ? RoundFloatToPixel(0.5f * (float)aEndBevelOffset, twipsPerPixel, true) : 0; mozilla::css::Side ridgeGrooveSide = (horizontal) ? NS_SIDE_TOP : NS_SIDE_LEFT; // FIXME: In theory, this should use the visited-dependent // background color, but I don't care. nscolor bevelColor = MakeBevelColor(ridgeGrooveSide, ridgeGroove, aBGColor->mBackgroundColor, aBorderColor); nsRect rect(aBorder); nscoord half; if (horizontal) { // top, bottom half = RoundFloatToPixel(0.5f * (float)aBorder.height, twipsPerPixel); rect.height = half; if (NS_SIDE_TOP == aStartBevelSide) { rect.x += startBevel; rect.width -= startBevel; } if (NS_SIDE_TOP == aEndBevelSide) { rect.width -= endBevel; } DrawSolidBorderSegment(aDrawTarget, rect, bevelColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } else { // left, right half = RoundFloatToPixel(0.5f * (float)aBorder.width, twipsPerPixel); rect.width = half; if (NS_SIDE_LEFT == aStartBevelSide) { rect.y += startBevel; rect.height -= startBevel; } if (NS_SIDE_LEFT == aEndBevelSide) { rect.height -= endBevel; } DrawSolidBorderSegment(aDrawTarget, rect, bevelColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } rect = aBorder; ridgeGrooveSide = (NS_SIDE_TOP == ridgeGrooveSide) ? NS_SIDE_BOTTOM : NS_SIDE_RIGHT; // FIXME: In theory, this should use the visited-dependent // background color, but I don't care. bevelColor = MakeBevelColor(ridgeGrooveSide, ridgeGroove, aBGColor->mBackgroundColor, aBorderColor); if (horizontal) { rect.y = rect.y + half; rect.height = aBorder.height - half; if (NS_SIDE_BOTTOM == aStartBevelSide) { rect.x += startBevel; rect.width -= startBevel; } if (NS_SIDE_BOTTOM == aEndBevelSide) { rect.width -= endBevel; } DrawSolidBorderSegment(aDrawTarget, rect, bevelColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } else { rect.x = rect.x + half; rect.width = aBorder.width - half; if (NS_SIDE_RIGHT == aStartBevelSide) { rect.y += aStartBevelOffset - startBevel; rect.height -= startBevel; } if (NS_SIDE_RIGHT == aEndBevelSide) { rect.height -= endBevel; } DrawSolidBorderSegment(aDrawTarget, rect, bevelColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } } break; case NS_STYLE_BORDER_STYLE_DOUBLE: // We can only do "double" borders if the thickness of the border // is more than 2px. Otherwise, we fall through to painting a // solid border. if ((aBorder.width > 2*twipsPerPixel || horizontal) && (aBorder.height > 2*twipsPerPixel || !horizontal)) { nscoord startBevel = (aStartBevelOffset > 0) ? RoundFloatToPixel(0.333333f * (float)aStartBevelOffset, twipsPerPixel) : 0; nscoord endBevel = (aEndBevelOffset > 0) ? RoundFloatToPixel(0.333333f * (float)aEndBevelOffset, twipsPerPixel) : 0; if (horizontal) { // top, bottom nscoord thirdHeight = RoundFloatToPixel(0.333333f * (float)aBorder.height, twipsPerPixel); // draw the top line or rect nsRect topRect(aBorder.x, aBorder.y, aBorder.width, thirdHeight); if (NS_SIDE_TOP == aStartBevelSide) { topRect.x += aStartBevelOffset - startBevel; topRect.width -= aStartBevelOffset - startBevel; } if (NS_SIDE_TOP == aEndBevelSide) { topRect.width -= aEndBevelOffset - endBevel; } DrawSolidBorderSegment(aDrawTarget, topRect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); // draw the botom line or rect nscoord heightOffset = aBorder.height - thirdHeight; nsRect bottomRect(aBorder.x, aBorder.y + heightOffset, aBorder.width, aBorder.height - heightOffset); if (NS_SIDE_BOTTOM == aStartBevelSide) { bottomRect.x += aStartBevelOffset - startBevel; bottomRect.width -= aStartBevelOffset - startBevel; } if (NS_SIDE_BOTTOM == aEndBevelSide) { bottomRect.width -= aEndBevelOffset - endBevel; } DrawSolidBorderSegment(aDrawTarget, bottomRect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } else { // left, right nscoord thirdWidth = RoundFloatToPixel(0.333333f * (float)aBorder.width, twipsPerPixel); nsRect leftRect(aBorder.x, aBorder.y, thirdWidth, aBorder.height); if (NS_SIDE_LEFT == aStartBevelSide) { leftRect.y += aStartBevelOffset - startBevel; leftRect.height -= aStartBevelOffset - startBevel; } if (NS_SIDE_LEFT == aEndBevelSide) { leftRect.height -= aEndBevelOffset - endBevel; } DrawSolidBorderSegment(aDrawTarget, leftRect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); nscoord widthOffset = aBorder.width - thirdWidth; nsRect rightRect(aBorder.x + widthOffset, aBorder.y, aBorder.width - widthOffset, aBorder.height); if (NS_SIDE_RIGHT == aStartBevelSide) { rightRect.y += aStartBevelOffset - startBevel; rightRect.height -= aStartBevelOffset - startBevel; } if (NS_SIDE_RIGHT == aEndBevelSide) { rightRect.height -= aEndBevelOffset - endBevel; } DrawSolidBorderSegment(aDrawTarget, rightRect, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, startBevel, aEndBevelSide, endBevel); } break; } // else fall through to solid MOZ_FALLTHROUGH; case NS_STYLE_BORDER_STYLE_SOLID: DrawSolidBorderSegment(aDrawTarget, aBorder, aBorderColor, aAppUnitsPerDevPixel, twipsPerPixel, aStartBevelSide, aStartBevelOffset, aEndBevelSide, aEndBevelOffset); break; case NS_STYLE_BORDER_STYLE_OUTSET: case NS_STYLE_BORDER_STYLE_INSET: NS_ASSERTION(false, "inset, outset should have been converted to groove, ridge"); break; case NS_STYLE_BORDER_STYLE_AUTO: NS_ASSERTION(false, "Unexpected 'auto' table border"); break; } } // End table border-collapsing section Rect nsCSSRendering::ExpandPaintingRectForDecorationLine( nsIFrame* aFrame, const uint8_t aStyle, const Rect& aClippedRect, const Float aICoordInFrame, const Float aCycleLength, bool aVertical) { switch (aStyle) { case NS_STYLE_TEXT_DECORATION_STYLE_DOTTED: case NS_STYLE_TEXT_DECORATION_STYLE_DASHED: case NS_STYLE_TEXT_DECORATION_STYLE_WAVY: break; default: NS_ERROR("Invalid style was specified"); return aClippedRect; } nsBlockFrame* block = nullptr; // Note that when we paint the decoration lines in relative positioned // box, we should paint them like all of the boxes are positioned as static. nscoord framePosInBlockAppUnits = 0; for (nsIFrame* f = aFrame; f; f = f->GetParent()) { block = do_QueryFrame(f); if (block) { break; } framePosInBlockAppUnits += aVertical ? f->GetNormalPosition().y : f->GetNormalPosition().x; } NS_ENSURE_TRUE(block, aClippedRect); nsPresContext *pc = aFrame->PresContext(); Float framePosInBlock = Float(pc->AppUnitsToGfxUnits(framePosInBlockAppUnits)); int32_t rectPosInBlock = int32_t(NS_round(framePosInBlock + aICoordInFrame)); int32_t extraStartEdge = rectPosInBlock - (rectPosInBlock / int32_t(aCycleLength) * aCycleLength); Rect rect(aClippedRect); if (aVertical) { rect.y -= extraStartEdge; rect.height += extraStartEdge; } else { rect.x -= extraStartEdge; rect.width += extraStartEdge; } return rect; } void nsCSSRendering::PaintDecorationLine(nsIFrame* aFrame, DrawTarget& aDrawTarget, const PaintDecorationLineParams& aParams) { NS_ASSERTION(aParams.style != NS_STYLE_TEXT_DECORATION_STYLE_NONE, "aStyle is none"); Rect rect = ToRect(GetTextDecorationRectInternal(aParams.pt, aParams)); if (rect.IsEmpty() || !rect.Intersects(aParams.dirtyRect)) { return; } if (aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE && aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_OVERLINE && aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH) { NS_ERROR("Invalid decoration value!"); return; } Float lineThickness = std::max(NS_round(aParams.lineSize.height), 1.0); ColorPattern color(ToDeviceColor(aParams.color)); StrokeOptions strokeOptions(lineThickness); DrawOptions drawOptions; Float dash[2]; AutoPopClips autoPopClips(&aDrawTarget); switch (aParams.style) { case NS_STYLE_TEXT_DECORATION_STYLE_SOLID: case NS_STYLE_TEXT_DECORATION_STYLE_DOUBLE: break; case NS_STYLE_TEXT_DECORATION_STYLE_DASHED: { autoPopClips.PushClipRect(rect); Float dashWidth = lineThickness * DOT_LENGTH * DASH_LENGTH; dash[0] = dashWidth; dash[1] = dashWidth; strokeOptions.mDashPattern = dash; strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); strokeOptions.mLineCap = CapStyle::BUTT; rect = ExpandPaintingRectForDecorationLine(aFrame, aParams.style, rect, aParams.icoordInFrame, dashWidth * 2, aParams.vertical); // We should continue to draw the last dash even if it is not in the rect. rect.width += dashWidth; break; } case NS_STYLE_TEXT_DECORATION_STYLE_DOTTED: { autoPopClips.PushClipRect(rect); Float dashWidth = lineThickness * DOT_LENGTH; if (lineThickness > 2.0) { dash[0] = 0.f; dash[1] = dashWidth * 2.f; strokeOptions.mLineCap = CapStyle::ROUND; } else { dash[0] = dashWidth; dash[1] = dashWidth; } strokeOptions.mDashPattern = dash; strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); rect = ExpandPaintingRectForDecorationLine(aFrame, aParams.style, rect, aParams.icoordInFrame, dashWidth * 2, aParams.vertical); // We should continue to draw the last dot even if it is not in the rect. rect.width += dashWidth; break; } case NS_STYLE_TEXT_DECORATION_STYLE_WAVY: autoPopClips.PushClipRect(rect); if (lineThickness > 2.0) { drawOptions.mAntialiasMode = AntialiasMode::SUBPIXEL; } else { // Don't use anti-aliasing here. Because looks like lighter color wavy // line at this case. And probably, users don't think the // non-anti-aliased wavy line is not pretty. drawOptions.mAntialiasMode = AntialiasMode::NONE; } break; default: NS_ERROR("Invalid style value!"); return; } // The block-direction position should be set to the middle of the line. if (aParams.vertical) { rect.x += lineThickness / 2; } else { rect.y += lineThickness / 2; } switch (aParams.style) { case NS_STYLE_TEXT_DECORATION_STYLE_SOLID: case NS_STYLE_TEXT_DECORATION_STYLE_DOTTED: case NS_STYLE_TEXT_DECORATION_STYLE_DASHED: { Point p1 = rect.TopLeft(); Point p2 = aParams.vertical ? rect.BottomLeft() : rect.TopRight(); aDrawTarget.StrokeLine(p1, p2, color, strokeOptions, drawOptions); return; } case NS_STYLE_TEXT_DECORATION_STYLE_DOUBLE: { /** * We are drawing double line as: * * +-------------------------------------------+ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v * | | * | | * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v * +-------------------------------------------+ */ Point p1 = rect.TopLeft(); Point p2 = aParams.vertical ? rect.BottomLeft() : rect.TopRight(); aDrawTarget.StrokeLine(p1, p2, color, strokeOptions, drawOptions); if (aParams.vertical) { rect.width -= lineThickness; } else { rect.height -= lineThickness; } p1 = aParams.vertical ? rect.TopRight() : rect.BottomLeft(); p2 = rect.BottomRight(); aDrawTarget.StrokeLine(p1, p2, color, strokeOptions, drawOptions); return; } case NS_STYLE_TEXT_DECORATION_STYLE_WAVY: { /** * We are drawing wavy line as: * * P: Path, X: Painted pixel * * +---------------------------------------+ * XX|X XXXXXX XXXXXX | * PP|PX XPPPPPPX XPPPPPPX | ^ * XX|XPX XPXXXXXXPX XPXXXXXXPX| | * | XPX XPX XPX XPX XP|X |adv * | XPXXXXXXPX XPXXXXXXPX X|PX | * | XPPPPPPX XPPPPPPX |XPX v * | XXXXXX XXXXXX | XX * +---------------------------------------+ * <---><---> ^ * adv flatLengthAtVertex rightMost * * 1. Always starts from top-left of the drawing area, however, we need * to draw the line from outside of the rect. Because the start * point of the line is not good style if we draw from inside it. * 2. First, draw horizontal line from outside the rect to top-left of * the rect; * 3. Goes down to bottom of the area at 45 degrees. * 4. Slides to right horizontaly, see |flatLengthAtVertex|. * 5. Goes up to top of the area at 45 degrees. * 6. Slides to right horizontaly. * 7. Repeat from 2 until reached to right-most edge of the area. * * In the vertical case, swap horizontal and vertical coordinates and * directions in the above description. */ Float& rectICoord = aParams.vertical ? rect.y : rect.x; Float& rectISize = aParams.vertical ? rect.height : rect.width; const Float rectBSize = aParams.vertical ? rect.width : rect.height; const Float adv = rectBSize - lineThickness; const Float flatLengthAtVertex = std::max((lineThickness - 1.0) * 2.0, 1.0); // Align the start of wavy lines to the nearest ancestor block. const Float cycleLength = 2 * (adv + flatLengthAtVertex); rect = ExpandPaintingRectForDecorationLine(aFrame, aParams.style, rect, aParams.icoordInFrame, cycleLength, aParams.vertical); // figure out if we can trim whole cycles from the left and right edges // of the line, to try and avoid creating an unnecessarily long and // complex path const Float dirtyRectICoord = aParams.vertical ? aParams.dirtyRect.y : aParams.dirtyRect.x; int32_t skipCycles = floor((dirtyRectICoord - rectICoord) / cycleLength); if (skipCycles > 0) { rectICoord += skipCycles * cycleLength; rectISize -= skipCycles * cycleLength; } rectICoord += lineThickness / 2.0; Point pt(rect.TopLeft()); Float& ptICoord = aParams.vertical ? pt.y : pt.x; Float& ptBCoord = aParams.vertical ? pt.x : pt.y; if (aParams.vertical) { ptBCoord += adv + lineThickness / 2.0; } Float iCoordLimit = ptICoord + rectISize + lineThickness; const Float dirtyRectIMost = aParams.vertical ? aParams.dirtyRect.YMost() : aParams.dirtyRect.XMost(); skipCycles = floor((iCoordLimit - dirtyRectIMost) / cycleLength); if (skipCycles > 0) { iCoordLimit -= skipCycles * cycleLength; } RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder(); RefPtr<Path> path; ptICoord -= lineThickness; builder->MoveTo(pt); // 1 ptICoord = rectICoord; builder->LineTo(pt); // 2 // In vertical mode, to go "down" relative to the text we need to // decrease the block coordinate, whereas in horizontal we increase // it. So the sense of this flag is effectively inverted. bool goDown = aParams.vertical ? false : true; uint32_t iter = 0; while (ptICoord < iCoordLimit) { if (++iter > 1000) { // stroke the current path and start again, to avoid pathological // behavior in cairo with huge numbers of path segments path = builder->Finish(); aDrawTarget.Stroke(path, color, strokeOptions, drawOptions); builder = aDrawTarget.CreatePathBuilder(); builder->MoveTo(pt); iter = 0; } ptICoord += adv; ptBCoord += goDown ? adv : -adv; builder->LineTo(pt); // 3 and 5 ptICoord += flatLengthAtVertex; builder->LineTo(pt); // 4 and 6 goDown = !goDown; } path = builder->Finish(); aDrawTarget.Stroke(path, color, strokeOptions, drawOptions); return; } default: NS_ERROR("Invalid style value!"); } } Rect nsCSSRendering::DecorationLineToPath(const PaintDecorationLineParams& aParams) { NS_ASSERTION(aParams.style != NS_STYLE_TEXT_DECORATION_STYLE_NONE, "aStyle is none"); Rect path; // To benefit from RVO, we return this from all return points Rect rect = ToRect(GetTextDecorationRectInternal(aParams.pt, aParams)); if (rect.IsEmpty() || !rect.Intersects(aParams.dirtyRect)) { return path; } if (aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE && aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_OVERLINE && aParams.decoration != NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH) { NS_ERROR("Invalid decoration value!"); return path; } if (aParams.style != NS_STYLE_TEXT_DECORATION_STYLE_SOLID) { // For the moment, we support only solid text decorations. return path; } Float lineThickness = std::max(NS_round(aParams.lineSize.height), 1.0); // The block-direction position should be set to the middle of the line. if (aParams.vertical) { rect.x += lineThickness / 2; path = Rect(rect.TopLeft() - Point(lineThickness / 2, 0.0), Size(lineThickness, rect.Height())); } else { rect.y += lineThickness / 2; path = Rect(rect.TopLeft() - Point(0.0, lineThickness / 2), Size(rect.Width(), lineThickness)); } return path; } nsRect nsCSSRendering::GetTextDecorationRect(nsPresContext* aPresContext, const DecorationRectParams& aParams) { NS_ASSERTION(aPresContext, "aPresContext is null"); NS_ASSERTION(aParams.style != NS_STYLE_TEXT_DECORATION_STYLE_NONE, "aStyle is none"); gfxRect rect = GetTextDecorationRectInternal(Point(0, 0), aParams); // The rect values are already rounded to nearest device pixels. nsRect r; r.x = aPresContext->GfxUnitsToAppUnits(rect.X()); r.y = aPresContext->GfxUnitsToAppUnits(rect.Y()); r.width = aPresContext->GfxUnitsToAppUnits(rect.Width()); r.height = aPresContext->GfxUnitsToAppUnits(rect.Height()); return r; } gfxRect nsCSSRendering::GetTextDecorationRectInternal(const Point& aPt, const DecorationRectParams& aParams) { NS_ASSERTION(aParams.style <= NS_STYLE_TEXT_DECORATION_STYLE_WAVY, "Invalid aStyle value"); if (aParams.style == NS_STYLE_TEXT_DECORATION_STYLE_NONE) return gfxRect(0, 0, 0, 0); bool canLiftUnderline = aParams.descentLimit >= 0.0; gfxFloat iCoord = aParams.vertical ? aPt.y : aPt.x; gfxFloat bCoord = aParams.vertical ? aPt.x : aPt.y; // 'left' and 'right' are relative to the line, so for vertical writing modes // they will actually become top and bottom of the rendered line. // Similarly, aLineSize.width and .height are actually length and thickness // of the line, which runs horizontally or vertically according to aVertical. const gfxFloat left = floor(iCoord + 0.5), right = floor(iCoord + aParams.lineSize.width + 0.5); // We compute |r| as if for a horizontal text run, and then swap vertical // and horizontal coordinates at the end if vertical was requested. gfxRect r(left, 0, right - left, 0); gfxFloat lineThickness = NS_round(aParams.lineSize.height); lineThickness = std::max(lineThickness, 1.0); gfxFloat ascent = NS_round(aParams.ascent); gfxFloat descentLimit = floor(aParams.descentLimit); gfxFloat suggestedMaxRectHeight = std::max(std::min(ascent, descentLimit), 1.0); r.height = lineThickness; if (aParams.style == NS_STYLE_TEXT_DECORATION_STYLE_DOUBLE) { /** * We will draw double line as: * * +-------------------------------------------+ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v * | | ^ * | | | gap * | | v * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v * +-------------------------------------------+ */ gfxFloat gap = NS_round(lineThickness / 2.0); gap = std::max(gap, 1.0); r.height = lineThickness * 2.0 + gap; if (canLiftUnderline) { if (r.Height() > suggestedMaxRectHeight) { // Don't shrink the line height, because the thickness has some meaning. // We can just shrink the gap at this time. r.height = std::max(suggestedMaxRectHeight, lineThickness * 2.0 + 1.0); } } } else if (aParams.style == NS_STYLE_TEXT_DECORATION_STYLE_WAVY) { /** * We will draw wavy line as: * * +-------------------------------------------+ * |XXXXX XXXXXX XXXXXX | ^ * |XXXXXX XXXXXXXX XXXXXXXX | | lineThickness * |XXXXXXX XXXXXXXXXX XXXXXXXXXX| v * | XXX XXX XXX XXX XX| * | XXXXXXXXXX XXXXXXXXXX X| * | XXXXXXXX XXXXXXXX | * | XXXXXX XXXXXX | * +-------------------------------------------+ */ r.height = lineThickness > 2.0 ? lineThickness * 4.0 : lineThickness * 3.0; if (canLiftUnderline) { if (r.Height() > suggestedMaxRectHeight) { // Don't shrink the line height even if there is not enough space, // because the thickness has some meaning. E.g., the 1px wavy line and // 2px wavy line can be used for different meaning in IME selections // at same time. r.height = std::max(suggestedMaxRectHeight, lineThickness * 2.0); } } } gfxFloat baseline = floor(bCoord + aParams.ascent + 0.5); gfxFloat offset = 0.0; switch (aParams.decoration) { case NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE: offset = aParams.offset; if (canLiftUnderline) { if (descentLimit < -offset + r.Height()) { // If we can ignore the offset and the decoration line is overflowing, // we should align the bottom edge of the decoration line rect if it's // possible. Otherwise, we should lift up the top edge of the rect as // far as possible. gfxFloat offsetBottomAligned = -descentLimit + r.Height(); gfxFloat offsetTopAligned = 0.0; offset = std::min(offsetBottomAligned, offsetTopAligned); } } break; case NS_STYLE_TEXT_DECORATION_LINE_OVERLINE: offset = aParams.offset - lineThickness + r.Height(); break; case NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH: { gfxFloat extra = floor(r.Height() / 2.0 + 0.5); extra = std::max(extra, lineThickness); offset = aParams.offset - lineThickness + extra; break; } default: NS_ERROR("Invalid decoration value!"); } if (aParams.vertical) { r.y = baseline + floor(offset + 0.5); Swap(r.x, r.y); Swap(r.width, r.height); } else { r.y = baseline - floor(offset + 0.5); } return r; } // ------------------ // ImageRenderer // ------------------ nsImageRenderer::nsImageRenderer(nsIFrame* aForFrame, const nsStyleImage* aImage, uint32_t aFlags) : mForFrame(aForFrame) , mImage(aImage) , mType(aImage->GetType()) , mImageContainer(nullptr) , mGradientData(nullptr) , mPaintServerFrame(nullptr) , mPrepareResult(DrawResult::NOT_READY) , mSize(0, 0) , mFlags(aFlags) , mExtendMode(ExtendMode::CLAMP) , mMaskOp(NS_STYLE_MASK_MODE_MATCH_SOURCE) { } nsImageRenderer::~nsImageRenderer() { } static bool ShouldTreatAsCompleteDueToSyncDecode(const nsStyleImage* aImage, uint32_t aFlags) { if (!(aFlags & nsImageRenderer::FLAG_SYNC_DECODE_IMAGES)) { return false; } if (aImage->GetType() != eStyleImageType_Image) { return false; } imgRequestProxy* req = aImage->GetImageData(); if (!req) { return false; } uint32_t status = 0; if (NS_FAILED(req->GetImageStatus(&status))) { return false; } if (status & imgIRequest::STATUS_ERROR) { // The image is "complete" since it's a corrupt image. If we created an // imgIContainer at all, return true. nsCOMPtr<imgIContainer> image; req->GetImage(getter_AddRefs(image)); return bool(image); } if (!(status & imgIRequest::STATUS_LOAD_COMPLETE)) { // We must have loaded all of the image's data and the size must be // available, or else sync decoding won't be able to decode the image. return false; } return true; } bool nsImageRenderer::PrepareImage() { if (mImage->IsEmpty()) { mPrepareResult = DrawResult::BAD_IMAGE; return false; } if (!mImage->IsComplete()) { // Make sure the image is actually decoding. mImage->StartDecoding(); // Check again to see if we finished. // We cannot prepare the image for rendering if it is not fully loaded. // Special case: If we requested a sync decode and the image has loaded, push // on through because the Draw() will do a sync decode then. if (!mImage->IsComplete() && !ShouldTreatAsCompleteDueToSyncDecode(mImage, mFlags)) { mPrepareResult = DrawResult::NOT_READY; return false; } } switch (mType) { case eStyleImageType_Image: { MOZ_ASSERT(mImage->GetImageData(), "must have image data, since we checked IsEmpty above"); nsCOMPtr<imgIContainer> srcImage; DebugOnly<nsresult> rv = mImage->GetImageData()->GetImage(getter_AddRefs(srcImage)); MOZ_ASSERT(NS_SUCCEEDED(rv) && srcImage, "If GetImage() is failing, mImage->IsComplete() " "should have returned false"); if (!mImage->GetCropRect()) { mImageContainer.swap(srcImage); } else { nsIntRect actualCropRect; bool isEntireImage; bool success = mImage->ComputeActualCropRect(actualCropRect, &isEntireImage); NS_ASSERTION(success, "ComputeActualCropRect() should not fail here"); if (!success || actualCropRect.IsEmpty()) { // The cropped image has zero size mPrepareResult = DrawResult::BAD_IMAGE; return false; } if (isEntireImage) { // The cropped image is identical to the source image mImageContainer.swap(srcImage); } else { nsCOMPtr<imgIContainer> subImage = ImageOps::Clip(srcImage, actualCropRect, Nothing()); mImageContainer.swap(subImage); } } mPrepareResult = DrawResult::SUCCESS; break; } case eStyleImageType_Gradient: mGradientData = mImage->GetGradientData(); mPrepareResult = DrawResult::SUCCESS; break; case eStyleImageType_Element: { nsAutoString elementId = NS_LITERAL_STRING("#") + nsDependentString(mImage->GetElementId()); nsCOMPtr<nsIURI> targetURI; nsCOMPtr<nsIURI> base = mForFrame->GetContent()->GetBaseURI(); nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(targetURI), elementId, mForFrame->GetContent()->GetUncomposedDoc(), base); nsSVGPaintingProperty* property = nsSVGEffects::GetPaintingPropertyForURI( targetURI, mForFrame->FirstContinuation(), nsSVGEffects::BackgroundImageProperty()); if (!property) { mPrepareResult = DrawResult::BAD_IMAGE; return false; } // If the referenced element is an <img>, <canvas>, or <video> element, // prefer SurfaceFromElement as it's more reliable. mImageElementSurface = nsLayoutUtils::SurfaceFromElement(property->GetReferencedElement()); if (!mImageElementSurface.GetSourceSurface()) { nsIFrame* paintServerFrame = property->GetReferencedFrame(); // If there's no referenced frame, or the referenced frame is // non-displayable SVG, then we have nothing valid to paint. if (!paintServerFrame || (paintServerFrame->IsFrameOfType(nsIFrame::eSVG) && !paintServerFrame->IsFrameOfType(nsIFrame::eSVGPaintServer) && !static_cast<nsISVGChildFrame*>(do_QueryFrame(paintServerFrame)))) { mPrepareResult = DrawResult::BAD_IMAGE; return false; } mPaintServerFrame = paintServerFrame; } mPrepareResult = DrawResult::SUCCESS; break; } case eStyleImageType_Null: default: break; } return IsReady(); } nsSize CSSSizeOrRatio::ComputeConcreteSize() const { NS_ASSERTION(CanComputeConcreteSize(), "Cannot compute"); if (mHasWidth && mHasHeight) { return nsSize(mWidth, mHeight); } if (mHasWidth) { nscoord height = NSCoordSaturatingNonnegativeMultiply( mWidth, double(mRatio.height) / mRatio.width); return nsSize(mWidth, height); } MOZ_ASSERT(mHasHeight); nscoord width = NSCoordSaturatingNonnegativeMultiply( mHeight, double(mRatio.width) / mRatio.height); return nsSize(width, mHeight); } CSSSizeOrRatio nsImageRenderer::ComputeIntrinsicSize() { NS_ASSERTION(IsReady(), "Ensure PrepareImage() has returned true " "before calling me"); CSSSizeOrRatio result; switch (mType) { case eStyleImageType_Image: { bool haveWidth, haveHeight; CSSIntSize imageIntSize; nsLayoutUtils::ComputeSizeForDrawing(mImageContainer, imageIntSize, result.mRatio, haveWidth, haveHeight); if (haveWidth) { result.SetWidth(nsPresContext::CSSPixelsToAppUnits(imageIntSize.width)); } if (haveHeight) { result.SetHeight(nsPresContext::CSSPixelsToAppUnits(imageIntSize.height)); } break; } case eStyleImageType_Element: { // XXX element() should have the width/height of the referenced element, // and that element's ratio, if it matches. If it doesn't match, it // should have no width/height or ratio. See element() in CSS images: // <http://dev.w3.org/csswg/css-images-4/#element-notation>. // Make sure to change nsStyleImageLayers::Size::DependsOnFrameSize // when fixing this! if (mPaintServerFrame) { // SVG images have no intrinsic size if (!mPaintServerFrame->IsFrameOfType(nsIFrame::eSVG)) { // The intrinsic image size for a generic nsIFrame paint server is // the union of the border-box rects of all of its continuations, // rounded to device pixels. int32_t appUnitsPerDevPixel = mForFrame->PresContext()->AppUnitsPerDevPixel(); result.SetSize( IntSizeToAppUnits( nsSVGIntegrationUtils::GetContinuationUnionSize(mPaintServerFrame). ToNearestPixels(appUnitsPerDevPixel), appUnitsPerDevPixel)); } } else { NS_ASSERTION(mImageElementSurface.GetSourceSurface(), "Surface should be ready."); IntSize surfaceSize = mImageElementSurface.mSize; result.SetSize( nsSize(nsPresContext::CSSPixelsToAppUnits(surfaceSize.width), nsPresContext::CSSPixelsToAppUnits(surfaceSize.height))); } break; } case eStyleImageType_Gradient: // Per <http://dev.w3.org/csswg/css3-images/#gradients>, gradients have no // intrinsic dimensions. case eStyleImageType_Null: default: break; } return result; } /* static */ nsSize nsImageRenderer::ComputeConcreteSize(const CSSSizeOrRatio& aSpecifiedSize, const CSSSizeOrRatio& aIntrinsicSize, const nsSize& aDefaultSize) { // The specified size is fully specified, just use that if (aSpecifiedSize.IsConcrete()) { return aSpecifiedSize.ComputeConcreteSize(); } MOZ_ASSERT(!aSpecifiedSize.mHasWidth || !aSpecifiedSize.mHasHeight); if (!aSpecifiedSize.mHasWidth && !aSpecifiedSize.mHasHeight) { // no specified size, try using the intrinsic size if (aIntrinsicSize.CanComputeConcreteSize()) { return aIntrinsicSize.ComputeConcreteSize(); } if (aIntrinsicSize.mHasWidth) { return nsSize(aIntrinsicSize.mWidth, aDefaultSize.height); } if (aIntrinsicSize.mHasHeight) { return nsSize(aDefaultSize.width, aIntrinsicSize.mHeight); } // couldn't use the intrinsic size either, revert to using the default size return ComputeConstrainedSize(aDefaultSize, aIntrinsicSize.mRatio, CONTAIN); } MOZ_ASSERT(aSpecifiedSize.mHasWidth || aSpecifiedSize.mHasHeight); // The specified height is partial, try to compute the missing part. if (aSpecifiedSize.mHasWidth) { nscoord height; if (aIntrinsicSize.HasRatio()) { height = NSCoordSaturatingNonnegativeMultiply( aSpecifiedSize.mWidth, double(aIntrinsicSize.mRatio.height) / aIntrinsicSize.mRatio.width); } else if (aIntrinsicSize.mHasHeight) { height = aIntrinsicSize.mHeight; } else { height = aDefaultSize.height; } return nsSize(aSpecifiedSize.mWidth, height); } MOZ_ASSERT(aSpecifiedSize.mHasHeight); nscoord width; if (aIntrinsicSize.HasRatio()) { width = NSCoordSaturatingNonnegativeMultiply( aSpecifiedSize.mHeight, double(aIntrinsicSize.mRatio.width) / aIntrinsicSize.mRatio.height); } else if (aIntrinsicSize.mHasWidth) { width = aIntrinsicSize.mWidth; } else { width = aDefaultSize.width; } return nsSize(width, aSpecifiedSize.mHeight); } /* static */ nsSize nsImageRenderer::ComputeConstrainedSize(const nsSize& aConstrainingSize, const nsSize& aIntrinsicRatio, FitType aFitType) { if (aIntrinsicRatio.width <= 0 && aIntrinsicRatio.height <= 0) { return aConstrainingSize; } float scaleX = double(aConstrainingSize.width) / aIntrinsicRatio.width; float scaleY = double(aConstrainingSize.height) / aIntrinsicRatio.height; nsSize size; if ((aFitType == CONTAIN) == (scaleX < scaleY)) { size.width = aConstrainingSize.width; size.height = NSCoordSaturatingNonnegativeMultiply( aIntrinsicRatio.height, scaleX); // If we're reducing the size by less than one css pixel, then just use the // constraining size. if (aFitType == CONTAIN && aConstrainingSize.height - size.height < nsPresContext::AppUnitsPerCSSPixel()) { size.height = aConstrainingSize.height; } } else { size.width = NSCoordSaturatingNonnegativeMultiply( aIntrinsicRatio.width, scaleY); if (aFitType == CONTAIN && aConstrainingSize.width - size.width < nsPresContext::AppUnitsPerCSSPixel()) { size.width = aConstrainingSize.width; } size.height = aConstrainingSize.height; } return size; } /** * mSize is the image's "preferred" size for this particular rendering, while * the drawn (aka concrete) size is the actual rendered size after accounting * for background-size etc.. The preferred size is most often the image's * intrinsic dimensions. But for images with incomplete intrinsic dimensions, * the preferred size varies, depending on the specified and default sizes, see * nsImageRenderer::Compute*Size. * * This distinction is necessary because the components of a vector image are * specified with respect to its preferred size for a rendering situation, not * to its actual rendered size. For example, consider a 4px wide background * vector image with no height which contains a left-aligned * 2px wide black rectangle with height 100%. If the background-size width is * auto (or 4px), the vector image will render 4px wide, and the black rectangle * will be 2px wide. If the background-size width is 8px, the vector image will * render 8px wide, and the black rectangle will be 4px wide -- *not* 2px wide. * In both cases mSize.width will be 4px; but in the first case the returned * width will be 4px, while in the second case the returned width will be 8px. */ void nsImageRenderer::SetPreferredSize(const CSSSizeOrRatio& aIntrinsicSize, const nsSize& aDefaultSize) { mSize.width = aIntrinsicSize.mHasWidth ? aIntrinsicSize.mWidth : aDefaultSize.width; mSize.height = aIntrinsicSize.mHasHeight ? aIntrinsicSize.mHeight : aDefaultSize.height; } // Convert from nsImageRenderer flags to the flags we want to use for drawing in // the imgIContainer namespace. static uint32_t ConvertImageRendererToDrawFlags(uint32_t aImageRendererFlags) { uint32_t drawFlags = imgIContainer::FLAG_NONE; if (aImageRendererFlags & nsImageRenderer::FLAG_SYNC_DECODE_IMAGES) { drawFlags |= imgIContainer::FLAG_SYNC_DECODE; } if (aImageRendererFlags & nsImageRenderer::FLAG_PAINTING_TO_WINDOW) { drawFlags |= imgIContainer::FLAG_HIGH_QUALITY_SCALING; } return drawFlags; } /* * SVG11: A luminanceToAlpha operation is equivalent to the following matrix operation: | * | R' | | 0 0 0 0 0 | | R | * | G' | | 0 0 0 0 0 | | G | * | B' | = | 0 0 0 0 0 | * | B | * | A' | | 0.2125 0.7154 0.0721 0 0 | | A | * | 1 | | 0 0 0 0 1 | | 1 | */ static void RGBALuminanceOperation(uint8_t *aData, int32_t aStride, const IntSize &aSize) { int32_t redFactor = 55; // 256 * 0.2125 int32_t greenFactor = 183; // 256 * 0.7154 int32_t blueFactor = 18; // 256 * 0.0721 for (int32_t y = 0; y < aSize.height; y++) { uint32_t *pixel = (uint32_t*)(aData + aStride * y); for (int32_t x = 0; x < aSize.width; x++) { *pixel = (((((*pixel & 0x00FF0000) >> 16) * redFactor) + (((*pixel & 0x0000FF00) >> 8) * greenFactor) + ((*pixel & 0x000000FF) * blueFactor)) >> 8) << 24; pixel++; } } } DrawResult nsImageRenderer::Draw(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, const nsRect& aDirtyRect, const nsRect& aDest, const nsRect& aFill, const nsPoint& aAnchor, const nsSize& aRepeatSize, const CSSIntRect& aSrc) { if (!IsReady()) { NS_NOTREACHED("Ensure PrepareImage() has returned true before calling me"); return DrawResult::TEMPORARY_ERROR; } if (aDest.IsEmpty() || aFill.IsEmpty() || mSize.width <= 0 || mSize.height <= 0) { return DrawResult::SUCCESS; } SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(mForFrame); DrawResult result = DrawResult::SUCCESS; RefPtr<gfxContext> ctx = aRenderingContext.ThebesContext(); IntRect tmpDTRect; if (ctx->CurrentOp() != CompositionOp::OP_OVER || mMaskOp == NS_STYLE_MASK_MODE_LUMINANCE) { gfxRect clipRect = ctx->GetClipExtents(); tmpDTRect = RoundedOut(ToRect(clipRect)); if (tmpDTRect.IsEmpty()) { return DrawResult::SUCCESS; } RefPtr<DrawTarget> tempDT = gfxPlatform::GetPlatform()->CreateSimilarSoftwareDrawTarget(ctx->GetDrawTarget(), tmpDTRect.Size(), SurfaceFormat::B8G8R8A8); if (!tempDT || !tempDT->IsValid()) { gfxDevCrash(LogReason::InvalidContext) << "ImageRenderer::Draw problem " << gfx::hexa(tempDT); return DrawResult::TEMPORARY_ERROR; } tempDT->SetTransform(Matrix::Translation(-tmpDTRect.TopLeft())); ctx = gfxContext::CreatePreservingTransformOrNull(tempDT); if (!ctx) { gfxDevCrash(LogReason::InvalidContext) << "ImageRenderer::Draw problem " << gfx::hexa(tempDT); return DrawResult::TEMPORARY_ERROR; } } switch (mType) { case eStyleImageType_Image: { CSSIntSize imageSize(nsPresContext::AppUnitsToIntCSSPixels(mSize.width), nsPresContext::AppUnitsToIntCSSPixels(mSize.height)); result = nsLayoutUtils::DrawBackgroundImage(*ctx, aPresContext, mImageContainer, imageSize, samplingFilter, aDest, aFill, aRepeatSize, aAnchor, aDirtyRect, ConvertImageRendererToDrawFlags(mFlags), mExtendMode); break; } case eStyleImageType_Gradient: { nsCSSRendering::PaintGradient(aPresContext, aRenderingContext, mGradientData, aDirtyRect, aDest, aFill, aRepeatSize, aSrc, mSize); break; } case eStyleImageType_Element: { RefPtr<gfxDrawable> drawable = DrawableForElement(aDest, aRenderingContext); if (!drawable) { NS_WARNING("Could not create drawable for element"); return DrawResult::TEMPORARY_ERROR; } nsCOMPtr<imgIContainer> image(ImageOps::CreateFromDrawable(drawable)); result = nsLayoutUtils::DrawImage(*ctx, aPresContext, image, samplingFilter, aDest, aFill, aAnchor, aDirtyRect, ConvertImageRendererToDrawFlags(mFlags)); break; } case eStyleImageType_Null: default: break; } if (!tmpDTRect.IsEmpty()) { RefPtr<SourceSurface> surf = ctx->GetDrawTarget()->Snapshot(); if (mMaskOp == NS_STYLE_MASK_MODE_LUMINANCE) { RefPtr<DataSourceSurface> maskData = surf->GetDataSurface(); DataSourceSurface::MappedSurface map; if (!maskData->Map(DataSourceSurface::MapType::WRITE, &map)) { return result; } RGBALuminanceOperation(map.mData, map.mStride, maskData->GetSize()); maskData->Unmap(); surf = maskData; } DrawTarget* dt = aRenderingContext.ThebesContext()->GetDrawTarget(); dt->DrawSurface(surf, Rect(tmpDTRect.x, tmpDTRect.y, tmpDTRect.width, tmpDTRect.height), Rect(0, 0, tmpDTRect.width, tmpDTRect.height), DrawSurfaceOptions(SamplingFilter::POINT), DrawOptions(1.0f, aRenderingContext.ThebesContext()->CurrentOp())); } return result; } already_AddRefed<gfxDrawable> nsImageRenderer::DrawableForElement(const nsRect& aImageRect, nsRenderingContext& aRenderingContext) { NS_ASSERTION(mType == eStyleImageType_Element, "DrawableForElement only makes sense if backed by an element"); if (mPaintServerFrame) { // XXX(seth): In order to not pass FLAG_SYNC_DECODE_IMAGES here, // DrawableFromPaintServer would have to return a DrawResult indicating // whether any images could not be painted because they weren't fully // decoded. Even always passing FLAG_SYNC_DECODE_IMAGES won't eliminate all // problems, as it won't help if there are image which haven't finished // loading, but it's better than nothing. int32_t appUnitsPerDevPixel = mForFrame->PresContext()->AppUnitsPerDevPixel(); nsRect destRect = aImageRect - aImageRect.TopLeft(); nsIntSize roundedOut = destRect.ToOutsidePixels(appUnitsPerDevPixel).Size(); IntSize imageSize(roundedOut.width, roundedOut.height); RefPtr<gfxDrawable> drawable = nsSVGIntegrationUtils::DrawableFromPaintServer( mPaintServerFrame, mForFrame, mSize, imageSize, aRenderingContext.GetDrawTarget(), aRenderingContext.ThebesContext()->CurrentMatrix(), nsSVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES); return drawable.forget(); } NS_ASSERTION(mImageElementSurface.GetSourceSurface(), "Surface should be ready."); RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable( mImageElementSurface.GetSourceSurface().get(), mImageElementSurface.mSize); return drawable.forget(); } DrawResult nsImageRenderer::DrawBackground(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, const nsRect& aDest, const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty, const nsSize& aRepeatSize) { if (!IsReady()) { NS_NOTREACHED("Ensure PrepareImage() has returned true before calling me"); return DrawResult::TEMPORARY_ERROR; } if (aDest.IsEmpty() || aFill.IsEmpty() || mSize.width <= 0 || mSize.height <= 0) { return DrawResult::SUCCESS; } return Draw(aPresContext, aRenderingContext, aDirty, aDest, aFill, aAnchor, aRepeatSize, CSSIntRect(0, 0, nsPresContext::AppUnitsToIntCSSPixels(mSize.width), nsPresContext::AppUnitsToIntCSSPixels(mSize.height))); } /** * Compute the size and position of the master copy of the image. I.e., a single * tile used to fill the dest rect. * aFill The destination rect to be filled * aHFill and aVFill are the repeat patterns for the component - * NS_STYLE_BORDER_IMAGE_REPEAT_* - i.e., how a tiling unit is used to fill aFill * aUnitSize The size of the source rect in dest coords. */ static nsRect ComputeTile(nsRect& aFill, uint8_t aHFill, uint8_t aVFill, const nsSize& aUnitSize, nsSize& aRepeatSize) { nsRect tile; switch (aHFill) { case NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH: tile.x = aFill.x; tile.width = aFill.width; aRepeatSize.width = tile.width; break; case NS_STYLE_BORDER_IMAGE_REPEAT_REPEAT: tile.x = aFill.x + aFill.width/2 - aUnitSize.width/2; tile.width = aUnitSize.width; aRepeatSize.width = tile.width; break; case NS_STYLE_BORDER_IMAGE_REPEAT_ROUND: tile.x = aFill.x; tile.width = ComputeRoundedSize(aUnitSize.width, aFill.width); aRepeatSize.width = tile.width; break; case NS_STYLE_BORDER_IMAGE_REPEAT_SPACE: { nscoord space; aRepeatSize.width = ComputeBorderSpacedRepeatSize(aUnitSize.width, aFill.width, space); tile.x = aFill.x + space; tile.width = aUnitSize.width; aFill.x = tile.x; aFill.width = aFill.width - space * 2; } break; default: NS_NOTREACHED("unrecognized border-image fill style"); } switch (aVFill) { case NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH: tile.y = aFill.y; tile.height = aFill.height; aRepeatSize.height = tile.height; break; case NS_STYLE_BORDER_IMAGE_REPEAT_REPEAT: tile.y = aFill.y + aFill.height/2 - aUnitSize.height/2; tile.height = aUnitSize.height; aRepeatSize.height = tile.height; break; case NS_STYLE_BORDER_IMAGE_REPEAT_ROUND: tile.y = aFill.y; tile.height = ComputeRoundedSize(aUnitSize.height, aFill.height); aRepeatSize.height = tile.height; break; case NS_STYLE_BORDER_IMAGE_REPEAT_SPACE: { nscoord space; aRepeatSize.height = ComputeBorderSpacedRepeatSize(aUnitSize.height, aFill.height, space); tile.y = aFill.y + space; tile.height = aUnitSize.height; aFill.y = tile.y; aFill.height = aFill.height - space * 2; } break; default: NS_NOTREACHED("unrecognized border-image fill style"); } return tile; } /** * Returns true if the given set of arguments will require the tiles which fill * the dest rect to be scaled from the source tile. See comment on ComputeTile * for argument descriptions. */ static bool RequiresScaling(const nsRect& aFill, uint8_t aHFill, uint8_t aVFill, const nsSize& aUnitSize) { // If we have no tiling in either direction, we can skip the intermediate // scaling step. return (aHFill != NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH || aVFill != NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH) && (aUnitSize.width != aFill.width || aUnitSize.height != aFill.height); } DrawResult nsImageRenderer::DrawBorderImageComponent(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, const nsRect& aDirtyRect, const nsRect& aFill, const CSSIntRect& aSrc, uint8_t aHFill, uint8_t aVFill, const nsSize& aUnitSize, uint8_t aIndex, const Maybe<nsSize>& aSVGViewportSize, const bool aHasIntrinsicRatio) { if (!IsReady()) { NS_NOTREACHED("Ensure PrepareImage() has returned true before calling me"); return DrawResult::BAD_ARGS; } if (aFill.IsEmpty() || aSrc.IsEmpty()) { return DrawResult::SUCCESS; } if (mType == eStyleImageType_Image || mType == eStyleImageType_Element) { nsCOMPtr<imgIContainer> subImage; // To draw one portion of an image into a border component, we stretch that // portion to match the size of that border component and then draw onto. // However, preserveAspectRatio attribute of a SVG image may break this rule. // To get correct rendering result, we add // FLAG_FORCE_PRESERVEASPECTRATIO_NONE flag here, to tell mImage to ignore // preserveAspectRatio attribute, and always do non-uniform stretch. uint32_t drawFlags = ConvertImageRendererToDrawFlags(mFlags) | imgIContainer::FLAG_FORCE_PRESERVEASPECTRATIO_NONE; // For those SVG image sources which don't have fixed aspect ratio (i.e. // without viewport size and viewBox), we should scale the source uniformly // after the viewport size is decided by "Default Sizing Algorithm". if (!aHasIntrinsicRatio) { drawFlags = drawFlags | imgIContainer::FLAG_FORCE_UNIFORM_SCALING; } // Retrieve or create the subimage we'll draw. nsIntRect srcRect(aSrc.x, aSrc.y, aSrc.width, aSrc.height); if (mType == eStyleImageType_Image) { if ((subImage = mImage->GetSubImage(aIndex)) == nullptr) { subImage = ImageOps::Clip(mImageContainer, srcRect, aSVGViewportSize); mImage->SetSubImage(aIndex, subImage); } } else { // This path, for eStyleImageType_Element, is currently slower than it // needs to be because we don't cache anything. (In particular, if we have // to draw to a temporary surface inside ClippedImage, we don't cache that // temporary surface since we immediately throw the ClippedImage we create // here away.) However, if we did cache, we'd need to know when to // invalidate that cache, and it's not clear that it's worth the trouble // since using border-image with -moz-element is rare. RefPtr<gfxDrawable> drawable = DrawableForElement(nsRect(nsPoint(), mSize), aRenderingContext); if (!drawable) { NS_WARNING("Could not create drawable for element"); return DrawResult::TEMPORARY_ERROR; } nsCOMPtr<imgIContainer> image(ImageOps::CreateFromDrawable(drawable)); subImage = ImageOps::Clip(image, srcRect, aSVGViewportSize); } MOZ_ASSERT_IF(aSVGViewportSize, subImage->GetType() == imgIContainer::TYPE_VECTOR); SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(mForFrame); if (!RequiresScaling(aFill, aHFill, aVFill, aUnitSize)) { return nsLayoutUtils::DrawSingleImage(*aRenderingContext.ThebesContext(), aPresContext, subImage, samplingFilter, aFill, aDirtyRect, nullptr, drawFlags); } nsSize repeatSize; nsRect fillRect(aFill); nsRect tile = ComputeTile(fillRect, aHFill, aVFill, aUnitSize, repeatSize); CSSIntSize imageSize(srcRect.width, srcRect.height); return nsLayoutUtils::DrawBackgroundImage(*aRenderingContext.ThebesContext(), aPresContext, subImage, imageSize, samplingFilter, tile, fillRect, repeatSize, tile.TopLeft(), aDirtyRect, drawFlags, ExtendMode::CLAMP); } nsSize repeatSize(aFill.Size()); nsRect fillRect(aFill); nsRect destTile = RequiresScaling(fillRect, aHFill, aVFill, aUnitSize) ? ComputeTile(fillRect, aHFill, aVFill, aUnitSize, repeatSize) : fillRect; return Draw(aPresContext, aRenderingContext, aDirtyRect, destTile, fillRect, destTile.TopLeft(), repeatSize, aSrc); } bool nsImageRenderer::IsRasterImage() { if (mType != eStyleImageType_Image || !mImageContainer) return false; return mImageContainer->GetType() == imgIContainer::TYPE_RASTER; } bool nsImageRenderer::IsAnimatedImage() { if (mType != eStyleImageType_Image || !mImageContainer) return false; bool animated = false; if (NS_SUCCEEDED(mImageContainer->GetAnimated(&animated)) && animated) return true; return false; } already_AddRefed<imgIContainer> nsImageRenderer::GetImage() { if (mType != eStyleImageType_Image || !mImageContainer) { return nullptr; } nsCOMPtr<imgIContainer> image = mImageContainer; return image.forget(); } void nsImageRenderer::PurgeCacheForViewportChange( const Maybe<nsSize>& aSVGViewportSize, const bool aHasIntrinsicRatio) { // Check if we should flush the cached data - only vector images need to do // the check since they might not have fixed ratio. if (mImageContainer && mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) { mImage->PurgeCacheForViewportChange(aSVGViewportSize, aHasIntrinsicRatio); } } #define MAX_BLUR_RADIUS 300 #define MAX_SPREAD_RADIUS 50 static inline gfxPoint ComputeBlurStdDev(nscoord aBlurRadius, int32_t aAppUnitsPerDevPixel, gfxFloat aScaleX, gfxFloat aScaleY) { // http://dev.w3.org/csswg/css3-background/#box-shadow says that the // standard deviation of the blur should be half the given blur value. gfxFloat blurStdDev = gfxFloat(aBlurRadius) / gfxFloat(aAppUnitsPerDevPixel); return gfxPoint(std::min((blurStdDev * aScaleX), gfxFloat(MAX_BLUR_RADIUS)) / 2.0, std::min((blurStdDev * aScaleY), gfxFloat(MAX_BLUR_RADIUS)) / 2.0); } static inline IntSize ComputeBlurRadius(nscoord aBlurRadius, int32_t aAppUnitsPerDevPixel, gfxFloat aScaleX = 1.0, gfxFloat aScaleY = 1.0) { gfxPoint scaledBlurStdDev = ComputeBlurStdDev(aBlurRadius, aAppUnitsPerDevPixel, aScaleX, aScaleY); return gfxAlphaBoxBlur::CalculateBlurRadius(scaledBlurStdDev); } // ----- // nsContextBoxBlur // ----- gfxContext* nsContextBoxBlur::Init(const nsRect& aRect, nscoord aSpreadRadius, nscoord aBlurRadius, int32_t aAppUnitsPerDevPixel, gfxContext* aDestinationCtx, const nsRect& aDirtyRect, const gfxRect* aSkipRect, uint32_t aFlags) { if (aRect.IsEmpty()) { mContext = nullptr; return nullptr; } IntSize blurRadius; IntSize spreadRadius; GetBlurAndSpreadRadius(aDestinationCtx->GetDrawTarget(), aAppUnitsPerDevPixel, aBlurRadius, aSpreadRadius, blurRadius, spreadRadius); mDestinationCtx = aDestinationCtx; // If not blurring, draw directly onto the destination device if (blurRadius.width <= 0 && blurRadius.height <= 0 && spreadRadius.width <= 0 && spreadRadius.height <= 0 && !(aFlags & FORCE_MASK)) { mContext = aDestinationCtx; return mContext; } // Convert from app units to device pixels gfxRect rect = nsLayoutUtils::RectToGfxRect(aRect, aAppUnitsPerDevPixel); gfxRect dirtyRect = nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel); dirtyRect.RoundOut(); gfxMatrix transform = aDestinationCtx->CurrentMatrix(); rect = transform.TransformBounds(rect); mPreTransformed = !transform.IsIdentity(); // Create the temporary surface for blurring dirtyRect = transform.TransformBounds(dirtyRect); if (aSkipRect) { gfxRect skipRect = transform.TransformBounds(*aSkipRect); mContext = mAlphaBoxBlur.Init(rect, spreadRadius, blurRadius, &dirtyRect, &skipRect); } else { mContext = mAlphaBoxBlur.Init(rect, spreadRadius, blurRadius, &dirtyRect, nullptr); } if (mContext) { // we don't need to blur if skipRect is equal to rect // and mContext will be nullptr mContext->Multiply(transform); } return mContext; } void nsContextBoxBlur::DoPaint() { if (mContext == mDestinationCtx) { return; } gfxContextMatrixAutoSaveRestore saveMatrix(mDestinationCtx); if (mPreTransformed) { mDestinationCtx->SetMatrix(gfxMatrix()); } mAlphaBoxBlur.Paint(mDestinationCtx); } gfxContext* nsContextBoxBlur::GetContext() { return mContext; } /* static */ nsMargin nsContextBoxBlur::GetBlurRadiusMargin(nscoord aBlurRadius, int32_t aAppUnitsPerDevPixel) { IntSize blurRadius = ComputeBlurRadius(aBlurRadius, aAppUnitsPerDevPixel); nsMargin result; result.top = result.bottom = blurRadius.height * aAppUnitsPerDevPixel; result.left = result.right = blurRadius.width * aAppUnitsPerDevPixel; return result; } /* static */ void nsContextBoxBlur::BlurRectangle(gfxContext* aDestinationCtx, const nsRect& aRect, int32_t aAppUnitsPerDevPixel, RectCornerRadii* aCornerRadii, nscoord aBlurRadius, const Color& aShadowColor, const nsRect& aDirtyRect, const gfxRect& aSkipRect) { DrawTarget& aDestDrawTarget = *aDestinationCtx->GetDrawTarget(); if (aRect.IsEmpty()) { return; } Rect shadowGfxRect = NSRectToRect(aRect, aAppUnitsPerDevPixel); if (aBlurRadius <= 0) { ColorPattern color(ToDeviceColor(aShadowColor)); if (aCornerRadii) { RefPtr<Path> roundedRect = MakePathForRoundedRect(aDestDrawTarget, shadowGfxRect, *aCornerRadii); aDestDrawTarget.Fill(roundedRect, color); } else { aDestDrawTarget.FillRect(shadowGfxRect, color); } return; } gfxFloat scaleX = 1; gfxFloat scaleY = 1; // Do blurs in device space when possible. // Chrome/Skia always does the blurs in device space // and will sometimes get incorrect results (e.g. rotated blurs) gfxMatrix transform = aDestinationCtx->CurrentMatrix(); // XXX: we could probably handle negative scales but for now it's easier just to fallback if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && transform._22 > 0.0) { scaleX = transform._11; scaleY = transform._22; aDestinationCtx->SetMatrix(gfxMatrix()); } else { transform = gfxMatrix(); } gfxPoint blurStdDev = ComputeBlurStdDev(aBlurRadius, aAppUnitsPerDevPixel, scaleX, scaleY); gfxRect dirtyRect = nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel); dirtyRect.RoundOut(); gfxRect shadowThebesRect = transform.TransformBounds(ThebesRect(shadowGfxRect)); dirtyRect = transform.TransformBounds(dirtyRect); gfxRect skipRect = transform.TransformBounds(aSkipRect); if (aCornerRadii) { aCornerRadii->Scale(scaleX, scaleY); } gfxAlphaBoxBlur::BlurRectangle(aDestinationCtx, shadowThebesRect, aCornerRadii, blurStdDev, aShadowColor, dirtyRect, skipRect); } /* static */ void nsContextBoxBlur::GetBlurAndSpreadRadius(DrawTarget* aDestDrawTarget, int32_t aAppUnitsPerDevPixel, nscoord aBlurRadius, nscoord aSpreadRadius, IntSize& aOutBlurRadius, IntSize& aOutSpreadRadius, bool aConstrainSpreadRadius) { // Do blurs in device space when possible. // Chrome/Skia always does the blurs in device space // and will sometimes get incorrect results (e.g. rotated blurs) Matrix transform = aDestDrawTarget->GetTransform(); // XXX: we could probably handle negative scales but for now it's easier just to fallback gfxFloat scaleX, scaleY; if (transform.HasNonAxisAlignedTransform() || transform._11 <= 0.0 || transform._22 <= 0.0) { scaleX = 1; scaleY = 1; } else { scaleX = transform._11; scaleY = transform._22; } // compute a large or smaller blur radius aOutBlurRadius = ComputeBlurRadius(aBlurRadius, aAppUnitsPerDevPixel, scaleX, scaleY); aOutSpreadRadius = IntSize(int32_t(aSpreadRadius * scaleX / aAppUnitsPerDevPixel), int32_t(aSpreadRadius * scaleY / aAppUnitsPerDevPixel)); if (aConstrainSpreadRadius) { aOutSpreadRadius.width = std::min(aOutSpreadRadius.width, int32_t(MAX_SPREAD_RADIUS)); aOutSpreadRadius.height = std::min(aOutSpreadRadius.height, int32_t(MAX_SPREAD_RADIUS)); } } /* static */ bool nsContextBoxBlur::InsetBoxBlur(gfxContext* aDestinationCtx, Rect aDestinationRect, Rect aShadowClipRect, Color& aShadowColor, nscoord aBlurRadiusAppUnits, nscoord aSpreadDistanceAppUnits, int32_t aAppUnitsPerDevPixel, bool aHasBorderRadius, RectCornerRadii& aInnerClipRectRadii, Rect aSkipRect, Point aShadowOffset) { if (aDestinationRect.IsEmpty()) { mContext = nullptr; return false; } gfxContextAutoSaveRestore autoRestore(aDestinationCtx); IntSize blurRadius; IntSize spreadRadius; // Convert the blur and spread radius to device pixels bool constrainSpreadRadius = false; GetBlurAndSpreadRadius(aDestinationCtx->GetDrawTarget(), aAppUnitsPerDevPixel, aBlurRadiusAppUnits, aSpreadDistanceAppUnits, blurRadius, spreadRadius, constrainSpreadRadius); // The blur and spread radius are scaled already, so scale all // input data to the blur. This way, we don't have to scale the min // inset blur to the invert of the dest context, then rescale it back // when we draw to the destination surface. gfxSize scale = aDestinationCtx->CurrentMatrix().ScaleFactors(true); Matrix transform = ToMatrix(aDestinationCtx->CurrentMatrix()); // XXX: we could probably handle negative scales but for now it's easier just to fallback if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && transform._22 > 0.0) { // If we don't have a rotation, we're pre-transforming all the rects. aDestinationCtx->SetMatrix(gfxMatrix()); } else { // Don't touch anything, we have a rotation. transform = Matrix(); } Rect transformedDestRect = transform.TransformBounds(aDestinationRect); Rect transformedShadowClipRect = transform.TransformBounds(aShadowClipRect); Rect transformedSkipRect = transform.TransformBounds(aSkipRect); transformedDestRect.Round(); transformedShadowClipRect.Round(); transformedSkipRect.RoundIn(); for (size_t i = 0; i < 4; i++) { aInnerClipRectRadii[i].width = std::floor(scale.width * aInnerClipRectRadii[i].width); aInnerClipRectRadii[i].height = std::floor(scale.height * aInnerClipRectRadii[i].height); } mAlphaBoxBlur.BlurInsetBox(aDestinationCtx, transformedDestRect, transformedShadowClipRect, blurRadius, spreadRadius, aShadowColor, aHasBorderRadius, aInnerClipRectRadii, transformedSkipRect, aShadowOffset); return true; }