summaryrefslogtreecommitdiffstats
path: root/layout/base/nsCSSRendering.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/base/nsCSSRendering.cpp')
-rw-r--r--layout/base/nsCSSRendering.cpp6138
1 files changed, 6138 insertions, 0 deletions
diff --git a/layout/base/nsCSSRendering.cpp b/layout/base/nsCSSRendering.cpp
new file mode 100644
index 000000000..1c6d97395
--- /dev/null
+++ b/layout/base/nsCSSRendering.cpp
@@ -0,0 +1,6138 @@
+/* -*- 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));
+}
+
+
+static float Interpolate(float aF1, float aF2, float aFrac)
+{
+ return aF1 + aFrac * (aF2 - aF1);
+}
+
+// Returns aFrac*aC2 + (1 - aFrac)*C1. The interpolation is done
+// in unpremultiplied 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 Color
+Premultiply(const Color& aColor)
+{
+ gfx::Float a = aColor.a;
+ return Color(aColor.r * a, aColor.g * a, aColor.b * a, a);
+}
+
+static Color
+Unpremultiply(const Color& aColor)
+{
+ gfx::Float a = aColor.a;
+ return (a > 0.f)
+ ? Color(aColor.r / a, aColor.g / a, aColor.b / a, a)
+ : aColor;
+}
+
+static Color
+TransparentColor(Color aColor) {
+ aColor.a = 0;
+ return aColor;
+}
+
+// Adjusts and adds color stops in such a way that drawing the gradient with
+// unpremultiplied interpolation looks nearly the same as if it were drawn with
+// premultiplied interpolation.
+static const float kAlphaIncrementPerGradientStep = 0.1f;
+static void
+ResolvePremultipliedAlpha(nsTArray<ColorStop>& aStops)
+{
+ for (size_t x = 1; x < aStops.Length(); x++) {
+ const ColorStop leftStop = aStops[x - 1];
+ const ColorStop rightStop = aStops[x];
+
+ // if the left and right stop have the same alpha value, we don't need
+ // to do anything
+ if (leftStop.mColor.a == rightStop.mColor.a) {
+ continue;
+ }
+
+ // Is the stop on the left 100% transparent? If so, have it adopt the color
+ // of the right stop
+ if (leftStop.mColor.a == 0) {
+ aStops[x - 1].mColor = TransparentColor(rightStop.mColor);
+ continue;
+ }
+
+ // Is the stop on the right completely transparent?
+ // If so, duplicate it and assign it the color on the left.
+ if (rightStop.mColor.a == 0) {
+ ColorStop newStop = rightStop;
+ newStop.mColor = TransparentColor(leftStop.mColor);
+ aStops.InsertElementAt(x, newStop);
+ x++;
+ continue;
+ }
+
+ // Now handle cases where one or both of the stops are partially transparent.
+ if (leftStop.mColor.a != 1.0f || rightStop.mColor.a != 1.0f) {
+ Color premulLeftColor = Premultiply(leftStop.mColor);
+ Color premulRightColor = Premultiply(rightStop.mColor);
+ // Calculate how many extra steps. We do a step per 10% transparency.
+ size_t stepCount = NSToIntFloor(fabsf(leftStop.mColor.a - rightStop.mColor.a) / kAlphaIncrementPerGradientStep);
+ for (size_t y = 1; y < stepCount; y++) {
+ float frac = static_cast<float>(y) / stepCount;
+ ColorStop newStop(Interpolate(leftStop.mPosition, rightStop.mPosition, frac), false,
+ Unpremultiply(InterpolateColor(premulLeftColor, premulRightColor, frac)));
+ aStops.InsertElementAt(x, newStop);
+ x++;
+ }
+ }
+ }
+}
+
+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,
+ Unpremultiply(InterpolateColor(Premultiply(aFirst.mColor),
+ Premultiply(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;
+ }
+
+ // 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);
+ ResolvePremultipliedAlpha(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;
+}