summaryrefslogtreecommitdiffstats
path: root/layout/painting/nsCSSRenderingBorders.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/painting/nsCSSRenderingBorders.cpp')
-rw-r--r--layout/painting/nsCSSRenderingBorders.cpp3891
1 files changed, 3891 insertions, 0 deletions
diff --git a/layout/painting/nsCSSRenderingBorders.cpp b/layout/painting/nsCSSRenderingBorders.cpp
new file mode 100644
index 0000000000..3f0bee7f85
--- /dev/null
+++ b/layout/painting/nsCSSRenderingBorders.cpp
@@ -0,0 +1,3891 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "nsCSSRenderingBorders.h"
+
+#include "gfxUtils.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Helpers.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "BorderConsts.h"
+#include "DashedCornerFinder.h"
+#include "DottedCornerFinder.h"
+#include "ImageRegion.h"
+#include "nsLayoutUtils.h"
+#include "nsStyleConsts.h"
+#include "nsContentUtils.h"
+#include "nsCSSColorUtils.h"
+#include "nsCSSRendering.h"
+#include "nsCSSRenderingGradients.h"
+#include "nsDisplayList.h"
+#include "nsExpirationTracker.h"
+#include "nsIScriptError.h"
+#include "nsClassHashtable.h"
+#include "nsPresContext.h"
+#include "nsStyleStruct.h"
+#include "gfx2DGlue.h"
+#include "gfxGradientCache.h"
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/Range.h"
+#include <algorithm>
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::image;
+
+#define MAX_COMPOSITE_BORDER_WIDTH LayoutDeviceIntCoord(10000)
+
+/**
+ * nsCSSRendering::PaintBorder
+ * nsCSSRendering::PaintOutline
+ * -> DrawBorders
+ *
+ * DrawBorders
+ * -> Ability to use specialized approach?
+ * |- Draw using specialized function
+ * |- separate corners?
+ * |- dashed side mask
+ * |
+ * -> can border be drawn in 1 pass? (e.g., solid border same color all
+ * around)
+ * |- DrawBorderSides with all 4 sides
+ * -> more than 1 pass?
+ * |- for each corner
+ * |- clip to DoCornerClipSubPath
+ * |- for each side adjacent to corner
+ * |- clip to GetSideClipSubPath
+ * |- DrawBorderSides with one side
+ * |- for each side
+ * |- GetSideClipWithoutCornersRect
+ * |- DrawDashedOrDottedSide || DrawBorderSides with one side
+ */
+
+static void ComputeBorderCornerDimensions(const Float* aBorderWidths,
+ const RectCornerRadii& aRadii,
+ RectCornerRadii* aDimsResult);
+
+// given a side index, get the previous and next side index
+#define NEXT_SIDE(_s) mozilla::Side(((_s) + 1) & 3)
+#define PREV_SIDE(_s) mozilla::Side(((_s) + 3) & 3)
+
+// given a corner index, get the previous and next corner index
+#define NEXT_CORNER(_s) Corner(((_s) + 1) & 3)
+#define PREV_CORNER(_s) Corner(((_s) + 3) & 3)
+
+// from the given base color and the background color, turn
+// color into a color for the given border pattern style
+static sRGBColor MakeBorderColor(nscolor aColor,
+ BorderColorStyle aBorderColorStyle);
+
+// Given a line index (an index starting from the outside of the
+// border going inwards) and an array of line styles, calculate the
+// color that that stripe of the border should be rendered in.
+static sRGBColor ComputeColorForLine(uint32_t aLineIndex,
+ const BorderColorStyle* aBorderColorStyle,
+ uint32_t aBorderColorStyleCount,
+ nscolor aBorderColor);
+
+// little helper function to check if the array of 4 floats given are
+// equal to the given value
+static bool CheckFourFloatsEqual(const Float* vals, Float k) {
+ return (vals[0] == k && vals[1] == k && vals[2] == k && vals[3] == k);
+}
+
+static bool IsZeroSize(const Size& sz) {
+ return sz.width == 0.0 || sz.height == 0.0;
+}
+
+/* static */
+bool nsCSSBorderRenderer::AllCornersZeroSize(const RectCornerRadii& corners) {
+ return IsZeroSize(corners[eCornerTopLeft]) &&
+ IsZeroSize(corners[eCornerTopRight]) &&
+ IsZeroSize(corners[eCornerBottomRight]) &&
+ IsZeroSize(corners[eCornerBottomLeft]);
+}
+
+static mozilla::Side GetHorizontalSide(Corner aCorner) {
+ return (aCorner == C_TL || aCorner == C_TR) ? eSideTop : eSideBottom;
+}
+
+static mozilla::Side GetVerticalSide(Corner aCorner) {
+ return (aCorner == C_TL || aCorner == C_BL) ? eSideLeft : eSideRight;
+}
+
+static Corner GetCWCorner(mozilla::Side aSide) {
+ return Corner(NEXT_SIDE(aSide));
+}
+
+static Corner GetCCWCorner(mozilla::Side aSide) { return Corner(aSide); }
+
+static bool IsSingleSide(mozilla::SideBits aSides) {
+ return aSides == SideBits::eTop || aSides == SideBits::eRight ||
+ aSides == SideBits::eBottom || aSides == SideBits::eLeft;
+}
+
+static bool IsHorizontalSide(mozilla::Side aSide) {
+ return aSide == eSideTop || aSide == eSideBottom;
+}
+
+typedef enum {
+ // Normal solid square corner. Will be rectangular, the size of the
+ // adjacent sides. If the corner has a border radius, the corner
+ // will always be solid, since we don't do dotted/dashed etc.
+ CORNER_NORMAL,
+
+ // Paint the corner in whatever style is not dotted/dashed of the
+ // adjacent corners.
+ CORNER_SOLID,
+
+ // Paint the corner as a dot, the size of the bigger of the adjacent
+ // sides.
+ CORNER_DOT
+} CornerStyle;
+
+nsCSSBorderRenderer::nsCSSBorderRenderer(
+ nsPresContext* aPresContext, DrawTarget* aDrawTarget,
+ const Rect& aDirtyRect, Rect& aOuterRect,
+ const StyleBorderStyle* aBorderStyles, const Float* aBorderWidths,
+ RectCornerRadii& aBorderRadii, const nscolor* aBorderColors,
+ bool aBackfaceIsVisible, const Maybe<Rect>& aClipRect)
+ : mPresContext(aPresContext),
+ mDrawTarget(aDrawTarget),
+ mDirtyRect(aDirtyRect),
+ mOuterRect(aOuterRect),
+ mBorderRadii(aBorderRadii),
+ mBackfaceIsVisible(aBackfaceIsVisible),
+ mLocalClip(aClipRect) {
+ PodCopy(mBorderStyles, aBorderStyles, 4);
+ PodCopy(mBorderWidths, aBorderWidths, 4);
+ PodCopy(mBorderColors, aBorderColors, 4);
+ mInnerRect = mOuterRect;
+ mInnerRect.Deflate(Margin(
+ mBorderStyles[0] != StyleBorderStyle::None ? mBorderWidths[0] : 0,
+ mBorderStyles[1] != StyleBorderStyle::None ? mBorderWidths[1] : 0,
+ mBorderStyles[2] != StyleBorderStyle::None ? mBorderWidths[2] : 0,
+ mBorderStyles[3] != StyleBorderStyle::None ? mBorderWidths[3] : 0));
+
+ ComputeBorderCornerDimensions(mBorderWidths, mBorderRadii,
+ &mBorderCornerDimensions);
+
+ mOneUnitBorder = CheckFourFloatsEqual(mBorderWidths, 1.0);
+ mNoBorderRadius = AllCornersZeroSize(mBorderRadii);
+ mAllBordersSameStyle = AreBorderSideFinalStylesSame(SideBits::eAll);
+ mAllBordersSameWidth = AllBordersSameWidth();
+ mAvoidStroke = false;
+}
+
+/* static */
+void nsCSSBorderRenderer::ComputeInnerRadii(const RectCornerRadii& aRadii,
+ const Float* aBorderSizes,
+ RectCornerRadii* aInnerRadiiRet) {
+ RectCornerRadii& iRadii = *aInnerRadiiRet;
+
+ iRadii[C_TL].width =
+ std::max(0.f, aRadii[C_TL].width - aBorderSizes[eSideLeft]);
+ iRadii[C_TL].height =
+ std::max(0.f, aRadii[C_TL].height - aBorderSizes[eSideTop]);
+
+ iRadii[C_TR].width =
+ std::max(0.f, aRadii[C_TR].width - aBorderSizes[eSideRight]);
+ iRadii[C_TR].height =
+ std::max(0.f, aRadii[C_TR].height - aBorderSizes[eSideTop]);
+
+ iRadii[C_BR].width =
+ std::max(0.f, aRadii[C_BR].width - aBorderSizes[eSideRight]);
+ iRadii[C_BR].height =
+ std::max(0.f, aRadii[C_BR].height - aBorderSizes[eSideBottom]);
+
+ iRadii[C_BL].width =
+ std::max(0.f, aRadii[C_BL].width - aBorderSizes[eSideLeft]);
+ iRadii[C_BL].height =
+ std::max(0.f, aRadii[C_BL].height - aBorderSizes[eSideBottom]);
+}
+
+/* static */
+void nsCSSBorderRenderer::ComputeOuterRadii(const RectCornerRadii& aRadii,
+ const Float* aBorderSizes,
+ RectCornerRadii* aOuterRadiiRet) {
+ RectCornerRadii& oRadii = *aOuterRadiiRet;
+
+ // default all corners to sharp corners
+ oRadii = RectCornerRadii(0.f);
+
+ // round the edges that have radii > 0.0 to start with
+ if (aRadii[C_TL].width > 0.f && aRadii[C_TL].height > 0.f) {
+ oRadii[C_TL].width =
+ std::max(0.f, aRadii[C_TL].width + aBorderSizes[eSideLeft]);
+ oRadii[C_TL].height =
+ std::max(0.f, aRadii[C_TL].height + aBorderSizes[eSideTop]);
+ }
+
+ if (aRadii[C_TR].width > 0.f && aRadii[C_TR].height > 0.f) {
+ oRadii[C_TR].width =
+ std::max(0.f, aRadii[C_TR].width + aBorderSizes[eSideRight]);
+ oRadii[C_TR].height =
+ std::max(0.f, aRadii[C_TR].height + aBorderSizes[eSideTop]);
+ }
+
+ if (aRadii[C_BR].width > 0.f && aRadii[C_BR].height > 0.f) {
+ oRadii[C_BR].width =
+ std::max(0.f, aRadii[C_BR].width + aBorderSizes[eSideRight]);
+ oRadii[C_BR].height =
+ std::max(0.f, aRadii[C_BR].height + aBorderSizes[eSideBottom]);
+ }
+
+ if (aRadii[C_BL].width > 0.f && aRadii[C_BL].height > 0.f) {
+ oRadii[C_BL].width =
+ std::max(0.f, aRadii[C_BL].width + aBorderSizes[eSideLeft]);
+ oRadii[C_BL].height =
+ std::max(0.f, aRadii[C_BL].height + aBorderSizes[eSideBottom]);
+ }
+}
+
+/*static*/ void ComputeBorderCornerDimensions(const Float* aBorderWidths,
+ const RectCornerRadii& aRadii,
+ RectCornerRadii* aDimsRet) {
+ Float leftWidth = aBorderWidths[eSideLeft];
+ Float topWidth = aBorderWidths[eSideTop];
+ Float rightWidth = aBorderWidths[eSideRight];
+ Float bottomWidth = aBorderWidths[eSideBottom];
+
+ if (nsCSSBorderRenderer::AllCornersZeroSize(aRadii)) {
+ // These will always be in pixel units from CSS
+ (*aDimsRet)[C_TL] = Size(leftWidth, topWidth);
+ (*aDimsRet)[C_TR] = Size(rightWidth, topWidth);
+ (*aDimsRet)[C_BR] = Size(rightWidth, bottomWidth);
+ (*aDimsRet)[C_BL] = Size(leftWidth, bottomWidth);
+ } else {
+ // Always round up to whole pixels for the corners; it's safe to
+ // make the corners bigger than necessary, and this way we ensure
+ // that we avoid seams.
+ (*aDimsRet)[C_TL] = Size(ceil(std::max(leftWidth, aRadii[C_TL].width)),
+ ceil(std::max(topWidth, aRadii[C_TL].height)));
+ (*aDimsRet)[C_TR] = Size(ceil(std::max(rightWidth, aRadii[C_TR].width)),
+ ceil(std::max(topWidth, aRadii[C_TR].height)));
+ (*aDimsRet)[C_BR] = Size(ceil(std::max(rightWidth, aRadii[C_BR].width)),
+ ceil(std::max(bottomWidth, aRadii[C_BR].height)));
+ (*aDimsRet)[C_BL] = Size(ceil(std::max(leftWidth, aRadii[C_BL].width)),
+ ceil(std::max(bottomWidth, aRadii[C_BL].height)));
+ }
+}
+
+bool nsCSSBorderRenderer::AreBorderSideFinalStylesSame(
+ mozilla::SideBits aSides) {
+ NS_ASSERTION(aSides != SideBits::eNone &&
+ (aSides & ~SideBits::eAll) == SideBits::eNone,
+ "AreBorderSidesSame: invalid whichSides!");
+
+ /* First check if the specified styles and colors are the same for all sides
+ */
+ int firstStyle = 0;
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ if (firstStyle == i) {
+ if ((static_cast<mozilla::SideBits>(1 << i) & aSides) ==
+ SideBits::eNone) {
+ firstStyle++;
+ }
+ continue;
+ }
+
+ if ((static_cast<mozilla::SideBits>(1 << i) & aSides) == SideBits::eNone) {
+ continue;
+ }
+
+ if (mBorderStyles[firstStyle] != mBorderStyles[i] ||
+ mBorderColors[firstStyle] != mBorderColors[i]) {
+ return false;
+ }
+ }
+
+ /* Then if it's one of the two-tone styles and we're not
+ * just comparing the TL or BR sides */
+ switch (mBorderStyles[firstStyle]) {
+ case StyleBorderStyle::Groove:
+ case StyleBorderStyle::Ridge:
+ case StyleBorderStyle::Inset:
+ case StyleBorderStyle::Outset:
+ return ((aSides & ~(SideBits::eTop | SideBits::eLeft)) ==
+ SideBits::eNone ||
+ (aSides & ~(SideBits::eBottom | SideBits::eRight)) ==
+ SideBits::eNone);
+ default:
+ return true;
+ }
+}
+
+bool nsCSSBorderRenderer::IsSolidCornerStyle(StyleBorderStyle aStyle,
+ Corner aCorner) {
+ switch (aStyle) {
+ case StyleBorderStyle::Solid:
+ return true;
+
+ case StyleBorderStyle::Inset:
+ case StyleBorderStyle::Outset:
+ return (aCorner == eCornerTopLeft || aCorner == eCornerBottomRight);
+
+ case StyleBorderStyle::Groove:
+ case StyleBorderStyle::Ridge:
+ return mOneUnitBorder &&
+ (aCorner == eCornerTopLeft || aCorner == eCornerBottomRight);
+
+ case StyleBorderStyle::Double:
+ return mOneUnitBorder;
+
+ default:
+ return false;
+ }
+}
+
+bool nsCSSBorderRenderer::IsCornerMergeable(Corner aCorner) {
+ // Corner between dotted borders with same width and small radii is
+ // merged into single dot.
+ //
+ // widthH / 2.0
+ // |<---------->|
+ // | |
+ // |radius.width|
+ // |<--->| |
+ // | | |
+ // | _+------+------------+-----
+ // | / ###|### |
+ // |/ #######|####### |
+ // + #########|######### |
+ // | ##########|########## |
+ // | ###########|########### |
+ // | ###########|########### |
+ // |############|############|
+ // +------------+############|
+ // |#########################|
+ // | ####################### |
+ // | ####################### |
+ // | ##################### |
+ // | ################### |
+ // | ############### |
+ // | ####### |
+ // +-------------------------+----
+ // | |
+ // | |
+ mozilla::Side sideH(GetHorizontalSide(aCorner));
+ mozilla::Side sideV(GetVerticalSide(aCorner));
+ StyleBorderStyle styleH = mBorderStyles[sideH];
+ StyleBorderStyle styleV = mBorderStyles[sideV];
+ if (styleH != styleV || styleH != StyleBorderStyle::Dotted) {
+ return false;
+ }
+
+ Float widthH = mBorderWidths[sideH];
+ Float widthV = mBorderWidths[sideV];
+ if (widthH != widthV) {
+ return false;
+ }
+
+ Size radius = mBorderRadii[aCorner];
+ return IsZeroSize(radius) ||
+ (radius.width < widthH / 2.0f && radius.height < widthH / 2.0f);
+}
+
+BorderColorStyle nsCSSBorderRenderer::BorderColorStyleForSolidCorner(
+ StyleBorderStyle aStyle, Corner aCorner) {
+ // note that this function assumes that the corner is already solid,
+ // as per the earlier function
+ switch (aStyle) {
+ case StyleBorderStyle::Solid:
+ case StyleBorderStyle::Double:
+ return BorderColorStyleSolid;
+
+ case StyleBorderStyle::Inset:
+ case StyleBorderStyle::Groove:
+ if (aCorner == eCornerTopLeft) {
+ return BorderColorStyleDark;
+ } else if (aCorner == eCornerBottomRight) {
+ return BorderColorStyleLight;
+ }
+ break;
+
+ case StyleBorderStyle::Outset:
+ case StyleBorderStyle::Ridge:
+ if (aCorner == eCornerTopLeft) {
+ return BorderColorStyleLight;
+ } else if (aCorner == eCornerBottomRight) {
+ return BorderColorStyleDark;
+ }
+ break;
+ default:
+ return BorderColorStyleNone;
+ }
+
+ return BorderColorStyleNone;
+}
+
+Rect nsCSSBorderRenderer::GetCornerRect(Corner aCorner) {
+ Point offset(0.f, 0.f);
+
+ if (aCorner == C_TR || aCorner == C_BR)
+ offset.x = mOuterRect.Width() - mBorderCornerDimensions[aCorner].width;
+ if (aCorner == C_BR || aCorner == C_BL)
+ offset.y = mOuterRect.Height() - mBorderCornerDimensions[aCorner].height;
+
+ return Rect(mOuterRect.TopLeft() + offset, mBorderCornerDimensions[aCorner]);
+}
+
+Rect nsCSSBorderRenderer::GetSideClipWithoutCornersRect(mozilla::Side aSide) {
+ Point offset(0.f, 0.f);
+
+ // The offset from the outside rect to the start of this side's
+ // box. For the top and bottom sides, the height of the box
+ // must be the border height; the x start must take into account
+ // the corner size (which may be bigger than the right or left
+ // side's width). The same applies to the right and left sides.
+ if (aSide == eSideTop) {
+ offset.x = mBorderCornerDimensions[C_TL].width;
+ } else if (aSide == eSideRight) {
+ offset.x = mOuterRect.Width() - mBorderWidths[eSideRight];
+ offset.y = mBorderCornerDimensions[C_TR].height;
+ } else if (aSide == eSideBottom) {
+ offset.x = mBorderCornerDimensions[C_BL].width;
+ offset.y = mOuterRect.Height() - mBorderWidths[eSideBottom];
+ } else if (aSide == eSideLeft) {
+ offset.y = mBorderCornerDimensions[C_TL].height;
+ }
+
+ // The sum of the width & height of the corners adjacent to the
+ // side. This relies on the relationship between side indexing and
+ // corner indexing; that is, 0 == SIDE_TOP and 0 == CORNER_TOP_LEFT,
+ // with both proceeding clockwise.
+ Size sideCornerSum = mBorderCornerDimensions[GetCCWCorner(aSide)] +
+ mBorderCornerDimensions[GetCWCorner(aSide)];
+ Rect rect(mOuterRect.TopLeft() + offset, mOuterRect.Size() - sideCornerSum);
+
+ if (IsHorizontalSide(aSide))
+ rect.height = mBorderWidths[aSide];
+ else
+ rect.width = mBorderWidths[aSide];
+
+ return rect;
+}
+
+// The side border type and the adjacent border types are
+// examined and one of the different types of clipping (listed
+// below) is selected.
+
+typedef enum {
+ // clip to the trapezoid formed by the corners of the
+ // inner and outer rectangles for the given side
+ //
+ // +---------------
+ // |\%%%%%%%%%%%%%%
+ // | \%%%%%%%%%%%%
+ // | \%%%%%%%%%%%
+ // | \%%%%%%%%%
+ // | +--------
+ // | |
+ // | |
+ SIDE_CLIP_TRAPEZOID,
+
+ // clip to the trapezoid formed by the outer rectangle
+ // corners and the center of the region, making sure
+ // that diagonal lines all go directly from the outside
+ // corner to the inside corner, but that they then continue on
+ // to the middle.
+ //
+ // This is needed for correctly clipping rounded borders,
+ // which might extend past the SIDE_CLIP_TRAPEZOID trap.
+ //
+ // +-------__--+---
+ // \%%%%_-%%%%%%%%
+ // \+-%%%%%%%%%%
+ // / \%%%%%%%%%%
+ // / \%%%%%%%%%
+ // | +%%_-+---
+ // | +%%%%%%
+ // | / \%%%%%
+ // + + \%%%
+ // | | +-
+ SIDE_CLIP_TRAPEZOID_FULL,
+
+ // clip to the rectangle formed by the given side including corner.
+ // This is used by the non-dotted side next to dotted side.
+ //
+ // +---------------
+ // |%%%%%%%%%%%%%%%
+ // |%%%%%%%%%%%%%%%
+ // |%%%%%%%%%%%%%%%
+ // |%%%%%%%%%%%%%%%
+ // +------+--------
+ // | |
+ // | |
+ SIDE_CLIP_RECTANGLE_CORNER,
+
+ // clip to the rectangle formed by the given side excluding corner.
+ // This is used by the dotted side next to non-dotted side.
+ //
+ // +------+--------
+ // | |%%%%%%%%
+ // | |%%%%%%%%
+ // | |%%%%%%%%
+ // | |%%%%%%%%
+ // | +--------
+ // | |
+ // | |
+ SIDE_CLIP_RECTANGLE_NO_CORNER,
+} SideClipType;
+
+// Given three points, p0, p1, and midPoint, move p1 further in to the
+// rectangle (of which aMidPoint is the center) so that it reaches the
+// closer of the horizontal or vertical lines intersecting the midpoint,
+// while maintaing the slope of the line. If p0 and p1 are the same,
+// just move p1 to midPoint (since there's no slope to maintain).
+// FIXME: Extending only to the midpoint isn't actually sufficient for
+// boxes with asymmetric radii.
+static void MaybeMoveToMidPoint(Point& aP0, Point& aP1,
+ const Point& aMidPoint) {
+ Point ps = aP1 - aP0;
+
+ if (ps.x == 0.0) {
+ if (ps.y == 0.0) {
+ aP1 = aMidPoint;
+ } else {
+ aP1.y = aMidPoint.y;
+ }
+ } else {
+ if (ps.y == 0.0) {
+ aP1.x = aMidPoint.x;
+ } else {
+ Float k =
+ std::min((aMidPoint.x - aP0.x) / ps.x, (aMidPoint.y - aP0.y) / ps.y);
+ aP1 = aP0 + ps * k;
+ }
+ }
+}
+
+already_AddRefed<Path> nsCSSBorderRenderer::GetSideClipSubPath(
+ mozilla::Side aSide) {
+ // the clip proceeds clockwise from the top left corner;
+ // so "start" in each case is the start of the region from that side.
+ //
+ // the final path will be formed like:
+ // s0 ------- e0
+ // | /
+ // s1 ----- e1
+ //
+ // that is, the second point will always be on the inside
+
+ Point start[2];
+ Point end[2];
+
+#define IS_DOTTED(_s) ((_s) == StyleBorderStyle::Dotted)
+ bool isDotted = IS_DOTTED(mBorderStyles[aSide]);
+ bool startIsDotted = IS_DOTTED(mBorderStyles[PREV_SIDE(aSide)]);
+ bool endIsDotted = IS_DOTTED(mBorderStyles[NEXT_SIDE(aSide)]);
+#undef IS_DOTTED
+
+ SideClipType startType = SIDE_CLIP_TRAPEZOID;
+ SideClipType endType = SIDE_CLIP_TRAPEZOID;
+
+ if (!IsZeroSize(mBorderRadii[GetCCWCorner(aSide)])) {
+ startType = SIDE_CLIP_TRAPEZOID_FULL;
+ } else if (startIsDotted && !isDotted) {
+ startType = SIDE_CLIP_RECTANGLE_CORNER;
+ } else if (!startIsDotted && isDotted) {
+ startType = SIDE_CLIP_RECTANGLE_NO_CORNER;
+ }
+
+ if (!IsZeroSize(mBorderRadii[GetCWCorner(aSide)])) {
+ endType = SIDE_CLIP_TRAPEZOID_FULL;
+ } else if (endIsDotted && !isDotted) {
+ endType = SIDE_CLIP_RECTANGLE_CORNER;
+ } else if (!endIsDotted && isDotted) {
+ endType = SIDE_CLIP_RECTANGLE_NO_CORNER;
+ }
+
+ Point midPoint = mInnerRect.Center();
+
+ start[0] = mOuterRect.CCWCorner(aSide);
+ start[1] = mInnerRect.CCWCorner(aSide);
+
+ end[0] = mOuterRect.CWCorner(aSide);
+ end[1] = mInnerRect.CWCorner(aSide);
+
+ if (startType == SIDE_CLIP_TRAPEZOID_FULL) {
+ MaybeMoveToMidPoint(start[0], start[1], midPoint);
+ } else if (startType == SIDE_CLIP_RECTANGLE_CORNER) {
+ if (IsHorizontalSide(aSide)) {
+ start[1] =
+ Point(mOuterRect.CCWCorner(aSide).x, mInnerRect.CCWCorner(aSide).y);
+ } else {
+ start[1] =
+ Point(mInnerRect.CCWCorner(aSide).x, mOuterRect.CCWCorner(aSide).y);
+ }
+ } else if (startType == SIDE_CLIP_RECTANGLE_NO_CORNER) {
+ if (IsHorizontalSide(aSide)) {
+ start[0] =
+ Point(mInnerRect.CCWCorner(aSide).x, mOuterRect.CCWCorner(aSide).y);
+ } else {
+ start[0] =
+ Point(mOuterRect.CCWCorner(aSide).x, mInnerRect.CCWCorner(aSide).y);
+ }
+ }
+
+ if (endType == SIDE_CLIP_TRAPEZOID_FULL) {
+ MaybeMoveToMidPoint(end[0], end[1], midPoint);
+ } else if (endType == SIDE_CLIP_RECTANGLE_CORNER) {
+ if (IsHorizontalSide(aSide)) {
+ end[1] =
+ Point(mOuterRect.CWCorner(aSide).x, mInnerRect.CWCorner(aSide).y);
+ } else {
+ end[1] =
+ Point(mInnerRect.CWCorner(aSide).x, mOuterRect.CWCorner(aSide).y);
+ }
+ } else if (endType == SIDE_CLIP_RECTANGLE_NO_CORNER) {
+ if (IsHorizontalSide(aSide)) {
+ end[0] =
+ Point(mInnerRect.CWCorner(aSide).x, mOuterRect.CWCorner(aSide).y);
+ } else {
+ end[0] =
+ Point(mOuterRect.CWCorner(aSide).x, mInnerRect.CWCorner(aSide).y);
+ }
+ }
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ builder->MoveTo(start[0]);
+ builder->LineTo(end[0]);
+ builder->LineTo(end[1]);
+ builder->LineTo(start[1]);
+ builder->Close();
+ return builder->Finish();
+}
+
+Point nsCSSBorderRenderer::GetStraightBorderPoint(mozilla::Side aSide,
+ Corner aCorner,
+ bool* aIsUnfilled,
+ Float aDotOffset) {
+ // Calculate the end point of the side for dashed/dotted border, that is also
+ // the end point of the corner curve. The point is specified by aSide and
+ // aCorner. (e.g. eSideTop and C_TL means the left end of border-top)
+ //
+ //
+ // aCorner aSide
+ // +--------------------
+ // |
+ // |
+ // | +----------
+ // | the end point
+ // |
+ // | +----------
+ // | |
+ // | |
+ // | |
+ //
+ // The position of the point depends on the border-style, border-width, and
+ // border-radius of the side, corner, and the adjacent side beyond the corner,
+ // to make those sides (and corner) interact well.
+ //
+ // If the style of aSide is dotted and the dot at the point should be
+ // unfilled, true is stored to *aIsUnfilled, otherwise false is stored.
+
+ const Float signsList[4][2] = {
+ {+1.0f, +1.0f}, {-1.0f, +1.0f}, {-1.0f, -1.0f}, {+1.0f, -1.0f}};
+ const Float(&signs)[2] = signsList[aCorner];
+
+ *aIsUnfilled = false;
+
+ Point P = mOuterRect.AtCorner(aCorner);
+ StyleBorderStyle style = mBorderStyles[aSide];
+ Float borderWidth = mBorderWidths[aSide];
+ Size dim = mBorderCornerDimensions[aCorner];
+ bool isHorizontal = IsHorizontalSide(aSide);
+ //
+ // aCorner aSide
+ // +--------------
+ // |
+ // | +----------
+ // | |
+ // otherSide | |
+ // | |
+ mozilla::Side otherSide = ((uint8_t)aSide == (uint8_t)aCorner)
+ ? PREV_SIDE(aSide)
+ : NEXT_SIDE(aSide);
+ StyleBorderStyle otherStyle = mBorderStyles[otherSide];
+ Float otherBorderWidth = mBorderWidths[otherSide];
+ Size radius = mBorderRadii[aCorner];
+ if (IsZeroSize(radius)) {
+ radius.width = 0.0f;
+ radius.height = 0.0f;
+ }
+ if (style == StyleBorderStyle::Dotted) {
+ // Offset the dot's location along the side toward the corner by a
+ // multiple of its width.
+ if (isHorizontal) {
+ P.x -= signs[0] * aDotOffset * borderWidth;
+ } else {
+ P.y -= signs[1] * aDotOffset * borderWidth;
+ }
+ }
+ if (style == StyleBorderStyle::Dotted &&
+ otherStyle == StyleBorderStyle::Dotted) {
+ if (borderWidth == otherBorderWidth) {
+ if (radius.width < borderWidth / 2.0f &&
+ radius.height < borderWidth / 2.0f) {
+ // Two dots are merged into one and placed at the corner.
+ //
+ // borderWidth / 2.0
+ // |<---------->|
+ // | |
+ // |radius.width|
+ // |<--->| |
+ // | | |
+ // | _+------+------------+-----
+ // | / ###|### |
+ // |/ #######|####### |
+ // + #########|######### |
+ // | ##########|########## |
+ // | ###########|########### |
+ // | ###########|########### |
+ // |############|############|
+ // +------------+############|
+ // |########### P ###########|
+ // | ####################### |
+ // | ####################### |
+ // | ##################### |
+ // | ################### |
+ // | ############### |
+ // | ####### |
+ // +-------------------------+----
+ // | |
+ // | |
+ P.x += signs[0] * borderWidth / 2.0f;
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ // Two dots are drawn separately.
+ //
+ // borderWidth * 1.5
+ // |<------------>|
+ // | |
+ // |radius.width |
+ // |<----->| |
+ // | | |
+ // | _--+-+----+---
+ // | _- | ##|##
+ // | / | ###|###
+ // |/ |####|####
+ // | |####+####
+ // | |### P ###
+ // + | ###|###
+ // | | ##|##
+ // +---------+----+---
+ // | ##### |
+ // | ####### |
+ // |#########|
+ // +----+----+
+ // |#########|
+ // | ####### |
+ // | ##### |
+ // | |
+ //
+ // There should be enough gap between 2 dots even if radius.width is
+ // small but larger than borderWidth / 2.0. borderWidth * 1.5 is the
+ // value that there's imaginally unfilled dot at the corner. The
+ // unfilled dot may overflow from the outer curve, but filled dots
+ // doesn't, so this could be acceptable solution at least for now.
+ // We may have to find better model/value.
+ //
+ // imaginally unfilled dot at the corner
+ // |
+ // v +----+---
+ // ***** | ##|##
+ // ******* | ###|###
+ // *********|####|####
+ // *********|####+####
+ // *********|### P ###
+ // ******* | ###|###
+ // ***** | ##|##
+ // +---------+----+---
+ // | ##### |
+ // | ####### |
+ // |#########|
+ // +----+----+
+ // |#########|
+ // | ####### |
+ // | ##### |
+ // | |
+ Float minimum = borderWidth * 1.5f;
+ if (isHorizontal) {
+ P.x += signs[0] * std::max(radius.width, minimum);
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ P.y += signs[1] * std::max(radius.height, minimum);
+ }
+ }
+
+ return P;
+ }
+
+ if (borderWidth < otherBorderWidth) {
+ // This side is smaller than other side, other side draws the corner.
+ //
+ // otherBorderWidth + borderWidth / 2.0
+ // |<---------->|
+ // | |
+ // +---------+--+--------
+ // | ##### | *|* ###
+ // | ####### |**|**#####
+ // |#########|**+**##+##
+ // |####+####|* P *#####
+ // |#########| *** ###
+ // | ####### +-----------
+ // | ##### | ^
+ // | | |
+ // | | first dot is not filled
+ // | |
+ //
+ // radius.width
+ // |<----------------->|
+ // | |
+ // | ___---+-------------
+ // | __-- #|# ###
+ // | _- ##|## #####
+ // | / ##+## ##+##
+ // | / # P # #####
+ // | | #|# ###
+ // | | __--+-------------
+ // || _- ^
+ // || / |
+ // | / first dot is filled
+ // | |
+ // | |
+ // | ##### |
+ // | ####### |
+ // |#########|
+ // +----+----+
+ // |#########|
+ // | ####### |
+ // | ##### |
+ Float minimum = otherBorderWidth + borderWidth / 2.0f;
+ if (isHorizontal) {
+ if (radius.width < minimum) {
+ *aIsUnfilled = true;
+ P.x += signs[0] * minimum;
+ } else {
+ P.x += signs[0] * radius.width;
+ }
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ if (radius.height < minimum) {
+ *aIsUnfilled = true;
+ P.y += signs[1] * minimum;
+ } else {
+ P.y += signs[1] * radius.height;
+ }
+ }
+
+ return P;
+ }
+
+ // This side is larger than other side, this side draws the corner.
+ //
+ // borderWidth / 2.0
+ // |<-->|
+ // | |
+ // +----+---------------------
+ // | ##|## #####
+ // | ###|### #######
+ // |####|#### #########
+ // |####+#### ####+####
+ // |### P ### #########
+ // | ####### #######
+ // | ##### #####
+ // +-----+---------------------
+ // | *** |
+ // |*****|
+ // |**+**| <-- first dot in other side is not filled
+ // |*****|
+ // | *** |
+ // | ### |
+ // |#####|
+ // |##+##|
+ // |#####|
+ // | ### |
+ // | |
+ if (isHorizontal) {
+ P.x += signs[0] * std::max(radius.width, borderWidth / 2.0f);
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ P.y += signs[1] * std::max(radius.height, borderWidth / 2.0f);
+ }
+ return P;
+ }
+
+ if (style == StyleBorderStyle::Dotted) {
+ // If only this side is dotted, other side draws the corner.
+ //
+ // otherBorderWidth + borderWidth / 2.0
+ // |<------->|
+ // | |
+ // +------+--+--------
+ // |## ##| *|* ###
+ // |## ##|**|**#####
+ // |## ##|**+**##+##
+ // |## ##|* P *#####
+ // |## ##| *** ###
+ // |## ##+-----------
+ // |## ##| ^
+ // |## ##| |
+ // |## ##| first dot is not filled
+ // |## ##|
+ //
+ // radius.width
+ // |<----------------->|
+ // | |
+ // | ___---+-------------
+ // | __-- #|# ###
+ // | _- ##|## #####
+ // | / ##+## ##+##
+ // | / # P # #####
+ // | | #|# ###
+ // | | __--+-------------
+ // || _- ^
+ // || / |
+ // | / first dot is filled
+ // | |
+ // | |
+ // | |
+ // | |
+ // | |
+ // +------+
+ // |## ##|
+ // |## ##|
+ // |## ##|
+ Float minimum = otherBorderWidth + borderWidth / 2.0f;
+ if (isHorizontal) {
+ if (radius.width < minimum) {
+ *aIsUnfilled = true;
+ P.x += signs[0] * minimum;
+ } else {
+ P.x += signs[0] * radius.width;
+ }
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ if (radius.height < minimum) {
+ *aIsUnfilled = true;
+ P.y += signs[1] * minimum;
+ } else {
+ P.y += signs[1] * radius.height;
+ }
+ }
+ return P;
+ }
+
+ if (otherStyle == StyleBorderStyle::Dotted && IsZeroSize(radius)) {
+ // If other side is dotted and radius=0, draw side to the end of corner.
+ //
+ // +-------------------------------
+ // |########## ##########
+ // P +########## ##########
+ // |########## ##########
+ // +-----+-------------------------
+ // | *** |
+ // |*****|
+ // |**+**| <-- first dot in other side is not filled
+ // |*****|
+ // | *** |
+ // | ### |
+ // |#####|
+ // |##+##|
+ // |#####|
+ // | ### |
+ // | |
+ if (isHorizontal) {
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ }
+ return P;
+ }
+
+ // Other cases.
+ //
+ // dim.width
+ // |<----------------->|
+ // | |
+ // | ___---+------------------
+ // | __-- |####### ###
+ // | _- P +####### ###
+ // | / |####### ###
+ // | / __---+------------------
+ // | | __--
+ // | | /
+ // || /
+ // || |
+ // | |
+ // | |
+ // | |
+ // | |
+ // +-+-+
+ // |###|
+ // |###|
+ // |###|
+ // |###|
+ // |###|
+ // | |
+ // | |
+ if (isHorizontal) {
+ P.x += signs[0] * dim.width;
+ P.y += signs[1] * borderWidth / 2.0f;
+ } else {
+ P.x += signs[0] * borderWidth / 2.0f;
+ P.y += signs[1] * dim.height;
+ }
+
+ return P;
+}
+
+void nsCSSBorderRenderer::GetOuterAndInnerBezier(Bezier* aOuterBezier,
+ Bezier* aInnerBezier,
+ Corner aCorner) {
+ // Return bezier control points for outer and inner curve for given corner.
+ //
+ // ___---+ outer curve
+ // __-- |
+ // _- |
+ // / |
+ // / |
+ // | |
+ // | __--+ inner curve
+ // | _-
+ // | /
+ // | /
+ // | |
+ // | |
+ // | |
+ // | |
+ // | |
+ // +---------+
+
+ mozilla::Side sideH(GetHorizontalSide(aCorner));
+ mozilla::Side sideV(GetVerticalSide(aCorner));
+
+ Size outerCornerSize(ceil(mBorderRadii[aCorner].width),
+ ceil(mBorderRadii[aCorner].height));
+ Size innerCornerSize(
+ ceil(std::max(0.0f, mBorderRadii[aCorner].width - mBorderWidths[sideV])),
+ ceil(
+ std::max(0.0f, mBorderRadii[aCorner].height - mBorderWidths[sideH])));
+
+ GetBezierPointsForCorner(aOuterBezier, aCorner, mOuterRect.AtCorner(aCorner),
+ outerCornerSize);
+
+ GetBezierPointsForCorner(aInnerBezier, aCorner, mInnerRect.AtCorner(aCorner),
+ innerCornerSize);
+}
+
+void nsCSSBorderRenderer::FillSolidBorder(const Rect& aOuterRect,
+ const Rect& aInnerRect,
+ const RectCornerRadii& aBorderRadii,
+ const Float* aBorderSizes,
+ SideBits aSides,
+ const ColorPattern& aColor) {
+ // Note that this function is allowed to draw more than just the
+ // requested sides.
+
+ // If we have a border radius, do full rounded rectangles
+ // and fill, regardless of what sides we're asked to draw.
+ if (!AllCornersZeroSize(aBorderRadii)) {
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+
+ RectCornerRadii innerRadii;
+ ComputeInnerRadii(aBorderRadii, aBorderSizes, &innerRadii);
+
+ // do the outer border
+ AppendRoundedRectToPath(builder, aOuterRect, aBorderRadii, true);
+
+ // then do the inner border CCW
+ AppendRoundedRectToPath(builder, aInnerRect, innerRadii, false);
+
+ RefPtr<Path> path = builder->Finish();
+
+ mDrawTarget->Fill(path, aColor);
+ return;
+ }
+
+ // If we're asked to draw all sides of an equal-sized border,
+ // stroking is fastest. This is a fairly common path, but partial
+ // sides is probably second in the list -- there are a bunch of
+ // common border styles, such as inset and outset, that are
+ // top-left/bottom-right split.
+ if (aSides == SideBits::eAll &&
+ CheckFourFloatsEqual(aBorderSizes, aBorderSizes[0]) && !mAvoidStroke) {
+ Float strokeWidth = aBorderSizes[0];
+ Rect r(aOuterRect);
+ r.Deflate(strokeWidth / 2.f);
+ mDrawTarget->StrokeRect(r, aColor, StrokeOptions(strokeWidth));
+ return;
+ }
+
+ // Otherwise, we have unequal sized borders or we're only
+ // drawing some sides; create rectangles for each side
+ // and fill them.
+
+ Rect r[4];
+
+ // compute base rects for each side
+ if (aSides & SideBits::eTop) {
+ r[eSideTop] = Rect(aOuterRect.X(), aOuterRect.Y(), aOuterRect.Width(),
+ aBorderSizes[eSideTop]);
+ }
+
+ if (aSides & SideBits::eBottom) {
+ r[eSideBottom] =
+ Rect(aOuterRect.X(), aOuterRect.YMost() - aBorderSizes[eSideBottom],
+ aOuterRect.Width(), aBorderSizes[eSideBottom]);
+ }
+
+ if (aSides & SideBits::eLeft) {
+ r[eSideLeft] = Rect(aOuterRect.X(), aOuterRect.Y(), aBorderSizes[eSideLeft],
+ aOuterRect.Height());
+ }
+
+ if (aSides & SideBits::eRight) {
+ r[eSideRight] =
+ Rect(aOuterRect.XMost() - aBorderSizes[eSideRight], aOuterRect.Y(),
+ aBorderSizes[eSideRight], aOuterRect.Height());
+ }
+
+ // If two sides meet at a corner that we're rendering, then
+ // make sure that we adjust one of the sides to avoid overlap.
+ // This is especially important in the case of colors with
+ // an alpha channel.
+
+ if ((aSides & (SideBits::eTop | SideBits::eLeft)) ==
+ (SideBits::eTop | SideBits::eLeft)) {
+ // adjust the left's top down a bit
+ r[eSideLeft].y += aBorderSizes[eSideTop];
+ r[eSideLeft].height -= aBorderSizes[eSideTop];
+ }
+
+ if ((aSides & (SideBits::eTop | SideBits::eRight)) ==
+ (SideBits::eTop | SideBits::eRight)) {
+ // adjust the top's left a bit
+ r[eSideTop].width -= aBorderSizes[eSideRight];
+ }
+
+ if ((aSides & (SideBits::eBottom | SideBits::eRight)) ==
+ (SideBits::eBottom | SideBits::eRight)) {
+ // adjust the right's bottom a bit
+ r[eSideRight].height -= aBorderSizes[eSideBottom];
+ }
+
+ if ((aSides & (SideBits::eBottom | SideBits::eLeft)) ==
+ (SideBits::eBottom | SideBits::eLeft)) {
+ // adjust the bottom's left a bit
+ r[eSideBottom].x += aBorderSizes[eSideLeft];
+ r[eSideBottom].width -= aBorderSizes[eSideLeft];
+ }
+
+ // Filling these one by one is faster than filling them all at once.
+ for (uint32_t i = 0; i < 4; i++) {
+ if (aSides & static_cast<mozilla::SideBits>(1 << i)) {
+ MaybeSnapToDevicePixels(r[i], *mDrawTarget, true);
+ mDrawTarget->FillRect(r[i], aColor);
+ }
+ }
+}
+
+sRGBColor MakeBorderColor(nscolor aColor, BorderColorStyle aBorderColorStyle) {
+ nscolor colors[2];
+ int k = 0;
+
+ switch (aBorderColorStyle) {
+ case BorderColorStyleNone:
+ return sRGBColor(0.f, 0.f, 0.f, 0.f); // transparent black
+
+ case BorderColorStyleLight:
+ k = 1;
+ [[fallthrough]];
+ case BorderColorStyleDark:
+ NS_GetSpecial3DColors(colors, aColor);
+ return sRGBColor::FromABGR(colors[k]);
+
+ case BorderColorStyleSolid:
+ default:
+ return sRGBColor::FromABGR(aColor);
+ }
+}
+
+sRGBColor ComputeColorForLine(uint32_t aLineIndex,
+ const BorderColorStyle* aBorderColorStyle,
+ uint32_t aBorderColorStyleCount,
+ nscolor aBorderColor) {
+ NS_ASSERTION(aLineIndex < aBorderColorStyleCount, "Invalid lineIndex given");
+
+ return MakeBorderColor(aBorderColor, aBorderColorStyle[aLineIndex]);
+}
+
+void nsCSSBorderRenderer::DrawBorderSides(mozilla::SideBits aSides) {
+ if (aSides == SideBits::eNone ||
+ (aSides & ~SideBits::eAll) != SideBits::eNone) {
+ NS_WARNING("DrawBorderSides: invalid sides!");
+ return;
+ }
+
+ StyleBorderStyle borderRenderStyle = StyleBorderStyle::None;
+ nscolor borderRenderColor;
+
+ uint32_t borderColorStyleCount = 0;
+ BorderColorStyle borderColorStyleTopLeft[3], borderColorStyleBottomRight[3];
+ BorderColorStyle* borderColorStyle = nullptr;
+
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ if ((aSides & static_cast<mozilla::SideBits>(1 << i)) == SideBits::eNone) {
+ continue;
+ }
+ borderRenderStyle = mBorderStyles[i];
+ borderRenderColor = mBorderColors[i];
+ break;
+ }
+
+ if (borderRenderStyle == StyleBorderStyle::None ||
+ borderRenderStyle == StyleBorderStyle::Hidden) {
+ return;
+ }
+
+ if (borderRenderStyle == StyleBorderStyle::Dashed ||
+ borderRenderStyle == StyleBorderStyle::Dotted) {
+ // Draw each corner separately, with the given side's color.
+ if (aSides & SideBits::eTop) {
+ DrawDashedOrDottedCorner(eSideTop, C_TL);
+ } else if (aSides & SideBits::eLeft) {
+ DrawDashedOrDottedCorner(eSideLeft, C_TL);
+ }
+
+ if (aSides & SideBits::eTop) {
+ DrawDashedOrDottedCorner(eSideTop, C_TR);
+ } else if (aSides & SideBits::eRight) {
+ DrawDashedOrDottedCorner(eSideRight, C_TR);
+ }
+
+ if (aSides & SideBits::eBottom) {
+ DrawDashedOrDottedCorner(eSideBottom, C_BL);
+ } else if (aSides & SideBits::eLeft) {
+ DrawDashedOrDottedCorner(eSideLeft, C_BL);
+ }
+
+ if (aSides & SideBits::eBottom) {
+ DrawDashedOrDottedCorner(eSideBottom, C_BR);
+ } else if (aSides & SideBits::eRight) {
+ DrawDashedOrDottedCorner(eSideRight, C_BR);
+ }
+ return;
+ }
+
+ // The borderColorStyle array goes from the outer to the inner style.
+ //
+ // If the border width is 1, we need to change the borderRenderStyle
+ // a bit to make sure that we get the right colors -- e.g. 'ridge'
+ // with a 1px border needs to look like solid, not like 'outset'.
+ if (mOneUnitBorder && (borderRenderStyle == StyleBorderStyle::Ridge ||
+ borderRenderStyle == StyleBorderStyle::Groove ||
+ borderRenderStyle == StyleBorderStyle::Double)) {
+ borderRenderStyle = StyleBorderStyle::Solid;
+ }
+
+ switch (borderRenderStyle) {
+ case StyleBorderStyle::Solid:
+ borderColorStyleTopLeft[0] = BorderColorStyleSolid;
+
+ borderColorStyleBottomRight[0] = BorderColorStyleSolid;
+
+ borderColorStyleCount = 1;
+ break;
+
+ case StyleBorderStyle::Groove:
+ borderColorStyleTopLeft[0] = BorderColorStyleDark;
+ borderColorStyleTopLeft[1] = BorderColorStyleLight;
+
+ borderColorStyleBottomRight[0] = BorderColorStyleLight;
+ borderColorStyleBottomRight[1] = BorderColorStyleDark;
+
+ borderColorStyleCount = 2;
+ break;
+
+ case StyleBorderStyle::Ridge:
+ borderColorStyleTopLeft[0] = BorderColorStyleLight;
+ borderColorStyleTopLeft[1] = BorderColorStyleDark;
+
+ borderColorStyleBottomRight[0] = BorderColorStyleDark;
+ borderColorStyleBottomRight[1] = BorderColorStyleLight;
+
+ borderColorStyleCount = 2;
+ break;
+
+ case StyleBorderStyle::Double:
+ borderColorStyleTopLeft[0] = BorderColorStyleSolid;
+ borderColorStyleTopLeft[1] = BorderColorStyleNone;
+ borderColorStyleTopLeft[2] = BorderColorStyleSolid;
+
+ borderColorStyleBottomRight[0] = BorderColorStyleSolid;
+ borderColorStyleBottomRight[1] = BorderColorStyleNone;
+ borderColorStyleBottomRight[2] = BorderColorStyleSolid;
+
+ borderColorStyleCount = 3;
+ break;
+
+ case StyleBorderStyle::Inset:
+ borderColorStyleTopLeft[0] = BorderColorStyleDark;
+ borderColorStyleBottomRight[0] = BorderColorStyleLight;
+
+ borderColorStyleCount = 1;
+ break;
+
+ case StyleBorderStyle::Outset:
+ borderColorStyleTopLeft[0] = BorderColorStyleLight;
+ borderColorStyleBottomRight[0] = BorderColorStyleDark;
+
+ borderColorStyleCount = 1;
+ break;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unhandled border style!!");
+ break;
+ }
+
+ // The only way to get to here is by having a
+ // borderColorStyleCount < 1 or > 3; this should never happen,
+ // since -moz-border-colors doesn't get handled here.
+ NS_ASSERTION(borderColorStyleCount > 0 && borderColorStyleCount < 4,
+ "Non-border-colors case with borderColorStyleCount < 1 or > 3; "
+ "what happened?");
+
+ // The caller should never give us anything with a mix
+ // of TL/BR if the border style would require a
+ // TL/BR split.
+ if (aSides & (SideBits::eBottom | SideBits::eRight)) {
+ borderColorStyle = borderColorStyleBottomRight;
+ } else {
+ borderColorStyle = borderColorStyleTopLeft;
+ }
+
+ // Distribute the border across the available space.
+ Float borderWidths[3][4];
+
+ if (borderColorStyleCount == 1) {
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ borderWidths[0][i] = mBorderWidths[i];
+ }
+ } else if (borderColorStyleCount == 2) {
+ // with 2 color styles, any extra pixel goes to the outside
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ borderWidths[0][i] =
+ int32_t(mBorderWidths[i]) / 2 + int32_t(mBorderWidths[i]) % 2;
+ borderWidths[1][i] = int32_t(mBorderWidths[i]) / 2;
+ }
+ } else if (borderColorStyleCount == 3) {
+ // with 3 color styles, any extra pixel (or lack of extra pixel)
+ // goes to the middle
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ if (mBorderWidths[i] == 1.0) {
+ borderWidths[0][i] = 1.f;
+ borderWidths[1][i] = borderWidths[2][i] = 0.f;
+ } else {
+ int32_t rest = int32_t(mBorderWidths[i]) % 3;
+ borderWidths[0][i] = borderWidths[2][i] = borderWidths[1][i] =
+ (int32_t(mBorderWidths[i]) - rest) / 3;
+
+ if (rest == 1) {
+ borderWidths[1][i] += 1.f;
+ } else if (rest == 2) {
+ borderWidths[0][i] += 1.f;
+ borderWidths[2][i] += 1.f;
+ }
+ }
+ }
+ }
+
+ // make a copy that we can modify
+ RectCornerRadii radii = mBorderRadii;
+
+ Rect soRect(mOuterRect);
+ Rect siRect(mOuterRect);
+
+ // If adjacent side is dotted and radius=0, draw side to the end of corner.
+ //
+ // +--------------------------------
+ // |################################
+ // |
+ // |################################
+ // +-----+--------------------------
+ // | |
+ // | |
+ // | |
+ // | |
+ // | |
+ // | ### |
+ // |#####|
+ // |#####|
+ // |#####|
+ // | ### |
+ // | |
+ bool noMarginTop = false;
+ bool noMarginRight = false;
+ bool noMarginBottom = false;
+ bool noMarginLeft = false;
+
+ // If there is at least one dotted side, every side is rendered separately.
+ if (IsSingleSide(aSides)) {
+ if (aSides == SideBits::eTop) {
+ if (mBorderStyles[eSideRight] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_TR])) {
+ noMarginRight = true;
+ }
+ if (mBorderStyles[eSideLeft] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_TL])) {
+ noMarginLeft = true;
+ }
+ } else if (aSides == SideBits::eRight) {
+ if (mBorderStyles[eSideTop] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_TR])) {
+ noMarginTop = true;
+ }
+ if (mBorderStyles[eSideBottom] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_BR])) {
+ noMarginBottom = true;
+ }
+ } else if (aSides == SideBits::eBottom) {
+ if (mBorderStyles[eSideRight] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_BR])) {
+ noMarginRight = true;
+ }
+ if (mBorderStyles[eSideLeft] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_BL])) {
+ noMarginLeft = true;
+ }
+ } else {
+ if (mBorderStyles[eSideTop] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_TL])) {
+ noMarginTop = true;
+ }
+ if (mBorderStyles[eSideBottom] == StyleBorderStyle::Dotted &&
+ IsZeroSize(mBorderRadii[C_BL])) {
+ noMarginBottom = true;
+ }
+ }
+ }
+
+ for (unsigned int i = 0; i < borderColorStyleCount; i++) {
+ // walk siRect inwards at the start of the loop to get the
+ // correct inner rect.
+ //
+ // If noMarginTop is false:
+ // --------------------+
+ // /|
+ // / |
+ // L |
+ // ----------------+ |
+ // | |
+ // | |
+ //
+ // If noMarginTop is true:
+ // ----------------+<--+
+ // | |
+ // | |
+ // | |
+ // | |
+ // | |
+ // | |
+ siRect.Deflate(Margin(noMarginTop ? 0 : borderWidths[i][0],
+ noMarginRight ? 0 : borderWidths[i][1],
+ noMarginBottom ? 0 : borderWidths[i][2],
+ noMarginLeft ? 0 : borderWidths[i][3]));
+
+ if (borderColorStyle[i] != BorderColorStyleNone) {
+ sRGBColor c = ComputeColorForLine(
+ i, borderColorStyle, borderColorStyleCount, borderRenderColor);
+ ColorPattern color(ToDeviceColor(c));
+
+ FillSolidBorder(soRect, siRect, radii, borderWidths[i], aSides, color);
+ }
+
+ ComputeInnerRadii(radii, borderWidths[i], &radii);
+
+ // And now soRect is the same as siRect, for the next line in.
+ soRect = siRect;
+ }
+}
+
+void nsCSSBorderRenderer::SetupDashedOptions(StrokeOptions* aStrokeOptions,
+ Float aDash[2],
+ mozilla::Side aSide,
+ Float aBorderLength,
+ bool isCorner) {
+ MOZ_ASSERT(mBorderStyles[aSide] == StyleBorderStyle::Dashed ||
+ mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dashed or dotted.");
+
+ StyleBorderStyle style = mBorderStyles[aSide];
+ Float borderWidth = mBorderWidths[aSide];
+
+ // Dashed line starts and ends with half segment in most case.
+ //
+ // __--+---+---+---+---+---+---+---+---+--__
+ // |###| | |###|###| | |###|
+ // |###| | |###|###| | |###|
+ // |###| | |###|###| | |###|
+ // __--+---+---+---+---+---+---+---+---+--__
+ //
+ // If radius=0 and other side is either dotted or 0-width, it starts or ends
+ // with full segment.
+ //
+ // +---+---+---+---+---+---+---+---+---+---+
+ // |###|###| | |###|###| | |###|###|
+ // |###|###| | |###|###| | |###|###|
+ // |###|###| | |###|###| | |###|###|
+ // +---++--+---+---+---+---+---+---+--++---+
+ // | | | |
+ // | | | |
+ // | | | |
+ // | | | |
+ // | ## | | ## |
+ // |####| |####|
+ // |####| |####|
+ // | ## | | ## |
+ // | | | |
+ bool fullStart = false, fullEnd = false;
+ Float halfDash;
+ if (style == StyleBorderStyle::Dashed) {
+ // If either end of the side is not connecting onto a corner then we want a
+ // full dash at that end.
+ //
+ // Note that in the case that a corner is empty, either the adjacent side
+ // has zero width, or else DrawBorders() set the corner to be empty
+ // (it does that if the adjacent side has zero length and the border widths
+ // of this and the adjacent sides are thin enough that the corner will be
+ // insignificantly small).
+
+ if (mBorderRadii[GetCCWCorner(aSide)].IsEmpty() &&
+ (mBorderCornerDimensions[GetCCWCorner(aSide)].IsEmpty() ||
+ mBorderStyles[PREV_SIDE(aSide)] == StyleBorderStyle::Dotted ||
+ // XXX why this <=1 check?
+ borderWidth <= 1.0f)) {
+ fullStart = true;
+ }
+
+ if (mBorderRadii[GetCWCorner(aSide)].IsEmpty() &&
+ (mBorderCornerDimensions[GetCWCorner(aSide)].IsEmpty() ||
+ mBorderStyles[NEXT_SIDE(aSide)] == StyleBorderStyle::Dotted)) {
+ fullEnd = true;
+ }
+
+ halfDash = borderWidth * DOT_LENGTH * DASH_LENGTH / 2.0f;
+ } else {
+ halfDash = borderWidth * DOT_LENGTH / 2.0f;
+ }
+
+ if (style == StyleBorderStyle::Dashed && aBorderLength > 0.0f) {
+ // The number of half segments, with maximum dash length.
+ int32_t count = floor(aBorderLength / halfDash);
+ Float minHalfDash = borderWidth * DOT_LENGTH / 2.0f;
+
+ if (fullStart && fullEnd) {
+ // count should be 4n + 2
+ //
+ // 1 + 4 + 4 + 1
+ //
+ // | | | | |
+ // +---+---+---+---+---+---+---+---+---+---+
+ // |###|###| | |###|###| | |###|###|
+ // |###|###| | |###|###| | |###|###|
+ // |###|###| | |###|###| | |###|###|
+ // +---+---+---+---+---+---+---+---+---+---+
+
+ // If border is too short, draw solid line.
+ if (aBorderLength < 6.0f * minHalfDash) {
+ return;
+ }
+
+ if (count % 4 == 0) {
+ count += 2;
+ } else if (count % 4 == 1) {
+ count += 1;
+ } else if (count % 4 == 3) {
+ count += 3;
+ }
+ } else if (fullStart || fullEnd) {
+ // count should be 4n + 1
+ //
+ // 1 + 4 + 4
+ //
+ // | | | |
+ // +---+---+---+---+---+---+---+---+---+
+ // |###|###| | |###|###| | |###|
+ // |###|###| | |###|###| | |###|
+ // |###|###| | |###|###| | |###|
+ // +---+---+---+---+---+---+---+---+---+
+ //
+ // 4 + 4 + 1
+ //
+ // | | | |
+ // +---+---+---+---+---+---+---+---+---+
+ // |###| | |###|###| | |###|###|
+ // |###| | |###|###| | |###|###|
+ // |###| | |###|###| | |###|###|
+ // +---+---+---+---+---+---+---+---+---+
+
+ // If border is too short, draw solid line.
+ if (aBorderLength < 5.0f * minHalfDash) {
+ return;
+ }
+
+ if (count % 4 == 0) {
+ count += 1;
+ } else if (count % 4 == 2) {
+ count += 3;
+ } else if (count % 4 == 3) {
+ count += 2;
+ }
+ } else {
+ // count should be 4n
+ //
+ // 4 + 4
+ //
+ // | | |
+ // +---+---+---+---+---+---+---+---+
+ // |###| | |###|###| | |###|
+ // |###| | |###|###| | |###|
+ // |###| | |###|###| | |###|
+ // +---+---+---+---+---+---+---+---+
+
+ // If border is too short, draw solid line.
+ if (aBorderLength < 4.0f * minHalfDash) {
+ return;
+ }
+
+ if (count % 4 == 1) {
+ count += 3;
+ } else if (count % 4 == 2) {
+ count += 2;
+ } else if (count % 4 == 3) {
+ count += 1;
+ }
+ }
+ halfDash = aBorderLength / count;
+ }
+
+ Float fullDash = halfDash * 2.0f;
+
+ aDash[0] = fullDash;
+ aDash[1] = fullDash;
+
+ if (style == StyleBorderStyle::Dashed && fullDash > 1.0f) {
+ if (!fullStart) {
+ // Draw half segments on both ends.
+ aStrokeOptions->mDashOffset = halfDash;
+ }
+ } else if (style != StyleBorderStyle::Dotted && isCorner) {
+ // If side ends with filled full segment, corner should start with unfilled
+ // full segment. Not needed for dotted corners, as they overlap one dot with
+ // the side's end.
+ //
+ // corner side
+ // ------------>|<---------------------------
+ // |
+ // __+---+---+---+---+---+---+---+---+
+ // _+- | |###|###| | |###|###| |
+ // /##| | |###|###| | |###|###| |
+ // +####| | |###|###| | |###|###| |
+ // /#\####| _+--+---+---+---+---+---+---+---+
+ // |####\##+-
+ // |#####+-
+ // +--###/
+ // | --+
+ aStrokeOptions->mDashOffset = fullDash;
+ }
+
+ aStrokeOptions->mDashPattern = aDash;
+ aStrokeOptions->mDashLength = 2;
+
+ PrintAsFormatString("dash: %f %f\n", aDash[0], aDash[1]);
+}
+
+static Float GetBorderLength(mozilla::Side aSide, const Point& aStart,
+ const Point& aEnd) {
+ if (aSide == eSideTop) {
+ return aEnd.x - aStart.x;
+ }
+ if (aSide == eSideRight) {
+ return aEnd.y - aStart.y;
+ }
+ if (aSide == eSideBottom) {
+ return aStart.x - aEnd.x;
+ }
+ return aStart.y - aEnd.y;
+}
+
+void nsCSSBorderRenderer::DrawDashedOrDottedSide(mozilla::Side aSide) {
+ // Draw dashed/dotted side with following approach.
+ //
+ // dashed side
+ // Draw dashed line along the side, with appropriate dash length and gap
+ // to make the side symmetric as far as possible. Dash length equals to
+ // the gap, and the ratio of the dash length to border-width is the maximum
+ // value in in [1, 3] range.
+ // In most case, line ends with half segment, to joint with corner easily.
+ // If adjacent side is dotted or 0px and border-radius for the corner
+ // between them is 0, the line ends with full segment.
+ // (see comment for GetStraightBorderPoint for more detail)
+ //
+ // dotted side
+ // If border-width <= 2.0, draw 1:1 dashed line.
+ // Otherwise, draw circles along the side, with appropriate gap that makes
+ // the side symmetric as far as possible. The ratio of the gap to
+ // border-width is the maximum value in [0.5, 1] range in most case.
+ // if the side is too short and there's only 2 dots, it can be more smaller.
+ // If there's no space to place 2 dots at the side, draw single dot at the
+ // middle of the side.
+ // In most case, line ends with filled dot, to joint with corner easily,
+ // If adjacent side is dotted with larger border-width, or other style,
+ // the line ends with unfilled dot.
+ // (see comment for GetStraightBorderPoint for more detail)
+
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dashed ||
+ mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dashed or dotted.");
+
+ Float borderWidth = mBorderWidths[aSide];
+ if (borderWidth == 0.0f) {
+ return;
+ }
+
+ if (mBorderStyles[aSide] == StyleBorderStyle::Dotted && borderWidth > 2.0f) {
+ DrawDottedSideSlow(aSide);
+ return;
+ }
+
+ nscolor borderColor = mBorderColors[aSide];
+ bool ignored;
+ // Get the start and end points of the side, ensuring that any dot origins get
+ // pushed outward to account for stroking.
+ Point start =
+ GetStraightBorderPoint(aSide, GetCCWCorner(aSide), &ignored, 0.5f);
+ Point end = GetStraightBorderPoint(aSide, GetCWCorner(aSide), &ignored, 0.5f);
+ if (borderWidth < 2.0f) {
+ // Round start to draw dot on each pixel.
+ if (IsHorizontalSide(aSide)) {
+ start.x = round(start.x);
+ } else {
+ start.y = round(start.y);
+ }
+ }
+
+ Float borderLength = GetBorderLength(aSide, start, end);
+ if (borderLength < 0.0f) {
+ return;
+ }
+
+ StrokeOptions strokeOptions(borderWidth);
+ Float dash[2];
+ SetupDashedOptions(&strokeOptions, dash, aSide, borderLength, false);
+
+ // For dotted sides that can merge with their prior dotted sides, advance the
+ // dash offset to measure the distance around the combined path. This prevents
+ // two dots from bunching together at a corner.
+ mozilla::Side mergeSide = aSide;
+ while (IsCornerMergeable(GetCCWCorner(mergeSide))) {
+ mergeSide = PREV_SIDE(mergeSide);
+ // If we looped all the way around, measure starting at the top side, since
+ // we need to pick a fixed location to start measuring distance from still.
+ if (mergeSide == aSide) {
+ mergeSide = eSideTop;
+ break;
+ }
+ }
+ while (mergeSide != aSide) {
+ // Measure the length of the merged side starting from a possibly
+ // unmergeable corner up to the merged corner. A merged corner effectively
+ // has no border radius, so we can just use the cheaper AtCorner to find the
+ // end point.
+ Float mergeLength =
+ GetBorderLength(mergeSide,
+ GetStraightBorderPoint(
+ mergeSide, GetCCWCorner(mergeSide), &ignored, 0.5f),
+ mOuterRect.AtCorner(GetCWCorner(mergeSide)));
+ // Add in the merged side length. Also offset the dash progress by an extra
+ // dot's width to avoid drawing a dot that would overdraw where the merged
+ // side would have ended in a gap, i.e. O_O_
+ // O
+ strokeOptions.mDashOffset += mergeLength + borderWidth;
+ mergeSide = NEXT_SIDE(mergeSide);
+ }
+
+ DrawOptions drawOptions;
+ if (mBorderStyles[aSide] == StyleBorderStyle::Dotted) {
+ drawOptions.mAntialiasMode = AntialiasMode::NONE;
+ }
+
+ mDrawTarget->StrokeLine(start, end, ColorPattern(ToDeviceColor(borderColor)),
+ strokeOptions, drawOptions);
+}
+
+void nsCSSBorderRenderer::DrawDottedSideSlow(mozilla::Side aSide) {
+ // Draw each circles separately for dotted with borderWidth > 2.0.
+ // Dashed line with CapStyle::ROUND doesn't render perfect circles.
+
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dotted.");
+
+ Float borderWidth = mBorderWidths[aSide];
+ if (borderWidth == 0.0f) {
+ return;
+ }
+
+ nscolor borderColor = mBorderColors[aSide];
+ bool isStartUnfilled, isEndUnfilled;
+ Point start =
+ GetStraightBorderPoint(aSide, GetCCWCorner(aSide), &isStartUnfilled);
+ Point end = GetStraightBorderPoint(aSide, GetCWCorner(aSide), &isEndUnfilled);
+ enum {
+ // Corner is not mergeable.
+ NO_MERGE,
+
+ // Corner between different colors.
+ // Two dots are merged into one, and both side draw half dot.
+ MERGE_HALF,
+
+ // Corner between same colors, CCW corner of the side.
+ // Two dots are merged into one, and this side draw entire dot.
+ //
+ // MERGE_ALL MERGE_NONE
+ // | |
+ // v v
+ // +-----------------------+----+
+ // | ## ## ## | ## |
+ // |#### #### #### |####|
+ // |#### #### #### |####|
+ // | ## ## ## | ## |
+ // +----+------------------+ |
+ // | | | |
+ // | | | |
+ // | | | |
+ // | ## | | ## |
+ // |####| |####|
+ MERGE_ALL,
+
+ // Corner between same colors, CW corner of the side.
+ // Two dots are merged into one, and this side doesn't draw dot.
+ MERGE_NONE
+ } mergeStart = NO_MERGE,
+ mergeEnd = NO_MERGE;
+
+ if (IsCornerMergeable(GetCCWCorner(aSide))) {
+ if (borderColor == mBorderColors[PREV_SIDE(aSide)]) {
+ mergeStart = MERGE_ALL;
+ } else {
+ mergeStart = MERGE_HALF;
+ }
+ }
+
+ if (IsCornerMergeable(GetCWCorner(aSide))) {
+ if (borderColor == mBorderColors[NEXT_SIDE(aSide)]) {
+ mergeEnd = MERGE_NONE;
+ } else {
+ mergeEnd = MERGE_HALF;
+ }
+ }
+
+ Float borderLength = GetBorderLength(aSide, start, end);
+ if (borderLength < 0.0f) {
+ if (isStartUnfilled || isEndUnfilled) {
+ return;
+ }
+ borderLength = 0.0f;
+ start = end = (start + end) / 2.0f;
+ }
+
+ Float dotWidth = borderWidth * DOT_LENGTH;
+ Float radius = borderWidth / 2.0f;
+ if (borderLength < dotWidth) {
+ // If dots on start and end may overlap, draw a dot at the middle of them.
+ //
+ // ___---+-------+---___
+ // __-- | ##### | --__
+ // #|#######|#
+ // ##|#######|##
+ // ###|#######|###
+ // ###+###+###+###
+ // start ## end #
+ // ##|#######|##
+ // #|#######|#
+ // | ##### |
+ // __--+-------+--__
+ // _- -_
+ //
+ // If that circle overflows from outer rect, do not draw it.
+ //
+ // +-------+
+ // | ##### |
+ // #|#######|#
+ // ##|#######|##
+ // ###|#######|###
+ // ###|###+###|###
+ // ###|#######|###
+ // ##|#######|##
+ // #|#######|#
+ // | ##### |
+ // +--+-+--+
+ // | | | |
+ // | | | |
+ if (!mOuterRect.Contains(Rect(start.x - radius, start.y - radius,
+ borderWidth, borderWidth))) {
+ return;
+ }
+
+ if (isStartUnfilled || isEndUnfilled) {
+ return;
+ }
+
+ Point P = (start + end) / 2;
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ builder->MoveTo(Point(P.x + radius, P.y));
+ builder->Arc(P, radius, 0.0f, Float(2.0 * M_PI));
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+ return;
+ }
+
+ if (mergeStart == MERGE_HALF || mergeEnd == MERGE_HALF) {
+ // MERGE_HALF
+ // Eo
+ // -------+----+
+ // ##### /
+ // ######/
+ // ######/
+ // ####+
+ // ##/ end
+ // /
+ // /
+ // --+
+ // Ei
+ //
+ // other (NO_MERGE, MERGE_ALL, MERGE_NONE)
+ // Eo
+ // ------------+
+ // ##### |
+ // ####### |
+ // #########|
+ // ####+####|
+ // ## end ##|
+ // ####### |
+ // ##### |
+ // ------------+
+ // Ei
+
+ Point I(0.0f, 0.0f), J(0.0f, 0.0f);
+ if (aSide == eSideTop) {
+ I.x = 1.0f;
+ J.y = 1.0f;
+ } else if (aSide == eSideRight) {
+ I.y = 1.0f;
+ J.x = -1.0f;
+ } else if (aSide == eSideBottom) {
+ I.x = -1.0f;
+ J.y = -1.0f;
+ } else if (aSide == eSideLeft) {
+ I.y = -1.0f;
+ J.x = 1.0f;
+ }
+
+ Point So, Si, Eo, Ei;
+
+ So = (start + (-I + -J) * borderWidth / 2.0f);
+ Si = (mergeStart == MERGE_HALF) ? (start + (I + J) * borderWidth / 2.0f)
+ : (start + (-I + J) * borderWidth / 2.0f);
+ Eo = (end + (I - J) * borderWidth / 2.0f);
+ Ei = (mergeEnd == MERGE_HALF) ? (end + (-I + J) * borderWidth / 2.0f)
+ : (end + (I + J) * borderWidth / 2.0f);
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ builder->MoveTo(So);
+ builder->LineTo(Eo);
+ builder->LineTo(Ei);
+ builder->LineTo(Si);
+ builder->Close();
+ RefPtr<Path> path = builder->Finish();
+
+ mDrawTarget->PushClip(path);
+ }
+
+ size_t count = round(borderLength / dotWidth);
+ if (isStartUnfilled == isEndUnfilled) {
+ // Split into 2n segments.
+ if (count % 2) {
+ count++;
+ }
+ } else {
+ // Split into 2n+1 segments.
+ if (count % 2 == 0) {
+ count++;
+ }
+ }
+
+ // A: radius == borderWidth / 2.0
+ // B: borderLength / count == borderWidth * (1 - overlap)
+ //
+ // A B B B B A
+ // |<-->|<------>|<------>|<------>|<------>|<-->|
+ // | | | | | | |
+ // +----+--------+--------+--------+--------+----+
+ // | ##|## **|** ##|## **|** ##|## |
+ // | ###|### ***|*** ###|### ***|*** ###|### |
+ // |####|####****|****####|####****|****####|####|
+ // |####+####****+****####+####****+****####+####|
+ // |# start #****|****####|####****|****## end ##|
+ // | ###|### ***|*** ###|### ***|*** ###|### |
+ // | ##|## **|** ##|## **|** ##|## |
+ // +----+----+---+--------+--------+---+----+----+
+ // | | | |
+ // | | | |
+
+ // If isStartUnfilled is true, draw dots on 2j+1 points, if not, draw dots on
+ // 2j points.
+ size_t from = isStartUnfilled ? 1 : 0;
+
+ // If mergeEnd == MERGE_NONE, last dot is drawn by next side.
+ size_t to = count;
+ if (mergeEnd == MERGE_NONE) {
+ if (to > 2) {
+ to -= 2;
+ } else {
+ to = 0;
+ }
+ }
+
+ Point fromP = (start * (count - from) + end * from) / count;
+ Point toP = (start * (count - to) + end * to) / count;
+ // Extend dirty rect to avoid clipping pixel for anti-aliasing.
+ const Float AA_MARGIN = 2.0f;
+
+ // The following algorithm assumes the border's rect and the dirty rect
+ // intersect.
+ MOZ_ASSERT(mDirtyRect.Intersects(mOuterRect));
+
+ if (aSide == eSideTop) {
+ // Tweak |from| and |to| to fit into |mDirtyRect + radius margin|,
+ // to render only paths that may overlap mDirtyRect.
+ //
+ // mDirtyRect + radius margin
+ // +--+---------------------+--+
+ // | |
+ // | mDirtyRect |
+ // + +---------------------+ +
+ // from ===> |from to | <=== to
+ // +-----+-----+-----+-----+-----+-----+-----+-----+
+ // ### |### ### ###| ###
+ // ##### ##### ##### ##### #####
+ // ##### ##### ##### ##### #####
+ // ##### ##### ##### ##### #####
+ // ### |### ### ###| ###
+ // | | | |
+ // + +---------------------+ +
+ // | |
+ // | |
+ // +--+---------------------+--+
+
+ Float left = mDirtyRect.x - radius - AA_MARGIN;
+ if (fromP.x < left) {
+ size_t tmp = ceil(count * (left - start.x) / (end.x - start.x));
+ if (tmp > from) {
+ // We increment by 2, so odd/even should match between before/after.
+ if ((tmp & 1) != (from & 1)) {
+ from = tmp - 1;
+ } else {
+ from = tmp;
+ }
+ }
+ }
+ Float right = mDirtyRect.x + mDirtyRect.width + radius + AA_MARGIN;
+ if (toP.x > right) {
+ size_t tmp = floor(count * (right - start.x) / (end.x - start.x));
+ if (tmp < to) {
+ if ((tmp & 1) != (to & 1)) {
+ to = tmp + 1;
+ } else {
+ to = tmp;
+ }
+ }
+ }
+ } else if (aSide == eSideRight) {
+ Float top = mDirtyRect.y - radius - AA_MARGIN;
+ if (fromP.y < top) {
+ size_t tmp = ceil(count * (top - start.y) / (end.y - start.y));
+ if (tmp > from) {
+ if ((tmp & 1) != (from & 1)) {
+ from = tmp - 1;
+ } else {
+ from = tmp;
+ }
+ }
+ }
+ Float bottom = mDirtyRect.y + mDirtyRect.height + radius + AA_MARGIN;
+ if (toP.y > bottom) {
+ size_t tmp = floor(count * (bottom - start.y) / (end.y - start.y));
+ if (tmp < to) {
+ if ((tmp & 1) != (to & 1)) {
+ to = tmp + 1;
+ } else {
+ to = tmp;
+ }
+ }
+ }
+ } else if (aSide == eSideBottom) {
+ Float right = mDirtyRect.x + mDirtyRect.width + radius + AA_MARGIN;
+ if (fromP.x > right) {
+ size_t tmp = ceil(count * (right - start.x) / (end.x - start.x));
+ if (tmp > from) {
+ if ((tmp & 1) != (from & 1)) {
+ from = tmp - 1;
+ } else {
+ from = tmp;
+ }
+ }
+ }
+ Float left = mDirtyRect.x - radius - AA_MARGIN;
+ if (toP.x < left) {
+ size_t tmp = floor(count * (left - start.x) / (end.x - start.x));
+ if (tmp < to) {
+ if ((tmp & 1) != (to & 1)) {
+ to = tmp + 1;
+ } else {
+ to = tmp;
+ }
+ }
+ }
+ } else if (aSide == eSideLeft) {
+ Float bottom = mDirtyRect.y + mDirtyRect.height + radius + AA_MARGIN;
+ if (fromP.y > bottom) {
+ size_t tmp = ceil(count * (bottom - start.y) / (end.y - start.y));
+ if (tmp > from) {
+ if ((tmp & 1) != (from & 1)) {
+ from = tmp - 1;
+ } else {
+ from = tmp;
+ }
+ }
+ }
+ Float top = mDirtyRect.y - radius - AA_MARGIN;
+ if (toP.y < top) {
+ size_t tmp = floor(count * (top - start.y) / (end.y - start.y));
+ if (tmp < to) {
+ if ((tmp & 1) != (to & 1)) {
+ to = tmp + 1;
+ } else {
+ to = tmp;
+ }
+ }
+ }
+ }
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ size_t segmentCount = 0;
+ for (size_t i = from; i <= to; i += 2) {
+ if (segmentCount > BORDER_SEGMENT_COUNT_MAX) {
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+ builder = mDrawTarget->CreatePathBuilder();
+ segmentCount = 0;
+ }
+
+ Point P = (start * (count - i) + end * i) / count;
+ builder->MoveTo(Point(P.x + radius, P.y));
+ builder->Arc(P, radius, 0.0f, Float(2.0 * M_PI));
+ segmentCount++;
+ }
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+
+ if (mergeStart == MERGE_HALF || mergeEnd == MERGE_HALF) {
+ mDrawTarget->PopClip();
+ }
+}
+
+void nsCSSBorderRenderer::DrawDashedOrDottedCorner(mozilla::Side aSide,
+ Corner aCorner) {
+ // Draw dashed/dotted corner with following approach.
+ //
+ // dashed corner
+ // If both side has same border-width and border-width <= 2.0, draw dashed
+ // line along the corner, with appropriate dash length and gap to make the
+ // corner symmetric as far as possible. Dash length equals to the gap, and
+ // the ratio of the dash length to border-width is the maximum value in in
+ // [1, 3] range.
+ // Otherwise, draw dashed segments along the corner, keeping same dash
+ // length ratio to border-width at that point.
+ // (see DashedCornerFinder.h for more detail)
+ // Line ends with half segments, to joint with both side easily.
+ //
+ // dotted corner
+ // If both side has same border-width and border-width <= 2.0, draw 1:1
+ // dashed line along the corner.
+ // Otherwise Draw circles along the corner, with appropriate gap that makes
+ // the corner symmetric as far as possible. The size of the circle may
+ // change along the corner, that is tangent to the outer curver and the
+ // inner curve. The ratio of the gap to circle diameter is the maximum
+ // value in [0.5, 1] range.
+ // (see DottedCornerFinder.h for more detail)
+ // Corner ends with filled dots but those dots are drawn by
+ // DrawDashedOrDottedSide. So this may draw no circles if there's no space
+ // between 2 dots at both ends.
+
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dashed ||
+ mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dashed or dotted.");
+
+ if (IsCornerMergeable(aCorner)) {
+ // DrawDashedOrDottedSide will draw corner.
+ return;
+ }
+
+ mozilla::Side sideH(GetHorizontalSide(aCorner));
+ mozilla::Side sideV(GetVerticalSide(aCorner));
+ Float borderWidthH = mBorderWidths[sideH];
+ Float borderWidthV = mBorderWidths[sideV];
+ if (borderWidthH == 0.0f && borderWidthV == 0.0f) {
+ return;
+ }
+
+ StyleBorderStyle styleH = mBorderStyles[sideH];
+ StyleBorderStyle styleV = mBorderStyles[sideV];
+
+ // Corner between dotted and others with radius=0 is drawn by side.
+ if (IsZeroSize(mBorderRadii[aCorner]) &&
+ (styleV == StyleBorderStyle::Dotted ||
+ styleH == StyleBorderStyle::Dotted)) {
+ return;
+ }
+
+ Float maxRadius =
+ std::max(mBorderRadii[aCorner].width, mBorderRadii[aCorner].height);
+ if (maxRadius > BORDER_DOTTED_CORNER_MAX_RADIUS) {
+ DrawFallbackSolidCorner(aSide, aCorner);
+ return;
+ }
+
+ if (borderWidthH != borderWidthV || borderWidthH > 2.0f) {
+ StyleBorderStyle style = mBorderStyles[aSide];
+ if (style == StyleBorderStyle::Dotted) {
+ DrawDottedCornerSlow(aSide, aCorner);
+ } else {
+ DrawDashedCornerSlow(aSide, aCorner);
+ }
+ return;
+ }
+
+ nscolor borderColor = mBorderColors[aSide];
+ Point points[4];
+ bool ignored;
+ // Get the start and end points of the corner arc, ensuring that any dot
+ // origins get pushed backwards towards the edges of the corner rect to
+ // account for stroking.
+ points[0] = GetStraightBorderPoint(sideH, aCorner, &ignored, -0.5f);
+ points[3] = GetStraightBorderPoint(sideV, aCorner, &ignored, -0.5f);
+ // Round points to draw dot on each pixel.
+ if (borderWidthH < 2.0f) {
+ points[0].x = round(points[0].x);
+ }
+ if (borderWidthV < 2.0f) {
+ points[3].y = round(points[3].y);
+ }
+ points[1] = points[0];
+ points[1].x += kKappaFactor * (points[3].x - points[0].x);
+ points[2] = points[3];
+ points[2].y += kKappaFactor * (points[0].y - points[3].y);
+
+ Float len = GetQuarterEllipticArcLength(fabs(points[0].x - points[3].x),
+ fabs(points[0].y - points[3].y));
+
+ Float dash[2];
+ StrokeOptions strokeOptions(borderWidthH);
+ SetupDashedOptions(&strokeOptions, dash, aSide, len, true);
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ builder->MoveTo(points[0]);
+ builder->BezierTo(points[1], points[2], points[3]);
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(borderColor)),
+ strokeOptions);
+}
+
+void nsCSSBorderRenderer::DrawDottedCornerSlow(mozilla::Side aSide,
+ Corner aCorner) {
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dotted.");
+
+ mozilla::Side sideH(GetHorizontalSide(aCorner));
+ mozilla::Side sideV(GetVerticalSide(aCorner));
+ Float R0 = mBorderWidths[sideH] / 2.0f;
+ Float Rn = mBorderWidths[sideV] / 2.0f;
+ if (R0 == 0.0f && Rn == 0.0f) {
+ return;
+ }
+
+ nscolor borderColor = mBorderColors[aSide];
+ Bezier outerBezier;
+ Bezier innerBezier;
+ GetOuterAndInnerBezier(&outerBezier, &innerBezier, aCorner);
+
+ bool ignored;
+ Point C0 = GetStraightBorderPoint(sideH, aCorner, &ignored);
+ Point Cn = GetStraightBorderPoint(sideV, aCorner, &ignored);
+ DottedCornerFinder finder(outerBezier, innerBezier, aCorner,
+ mBorderRadii[aCorner].width,
+ mBorderRadii[aCorner].height, C0, R0, Cn, Rn,
+ mBorderCornerDimensions[aCorner]);
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ size_t segmentCount = 0;
+ const Float AA_MARGIN = 2.0f;
+ Rect marginedDirtyRect = mDirtyRect;
+ marginedDirtyRect.Inflate(std::max(R0, Rn) + AA_MARGIN);
+ bool entered = false;
+ while (finder.HasMore()) {
+ if (segmentCount > BORDER_SEGMENT_COUNT_MAX) {
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+ builder = mDrawTarget->CreatePathBuilder();
+ segmentCount = 0;
+ }
+
+ DottedCornerFinder::Result result = finder.Next();
+
+ if (marginedDirtyRect.Contains(result.C) && result.r > 0) {
+ entered = true;
+ builder->MoveTo(Point(result.C.x + result.r, result.C.y));
+ builder->Arc(result.C, result.r, 0, Float(2.0 * M_PI));
+ segmentCount++;
+ } else if (entered) {
+ break;
+ }
+ }
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+}
+
+static inline bool DashedPathOverlapsRect(Rect& pathRect,
+ const Rect& marginedDirtyRect,
+ DashedCornerFinder::Result& result) {
+ // Calculate a rect that contains all control points of the |result| path,
+ // and check if it intersects with |marginedDirtyRect|.
+ pathRect.SetRect(result.outerSectionBezier.mPoints[0].x,
+ result.outerSectionBezier.mPoints[0].y, 0, 0);
+ pathRect.ExpandToEnclose(result.outerSectionBezier.mPoints[1]);
+ pathRect.ExpandToEnclose(result.outerSectionBezier.mPoints[2]);
+ pathRect.ExpandToEnclose(result.outerSectionBezier.mPoints[3]);
+ pathRect.ExpandToEnclose(result.innerSectionBezier.mPoints[0]);
+ pathRect.ExpandToEnclose(result.innerSectionBezier.mPoints[1]);
+ pathRect.ExpandToEnclose(result.innerSectionBezier.mPoints[2]);
+ pathRect.ExpandToEnclose(result.innerSectionBezier.mPoints[3]);
+
+ return pathRect.Intersects(marginedDirtyRect);
+}
+
+void nsCSSBorderRenderer::DrawDashedCornerSlow(mozilla::Side aSide,
+ Corner aCorner) {
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dashed,
+ "Style should be dashed.");
+
+ mozilla::Side sideH(GetHorizontalSide(aCorner));
+ mozilla::Side sideV(GetVerticalSide(aCorner));
+ Float borderWidthH = mBorderWidths[sideH];
+ Float borderWidthV = mBorderWidths[sideV];
+ if (borderWidthH == 0.0f && borderWidthV == 0.0f) {
+ return;
+ }
+
+ nscolor borderColor = mBorderColors[aSide];
+ Bezier outerBezier;
+ Bezier innerBezier;
+ GetOuterAndInnerBezier(&outerBezier, &innerBezier, aCorner);
+
+ DashedCornerFinder finder(outerBezier, innerBezier, borderWidthH,
+ borderWidthV, mBorderCornerDimensions[aCorner]);
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ size_t segmentCount = 0;
+ const Float AA_MARGIN = 2.0f;
+ Rect marginedDirtyRect = mDirtyRect;
+ marginedDirtyRect.Inflate(AA_MARGIN);
+ Rect pathRect;
+ bool entered = false;
+ while (finder.HasMore()) {
+ if (segmentCount > BORDER_SEGMENT_COUNT_MAX) {
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+ builder = mDrawTarget->CreatePathBuilder();
+ segmentCount = 0;
+ }
+
+ DashedCornerFinder::Result result = finder.Next();
+
+ if (DashedPathOverlapsRect(pathRect, marginedDirtyRect, result)) {
+ entered = true;
+ builder->MoveTo(result.outerSectionBezier.mPoints[0]);
+ builder->BezierTo(result.outerSectionBezier.mPoints[1],
+ result.outerSectionBezier.mPoints[2],
+ result.outerSectionBezier.mPoints[3]);
+ builder->LineTo(result.innerSectionBezier.mPoints[3]);
+ builder->BezierTo(result.innerSectionBezier.mPoints[2],
+ result.innerSectionBezier.mPoints[1],
+ result.innerSectionBezier.mPoints[0]);
+ builder->LineTo(result.outerSectionBezier.mPoints[0]);
+ segmentCount++;
+ } else if (entered) {
+ break;
+ }
+ }
+
+ if (outerBezier.mPoints[0].x != innerBezier.mPoints[0].x) {
+ // Fill gap before the first section.
+ //
+ // outnerPoint[0]
+ // |
+ // v
+ // _+-----------+--
+ // / \##########|
+ // / \#########|
+ // + \########|
+ // |\ \######|
+ // | \ \#####|
+ // | \ \####|
+ // | \ \##|
+ // | \ \#|
+ // | \ \|
+ // | \ _-+--
+ // +--------------+ ^
+ // | | |
+ // | | innerPoint[0]
+ // | |
+ builder->MoveTo(outerBezier.mPoints[0]);
+ builder->LineTo(innerBezier.mPoints[0]);
+ builder->LineTo(Point(innerBezier.mPoints[0].x, outerBezier.mPoints[0].y));
+ builder->LineTo(outerBezier.mPoints[0]);
+ }
+
+ if (outerBezier.mPoints[3].y != innerBezier.mPoints[3].y) {
+ // Fill gap after the last section.
+ //
+ // outnerPoint[3]
+ // |
+ // |
+ // | _+-----------+--
+ // | / \ |
+ // v/ \ |
+ // + \ |
+ // |\ \ |
+ // |##\ \ |
+ // |####\ \ |
+ // |######\ \ |
+ // |########\ \ |
+ // |##########\ \|
+ // |############\ _-+--
+ // +--------------+<-- innerPoint[3]
+ // | |
+ // | |
+ // | |
+ builder->MoveTo(outerBezier.mPoints[3]);
+ builder->LineTo(innerBezier.mPoints[3]);
+ builder->LineTo(Point(outerBezier.mPoints[3].x, innerBezier.mPoints[3].y));
+ builder->LineTo(outerBezier.mPoints[3]);
+ }
+
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+}
+
+void nsCSSBorderRenderer::DrawFallbackSolidCorner(mozilla::Side aSide,
+ Corner aCorner) {
+ // Render too large dashed or dotted corner with solid style, to avoid hangup
+ // inside DashedCornerFinder and DottedCornerFinder.
+
+ NS_ASSERTION(mBorderStyles[aSide] == StyleBorderStyle::Dashed ||
+ mBorderStyles[aSide] == StyleBorderStyle::Dotted,
+ "Style should be dashed or dotted.");
+
+ nscolor borderColor = mBorderColors[aSide];
+ Bezier outerBezier;
+ Bezier innerBezier;
+ GetOuterAndInnerBezier(&outerBezier, &innerBezier, aCorner);
+
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+
+ builder->MoveTo(outerBezier.mPoints[0]);
+ builder->BezierTo(outerBezier.mPoints[1], outerBezier.mPoints[2],
+ outerBezier.mPoints[3]);
+ builder->LineTo(innerBezier.mPoints[3]);
+ builder->BezierTo(innerBezier.mPoints[2], innerBezier.mPoints[1],
+ innerBezier.mPoints[0]);
+ builder->LineTo(outerBezier.mPoints[0]);
+
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
+
+ if (!mPresContext->HasWarnedAboutTooLargeDashedOrDottedRadius()) {
+ mPresContext->SetHasWarnedAboutTooLargeDashedOrDottedRadius();
+ nsContentUtils::ReportToConsole(
+ nsIScriptError::warningFlag, "CSS"_ns, mPresContext->Document(),
+ nsContentUtils::eCSS_PROPERTIES,
+ mBorderStyles[aSide] == StyleBorderStyle::Dashed
+ ? "TooLargeDashedRadius"
+ : "TooLargeDottedRadius");
+ }
+}
+
+bool nsCSSBorderRenderer::AllBordersSameWidth() {
+ if (mBorderWidths[0] == mBorderWidths[1] &&
+ mBorderWidths[0] == mBorderWidths[2] &&
+ mBorderWidths[0] == mBorderWidths[3]) {
+ return true;
+ }
+
+ return false;
+}
+
+bool nsCSSBorderRenderer::AllBordersSolid() {
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ if (mBorderStyles[i] == StyleBorderStyle::Solid ||
+ mBorderStyles[i] == StyleBorderStyle::None ||
+ mBorderStyles[i] == StyleBorderStyle::Hidden) {
+ continue;
+ }
+ return false;
+ }
+
+ return true;
+}
+
+static bool IsVisible(StyleBorderStyle aStyle) {
+ if (aStyle != StyleBorderStyle::None && aStyle != StyleBorderStyle::Hidden) {
+ return true;
+ }
+ return false;
+}
+
+struct twoFloats {
+ Float a, b;
+
+ twoFloats operator*(const Size& aSize) const {
+ return {a * aSize.width, b * aSize.height};
+ }
+
+ twoFloats operator*(Float aScale) const { return {a * aScale, b * aScale}; }
+
+ twoFloats operator+(const Point& aPoint) const {
+ return {a + aPoint.x, b + aPoint.y};
+ }
+
+ operator Point() const { return Point(a, b); }
+};
+
+void nsCSSBorderRenderer::DrawSingleWidthSolidBorder() {
+ // Easy enough to deal with.
+ Rect rect = mOuterRect;
+ rect.Deflate(0.5);
+
+ const twoFloats cornerAdjusts[4] = {
+ {+0.5, 0}, {0, +0.5}, {-0.5, 0}, {0, -0.5}};
+ for (const auto side : mozilla::AllPhysicalSides()) {
+ Point firstCorner = rect.CCWCorner(side) + cornerAdjusts[side];
+ Point secondCorner = rect.CWCorner(side) + cornerAdjusts[side];
+
+ ColorPattern color(ToDeviceColor(mBorderColors[side]));
+
+ mDrawTarget->StrokeLine(firstCorner, secondCorner, color);
+ }
+}
+
+// Intersect a ray from the inner corner to the outer corner
+// with the border radius, yielding the intersection point.
+static Point IntersectBorderRadius(const Point& aCenter, const Size& aRadius,
+ const Point& aInnerCorner,
+ const Point& aCornerDirection) {
+ Point toCorner = aCornerDirection;
+ // transform to-corner ray to unit-circle space
+ toCorner.x /= aRadius.width;
+ toCorner.y /= aRadius.height;
+ // normalize to-corner ray
+ Float cornerDist = toCorner.Length();
+ if (cornerDist < 1.0e-6f) {
+ return aInnerCorner;
+ }
+ toCorner = toCorner / cornerDist;
+ // ray from inner corner to border radius center
+ Point toCenter = aCenter - aInnerCorner;
+ // transform to-center ray to unit-circle space
+ toCenter.x /= aRadius.width;
+ toCenter.y /= aRadius.height;
+ // compute offset of intersection with border radius unit circle
+ Float offset = toCenter.DotProduct(toCorner);
+ // compute discriminant to check for intersections
+ Float discrim = 1.0f - toCenter.DotProduct(toCenter) + offset * offset;
+ // choose farthest intersection
+ offset += sqrtf(std::max(discrim, 0.0f));
+ // transform to-corner ray back out of unit-circle space
+ toCorner.x *= aRadius.width;
+ toCorner.y *= aRadius.height;
+ return aInnerCorner + toCorner * offset;
+}
+
+// Calculate the split point and split angle for a border radius with
+// differing sides.
+static inline void SplitBorderRadius(const Point& aCenter, const Size& aRadius,
+ const Point& aOuterCorner,
+ const Point& aInnerCorner,
+ const twoFloats& aCornerMults,
+ Float aStartAngle, Point& aSplit,
+ Float& aSplitAngle) {
+ Point cornerDir = aOuterCorner - aInnerCorner;
+ if (cornerDir.x == cornerDir.y && aRadius.IsSquare()) {
+ // optimize 45-degree intersection with circle since we can assume
+ // the circle center lies along the intersection edge
+ aSplit = aCenter - aCornerMults * (aRadius * Float(1.0f / M_SQRT2));
+ aSplitAngle = aStartAngle + 0.5f * M_PI / 2.0f;
+ } else {
+ aSplit = IntersectBorderRadius(aCenter, aRadius, aInnerCorner, cornerDir);
+ aSplitAngle = atan2f((aSplit.y - aCenter.y) / aRadius.height,
+ (aSplit.x - aCenter.x) / aRadius.width);
+ }
+}
+
+// Compute the size of the skirt needed, given the color alphas
+// of each corner side and the slope between them.
+static void ComputeCornerSkirtSize(Float aAlpha1, Float aAlpha2, Float aSlopeY,
+ Float aSlopeX, Float& aSizeResult,
+ Float& aSlopeResult) {
+ // If either side is (almost) invisible or there is no diagonal edge,
+ // then don't try to render a skirt.
+ if (aAlpha1 < 0.01f || aAlpha2 < 0.01f) {
+ return;
+ }
+ aSlopeX = fabs(aSlopeX);
+ aSlopeY = fabs(aSlopeY);
+ if (aSlopeX < 1.0e-6f || aSlopeY < 1.0e-6f) {
+ return;
+ }
+
+ // If first and second color don't match, we need to split the corner in
+ // half. The diagonal edges created may not have full pixel coverage given
+ // anti-aliasing, so we need to compute a small subpixel skirt edge. This
+ // assumes each half has half coverage to start with, and that coverage
+ // increases as the skirt is pushed over, with the end result that we want
+ // to roughly preserve the alpha value along this edge.
+ // Given slope m, alphas a and A, use quadratic formula to solve for S in:
+ // a*(1 - 0.5*(1-S)*(1-mS))*(1 - 0.5*A) + 0.5*A = A
+ // yielding:
+ // S = ((1+m) - sqrt((1+m)*(1+m) + 4*m*(1 - A/(a*(1-0.5*A))))) / (2*m)
+ // and substitute k = (1+m)/(2*m):
+ // S = k - sqrt(k*k + (1 - A/(a*(1-0.5*A)))/m)
+ Float slope = aSlopeY / aSlopeX;
+ Float slopeScale = (1.0f + slope) / (2.0f * slope);
+ Float discrim = slopeScale * slopeScale +
+ (1 - aAlpha2 / (aAlpha1 * (1.0f - 0.49f * aAlpha2))) / slope;
+ if (discrim >= 0) {
+ aSizeResult = slopeScale - sqrtf(discrim);
+ aSlopeResult = slope;
+ }
+}
+
+// Draws a border radius with possibly different sides.
+// A skirt is drawn underneath the corner intersection to hide possible
+// seams when anti-aliased drawing is used.
+static void DrawBorderRadius(
+ DrawTarget* aDrawTarget, Corner c, const Point& aOuterCorner,
+ const Point& aInnerCorner, const twoFloats& aCornerMultPrev,
+ const twoFloats& aCornerMultNext, const Size& aCornerDims,
+ const Size& aOuterRadius, const Size& aInnerRadius,
+ const DeviceColor& aFirstColor, const DeviceColor& aSecondColor,
+ Float aSkirtSize, Float aSkirtSlope) {
+ // Connect edge to outer arc start point
+ Point outerCornerStart = aOuterCorner + aCornerMultPrev * aCornerDims;
+ // Connect edge to outer arc end point
+ Point outerCornerEnd = aOuterCorner + aCornerMultNext * aCornerDims;
+ // Connect edge to inner arc start point
+ Point innerCornerStart =
+ outerCornerStart + aCornerMultNext * (aCornerDims - aInnerRadius);
+ // Connect edge to inner arc end point
+ Point innerCornerEnd =
+ outerCornerEnd + aCornerMultPrev * (aCornerDims - aInnerRadius);
+
+ // Outer arc start point
+ Point outerArcStart = aOuterCorner + aCornerMultPrev * aOuterRadius;
+ // Outer arc end point
+ Point outerArcEnd = aOuterCorner + aCornerMultNext * aOuterRadius;
+ // Inner arc start point
+ Point innerArcStart = aInnerCorner + aCornerMultPrev * aInnerRadius;
+ // Inner arc end point
+ Point innerArcEnd = aInnerCorner + aCornerMultNext * aInnerRadius;
+
+ // Outer radius center
+ Point outerCenter =
+ aOuterCorner + (aCornerMultPrev + aCornerMultNext) * aOuterRadius;
+ // Inner radius center
+ Point innerCenter =
+ aInnerCorner + (aCornerMultPrev + aCornerMultNext) * aInnerRadius;
+
+ RefPtr<PathBuilder> builder;
+ RefPtr<Path> path;
+
+ if (aFirstColor.a > 0) {
+ builder = aDrawTarget->CreatePathBuilder();
+ builder->MoveTo(outerCornerStart);
+ }
+
+ if (aFirstColor != aSecondColor) {
+ // Start and end angles of corner quadrant
+ constexpr float PIf = M_PI;
+ Float startAngle = (static_cast<float>(c) * PIf) / 2.0f - PIf;
+ Float endAngle = startAngle + PIf / 2.0f;
+ Float outerSplitAngle, innerSplitAngle;
+ Point outerSplit, innerSplit;
+
+ // Outer half-way point
+ SplitBorderRadius(outerCenter, aOuterRadius, aOuterCorner, aInnerCorner,
+ aCornerMultPrev + aCornerMultNext, startAngle, outerSplit,
+ outerSplitAngle);
+ // Inner half-way point
+ if (aInnerRadius.IsEmpty()) {
+ innerSplit = aInnerCorner;
+ innerSplitAngle = endAngle;
+ } else {
+ SplitBorderRadius(innerCenter, aInnerRadius, aOuterCorner, aInnerCorner,
+ aCornerMultPrev + aCornerMultNext, startAngle,
+ innerSplit, innerSplitAngle);
+ }
+
+ // Draw first half with first color
+ if (aFirstColor.a > 0) {
+ AcuteArcToBezier(builder.get(), outerCenter, aOuterRadius, outerArcStart,
+ outerSplit, startAngle, outerSplitAngle);
+ // Draw skirt as part of first half
+ if (aSkirtSize > 0) {
+ builder->LineTo(outerSplit + aCornerMultNext * aSkirtSize);
+ builder->LineTo(innerSplit -
+ aCornerMultPrev * (aSkirtSize * aSkirtSlope));
+ }
+ AcuteArcToBezier(builder.get(), innerCenter, aInnerRadius, innerSplit,
+ innerArcStart, innerSplitAngle, startAngle);
+ if ((innerCornerStart - innerArcStart).DotProduct(aCornerMultPrev) > 0) {
+ builder->LineTo(innerCornerStart);
+ }
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aFirstColor));
+ }
+
+ // Draw second half with second color
+ if (aSecondColor.a > 0) {
+ builder = aDrawTarget->CreatePathBuilder();
+ builder->MoveTo(outerCornerEnd);
+ if ((innerArcEnd - innerCornerEnd).DotProduct(aCornerMultNext) < 0) {
+ builder->LineTo(innerCornerEnd);
+ }
+ AcuteArcToBezier(builder.get(), innerCenter, aInnerRadius, innerArcEnd,
+ innerSplit, endAngle, innerSplitAngle);
+ AcuteArcToBezier(builder.get(), outerCenter, aOuterRadius, outerSplit,
+ outerArcEnd, outerSplitAngle, endAngle);
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aSecondColor));
+ }
+ } else if (aFirstColor.a > 0) {
+ // Draw corner with single color
+ AcuteArcToBezier(builder.get(), outerCenter, aOuterRadius, outerArcStart,
+ outerArcEnd);
+ builder->LineTo(outerCornerEnd);
+ if ((innerArcEnd - innerCornerEnd).DotProduct(aCornerMultNext) < 0) {
+ builder->LineTo(innerCornerEnd);
+ }
+ AcuteArcToBezier(builder.get(), innerCenter, aInnerRadius, innerArcEnd,
+ innerArcStart, -kKappaFactor);
+ if ((innerCornerStart - innerArcStart).DotProduct(aCornerMultPrev) > 0) {
+ builder->LineTo(innerCornerStart);
+ }
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aFirstColor));
+ }
+}
+
+// Draw a corner with possibly different sides.
+// A skirt is drawn underneath the corner intersection to hide possible
+// seams when anti-aliased drawing is used.
+static void DrawCorner(DrawTarget* aDrawTarget, const Point& aOuterCorner,
+ const Point& aInnerCorner,
+ const twoFloats& aCornerMultPrev,
+ const twoFloats& aCornerMultNext,
+ const Size& aCornerDims, const DeviceColor& aFirstColor,
+ const DeviceColor& aSecondColor, Float aSkirtSize,
+ Float aSkirtSlope) {
+ // Corner box start point
+ Point cornerStart = aOuterCorner + aCornerMultPrev * aCornerDims;
+ // Corner box end point
+ Point cornerEnd = aOuterCorner + aCornerMultNext * aCornerDims;
+
+ RefPtr<PathBuilder> builder;
+ RefPtr<Path> path;
+
+ if (aFirstColor.a > 0) {
+ builder = aDrawTarget->CreatePathBuilder();
+ builder->MoveTo(cornerStart);
+ }
+
+ if (aFirstColor != aSecondColor) {
+ // Draw first half with first color
+ if (aFirstColor.a > 0) {
+ builder->LineTo(aOuterCorner);
+ // Draw skirt as part of first half
+ if (aSkirtSize > 0) {
+ builder->LineTo(aOuterCorner + aCornerMultNext * aSkirtSize);
+ builder->LineTo(aInnerCorner -
+ aCornerMultPrev * (aSkirtSize * aSkirtSlope));
+ }
+ builder->LineTo(aInnerCorner);
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aFirstColor));
+ }
+
+ // Draw second half with second color
+ if (aSecondColor.a > 0) {
+ builder = aDrawTarget->CreatePathBuilder();
+ builder->MoveTo(cornerEnd);
+ builder->LineTo(aInnerCorner);
+ builder->LineTo(aOuterCorner);
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aSecondColor));
+ }
+ } else if (aFirstColor.a > 0) {
+ // Draw corner with single color
+ builder->LineTo(aOuterCorner);
+ builder->LineTo(cornerEnd);
+ builder->LineTo(aInnerCorner);
+ builder->Close();
+ path = builder->Finish();
+ aDrawTarget->Fill(path, ColorPattern(aFirstColor));
+ }
+}
+
+void nsCSSBorderRenderer::DrawSolidBorder() {
+ const twoFloats cornerMults[4] = {{-1, 0}, {0, -1}, {+1, 0}, {0, +1}};
+
+ const twoFloats centerAdjusts[4] = {
+ {0, +0.5}, {-0.5, 0}, {0, -0.5}, {+0.5, 0}};
+
+ RectCornerRadii innerRadii;
+ ComputeInnerRadii(mBorderRadii, mBorderWidths, &innerRadii);
+
+ Rect strokeRect = mOuterRect;
+ strokeRect.Deflate(Margin(mBorderWidths[0] / 2.0, mBorderWidths[1] / 2.0,
+ mBorderWidths[2] / 2.0, mBorderWidths[3] / 2.0));
+
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ // We now draw the current side and the CW corner following it.
+ // The CCW corner of this side was already drawn in the previous iteration.
+ // The side will be drawn as an explicit stroke, and the CW corner will be
+ // filled separately.
+ // If the next side does not have a matching color, then we split the
+ // corner into two halves, one of each side's color and draw both.
+ // Thus, the CCW corner of the next side will end up drawn here.
+
+ // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
+ Corner c = Corner((i + 1) % 4);
+ Corner prevCorner = Corner(i);
+
+ // i+2 and i+3 respectively. These are used to index into the corner
+ // multiplier table, and were deduced by calculating out the long form
+ // of each corner and finding a pattern in the signs and values.
+ int i1 = (i + 1) % 4;
+ int i2 = (i + 2) % 4;
+ int i3 = (i + 3) % 4;
+
+ Float sideWidth = 0.0f;
+ DeviceColor firstColor, secondColor;
+ if (IsVisible(mBorderStyles[i]) && mBorderWidths[i]) {
+ // draw the side since it is visible
+ sideWidth = mBorderWidths[i];
+ firstColor = ToDeviceColor(mBorderColors[i]);
+ // if the next side is visible, use its color for corner
+ secondColor = IsVisible(mBorderStyles[i1]) && mBorderWidths[i1]
+ ? ToDeviceColor(mBorderColors[i1])
+ : firstColor;
+ } else if (IsVisible(mBorderStyles[i1]) && mBorderWidths[i1]) {
+ // assign next side's color to both corner sides
+ firstColor = ToDeviceColor(mBorderColors[i1]);
+ secondColor = firstColor;
+ } else {
+ // neither side is visible, so nothing to do
+ continue;
+ }
+
+ Point outerCorner = mOuterRect.AtCorner(c);
+ Point innerCorner = mInnerRect.AtCorner(c);
+
+ // start and end points of border side stroke between corners
+ Point sideStart = mOuterRect.AtCorner(prevCorner) +
+ cornerMults[i2] * mBorderCornerDimensions[prevCorner];
+ Point sideEnd = outerCorner + cornerMults[i] * mBorderCornerDimensions[c];
+ // check if the side is visible and not inverted
+ if (sideWidth > 0 && firstColor.a > 0 &&
+ -(sideEnd - sideStart).DotProduct(cornerMults[i]) > 0) {
+ mDrawTarget->StrokeLine(sideStart + centerAdjusts[i] * sideWidth,
+ sideEnd + centerAdjusts[i] * sideWidth,
+ ColorPattern(firstColor),
+ StrokeOptions(sideWidth));
+ }
+
+ Float skirtSize = 0.0f, skirtSlope = 0.0f;
+ // the sides don't match, so compute a skirt
+ if (firstColor != secondColor &&
+ mPresContext->Type() != nsPresContext::eContext_Print) {
+ Point cornerDir = outerCorner - innerCorner;
+ ComputeCornerSkirtSize(
+ firstColor.a, secondColor.a, cornerDir.DotProduct(cornerMults[i]),
+ cornerDir.DotProduct(cornerMults[i3]), skirtSize, skirtSlope);
+ }
+
+ if (!mBorderRadii[c].IsEmpty()) {
+ // the corner has a border radius
+ DrawBorderRadius(mDrawTarget, c, outerCorner, innerCorner, cornerMults[i],
+ cornerMults[i3], mBorderCornerDimensions[c],
+ mBorderRadii[c], innerRadii[c], firstColor, secondColor,
+ skirtSize, skirtSlope);
+ } else if (!mBorderCornerDimensions[c].IsEmpty()) {
+ // a corner with no border radius
+ DrawCorner(mDrawTarget, outerCorner, innerCorner, cornerMults[i],
+ cornerMults[i3], mBorderCornerDimensions[c], firstColor,
+ secondColor, skirtSize, skirtSlope);
+ }
+ }
+}
+
+void nsCSSBorderRenderer::DrawBorders() {
+ if (MOZ_UNLIKELY(!mDirtyRect.Intersects(mOuterRect))) {
+ return;
+ }
+
+ if (mAllBordersSameStyle && (mBorderStyles[0] == StyleBorderStyle::None ||
+ mBorderStyles[0] == StyleBorderStyle::Hidden ||
+ mBorderColors[0] == NS_RGBA(0, 0, 0, 0))) {
+ // All borders are the same style, and the style is either none or hidden,
+ // or the color is transparent.
+ return;
+ }
+
+ if (mAllBordersSameWidth && mBorderWidths[0] == 0.0) {
+ // Some of the mAllBordersSameWidth codepaths depend on the border
+ // width being greater than zero.
+ return;
+ }
+
+ AutoRestoreTransform autoRestoreTransform;
+ Matrix mat = mDrawTarget->GetTransform();
+
+ // Clamp the CTM to be pixel-aligned; we do this only
+ // for translation-only matrices now, but we could do it
+ // if the matrix has just a scale as well. We should not
+ // do it if there's a rotation.
+ if (mat.HasNonTranslation()) {
+ if (!mat.HasNonAxisAlignedTransform()) {
+ // Scale + transform. Avoid stroke fast-paths so that we have a chance
+ // of snapping to pixel boundaries.
+ mAvoidStroke = true;
+ }
+ } else {
+ mat._31 = floor(mat._31 + 0.5);
+ mat._32 = floor(mat._32 + 0.5);
+ autoRestoreTransform.Init(mDrawTarget);
+ mDrawTarget->SetTransform(mat);
+
+ // round mOuterRect and mInnerRect; they're already an integer
+ // number of pixels apart and should stay that way after
+ // rounding. We don't do this if there's a scale in the current transform
+ // since this loses information that might be relevant when we're scaling.
+ mOuterRect.Round();
+ mInnerRect.Round();
+ }
+
+ // Initial values only used when the border colors/widths are all the same:
+ ColorPattern color(ToDeviceColor(mBorderColors[eSideTop]));
+ StrokeOptions strokeOptions(mBorderWidths[eSideTop]); // stroke width
+
+ // First there's a couple of 'special cases' that have specifically optimized
+ // drawing paths, when none of these can be used we move on to the generalized
+ // border drawing code.
+ if (mAllBordersSameStyle && mAllBordersSameWidth &&
+ mBorderStyles[0] == StyleBorderStyle::Solid && mNoBorderRadius &&
+ !mAvoidStroke) {
+ // Very simple case.
+ Rect rect = mOuterRect;
+ rect.Deflate(mBorderWidths[0] / 2.0);
+ mDrawTarget->StrokeRect(rect, color, strokeOptions);
+ return;
+ }
+
+ if (mAllBordersSameStyle && mBorderStyles[0] == StyleBorderStyle::Solid &&
+ !mAvoidStroke && !mNoBorderRadius) {
+ // Relatively simple case.
+ RoundedRect borderInnerRect(mOuterRect, mBorderRadii);
+ borderInnerRect.Deflate(mBorderWidths[eSideTop], mBorderWidths[eSideBottom],
+ mBorderWidths[eSideLeft],
+ mBorderWidths[eSideRight]);
+
+ // Instead of stroking we just use two paths: an inner and an outer.
+ // This allows us to draw borders that we couldn't when stroking. For
+ // example, borders with a border width >= the border radius. (i.e. when
+ // there are square corners on the inside)
+ //
+ // Further, this approach can be more efficient because the backend
+ // doesn't need to compute an offset curve to stroke the path. We know that
+ // the rounded parts are elipses we can offset exactly and can just compute
+ // a new cubic approximation.
+ RefPtr<PathBuilder> builder = mDrawTarget->CreatePathBuilder();
+ AppendRoundedRectToPath(builder, mOuterRect, mBorderRadii, true);
+ AppendRoundedRectToPath(builder, borderInnerRect.rect,
+ borderInnerRect.corners, false);
+ RefPtr<Path> path = builder->Finish();
+ mDrawTarget->Fill(path, color);
+ return;
+ }
+
+ const bool allBordersSolid = AllBordersSolid();
+
+ // This leaves the border corners non-interpolated for single width borders.
+ // Doing this is slightly faster and shouldn't be a problem visually.
+ if (allBordersSolid && mAllBordersSameWidth && mBorderWidths[0] == 1 &&
+ mNoBorderRadius && !mAvoidStroke) {
+ DrawSingleWidthSolidBorder();
+ return;
+ }
+
+ if (allBordersSolid && !mAvoidStroke) {
+ DrawSolidBorder();
+ return;
+ }
+
+ PrintAsString(" mOuterRect: ");
+ PrintAsString(mOuterRect);
+ PrintAsStringNewline();
+ PrintAsString(" mInnerRect: ");
+ PrintAsString(mInnerRect);
+ PrintAsStringNewline();
+ PrintAsFormatString(" mBorderColors: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+ mBorderColors[0], mBorderColors[1], mBorderColors[2],
+ mBorderColors[3]);
+
+ // if conditioning the outside rect failed, then bail -- the outside
+ // rect is supposed to enclose the entire border
+ {
+ gfxRect outerRect = ThebesRect(mOuterRect);
+ gfxUtils::ConditionRect(outerRect);
+ if (outerRect.IsEmpty()) {
+ return;
+ }
+ mOuterRect = ToRect(outerRect);
+
+ if (MOZ_UNLIKELY(!mDirtyRect.Intersects(mOuterRect))) {
+ return;
+ }
+
+ gfxRect innerRect = ThebesRect(mInnerRect);
+ gfxUtils::ConditionRect(innerRect);
+ mInnerRect = ToRect(innerRect);
+ }
+
+ SideBits dashedSides = SideBits::eNone;
+ bool forceSeparateCorners = false;
+
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ StyleBorderStyle style = mBorderStyles[i];
+ if (style == StyleBorderStyle::Dashed ||
+ style == StyleBorderStyle::Dotted) {
+ // we need to draw things separately for dashed/dotting
+ forceSeparateCorners = true;
+ dashedSides |= static_cast<mozilla::SideBits>(1 << i);
+ }
+ }
+
+ PrintAsFormatString(" mAllBordersSameStyle: %d dashedSides: 0x%02x\n",
+ mAllBordersSameStyle,
+ static_cast<unsigned int>(dashedSides));
+
+ if (mAllBordersSameStyle && !forceSeparateCorners) {
+ /* Draw everything in one go */
+ DrawBorderSides(SideBits::eAll);
+ PrintAsStringNewline("---------------- (1)");
+ } else {
+ AUTO_PROFILER_LABEL("nsCSSBorderRenderer::DrawBorders:multipass", GRAPHICS);
+
+ /* We have more than one pass to go. Draw the corners separately from the
+ * sides. */
+
+ // The corner is going to have negligible size if its two adjacent border
+ // sides are only 1px wide and there is no border radius. In that case we
+ // skip the overhead of painting the corner by setting the width or height
+ // of the corner to zero, which effectively extends one of the corner's
+ // adjacent border sides. We extend the longer adjacent side so that
+ // opposite sides will be the same length, which is necessary for opposite
+ // dashed/dotted sides to be symmetrical.
+ //
+ // if width > height
+ // +--+--------------+--+ +--------------------+
+ // | | | | | |
+ // +--+--------------+--+ +--+--------------+--+
+ // | | | | | | | |
+ // | | | | => | | | |
+ // | | | | | | | |
+ // +--+--------------+--+ +--+--------------+--+
+ // | | | | | |
+ // +--+--------------+--+ +--------------------+
+ //
+ // if width <= height
+ // +--+--------+--+ +--+--------+--+
+ // | | | | | | | |
+ // +--+--------+--+ | +--------+ |
+ // | | | | | | | |
+ // | | | | | | | |
+ // | | | | | | | |
+ // | | | | => | | | |
+ // | | | | | | | |
+ // | | | | | | | |
+ // | | | | | | | |
+ // +--+--------+--+ | +--------+ |
+ // | | | | | | | |
+ // +--+--------+--+ +--+--------+--+
+ //
+ // Note that if we have different border widths we could end up with
+ // opposite sides of different length. For example, if the left and
+ // bottom borders are 2px wide instead of 1px, we will end up doing
+ // something like:
+ //
+ // +----+------------+--+ +----+---------------+
+ // | | | | | | |
+ // +----+------------+--+ +----+------------+--+
+ // | | | | | | | |
+ // | | | | => | | | |
+ // | | | | | | | |
+ // +----+------------+--+ +----+------------+--+
+ // | | | | | | | |
+ // | | | | | | | |
+ // +----+------------+--+ +----+------------+--+
+ //
+ // XXX Should we only do this optimization if |mAllBordersSameWidth| is
+ // true?
+ //
+ // XXX In fact is this optimization even worth the complexity it adds to
+ // the code? 1px wide dashed borders are not overly common, and drawing
+ // corners for them is not that expensive.
+ for (const auto corner : mozilla::AllPhysicalCorners()) {
+ const mozilla::Side sides[2] = {mozilla::Side(corner), PREV_SIDE(corner)};
+
+ if (!IsZeroSize(mBorderRadii[corner])) {
+ continue;
+ }
+
+ if (mBorderWidths[sides[0]] == 1.0 && mBorderWidths[sides[1]] == 1.0) {
+ if (mOuterRect.Width() > mOuterRect.Height()) {
+ mBorderCornerDimensions[corner].width = 0.0;
+ } else {
+ mBorderCornerDimensions[corner].height = 0.0;
+ }
+ }
+ }
+
+ // First, the corners
+ for (const auto corner : mozilla::AllPhysicalCorners()) {
+ // if there's no corner, don't do all this work for it
+ if (IsZeroSize(mBorderCornerDimensions[corner])) {
+ continue;
+ }
+
+ const int sides[2] = {corner, PREV_SIDE(corner)};
+ SideBits sideBits =
+ static_cast<SideBits>((1 << sides[0]) | (1 << sides[1]));
+
+ bool simpleCornerStyle = AreBorderSideFinalStylesSame(sideBits);
+
+ // If we don't have anything complex going on in this corner,
+ // then we can just fill the corner with a solid color, and avoid
+ // the potentially expensive clip.
+ if (simpleCornerStyle && IsZeroSize(mBorderRadii[corner]) &&
+ IsSolidCornerStyle(mBorderStyles[sides[0]], corner)) {
+ sRGBColor color = MakeBorderColor(
+ mBorderColors[sides[0]],
+ BorderColorStyleForSolidCorner(mBorderStyles[sides[0]], corner));
+ mDrawTarget->FillRect(GetCornerRect(corner),
+ ColorPattern(ToDeviceColor(color)));
+ continue;
+ }
+
+ // clip to the corner
+ mDrawTarget->PushClipRect(GetCornerRect(corner));
+
+ if (simpleCornerStyle) {
+ // we don't need a group for this corner, the sides are the same,
+ // but we weren't able to render just a solid block for the corner.
+ DrawBorderSides(sideBits);
+ } else {
+ // Sides are different. We could draw using OP_ADD to
+ // get correct color blending behaviour at the seam. We'd need
+ // to do it in an offscreen surface to ensure that we're
+ // always compositing on transparent black. If the colors
+ // don't have transparency and the current destination surface
+ // has an alpha channel, we could just clear the region and
+ // avoid the temporary, but that situation doesn't happen all
+ // that often in practice (we double buffer to no-alpha
+ // surfaces). We choose just to seam though, as the performance
+ // advantages outway the modest easthetic improvement.
+
+ for (int cornerSide = 0; cornerSide < 2; cornerSide++) {
+ mozilla::Side side = mozilla::Side(sides[cornerSide]);
+ StyleBorderStyle style = mBorderStyles[side];
+
+ PrintAsFormatString("corner: %d cornerSide: %d side: %d style: %d\n",
+ corner, cornerSide, side,
+ static_cast<int>(style));
+
+ RefPtr<Path> path = GetSideClipSubPath(side);
+ mDrawTarget->PushClip(path);
+
+ DrawBorderSides(static_cast<mozilla::SideBits>(1 << side));
+
+ mDrawTarget->PopClip();
+ }
+ }
+
+ mDrawTarget->PopClip();
+
+ PrintAsStringNewline();
+ }
+
+ // in the case of a single-unit border, we already munged the
+ // corners up above; so we can just draw the top left and bottom
+ // right sides separately, if they're the same.
+ //
+ // We need to check for mNoBorderRadius, because when there is
+ // one, FillSolidBorder always draws the full rounded rectangle
+ // and expects there to be a clip in place.
+ SideBits alreadyDrawnSides = SideBits::eNone;
+ if (mOneUnitBorder && mNoBorderRadius &&
+ (dashedSides & (SideBits::eTop | SideBits::eLeft)) == SideBits::eNone) {
+ bool tlBordersSameStyle =
+ AreBorderSideFinalStylesSame(SideBits::eTop | SideBits::eLeft);
+ bool brBordersSameStyle =
+ AreBorderSideFinalStylesSame(SideBits::eBottom | SideBits::eRight);
+
+ if (tlBordersSameStyle) {
+ DrawBorderSides(SideBits::eTop | SideBits::eLeft);
+ alreadyDrawnSides |= (SideBits::eTop | SideBits::eLeft);
+ }
+
+ if (brBordersSameStyle &&
+ (dashedSides & (SideBits::eBottom | SideBits::eRight)) ==
+ SideBits::eNone) {
+ DrawBorderSides(SideBits::eBottom | SideBits::eRight);
+ alreadyDrawnSides |= (SideBits::eBottom | SideBits::eRight);
+ }
+ }
+
+ // We're done with the corners, now draw the sides.
+ for (const auto side : mozilla::AllPhysicalSides()) {
+ // if we drew it above, skip it
+ if (alreadyDrawnSides & static_cast<mozilla::SideBits>(1 << side)) {
+ continue;
+ }
+
+ // If there's no border on this side, skip it
+ if (mBorderWidths[side] == 0.0 ||
+ mBorderStyles[side] == StyleBorderStyle::Hidden ||
+ mBorderStyles[side] == StyleBorderStyle::None) {
+ continue;
+ }
+
+ if (dashedSides & static_cast<mozilla::SideBits>(1 << side)) {
+ // Dashed sides will always draw just the part ignoring the
+ // corners for the side, so no need to clip.
+ DrawDashedOrDottedSide(side);
+
+ PrintAsStringNewline("---------------- (d)");
+ continue;
+ }
+
+ // Undashed sides will currently draw the entire side,
+ // including parts that would normally be covered by a corner,
+ // so we need to clip.
+ //
+ // XXX Optimization -- it would be good to make this work like
+ // DrawDashedOrDottedSide, and have a DrawOneSide function that just
+ // draws one side and not the corners, because then we can
+ // avoid the potentially expensive clip.
+ mDrawTarget->PushClipRect(GetSideClipWithoutCornersRect(side));
+
+ DrawBorderSides(static_cast<mozilla::SideBits>(1 << side));
+
+ mDrawTarget->PopClip();
+
+ PrintAsStringNewline("---------------- (*)");
+ }
+ }
+}
+
+void nsCSSBorderRenderer::CreateWebRenderCommands(
+ nsDisplayItem* aItem, wr::DisplayListBuilder& aBuilder,
+ wr::IpcResourceUpdateQueue& aResources,
+ const layers::StackingContextHelper& aSc) {
+ LayoutDeviceRect outerRect = LayoutDeviceRect::FromUnknownRect(mOuterRect);
+ wr::LayoutRect roundedRect = wr::ToLayoutRect(outerRect);
+ wr::LayoutRect clipRect = roundedRect;
+ wr::BorderSide side[4];
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ side[i] =
+ wr::ToBorderSide(ToDeviceColor(mBorderColors[i]), mBorderStyles[i]);
+ }
+
+ wr::BorderRadius borderRadius = wr::ToBorderRadius(mBorderRadii);
+
+ if (mLocalClip) {
+ LayoutDeviceRect localClip =
+ LayoutDeviceRect::FromUnknownRect(mLocalClip.value());
+ clipRect = wr::ToLayoutRect(localClip.Intersect(outerRect));
+ }
+
+ Range<const wr::BorderSide> wrsides(side, 4);
+ aBuilder.PushBorder(roundedRect, clipRect, mBackfaceIsVisible,
+ wr::ToBorderWidths(mBorderWidths[0], mBorderWidths[1],
+ mBorderWidths[2], mBorderWidths[3]),
+ wrsides, borderRadius);
+}
+
+/* static */
+Maybe<nsCSSBorderImageRenderer>
+nsCSSBorderImageRenderer::CreateBorderImageRenderer(
+ nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea,
+ const nsStyleBorder& aStyleBorder, const nsRect& aDirtyRect,
+ Sides aSkipSides, uint32_t aFlags, ImgDrawResult* aDrawResult) {
+ MOZ_ASSERT(aDrawResult);
+
+ if (aDirtyRect.IsEmpty()) {
+ *aDrawResult = ImgDrawResult::SUCCESS;
+ return Nothing();
+ }
+
+ nsImageRenderer imgRenderer(aForFrame, &aStyleBorder.mBorderImageSource,
+ aFlags);
+ if (!imgRenderer.PrepareImage()) {
+ *aDrawResult = imgRenderer.PrepareResult();
+ return Nothing();
+ }
+
+ // We should always get here with the frame's border, but we may construct an
+ // nsStyleBorder om the stack to deal with :visited and other shenaningans.
+ //
+ // We always copy the border image and such from the non-visited one, so
+ // there's no need to do anything with it.
+ MOZ_ASSERT(aStyleBorder.GetBorderImageRequest() ==
+ aForFrame->StyleBorder()->GetBorderImageRequest());
+
+ nsCSSBorderImageRenderer renderer(aForFrame, aBorderArea, aStyleBorder,
+ aSkipSides, imgRenderer);
+ *aDrawResult = ImgDrawResult::SUCCESS;
+ return Some(renderer);
+}
+
+ImgDrawResult nsCSSBorderImageRenderer::DrawBorderImage(
+ nsPresContext* aPresContext, gfxContext& aRenderingContext,
+ nsIFrame* aForFrame, const nsRect& aDirtyRect) {
+ // NOTE: no Save() yet, we do that later by calling autoSR.EnsureSaved()
+ // in case we need it.
+ gfxContextAutoSaveRestore autoSR;
+
+ if (!mClip.IsEmpty()) {
+ autoSR.EnsureSaved(&aRenderingContext);
+ aRenderingContext.Clip(NSRectToSnappedRect(
+ mClip, aForFrame->PresContext()->AppUnitsPerDevPixel(),
+ *aRenderingContext.GetDrawTarget()));
+ }
+
+ // 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.
+ CSSSizeOrRatio intrinsicSize = mImageRenderer.ComputeIntrinsicSize();
+ Maybe<nsSize> svgViewportSize =
+ intrinsicSize.CanComputeConcreteSize() ? Nothing() : Some(mImageSize);
+ bool hasIntrinsicRatio = intrinsicSize.HasRatio();
+
+ // 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] = {
+ mArea.x + 0,
+ mArea.x + mWidths.left,
+ mArea.x + mArea.width - mWidths.right,
+ };
+ const nscoord borderY[3] = {
+ mArea.y + 0,
+ mArea.y + mWidths.top,
+ mArea.y + mArea.height - mWidths.bottom,
+ };
+ const nscoord borderWidth[3] = {
+ mWidths.left,
+ mArea.width - mWidths.left - mWidths.right,
+ mWidths.right,
+ };
+ const nscoord borderHeight[3] = {
+ mWidths.top,
+ mArea.height - mWidths.top - mWidths.bottom,
+ mWidths.bottom,
+ };
+ const int32_t sliceX[3] = {
+ 0,
+ mSlice.left,
+ mImageSize.width - mSlice.right,
+ };
+ const int32_t sliceY[3] = {
+ 0,
+ mSlice.top,
+ mImageSize.height - mSlice.bottom,
+ };
+ const int32_t sliceWidth[3] = {
+ mSlice.left,
+ std::max(mImageSize.width - mSlice.left - mSlice.right, 0),
+ mSlice.right,
+ };
+ const int32_t sliceHeight[3] = {
+ mSlice.top,
+ std::max(mImageSize.height - mSlice.top - mSlice.bottom, 0),
+ mSlice.bottom,
+ };
+
+ ImgDrawResult result = ImgDrawResult::SUCCESS;
+
+ for (int i = LEFT; i <= RIGHT; i++) {
+ for (int j = TOP; j <= BOTTOM; j++) {
+ StyleBorderImageRepeat fillStyleH, fillStyleV;
+ nsSize unitSize;
+
+ if (i == MIDDLE && j == MIDDLE) {
+ // Discard the middle portion unless set to fill.
+ if (!mFill) {
+ continue;
+ }
+
+ // 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 < mWidths.left && 0 < mSlice.left) {
+ vFactor = gfxFloat(mWidths.left) / mSlice.left;
+ } else if (0 < mWidths.right && 0 < mSlice.right) {
+ vFactor = gfxFloat(mWidths.right) / mSlice.right;
+ } else {
+ vFactor = 1;
+ }
+
+ if (0 < mWidths.top && 0 < mSlice.top) {
+ hFactor = gfxFloat(mWidths.top) / mSlice.top;
+ } else if (0 < mWidths.bottom && 0 < mSlice.bottom) {
+ hFactor = gfxFloat(mWidths.bottom) / mSlice.bottom;
+ } else {
+ hFactor = 1;
+ }
+
+ unitSize.width = sliceWidth[i] * hFactor;
+ unitSize.height = sliceHeight[j] * vFactor;
+ fillStyleH = mRepeatModeHorizontal;
+ fillStyleV = mRepeatModeVertical;
+
+ } 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 = mRepeatModeHorizontal;
+ fillStyleV = StyleBorderImageRepeat::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 = StyleBorderImageRepeat::Stretch;
+ fillStyleV = mRepeatModeVertical;
+
+ } else {
+ // Corners are always stretched to fit the corner.
+ unitSize.width = borderWidth[i];
+ unitSize.height = borderHeight[j];
+ fillStyleH = StyleBorderImageRepeat::Stretch;
+ fillStyleV = StyleBorderImageRepeat::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(AppUnitsPerCSSPixel());
+ result &= mImageRenderer.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;
+}
+
+ImgDrawResult nsCSSBorderImageRenderer::CreateWebRenderCommands(
+ nsDisplayItem* aItem, nsIFrame* aForFrame,
+ mozilla::wr::DisplayListBuilder& aBuilder,
+ mozilla::wr::IpcResourceUpdateQueue& aResources,
+ const mozilla::layers::StackingContextHelper& aSc,
+ mozilla::layers::RenderRootStateManager* aManager,
+ nsDisplayListBuilder* aDisplayListBuilder) {
+ if (!mImageRenderer.IsReady()) {
+ return ImgDrawResult::NOT_READY;
+ }
+
+ float widths[4];
+ float slice[4];
+ const int32_t appUnitsPerDevPixel =
+ aForFrame->PresContext()->AppUnitsPerDevPixel();
+ for (const auto i : mozilla::AllPhysicalSides()) {
+ slice[i] = (float)(mSlice.Side(i)) / appUnitsPerDevPixel;
+ widths[i] = (float)(mWidths.Side(i)) / appUnitsPerDevPixel;
+ }
+
+ LayoutDeviceRect destRect =
+ LayoutDeviceRect::FromAppUnits(mArea, appUnitsPerDevPixel);
+ destRect.Round();
+ wr::LayoutRect dest = wr::ToLayoutRect(destRect);
+
+ wr::LayoutRect clip = dest;
+ if (!mClip.IsEmpty()) {
+ LayoutDeviceRect clipRect =
+ LayoutDeviceRect::FromAppUnits(mClip, appUnitsPerDevPixel);
+ clip = wr::ToLayoutRect(clipRect);
+ }
+
+ ImgDrawResult drawResult = ImgDrawResult::SUCCESS;
+ switch (mImageRenderer.GetType()) {
+ case StyleImage::Tag::Rect:
+ case StyleImage::Tag::Url: {
+ RefPtr<imgIContainer> img = mImageRenderer.GetImage();
+ if (!img || img->GetType() == imgIContainer::TYPE_VECTOR) {
+ // Vector images will redraw each segment of the border up to 8 times.
+ // We draw using a restricted region derived from the segment's clip and
+ // scale the image accordingly (see ClippedImage::Draw). If we follow
+ // this convention as is for WebRender, we will need to rasterize the
+ // entire vector image scaled up without the restriction region, which
+ // means our main thread CPU and memory footprints will be much higher.
+ // Ideally we would be able to provide a raster image for each segment
+ // of the border. For now we use fallback.
+ return ImgDrawResult::NOT_SUPPORTED;
+ }
+
+ uint32_t flags = aDisplayListBuilder->GetImageDecodeFlags();
+
+ LayoutDeviceRect imageRect = LayoutDeviceRect::FromAppUnits(
+ nsRect(nsPoint(), mImageRenderer.GetSize()), appUnitsPerDevPixel);
+
+ SVGImageContext svgContext;
+ Maybe<ImageIntRegion> region;
+ gfx::IntSize decodeSize =
+ nsLayoutUtils::ComputeImageContainerDrawingParameters(
+ img, aForFrame, imageRect, imageRect, aSc, flags, svgContext,
+ region);
+
+ RefPtr<WebRenderImageProvider> provider;
+ drawResult = img->GetImageProvider(aManager->LayerManager(), decodeSize,
+ svgContext, region, flags,
+ getter_AddRefs(provider));
+
+ Maybe<wr::ImageKey> key =
+ aManager->CommandBuilder().CreateImageProviderKey(
+ aItem, provider, drawResult, aResources);
+ if (key.isNothing()) {
+ break;
+ }
+
+ auto rendering =
+ wr::ToImageRendering(aItem->Frame()->UsedImageRendering());
+ if (mFill) {
+ float epsilon = 0.0001;
+ bool noVerticalBorders = widths[0] <= epsilon && widths[2] < epsilon;
+ bool noHorizontalBorders = widths[1] <= epsilon && widths[3] < epsilon;
+
+ // Border image with no border. It's a little silly but WebRender
+ // currently does not handle this. We could fall back to a blob image
+ // but there are reftests that are sensible to the test going through a
+ // blob while the reference doesn't.
+ if (noVerticalBorders && noHorizontalBorders) {
+ aBuilder.PushImage(dest, clip, !aItem->BackfaceIsHidden(), false,
+ rendering, key.value());
+ break;
+ }
+
+ // Fall-back if we want to fill the middle area and opposite edges are
+ // both empty.
+ // TODO(bug 1609893): moving some of the repetition handling code out
+ // of the image shader will make it easier to handle these cases
+ // properly.
+ if (noHorizontalBorders || noVerticalBorders) {
+ return ImgDrawResult::NOT_SUPPORTED;
+ }
+ }
+
+ wr::WrBorderImage params{
+ wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
+ key.value(),
+ rendering,
+ mImageSize.width / appUnitsPerDevPixel,
+ mImageSize.height / appUnitsPerDevPixel,
+ mFill,
+ wr::ToDeviceIntSideOffsets(slice[0], slice[1], slice[2], slice[3]),
+ wr::ToRepeatMode(mRepeatModeHorizontal),
+ wr::ToRepeatMode(mRepeatModeVertical)};
+
+ aBuilder.PushBorderImage(dest, clip, !aItem->BackfaceIsHidden(), params);
+ break;
+ }
+ case StyleImage::Tag::Gradient: {
+ const StyleGradient& gradient = *mImageRenderer.GetGradientData();
+ nsCSSGradientRenderer renderer = nsCSSGradientRenderer::Create(
+ aForFrame->PresContext(), aForFrame->Style(), gradient, mImageSize);
+
+ wr::ExtendMode extendMode;
+ nsTArray<wr::GradientStop> stops;
+ LayoutDevicePoint lineStart;
+ LayoutDevicePoint lineEnd;
+ LayoutDeviceSize gradientRadius;
+ LayoutDevicePoint gradientCenter;
+ float gradientAngle;
+ renderer.BuildWebRenderParameters(1.0, extendMode, stops, lineStart,
+ lineEnd, gradientRadius, gradientCenter,
+ gradientAngle);
+
+ if (gradient.IsLinear()) {
+ LayoutDevicePoint startPoint =
+ LayoutDevicePoint(dest.min.x, dest.min.y) + lineStart;
+ LayoutDevicePoint endPoint =
+ LayoutDevicePoint(dest.min.x, dest.min.y) + lineEnd;
+
+ aBuilder.PushBorderGradient(
+ dest, clip, !aItem->BackfaceIsHidden(),
+ wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
+ (float)(mImageSize.width) / appUnitsPerDevPixel,
+ (float)(mImageSize.height) / appUnitsPerDevPixel, mFill,
+ wr::ToDeviceIntSideOffsets(slice[0], slice[1], slice[2], slice[3]),
+ wr::ToLayoutPoint(startPoint), wr::ToLayoutPoint(endPoint), stops,
+ extendMode);
+ } else if (gradient.IsRadial()) {
+ aBuilder.PushBorderRadialGradient(
+ dest, clip, !aItem->BackfaceIsHidden(),
+ wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
+ mFill, wr::ToLayoutPoint(lineStart),
+ wr::ToLayoutSize(gradientRadius), stops, extendMode);
+ } else {
+ MOZ_ASSERT(gradient.IsConic());
+ aBuilder.PushBorderConicGradient(
+ dest, clip, !aItem->BackfaceIsHidden(),
+ wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
+ mFill, wr::ToLayoutPoint(gradientCenter), gradientAngle, stops,
+ extendMode);
+ }
+ break;
+ }
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unsupport border image type");
+ drawResult = ImgDrawResult::NOT_SUPPORTED;
+ }
+
+ return drawResult;
+}
+
+nsCSSBorderImageRenderer::nsCSSBorderImageRenderer(
+ const nsCSSBorderImageRenderer& aRhs)
+ : mImageRenderer(aRhs.mImageRenderer),
+ mImageSize(aRhs.mImageSize),
+ mSlice(aRhs.mSlice),
+ mWidths(aRhs.mWidths),
+ mImageOutset(aRhs.mImageOutset),
+ mArea(aRhs.mArea),
+ mClip(aRhs.mClip),
+ mRepeatModeHorizontal(aRhs.mRepeatModeHorizontal),
+ mRepeatModeVertical(aRhs.mRepeatModeVertical),
+ mFill(aRhs.mFill) {
+ Unused << mImageRenderer.PrepareResult();
+}
+
+nsCSSBorderImageRenderer& nsCSSBorderImageRenderer::operator=(
+ const nsCSSBorderImageRenderer& aRhs) {
+ mImageRenderer = aRhs.mImageRenderer;
+ mImageSize = aRhs.mImageSize;
+ mSlice = aRhs.mSlice;
+ mWidths = aRhs.mWidths;
+ mImageOutset = aRhs.mImageOutset;
+ mArea = aRhs.mArea;
+ mClip = aRhs.mClip;
+ mRepeatModeHorizontal = aRhs.mRepeatModeHorizontal;
+ mRepeatModeVertical = aRhs.mRepeatModeVertical;
+ mFill = aRhs.mFill;
+ Unused << mImageRenderer.PrepareResult();
+
+ return *this;
+}
+
+nsCSSBorderImageRenderer::nsCSSBorderImageRenderer(
+ nsIFrame* aForFrame, const nsRect& aBorderArea,
+ const nsStyleBorder& aStyleBorder, Sides aSkipSides,
+ const nsImageRenderer& aImageRenderer)
+ : mImageRenderer(aImageRenderer) {
+ // 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>.
+ nsMargin borderWidths(aStyleBorder.GetComputedBorder());
+ mImageOutset = aStyleBorder.GetImageOutset();
+ if (nsCSSRendering::IsBoxDecorationSlice(aStyleBorder) &&
+ !aSkipSides.IsEmpty()) {
+ mArea = nsCSSRendering::BoxDecorationRectForBorder(
+ aForFrame, aBorderArea, aSkipSides, &aStyleBorder);
+ if (mArea.IsEqualEdges(aBorderArea)) {
+ // No need for a clip, just skip the sides we don't want.
+ borderWidths.ApplySkipSides(aSkipSides);
+ mImageOutset.ApplySkipSides(aSkipSides);
+ mArea.Inflate(mImageOutset);
+ } 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.
+ mArea.Inflate(mImageOutset);
+ mImageOutset.ApplySkipSides(aSkipSides);
+ mClip = aBorderArea;
+ mClip.Inflate(mImageOutset);
+ }
+ } else {
+ mArea = aBorderArea;
+ mArea.Inflate(mImageOutset);
+ }
+
+ // Calculate the image size used to compute slice points.
+ CSSSizeOrRatio intrinsicSize = mImageRenderer.ComputeIntrinsicSize();
+ mImageSize = nsImageRenderer::ComputeConcreteSize(
+ CSSSizeOrRatio(), intrinsicSize, mArea.Size());
+ mImageRenderer.SetPreferredSize(intrinsicSize, mImageSize);
+
+ // 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;
+ for (const auto s : mozilla::AllPhysicalSides()) {
+ const auto& slice = aStyleBorder.mBorderImageSlice.offsets.Get(s);
+ int32_t imgDimension =
+ SideIsVertical(s) ? mImageSize.width : mImageSize.height;
+ nscoord borderDimension = SideIsVertical(s) ? mArea.width : mArea.height;
+ double value;
+ if (slice.IsNumber()) {
+ value = nsPresContext::CSSPixelsToAppUnits(NS_lround(slice.AsNumber()));
+ } else {
+ MOZ_ASSERT(slice.IsPercentage());
+ value = slice.AsPercentage()._0 * imgDimension;
+ }
+ if (value < 0) {
+ value = 0;
+ }
+ if (value > imgDimension && imgDimension > 0) {
+ value = imgDimension;
+ }
+ mSlice.Side(s) = value;
+
+ const auto& width = aStyleBorder.mBorderImageWidth.Get(s);
+ switch (width.tag) {
+ case StyleBorderImageSideWidth::Tag::LengthPercentage:
+ value =
+ std::max(0, width.AsLengthPercentage().Resolve(borderDimension));
+ break;
+ case StyleBorderImageSideWidth::Tag::Number:
+ value = width.AsNumber() * borderWidths.Side(s);
+ break;
+ case StyleBorderImageSideWidth::Tag::Auto:
+ value = mSlice.Side(s);
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("unexpected CSS unit for border image area");
+ value = 0;
+ break;
+ }
+ // NSToCoordRoundWithClamp rounds towards infinity, but that's OK
+ // because we expect value to be non-negative.
+ MOZ_ASSERT(value >= 0);
+ mWidths.Side(s) = NSToCoordRoundWithClamp(value);
+ MOZ_ASSERT(mWidths.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(mWidths.left) + uint32_t(mWidths.right);
+ double scaleX = combinedBorderWidth > uint32_t(mArea.width)
+ ? mArea.width / double(combinedBorderWidth)
+ : 1.0;
+ uint32_t combinedBorderHeight =
+ uint32_t(mWidths.top) + uint32_t(mWidths.bottom);
+ double scaleY = combinedBorderHeight > uint32_t(mArea.height)
+ ? mArea.height / double(combinedBorderHeight)
+ : 1.0;
+ double scale = std::min(scaleX, scaleY);
+ if (scale < 1.0) {
+ mWidths.left *= scale;
+ mWidths.right *= scale;
+ mWidths.top *= scale;
+ mWidths.bottom *= scale;
+ NS_ASSERTION(mWidths.left + mWidths.right <= mArea.width &&
+ mWidths.top + mWidths.bottom <= mArea.height,
+ "rounding error in width reduction???");
+ }
+
+ mRepeatModeHorizontal = aStyleBorder.mBorderImageRepeatH;
+ mRepeatModeVertical = aStyleBorder.mBorderImageRepeatV;
+ mFill = aStyleBorder.mBorderImageSlice.fill;
+}