зеркало из https://github.com/mozilla/gecko-dev.git
4106 строки
136 KiB
C++
4106 строки
136 KiB
C++
/* -*- 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 "nsLayoutUtils.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCSSColorUtils.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsCSSRenderingGradients.h"
|
|
#include "nsDisplayList.h"
|
|
#include "GeckoProfiler.h"
|
|
#include "nsExpirationTracker.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsClassHashtable.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsStyleStruct.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "gfx2DGlue.h"
|
|
#include "gfxGradientCache.h"
|
|
#include "mozilla/layers/StackingContextHelper.h"
|
|
#include "mozilla/layers/WebRenderLayerManager.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 Color
|
|
MakeBorderColor(nscolor aColor,
|
|
nscolor aBackgroundColor,
|
|
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 Color
|
|
ComputeColorForLine(uint32_t aLineIndex,
|
|
const BorderColorStyle* aBorderColorStyle,
|
|
uint32_t aBorderColorStyleCount,
|
|
nscolor aBorderColor,
|
|
nscolor aBackgroundColor);
|
|
|
|
// 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(int aSides)
|
|
{
|
|
return aSides == eSideBitsTop || aSides == eSideBitsRight ||
|
|
aSides == eSideBitsBottom || aSides == eSideBitsLeft;
|
|
}
|
|
|
|
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,
|
|
const nsIDocument* aDocument,
|
|
DrawTarget* aDrawTarget,
|
|
const Rect& aDirtyRect,
|
|
Rect& aOuterRect,
|
|
const uint8_t* aBorderStyles,
|
|
const Float* aBorderWidths,
|
|
RectCornerRadii& aBorderRadii,
|
|
const nscolor* aBorderColors,
|
|
nscolor aBackgroundColor,
|
|
bool aBackfaceIsVisible,
|
|
const Maybe<Rect>& aClipRect)
|
|
: mPresContext(aPresContext)
|
|
, mDocument(aDocument)
|
|
, mDrawTarget(aDrawTarget)
|
|
, mDirtyRect(aDirtyRect)
|
|
, mOuterRect(aOuterRect)
|
|
, mBorderRadii(aBorderRadii)
|
|
, mBackgroundColor(aBackgroundColor)
|
|
, mBackfaceIsVisible(aBackfaceIsVisible)
|
|
, mLocalClip(aClipRect)
|
|
{
|
|
PodCopy(mBorderStyles, aBorderStyles, 4);
|
|
PodCopy(mBorderWidths, aBorderWidths, 4);
|
|
PodCopy(mBorderColors, aBorderColors, 4);
|
|
mInnerRect = mOuterRect;
|
|
mInnerRect.Deflate(Margin(
|
|
mBorderStyles[0] != NS_STYLE_BORDER_STYLE_NONE ? mBorderWidths[0] : 0,
|
|
mBorderStyles[1] != NS_STYLE_BORDER_STYLE_NONE ? mBorderWidths[1] : 0,
|
|
mBorderStyles[2] != NS_STYLE_BORDER_STYLE_NONE ? mBorderWidths[2] : 0,
|
|
mBorderStyles[3] != NS_STYLE_BORDER_STYLE_NONE ? mBorderWidths[3] : 0));
|
|
|
|
ComputeBorderCornerDimensions(
|
|
mBorderWidths, mBorderRadii, &mBorderCornerDimensions);
|
|
|
|
mOneUnitBorder = CheckFourFloatsEqual(mBorderWidths, 1.0);
|
|
mNoBorderRadius = AllCornersZeroSize(mBorderRadii);
|
|
mAllBordersSameStyle = AreBorderSideFinalStylesSame(eSideBitsAll);
|
|
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(uint8_t aSides)
|
|
{
|
|
NS_ASSERTION(aSides != 0 && (aSides & ~eSideBitsAll) == 0,
|
|
"AreBorderSidesSame: invalid whichSides!");
|
|
|
|
/* First check if the specified styles and colors are the same for all sides
|
|
*/
|
|
int firstStyle = 0;
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
if (firstStyle == i) {
|
|
if (((1 << i) & aSides) == 0)
|
|
firstStyle++;
|
|
continue;
|
|
}
|
|
|
|
if (((1 << i) & aSides) == 0) {
|
|
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 NS_STYLE_BORDER_STYLE_GROOVE:
|
|
case NS_STYLE_BORDER_STYLE_RIDGE:
|
|
case NS_STYLE_BORDER_STYLE_INSET:
|
|
case NS_STYLE_BORDER_STYLE_OUTSET:
|
|
return ((aSides & ~(eSideBitsTop | eSideBitsLeft)) == 0 ||
|
|
(aSides & ~(eSideBitsBottom | eSideBitsRight)) == 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsCSSBorderRenderer::IsSolidCornerStyle(uint8_t aStyle, Corner aCorner)
|
|
{
|
|
switch (aStyle) {
|
|
case NS_STYLE_BORDER_STYLE_SOLID:
|
|
return true;
|
|
|
|
case NS_STYLE_BORDER_STYLE_INSET:
|
|
case NS_STYLE_BORDER_STYLE_OUTSET:
|
|
return (aCorner == eCornerTopLeft || aCorner == eCornerBottomRight);
|
|
|
|
case NS_STYLE_BORDER_STYLE_GROOVE:
|
|
case NS_STYLE_BORDER_STYLE_RIDGE:
|
|
return mOneUnitBorder &&
|
|
(aCorner == eCornerTopLeft || aCorner == eCornerBottomRight);
|
|
|
|
case NS_STYLE_BORDER_STYLE_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));
|
|
uint8_t styleH = mBorderStyles[sideH];
|
|
uint8_t styleV = mBorderStyles[sideV];
|
|
if (styleH != styleV || styleH != NS_STYLE_BORDER_STYLE_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(uint8_t aStyle,
|
|
Corner aCorner)
|
|
{
|
|
// note that this function assumes that the corner is already solid,
|
|
// as per the earlier function
|
|
switch (aStyle) {
|
|
case NS_STYLE_BORDER_STYLE_SOLID:
|
|
case NS_STYLE_BORDER_STYLE_DOUBLE:
|
|
return BorderColorStyleSolid;
|
|
|
|
case NS_STYLE_BORDER_STYLE_INSET:
|
|
case NS_STYLE_BORDER_STYLE_GROOVE:
|
|
if (aCorner == eCornerTopLeft)
|
|
return BorderColorStyleDark;
|
|
else if (aCorner == eCornerBottomRight)
|
|
return BorderColorStyleLight;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_OUTSET:
|
|
case NS_STYLE_BORDER_STYLE_RIDGE:
|
|
if (aCorner == eCornerTopLeft)
|
|
return BorderColorStyleLight;
|
|
else if (aCorner == eCornerBottomRight)
|
|
return BorderColorStyleDark;
|
|
break;
|
|
}
|
|
|
|
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) == NS_STYLE_BORDER_STYLE_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);
|
|
uint8_t 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);
|
|
uint8_t otherStyle = mBorderStyles[otherSide];
|
|
Float otherBorderWidth = mBorderWidths[otherSide];
|
|
Size radius = mBorderRadii[aCorner];
|
|
if (IsZeroSize(radius)) {
|
|
radius.width = 0.0f;
|
|
radius.height = 0.0f;
|
|
}
|
|
if (style == NS_STYLE_BORDER_STYLE_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 == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
otherStyle == NS_STYLE_BORDER_STYLE_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 == NS_STYLE_BORDER_STYLE_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 == NS_STYLE_BORDER_STYLE_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,
|
|
int 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 == eSideBitsAll &&
|
|
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 & eSideBitsTop) {
|
|
r[eSideTop] = Rect(aOuterRect.X(),
|
|
aOuterRect.Y(),
|
|
aOuterRect.Width(),
|
|
aBorderSizes[eSideTop]);
|
|
}
|
|
|
|
if (aSides & eSideBitsBottom) {
|
|
r[eSideBottom] = Rect(aOuterRect.X(),
|
|
aOuterRect.YMost() - aBorderSizes[eSideBottom],
|
|
aOuterRect.Width(),
|
|
aBorderSizes[eSideBottom]);
|
|
}
|
|
|
|
if (aSides & eSideBitsLeft) {
|
|
r[eSideLeft] = Rect(aOuterRect.X(),
|
|
aOuterRect.Y(),
|
|
aBorderSizes[eSideLeft],
|
|
aOuterRect.Height());
|
|
}
|
|
|
|
if (aSides & eSideBitsRight) {
|
|
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 & (eSideBitsTop | eSideBitsLeft)) ==
|
|
(eSideBitsTop | eSideBitsLeft)) {
|
|
// adjust the left's top down a bit
|
|
r[eSideLeft].y += aBorderSizes[eSideTop];
|
|
r[eSideLeft].height -= aBorderSizes[eSideTop];
|
|
}
|
|
|
|
if ((aSides & (eSideBitsTop | eSideBitsRight)) ==
|
|
(eSideBitsTop | eSideBitsRight)) {
|
|
// adjust the top's left a bit
|
|
r[eSideTop].width -= aBorderSizes[eSideRight];
|
|
}
|
|
|
|
if ((aSides & (eSideBitsBottom | eSideBitsRight)) ==
|
|
(eSideBitsBottom | eSideBitsRight)) {
|
|
// adjust the right's bottom a bit
|
|
r[eSideRight].height -= aBorderSizes[eSideBottom];
|
|
}
|
|
|
|
if ((aSides & (eSideBitsBottom | eSideBitsLeft)) ==
|
|
(eSideBitsBottom | eSideBitsLeft)) {
|
|
// 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 & (1 << i)) {
|
|
MaybeSnapToDevicePixels(r[i], *mDrawTarget, true);
|
|
mDrawTarget->FillRect(r[i], aColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
Color
|
|
MakeBorderColor(nscolor aColor,
|
|
nscolor aBackgroundColor,
|
|
BorderColorStyle aBorderColorStyle)
|
|
{
|
|
nscolor colors[2];
|
|
int k = 0;
|
|
|
|
switch (aBorderColorStyle) {
|
|
case BorderColorStyleNone:
|
|
return Color(0.f, 0.f, 0.f, 0.f); // transparent black
|
|
|
|
case BorderColorStyleLight:
|
|
k = 1;
|
|
MOZ_FALLTHROUGH;
|
|
case BorderColorStyleDark:
|
|
NS_GetSpecial3DColors(colors, aBackgroundColor, aColor);
|
|
return Color::FromABGR(colors[k]);
|
|
|
|
case BorderColorStyleSolid:
|
|
default:
|
|
return Color::FromABGR(aColor);
|
|
}
|
|
}
|
|
|
|
Color
|
|
ComputeColorForLine(uint32_t aLineIndex,
|
|
const BorderColorStyle* aBorderColorStyle,
|
|
uint32_t aBorderColorStyleCount,
|
|
nscolor aBorderColor,
|
|
nscolor aBackgroundColor)
|
|
{
|
|
NS_ASSERTION(aLineIndex < aBorderColorStyleCount, "Invalid lineIndex given");
|
|
|
|
return MakeBorderColor(
|
|
aBorderColor, aBackgroundColor, aBorderColorStyle[aLineIndex]);
|
|
}
|
|
|
|
void
|
|
nsCSSBorderRenderer::DrawBorderSides(int aSides)
|
|
{
|
|
if (aSides == 0 || (aSides & ~eSideBitsAll) != 0) {
|
|
NS_WARNING("DrawBorderSides: invalid sides!");
|
|
return;
|
|
}
|
|
|
|
uint8_t borderRenderStyle = NS_STYLE_BORDER_STYLE_NONE;
|
|
nscolor borderRenderColor;
|
|
|
|
uint32_t borderColorStyleCount = 0;
|
|
BorderColorStyle borderColorStyleTopLeft[3], borderColorStyleBottomRight[3];
|
|
BorderColorStyle* borderColorStyle = nullptr;
|
|
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
if ((aSides & (1 << i)) == 0)
|
|
continue;
|
|
borderRenderStyle = mBorderStyles[i];
|
|
borderRenderColor = mBorderColors[i];
|
|
break;
|
|
}
|
|
|
|
if (borderRenderStyle == NS_STYLE_BORDER_STYLE_NONE ||
|
|
borderRenderStyle == NS_STYLE_BORDER_STYLE_HIDDEN)
|
|
return;
|
|
|
|
if (borderRenderStyle == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
borderRenderStyle == NS_STYLE_BORDER_STYLE_DOTTED) {
|
|
// Draw each corner separately, with the given side's color.
|
|
if (aSides & eSideBitsTop) {
|
|
DrawDashedOrDottedCorner(eSideTop, C_TL);
|
|
} else if (aSides & eSideBitsLeft) {
|
|
DrawDashedOrDottedCorner(eSideLeft, C_TL);
|
|
}
|
|
|
|
if (aSides & eSideBitsTop) {
|
|
DrawDashedOrDottedCorner(eSideTop, C_TR);
|
|
} else if (aSides & eSideBitsRight) {
|
|
DrawDashedOrDottedCorner(eSideRight, C_TR);
|
|
}
|
|
|
|
if (aSides & eSideBitsBottom) {
|
|
DrawDashedOrDottedCorner(eSideBottom, C_BL);
|
|
} else if (aSides & eSideBitsLeft) {
|
|
DrawDashedOrDottedCorner(eSideLeft, C_BL);
|
|
}
|
|
|
|
if (aSides & eSideBitsBottom) {
|
|
DrawDashedOrDottedCorner(eSideBottom, C_BR);
|
|
} else if (aSides & eSideBitsRight) {
|
|
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 == NS_STYLE_BORDER_STYLE_RIDGE ||
|
|
borderRenderStyle == NS_STYLE_BORDER_STYLE_GROOVE ||
|
|
borderRenderStyle == NS_STYLE_BORDER_STYLE_DOUBLE))
|
|
borderRenderStyle = NS_STYLE_BORDER_STYLE_SOLID;
|
|
|
|
switch (borderRenderStyle) {
|
|
case NS_STYLE_BORDER_STYLE_SOLID:
|
|
borderColorStyleTopLeft[0] = BorderColorStyleSolid;
|
|
|
|
borderColorStyleBottomRight[0] = BorderColorStyleSolid;
|
|
|
|
borderColorStyleCount = 1;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_GROOVE:
|
|
borderColorStyleTopLeft[0] = BorderColorStyleDark;
|
|
borderColorStyleTopLeft[1] = BorderColorStyleLight;
|
|
|
|
borderColorStyleBottomRight[0] = BorderColorStyleLight;
|
|
borderColorStyleBottomRight[1] = BorderColorStyleDark;
|
|
|
|
borderColorStyleCount = 2;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_RIDGE:
|
|
borderColorStyleTopLeft[0] = BorderColorStyleLight;
|
|
borderColorStyleTopLeft[1] = BorderColorStyleDark;
|
|
|
|
borderColorStyleBottomRight[0] = BorderColorStyleDark;
|
|
borderColorStyleBottomRight[1] = BorderColorStyleLight;
|
|
|
|
borderColorStyleCount = 2;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_DOUBLE:
|
|
borderColorStyleTopLeft[0] = BorderColorStyleSolid;
|
|
borderColorStyleTopLeft[1] = BorderColorStyleNone;
|
|
borderColorStyleTopLeft[2] = BorderColorStyleSolid;
|
|
|
|
borderColorStyleBottomRight[0] = BorderColorStyleSolid;
|
|
borderColorStyleBottomRight[1] = BorderColorStyleNone;
|
|
borderColorStyleBottomRight[2] = BorderColorStyleSolid;
|
|
|
|
borderColorStyleCount = 3;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_INSET:
|
|
borderColorStyleTopLeft[0] = BorderColorStyleDark;
|
|
borderColorStyleBottomRight[0] = BorderColorStyleLight;
|
|
|
|
borderColorStyleCount = 1;
|
|
break;
|
|
|
|
case NS_STYLE_BORDER_STYLE_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 & (eSideBitsBottom | eSideBitsRight))
|
|
borderColorStyle = borderColorStyleBottomRight;
|
|
else
|
|
borderColorStyle = borderColorStyleTopLeft;
|
|
|
|
// Distribute the border across the available space.
|
|
Float borderWidths[3][4];
|
|
|
|
if (borderColorStyleCount == 1) {
|
|
NS_FOR_CSS_SIDES(i) { borderWidths[0][i] = mBorderWidths[i]; }
|
|
} else if (borderColorStyleCount == 2) {
|
|
// with 2 color styles, any extra pixel goes to the outside
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
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
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
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 == eSideBitsTop) {
|
|
if (mBorderStyles[eSideRight] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_TR])) {
|
|
noMarginRight = true;
|
|
}
|
|
if (mBorderStyles[eSideLeft] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_TL])) {
|
|
noMarginLeft = true;
|
|
}
|
|
} else if (aSides == eSideBitsRight) {
|
|
if (mBorderStyles[eSideTop] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_TR])) {
|
|
noMarginTop = true;
|
|
}
|
|
if (mBorderStyles[eSideBottom] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_BR])) {
|
|
noMarginBottom = true;
|
|
}
|
|
} else if (aSides == eSideBitsBottom) {
|
|
if (mBorderStyles[eSideRight] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_BR])) {
|
|
noMarginRight = true;
|
|
}
|
|
if (mBorderStyles[eSideLeft] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_BL])) {
|
|
noMarginLeft = true;
|
|
}
|
|
} else {
|
|
if (mBorderStyles[eSideTop] == NS_STYLE_BORDER_STYLE_DOTTED &&
|
|
IsZeroSize(mBorderRadii[C_TL])) {
|
|
noMarginTop = true;
|
|
}
|
|
if (mBorderStyles[eSideBottom] == NS_STYLE_BORDER_STYLE_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) {
|
|
Color c = ComputeColorForLine(i,
|
|
borderColorStyle,
|
|
borderColorStyleCount,
|
|
borderRenderColor,
|
|
mBackgroundColor);
|
|
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] == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DOTTED,
|
|
"Style should be dashed or dotted.");
|
|
|
|
uint8_t 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 == NS_STYLE_BORDER_STYLE_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)] == NS_STYLE_BORDER_STYLE_DOTTED ||
|
|
// XXX why this <=1 check?
|
|
borderWidth <= 1.0f)) {
|
|
fullStart = true;
|
|
}
|
|
|
|
if (mBorderRadii[GetCWCorner(aSide)].IsEmpty() &&
|
|
(mBorderCornerDimensions[GetCWCorner(aSide)].IsEmpty() ||
|
|
mBorderStyles[NEXT_SIDE(aSide)] == NS_STYLE_BORDER_STYLE_DOTTED)) {
|
|
fullEnd = true;
|
|
}
|
|
|
|
halfDash = borderWidth * DOT_LENGTH * DASH_LENGTH / 2.0f;
|
|
} else {
|
|
halfDash = borderWidth * DOT_LENGTH / 2.0f;
|
|
}
|
|
|
|
if (style == NS_STYLE_BORDER_STYLE_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 == NS_STYLE_BORDER_STYLE_DASHED && fullDash > 1.0f) {
|
|
if (!fullStart) {
|
|
// Draw half segments on both ends.
|
|
aStrokeOptions->mDashOffset = halfDash;
|
|
}
|
|
} else if (style != NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DOTTED,
|
|
"Style should be dashed or dotted.");
|
|
|
|
Float borderWidth = mBorderWidths[aSide];
|
|
if (borderWidth == 0.0f) {
|
|
return;
|
|
}
|
|
|
|
if (mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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;
|
|
|
|
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] == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_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;
|
|
}
|
|
|
|
Float styleH = mBorderStyles[sideH];
|
|
Float styleV = mBorderStyles[sideV];
|
|
|
|
// Corner between dotted and others with radius=0 is drawn by side.
|
|
if (IsZeroSize(mBorderRadii[aCorner]) &&
|
|
(styleV == NS_STYLE_BORDER_STYLE_DOTTED ||
|
|
styleH == NS_STYLE_BORDER_STYLE_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) {
|
|
uint8_t style = mBorderStyles[aSide];
|
|
if (style == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_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 (mDocument) {
|
|
if (!mPresContext->HasWarnedAboutTooLargeDashedOrDottedRadius()) {
|
|
mPresContext->SetHasWarnedAboutTooLargeDashedOrDottedRadius();
|
|
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
|
|
NS_LITERAL_CSTRING("CSS"),
|
|
mDocument,
|
|
nsContentUtils::eCSS_PROPERTIES,
|
|
mBorderStyles[aSide] ==
|
|
NS_STYLE_BORDER_STYLE_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()
|
|
{
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
if (mBorderStyles[i] == NS_STYLE_BORDER_STYLE_SOLID ||
|
|
mBorderStyles[i] == NS_STYLE_BORDER_STYLE_NONE ||
|
|
mBorderStyles[i] == NS_STYLE_BORDER_STYLE_HIDDEN) {
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
IsVisible(int aStyle)
|
|
{
|
|
if (aStyle != NS_STYLE_BORDER_STYLE_NONE &&
|
|
aStyle != NS_STYLE_BORDER_STYLE_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 }
|
|
};
|
|
NS_FOR_CSS_SIDES(side)
|
|
{
|
|
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 Color& aFirstColor,
|
|
const Color& 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
|
|
Float startAngle = (c * M_PI) / 2.0f - M_PI,
|
|
endAngle = startAngle + M_PI / 2.0f, 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 Color& aFirstColor,
|
|
const Color& 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));
|
|
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
// 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;
|
|
Color 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 (mAllBordersSameStyle &&
|
|
(mBorderStyles[0] == NS_STYLE_BORDER_STYLE_NONE ||
|
|
mBorderStyles[0] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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] == NS_STYLE_BORDER_STYLE_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);
|
|
|
|
gfxRect innerRect = ThebesRect(mInnerRect);
|
|
gfxUtils::ConditionRect(innerRect);
|
|
mInnerRect = ToRect(innerRect);
|
|
}
|
|
|
|
int dashedSides = 0;
|
|
bool forceSeparateCorners = false;
|
|
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
uint8_t style = mBorderStyles[i];
|
|
if (style == NS_STYLE_BORDER_STYLE_DASHED ||
|
|
style == NS_STYLE_BORDER_STYLE_DOTTED) {
|
|
// we need to draw things separately for dashed/dotting
|
|
forceSeparateCorners = true;
|
|
dashedSides |= (1 << i);
|
|
}
|
|
}
|
|
|
|
PrintAsFormatString(" mAllBordersSameStyle: %d dashedSides: 0x%02x\n",
|
|
mAllBordersSameStyle,
|
|
dashedSides);
|
|
|
|
if (mAllBordersSameStyle && !forceSeparateCorners) {
|
|
/* Draw everything in one go */
|
|
DrawBorderSides(eSideBitsAll);
|
|
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.
|
|
NS_FOR_CSS_FULL_CORNERS(corner)
|
|
{
|
|
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
|
|
NS_FOR_CSS_FULL_CORNERS(corner)
|
|
{
|
|
// 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) };
|
|
int 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)) {
|
|
Color color = MakeBorderColor(
|
|
mBorderColors[sides[0]],
|
|
mBackgroundColor,
|
|
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]);
|
|
uint8_t style = mBorderStyles[side];
|
|
|
|
PrintAsFormatString("corner: %d cornerSide: %d side: %d style: %d\n",
|
|
corner,
|
|
cornerSide,
|
|
side,
|
|
style);
|
|
|
|
RefPtr<Path> path = GetSideClipSubPath(side);
|
|
mDrawTarget->PushClip(path);
|
|
|
|
DrawBorderSides(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.
|
|
int alreadyDrawnSides = 0;
|
|
if (mOneUnitBorder && mNoBorderRadius &&
|
|
(dashedSides & (eSideBitsTop | eSideBitsLeft)) == 0) {
|
|
bool tlBordersSameStyle =
|
|
AreBorderSideFinalStylesSame(eSideBitsTop | eSideBitsLeft);
|
|
bool brBordersSameStyle =
|
|
AreBorderSideFinalStylesSame(eSideBitsBottom | eSideBitsRight);
|
|
|
|
if (tlBordersSameStyle) {
|
|
DrawBorderSides(eSideBitsTop | eSideBitsLeft);
|
|
alreadyDrawnSides |= (eSideBitsTop | eSideBitsLeft);
|
|
}
|
|
|
|
if (brBordersSameStyle &&
|
|
(dashedSides & (eSideBitsBottom | eSideBitsRight)) == 0) {
|
|
DrawBorderSides(eSideBitsBottom | eSideBitsRight);
|
|
alreadyDrawnSides |= (eSideBitsBottom | eSideBitsRight);
|
|
}
|
|
}
|
|
|
|
// We're done with the corners, now draw the sides.
|
|
NS_FOR_CSS_SIDES(side)
|
|
{
|
|
// if we drew it above, skip it
|
|
if (alreadyDrawnSides & (1 << side))
|
|
continue;
|
|
|
|
// If there's no border on this side, skip it
|
|
if (mBorderWidths[side] == 0.0 ||
|
|
mBorderStyles[side] == NS_STYLE_BORDER_STYLE_HIDDEN ||
|
|
mBorderStyles[side] == NS_STYLE_BORDER_STYLE_NONE)
|
|
continue;
|
|
|
|
if (dashedSides & (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(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::ToRoundedLayoutRect(outerRect);
|
|
wr::BorderSide side[4];
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
side[i] =
|
|
wr::ToBorderSide(ToDeviceColor(mBorderColors[i]), mBorderStyles[i]);
|
|
}
|
|
|
|
wr::BorderRadius borderRadius =
|
|
wr::ToBorderRadius(LayoutDeviceSize::FromUnknownSize(mBorderRadii[0]),
|
|
LayoutDeviceSize::FromUnknownSize(mBorderRadii[1]),
|
|
LayoutDeviceSize::FromUnknownSize(mBorderRadii[3]),
|
|
LayoutDeviceSize::FromUnknownSize(mBorderRadii[2]));
|
|
|
|
if (mLocalClip) {
|
|
LayoutDeviceRect clip =
|
|
LayoutDeviceRect::FromUnknownRect(mLocalClip.value());
|
|
wr::LayoutRect clipRect = wr::ToRoundedLayoutRect(clip);
|
|
wr::WrClipId clipId = aBuilder.DefineClip(Nothing(), clipRect);
|
|
aBuilder.PushClip(clipId);
|
|
}
|
|
|
|
Range<const wr::BorderSide> wrsides(side, 4);
|
|
aBuilder.PushBorder(
|
|
roundedRect,
|
|
roundedRect,
|
|
mBackfaceIsVisible,
|
|
wr::ToBorderWidths(
|
|
mBorderWidths[0], mBorderWidths[1], mBorderWidths[2], mBorderWidths[3]),
|
|
wrsides,
|
|
borderRadius);
|
|
|
|
if (mLocalClip) {
|
|
aBuilder.PopClip();
|
|
}
|
|
}
|
|
|
|
/* 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();
|
|
}
|
|
|
|
// Ensure we get invalidated for loads and animations of the image.
|
|
// We need to do this here because this might be the only code that
|
|
// knows about the association of the style data with the frame.
|
|
// XXX We shouldn't really... since if anybody is passing in a
|
|
// different style, they'll potentially have the wrong size for the
|
|
// border too.
|
|
aForFrame->AssociateImage(aStyleBorder.mBorderImageSource, aPresContext, 0);
|
|
|
|
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();
|
|
mImageRenderer.PurgeCacheForViewportChange(svgViewportSize,
|
|
hasIntrinsicRatio);
|
|
|
|
// These helper tables recharacterize the 'slice' and 'width' margins
|
|
// in a more convenient form: they are the x/y/width/height coords
|
|
// required for various bands of the border, and they have been transformed
|
|
// to be relative to the innerRect (for 'slice') or the page (for 'border').
|
|
enum
|
|
{
|
|
LEFT,
|
|
MIDDLE,
|
|
RIGHT,
|
|
TOP = LEFT,
|
|
BOTTOM = RIGHT
|
|
};
|
|
const nscoord borderX[3] = {
|
|
mArea.x + 0,
|
|
mArea.x + mWidths.left,
|
|
mArea.x + mArea.width - mWidths.right,
|
|
};
|
|
const nscoord borderY[3] = {
|
|
mArea.y + 0,
|
|
mArea.y + mWidths.top,
|
|
mArea.y + mArea.height - mWidths.bottom,
|
|
};
|
|
const nscoord borderWidth[3] = {
|
|
mWidths.left,
|
|
mArea.width - mWidths.left - mWidths.right,
|
|
mWidths.right,
|
|
};
|
|
const nscoord borderHeight[3] = {
|
|
mWidths.top,
|
|
mArea.height - mWidths.top - mWidths.bottom,
|
|
mWidths.bottom,
|
|
};
|
|
const int32_t sliceX[3] = {
|
|
0,
|
|
mSlice.left,
|
|
mImageSize.width - mSlice.right,
|
|
};
|
|
const int32_t sliceY[3] = {
|
|
0,
|
|
mSlice.top,
|
|
mImageSize.height - mSlice.bottom,
|
|
};
|
|
const int32_t sliceWidth[3] = {
|
|
mSlice.left,
|
|
std::max(mImageSize.width - mSlice.left - mSlice.right, 0),
|
|
mSlice.right,
|
|
};
|
|
const int32_t sliceHeight[3] = {
|
|
mSlice.top,
|
|
std::max(mImageSize.height - mSlice.top - mSlice.bottom, 0),
|
|
mSlice.bottom,
|
|
};
|
|
|
|
ImgDrawResult result = ImgDrawResult::SUCCESS;
|
|
|
|
for (int i = LEFT; i <= RIGHT; i++) {
|
|
for (int j = TOP; j <= BOTTOM; j++) {
|
|
StyleBorderImageRepeat fillStyleH, fillStyleV;
|
|
nsSize unitSize;
|
|
|
|
if (i == MIDDLE && j == MIDDLE) {
|
|
// Discard the middle portion unless set to fill.
|
|
if (NS_STYLE_BORDER_IMAGE_SLICE_NOFILL == mFill) {
|
|
continue;
|
|
}
|
|
|
|
NS_ASSERTION(NS_STYLE_BORDER_IMAGE_SLICE_FILL == mFill,
|
|
"Unexpected border image fill");
|
|
|
|
// css-background:
|
|
// The middle image's width is scaled by the same factor as the
|
|
// top image unless that factor is zero or infinity, in which
|
|
// case the scaling factor of the bottom is substituted, and
|
|
// failing that, the width is not scaled. The height of the
|
|
// middle image is scaled by the same factor as the left image
|
|
// unless that factor is zero or infinity, in which case the
|
|
// scaling factor of the right image is substituted, and failing
|
|
// that, the height is not scaled.
|
|
gfxFloat hFactor, vFactor;
|
|
|
|
if (0 < mWidths.left && 0 < mSlice.left)
|
|
vFactor = gfxFloat(mWidths.left) / mSlice.left;
|
|
else if (0 < mWidths.right && 0 < mSlice.right)
|
|
vFactor = gfxFloat(mWidths.right) / mSlice.right;
|
|
else
|
|
vFactor = 1;
|
|
|
|
if (0 < mWidths.top && 0 < mSlice.top)
|
|
hFactor = gfxFloat(mWidths.top) / mSlice.top;
|
|
else if (0 < mWidths.bottom && 0 < mSlice.bottom)
|
|
hFactor = gfxFloat(mWidths.bottom) / mSlice.bottom;
|
|
else
|
|
hFactor = 1;
|
|
|
|
unitSize.width = sliceWidth[i] * hFactor;
|
|
unitSize.height = sliceHeight[j] * vFactor;
|
|
fillStyleH = mRepeatModeHorizontal;
|
|
fillStyleV = mRepeatModeVertical;
|
|
|
|
} else if (i == MIDDLE) { // top, bottom
|
|
// Sides are always stretched to the thickness of their border,
|
|
// and stretched proportionately on the other axis.
|
|
gfxFloat factor;
|
|
if (0 < borderHeight[j] && 0 < sliceHeight[j])
|
|
factor = gfxFloat(borderHeight[j]) / sliceHeight[j];
|
|
else
|
|
factor = 1;
|
|
|
|
unitSize.width = sliceWidth[i] * factor;
|
|
unitSize.height = borderHeight[j];
|
|
fillStyleH = mRepeatModeHorizontal;
|
|
fillStyleV = StyleBorderImageRepeat::Stretch;
|
|
|
|
} else if (j == MIDDLE) { // left, right
|
|
gfxFloat factor;
|
|
if (0 < borderWidth[i] && 0 < sliceWidth[i])
|
|
factor = gfxFloat(borderWidth[i]) / sliceWidth[i];
|
|
else
|
|
factor = 1;
|
|
|
|
unitSize.width = borderWidth[i];
|
|
unitSize.height = sliceHeight[j] * factor;
|
|
fillStyleH = StyleBorderImageRepeat::Stretch;
|
|
fillStyleV = mRepeatModeVertical;
|
|
|
|
} else {
|
|
// Corners are always stretched to fit the corner.
|
|
unitSize.width = borderWidth[i];
|
|
unitSize.height = borderHeight[j];
|
|
fillStyleH = StyleBorderImageRepeat::Stretch;
|
|
fillStyleV = StyleBorderImageRepeat::Stretch;
|
|
}
|
|
|
|
nsRect destArea(borderX[i], borderY[j], borderWidth[i], borderHeight[j]);
|
|
nsRect subArea(sliceX[i], sliceY[j], sliceWidth[i], sliceHeight[j]);
|
|
if (subArea.IsEmpty())
|
|
continue;
|
|
|
|
nsIntRect intSubArea = subArea.ToOutsidePixels(AppUnitsPerCSSPixel());
|
|
result &= mImageRenderer.DrawBorderImageComponent(
|
|
aPresContext,
|
|
aRenderingContext,
|
|
aDirtyRect,
|
|
destArea,
|
|
CSSIntRect(
|
|
intSubArea.x, intSubArea.y, intSubArea.width, intSubArea.height),
|
|
fillStyleH,
|
|
fillStyleV,
|
|
unitSize,
|
|
j * (RIGHT + 1) + i,
|
|
svgViewportSize,
|
|
hasIntrinsicRatio);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
nsCSSBorderImageRenderer::CreateWebRenderCommands(
|
|
nsDisplayItem* aItem,
|
|
nsIFrame* aForFrame,
|
|
mozilla::wr::DisplayListBuilder& aBuilder,
|
|
mozilla::wr::IpcResourceUpdateQueue& aResources,
|
|
const mozilla::layers::StackingContextHelper& aSc,
|
|
mozilla::layers::WebRenderLayerManager* aManager,
|
|
nsDisplayListBuilder* aDisplayListBuilder)
|
|
{
|
|
if (!mImageRenderer.IsReady()) {
|
|
return;
|
|
}
|
|
|
|
float widths[4];
|
|
float slice[4];
|
|
float outset[4];
|
|
const int32_t appUnitsPerDevPixel =
|
|
aForFrame->PresContext()->AppUnitsPerDevPixel();
|
|
NS_FOR_CSS_SIDES(i)
|
|
{
|
|
slice[i] = (float)(mSlice.Side(i)) / appUnitsPerDevPixel;
|
|
widths[i] = (float)(mWidths.Side(i)) / appUnitsPerDevPixel;
|
|
outset[i] = (float)(mImageOutset.Side(i)) / appUnitsPerDevPixel;
|
|
}
|
|
|
|
LayoutDeviceRect destRect =
|
|
LayoutDeviceRect::FromAppUnits(mArea, appUnitsPerDevPixel);
|
|
wr::LayoutRect dest = wr::ToRoundedLayoutRect(destRect);
|
|
|
|
wr::LayoutRect clip = dest;
|
|
if (!mClip.IsEmpty()) {
|
|
LayoutDeviceRect clipRect =
|
|
LayoutDeviceRect::FromAppUnits(mClip, appUnitsPerDevPixel);
|
|
clip = wr::ToRoundedLayoutRect(clipRect);
|
|
}
|
|
|
|
switch (mImageRenderer.GetType()) {
|
|
case eStyleImageType_Image: {
|
|
uint32_t flags = imgIContainer::FLAG_ASYNC_NOTIFY;
|
|
if (aDisplayListBuilder->IsPaintingToWindow()) {
|
|
flags |= imgIContainer::FLAG_HIGH_QUALITY_SCALING;
|
|
}
|
|
if (aDisplayListBuilder->ShouldSyncDecodeImages()) {
|
|
flags |= imgIContainer::FLAG_SYNC_DECODE;
|
|
}
|
|
|
|
RefPtr<imgIContainer> img = mImageRenderer.GetImage();
|
|
Maybe<SVGImageContext> svgContext;
|
|
gfx::IntSize decodeSize =
|
|
nsLayoutUtils::ComputeImageContainerDrawingParameters(
|
|
img, aForFrame, destRect, aSc, flags, svgContext);
|
|
|
|
RefPtr<layers::ImageContainer> container;
|
|
img->GetImageContainerAtSize(aManager, decodeSize, svgContext,
|
|
flags, getter_AddRefs(container));
|
|
if (!container) {
|
|
return;
|
|
}
|
|
|
|
mozilla::wr::ImageRendering rendering = wr::ToImageRendering(
|
|
nsLayoutUtils::GetSamplingFilterForFrame(aItem->Frame()));
|
|
gfx::IntSize size;
|
|
Maybe<wr::ImageKey> key =
|
|
aManager->CommandBuilder().CreateImageKey(aItem,
|
|
container,
|
|
aBuilder,
|
|
aResources,
|
|
rendering,
|
|
aSc,
|
|
size,
|
|
Nothing());
|
|
if (key.isNothing()) {
|
|
return;
|
|
}
|
|
|
|
aBuilder.PushBorderImage(
|
|
dest,
|
|
clip,
|
|
!aItem->BackfaceIsHidden(),
|
|
wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
|
|
key.value(),
|
|
(float)(mImageSize.width) / appUnitsPerDevPixel,
|
|
(float)(mImageSize.height) / appUnitsPerDevPixel,
|
|
wr::ToSideOffsets2D_u32(slice[0], slice[1], slice[2], slice[3]),
|
|
wr::ToSideOffsets2D_f32(outset[0], outset[1], outset[2], outset[3]),
|
|
wr::ToRepeatMode(mRepeatModeHorizontal),
|
|
wr::ToRepeatMode(mRepeatModeVertical));
|
|
break;
|
|
}
|
|
case eStyleImageType_Gradient: {
|
|
RefPtr<nsStyleGradient> gradientData = mImageRenderer.GetGradientData();
|
|
nsCSSGradientRenderer renderer = nsCSSGradientRenderer::Create(
|
|
aForFrame->PresContext(), aForFrame->Style(), gradientData, mImageSize);
|
|
|
|
wr::ExtendMode extendMode;
|
|
nsTArray<wr::GradientStop> stops;
|
|
LayoutDevicePoint lineStart;
|
|
LayoutDevicePoint lineEnd;
|
|
LayoutDeviceSize gradientRadius;
|
|
renderer.BuildWebRenderParameters(
|
|
1.0, extendMode, stops, lineStart, lineEnd, gradientRadius);
|
|
|
|
if (gradientData->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR) {
|
|
LayoutDevicePoint startPoint =
|
|
LayoutDevicePoint(dest.origin.x, dest.origin.y) + lineStart;
|
|
LayoutDevicePoint endPoint =
|
|
LayoutDevicePoint(dest.origin.x, dest.origin.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,
|
|
wr::ToSideOffsets2D_u32(slice[0], slice[1], slice[2], slice[3]),
|
|
wr::ToLayoutPoint(startPoint),
|
|
wr::ToLayoutPoint(endPoint),
|
|
stops,
|
|
extendMode,
|
|
wr::ToSideOffsets2D_f32(outset[0], outset[1], outset[2], outset[3]));
|
|
} else {
|
|
aBuilder.PushBorderRadialGradient(
|
|
dest,
|
|
clip,
|
|
!aItem->BackfaceIsHidden(),
|
|
wr::ToBorderWidths(widths[0], widths[1], widths[2], widths[3]),
|
|
wr::ToLayoutPoint(lineStart),
|
|
wr::ToLayoutSize(gradientRadius),
|
|
stops,
|
|
extendMode,
|
|
wr::ToSideOffsets2D_f32(outset[0], outset[1], outset[2], outset[3]));
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unsupport border image type");
|
|
}
|
|
}
|
|
|
|
nsCSSBorderImageRenderer::nsCSSBorderImageRenderer(
|
|
const nsCSSBorderImageRenderer& aRhs)
|
|
: mImageRenderer(aRhs.mImageRenderer)
|
|
, mImageSize(aRhs.mImageSize)
|
|
, mSlice(aRhs.mSlice)
|
|
, mWidths(aRhs.mWidths)
|
|
, mImageOutset(aRhs.mImageOutset)
|
|
, mArea(aRhs.mArea)
|
|
, mClip(aRhs.mClip)
|
|
, mRepeatModeHorizontal(aRhs.mRepeatModeHorizontal)
|
|
, mRepeatModeVertical(aRhs.mRepeatModeVertical)
|
|
, mFill(aRhs.mFill)
|
|
{
|
|
Unused << mImageRenderer.PrepareResult();
|
|
}
|
|
|
|
nsCSSBorderImageRenderer&
|
|
nsCSSBorderImageRenderer::operator=(const nsCSSBorderImageRenderer& aRhs)
|
|
{
|
|
mImageRenderer = aRhs.mImageRenderer;
|
|
mImageSize = aRhs.mImageSize;
|
|
mSlice = aRhs.mSlice;
|
|
mWidths = aRhs.mWidths;
|
|
mImageOutset = aRhs.mImageOutset;
|
|
mArea = aRhs.mArea;
|
|
mClip = aRhs.mClip;
|
|
mRepeatModeHorizontal = aRhs.mRepeatModeHorizontal;
|
|
mRepeatModeVertical = aRhs.mRepeatModeVertical;
|
|
mFill = aRhs.mFill;
|
|
Unused << mImageRenderer.PrepareResult();
|
|
|
|
return *this;
|
|
}
|
|
|
|
nsCSSBorderImageRenderer::nsCSSBorderImageRenderer(
|
|
nsIFrame* aForFrame,
|
|
const nsRect& aBorderArea,
|
|
const nsStyleBorder& aStyleBorder,
|
|
Sides aSkipSides,
|
|
const nsImageRenderer& aImageRenderer)
|
|
: mImageRenderer(aImageRenderer)
|
|
{
|
|
// Determine the border image area, which by default corresponds to the
|
|
// border box but can be modified by 'border-image-outset'.
|
|
// Note that 'border-radius' do not apply to 'border-image' borders per
|
|
// <http://dev.w3.org/csswg/css-backgrounds/#corner-clipping>.
|
|
nsMargin borderWidths(aStyleBorder.GetComputedBorder());
|
|
mImageOutset = aStyleBorder.GetImageOutset();
|
|
if (nsCSSRendering::IsBoxDecorationSlice(aStyleBorder) &&
|
|
!aSkipSides.IsEmpty()) {
|
|
mArea = nsCSSRendering::BoxDecorationRectForBorder(
|
|
aForFrame, aBorderArea, aSkipSides, &aStyleBorder);
|
|
if (mArea.IsEqualEdges(aBorderArea)) {
|
|
// No need for a clip, just skip the sides we don't want.
|
|
borderWidths.ApplySkipSides(aSkipSides);
|
|
mImageOutset.ApplySkipSides(aSkipSides);
|
|
mArea.Inflate(mImageOutset);
|
|
} else {
|
|
// We're drawing borders around the joined continuation boxes so we need
|
|
// to clip that to the slice that we want for this frame.
|
|
mArea.Inflate(mImageOutset);
|
|
mImageOutset.ApplySkipSides(aSkipSides);
|
|
mClip = aBorderArea;
|
|
mClip.Inflate(mImageOutset);
|
|
}
|
|
} else {
|
|
mArea = aBorderArea;
|
|
mArea.Inflate(mImageOutset);
|
|
}
|
|
|
|
// Calculate the image size used to compute slice points.
|
|
CSSSizeOrRatio intrinsicSize = mImageRenderer.ComputeIntrinsicSize();
|
|
mImageSize = nsImageRenderer::ComputeConcreteSize(
|
|
CSSSizeOrRatio(), intrinsicSize, mArea.Size());
|
|
mImageRenderer.SetPreferredSize(intrinsicSize, mImageSize);
|
|
|
|
// Compute the used values of 'border-image-slice' and 'border-image-width';
|
|
// we do them together because the latter can depend on the former.
|
|
nsMargin slice;
|
|
nsMargin border;
|
|
NS_FOR_CSS_SIDES(s)
|
|
{
|
|
nsStyleCoord coord = aStyleBorder.mBorderImageSlice.Get(s);
|
|
int32_t imgDimension =
|
|
SideIsVertical(s) ? mImageSize.width : mImageSize.height;
|
|
nscoord borderDimension = SideIsVertical(s) ? mArea.width : mArea.height;
|
|
double value;
|
|
switch (coord.GetUnit()) {
|
|
case eStyleUnit_Percent:
|
|
value = coord.GetPercentValue() * imgDimension;
|
|
break;
|
|
case eStyleUnit_Factor:
|
|
value =
|
|
nsPresContext::CSSPixelsToAppUnits(NS_lround(coord.GetFactorValue()));
|
|
break;
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("unexpected CSS unit for image slice");
|
|
value = 0;
|
|
break;
|
|
}
|
|
if (value < 0)
|
|
value = 0;
|
|
if (value > imgDimension)
|
|
value = imgDimension;
|
|
mSlice.Side(s) = value;
|
|
|
|
coord = aStyleBorder.mBorderImageWidth.Get(s);
|
|
switch (coord.GetUnit()) {
|
|
case eStyleUnit_Coord: // absolute dimension
|
|
value = coord.GetCoordValue();
|
|
break;
|
|
case eStyleUnit_Percent:
|
|
value = coord.GetPercentValue() * borderDimension;
|
|
break;
|
|
case eStyleUnit_Factor:
|
|
value = coord.GetFactorValue() * borderWidths.Side(s);
|
|
break;
|
|
case eStyleUnit_Auto: // same as the slice value, in CSS pixels
|
|
value = mSlice.Side(s);
|
|
break;
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("unexpected CSS unit for border image area "
|
|
"division");
|
|
value = 0;
|
|
break;
|
|
}
|
|
// NSToCoordRoundWithClamp rounds towards infinity, but that's OK
|
|
// because we expect value to be non-negative.
|
|
MOZ_ASSERT(value >= 0);
|
|
mWidths.Side(s) = NSToCoordRoundWithClamp(value);
|
|
MOZ_ASSERT(mWidths.Side(s) >= 0);
|
|
}
|
|
|
|
// "If two opposite border-image-width offsets are large enough that they
|
|
// overlap, their used values are proportionately reduced until they no
|
|
// longer overlap."
|
|
uint32_t combinedBorderWidth =
|
|
uint32_t(mWidths.left) + uint32_t(mWidths.right);
|
|
double scaleX = combinedBorderWidth > uint32_t(mArea.width)
|
|
? mArea.width / double(combinedBorderWidth)
|
|
: 1.0;
|
|
uint32_t combinedBorderHeight =
|
|
uint32_t(mWidths.top) + uint32_t(mWidths.bottom);
|
|
double scaleY = combinedBorderHeight > uint32_t(mArea.height)
|
|
? mArea.height / double(combinedBorderHeight)
|
|
: 1.0;
|
|
double scale = std::min(scaleX, scaleY);
|
|
if (scale < 1.0) {
|
|
mWidths.left *= scale;
|
|
mWidths.right *= scale;
|
|
mWidths.top *= scale;
|
|
mWidths.bottom *= scale;
|
|
NS_ASSERTION(mWidths.left + mWidths.right <= mArea.width &&
|
|
mWidths.top + mWidths.bottom <= mArea.height,
|
|
"rounding error in width reduction???");
|
|
}
|
|
|
|
mRepeatModeHorizontal = aStyleBorder.mBorderImageRepeatH;
|
|
mRepeatModeVertical = aStyleBorder.mBorderImageRepeatV;
|
|
mFill = aStyleBorder.mBorderImageFill;
|
|
}
|