mozilla-central/layout/painting/nsCSSRenderingBorders.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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++) {
StyleBorderImageRepeatKeyword 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 = StyleBorderImageRepeatKeyword::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 = StyleBorderImageRepeatKeyword::Stretch;
fillStyleV = mRepeatModeVertical;
} else {
// Corners are always stretched to fit the corner.
unitSize.width = borderWidth[i];
unitSize.height = borderHeight[j];
fillStyleH = StyleBorderImageRepeatKeyword::Stretch;
fillStyleV = StyleBorderImageRepeatKeyword::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::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
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.mBorderImageRepeat._0;
mRepeatModeVertical = aStyleBorder.mBorderImageRepeat._1;
mFill = aStyleBorder.mBorderImageSlice.fill;
}