wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-29 02:27:30 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1925 - Move Corner enum from mozilla::css to mozilla namespace.

Browse source
This commit is contained in:
Moonchild 2024-08-01 20:28:28 +02:00 • committed by roytam1
commit b3a51c2711
8 changed files with 45 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gfx/2d/BezierUtils.cpp
View file

@ -241,7 +241,7 @@ FindBezierNearestPoint(const Bezier& aBezier, const Point& aTarget,
} }
void void
GetBezierPointsForCorner(Bezier* aBezier, mozilla::css::Corner aCorner, GetBezierPointsForCorner(Bezier* aBezier, mozilla::Corner aCorner,
const Point& aCornerPoint, const Size& aCornerSize) const Point& aCornerPoint, const Size& aCornerSize)
{ {
// Calculate bezier control points for elliptic arc. // Calculate bezier control points for elliptic arc.

2
gfx/2d/BezierUtils.h
View file

@ -127,7 +127,7 @@ Point FindBezierNearestPoint(const Bezier& aBezier, const Point& aTarget,
// | | // | |
// v mPoints[0] | // v mPoints[0] |
// -------------+ // -------------+
void GetBezierPointsForCorner(Bezier* aBezier, mozilla::css::Corner aCorner, void GetBezierPointsForCorner(Bezier* aBezier, mozilla::Corner aCorner,
const Point& aCornerPoint, const Point& aCornerPoint,
const Size& aCornerSize); const Size& aCornerSize);

18
gfx/2d/Types.h
View file

@ -406,7 +406,6 @@ static inline Side& operator++(Side& side) {
return side; return side;
} }
namespace css {
enum Corner { enum Corner {
// This order is important! // This order is important!
eCornerTopLeft = 0, eCornerTopLeft = 0,
@ -415,23 +414,22 @@ enum Corner {
eCornerBottomLeft = 3, eCornerBottomLeft = 3,
eNumCorners = 4 eNumCorners = 4
}; };
} // namespace css
#define NS_CORNER_TOP_LEFT mozilla::css::eCornerTopLeft #define NS_CORNER_TOP_LEFT mozilla::eCornerTopLeft
#define NS_CORNER_TOP_RIGHT mozilla::css::eCornerTopRight #define NS_CORNER_TOP_RIGHT mozilla::eCornerTopRight
#define NS_CORNER_BOTTOM_RIGHT mozilla::css::eCornerBottomRight #define NS_CORNER_BOTTOM_RIGHT mozilla::eCornerBottomRight
#define NS_CORNER_BOTTOM_LEFT mozilla::css::eCornerBottomLeft #define NS_CORNER_BOTTOM_LEFT mozilla::eCornerBottomLeft
#define NS_NUM_CORNERS mozilla::css::eNumCorners #define NS_NUM_CORNERS mozilla::eNumCorners
#define NS_FOR_CSS_CORNERS(var_) \ #define NS_FOR_CSS_CORNERS(var_) \
for (mozilla::css::Corner var_ = NS_CORNER_TOP_LEFT; \ for (mozilla::Corner var_ = NS_CORNER_TOP_LEFT; \
var_ <= NS_CORNER_BOTTOM_LEFT; \ var_ <= NS_CORNER_BOTTOM_LEFT; \
var_++) var_++)
static inline mozilla::css::Corner operator++(mozilla::css::Corner& corner, int) { static inline mozilla::Corner operator++(mozilla::Corner& corner, int) {
MOZ_ASSERT(corner >= NS_CORNER_TOP_LEFT && MOZ_ASSERT(corner >= NS_CORNER_TOP_LEFT &&
corner < NS_NUM_CORNERS, "Out of range corner"); corner < NS_NUM_CORNERS, "Out of range corner");
corner = mozilla::css::Corner(corner + 1); corner = mozilla::Corner(corner + 1);
return corner; return corner;
} }

2
gfx/thebes/gfxRect.h
View file

@ -45,7 +45,7 @@ struct gfxRect :
*/ */
bool WithinEpsilonOfIntegerPixels(gfxFloat aEpsilon) const; bool WithinEpsilonOfIntegerPixels(gfxFloat aEpsilon) const;
gfxPoint AtCorner(mozilla::css::Corner corner) const { gfxPoint AtCorner(mozilla::Corner corner) const {
switch (corner) { switch (corner) {
case NS_CORNER_TOP_LEFT: return TopLeft(); case NS_CORNER_TOP_LEFT: return TopLeft();
case NS_CORNER_TOP_RIGHT: return TopRight(); case NS_CORNER_TOP_RIGHT: return TopRight();

2
layout/base/DottedCornerFinder.cpp
View file

@ -44,7 +44,7 @@ nsDataHashtable<FourFloatsHashKey, BestOverlap> DottedCornerCache;
DottedCornerFinder::DottedCornerFinder(const Bezier& aOuterBezier, DottedCornerFinder::DottedCornerFinder(const Bezier& aOuterBezier,
const Bezier& aInnerBezier, const Bezier& aInnerBezier,
mozilla::css::Corner aCorner, mozilla::Corner aCorner,
Float aBorderRadiusX, Float aBorderRadiusX,
Float aBorderRadiusY, Float aBorderRadiusY,
const Point& aC0, Float aR0, const Point& aC0, Float aR0,

4
layout/base/DottedCornerFinder.h
View file

@ -116,7 +116,7 @@ public:
// |<------->| // |<------->|
// aRn // aRn
DottedCornerFinder(const Bezier& aOuterBezier, const Bezier& aInnerBezier, DottedCornerFinder(const Bezier& aOuterBezier, const Bezier& aInnerBezier,
mozilla::css::Corner aCorner, mozilla::Corner aCorner,
Float aBorderRadiusX, Float aBorderRadiusY, Float aBorderRadiusX, Float aBorderRadiusY,
const Point& aC0, Float aR0, const Point& aCn, Float aRn, const Point& aC0, Float aR0, const Point& aCn, Float aRn,
const Size& aCornerDim); const Size& aCornerDim);
@ -150,7 +150,7 @@ private:
Bezier mInnerBezier; Bezier mInnerBezier;
Bezier mCenterBezier; Bezier mCenterBezier;
mozilla::css::Corner mCorner; mozilla::Corner mCorner;
// Sign of the normal vector used in radius calculation, flipped depends on // Sign of the normal vector used in radius calculation, flipped depends on
// corner and start and end radii. // corner and start and end radii.

42
layout/base/nsCSSRenderingBorders.cpp
View file

@ -67,8 +67,8 @@ static void ComputeBorderCornerDimensions(const Float* aBorderWidths,
#define PREV_SIDE(_s) mozilla::Side(((_s) + 3) & 3) #define PREV_SIDE(_s) mozilla::Side(((_s) + 3) & 3)
// given a corner index, get the previous and next corner index // given a corner index, get the previous and next corner index
#define NEXT_CORNER(_s) mozilla::css::Corner(((_s) + 1) & 3) #define NEXT_CORNER(_s) mozilla::Corner(((_s) + 1) & 3)
#define PREV_CORNER(_s) mozilla::css::Corner(((_s) + 3) & 3) #define PREV_CORNER(_s) mozilla::Corner(((_s) + 3) & 3)
// from the given base color and the background color, turn // from the given base color and the background color, turn
// color into a color for the given border pattern style // color into a color for the given border pattern style
@ -114,27 +114,27 @@ AllCornersZeroSize(const RectCornerRadii& corners) {
} }
static mozilla::Side static mozilla::Side
GetHorizontalSide(mozilla::css::Corner aCorner) GetHorizontalSide(mozilla::Corner aCorner)
{ {
return (aCorner == C_TL || aCorner == C_TR) ? eSideTop : eSideBottom; return (aCorner == C_TL || aCorner == C_TR) ? eSideTop : eSideBottom;
} }
static mozilla::Side static mozilla::Side
GetVerticalSide(mozilla::css::Corner aCorner) GetVerticalSide(mozilla::Corner aCorner)
{ {
return (aCorner == C_TL || aCorner == C_BL) ? eSideLeft : eSideRight; return (aCorner == C_TL || aCorner == C_BL) ? eSideLeft : eSideRight;
} }
static mozilla::css::Corner static mozilla::Corner
GetCWCorner(mozilla::Side aSide) GetCWCorner(mozilla::Side aSide)
{ {
return mozilla::css::Corner(NEXT_SIDE(aSide)); return mozilla::Corner(NEXT_SIDE(aSide));
} }
static mozilla::css::Corner static mozilla::Corner
GetCCWCorner(mozilla::Side aSide) GetCCWCorner(mozilla::Side aSide)
{ {
return mozilla::css::Corner(aSide); return mozilla::Corner(aSide);
} }
static bool static bool
@ -332,7 +332,7 @@ nsCSSBorderRenderer::AreBorderSideFinalStylesSame(uint8_t aSides)
} }
bool bool
nsCSSBorderRenderer::IsSolidCornerStyle(uint8_t aStyle, mozilla::css::Corner aCorner) nsCSSBorderRenderer::IsSolidCornerStyle(uint8_t aStyle, mozilla::Corner aCorner)
{ {
switch (aStyle) { switch (aStyle) {
case NS_STYLE_BORDER_STYLE_SOLID: case NS_STYLE_BORDER_STYLE_SOLID:
@ -355,7 +355,7 @@ nsCSSBorderRenderer::IsSolidCornerStyle(uint8_t aStyle, mozilla::css::Corner aCo
} }
bool bool
nsCSSBorderRenderer::IsCornerMergeable(mozilla::css::Corner aCorner) nsCSSBorderRenderer::IsCornerMergeable(mozilla::Corner aCorner)
{ {
// Corner between dotted borders with same width and small radii is // Corner between dotted borders with same width and small radii is
// merged into single dot. // merged into single dot.
@ -405,7 +405,7 @@ nsCSSBorderRenderer::IsCornerMergeable(mozilla::css::Corner aCorner)
} }
BorderColorStyle BorderColorStyle
nsCSSBorderRenderer::BorderColorStyleForSolidCorner(uint8_t aStyle, mozilla::css::Corner aCorner) nsCSSBorderRenderer::BorderColorStyleForSolidCorner(uint8_t aStyle, mozilla::Corner aCorner)
{ {
// note that this function assumes that the corner is already solid, // note that this function assumes that the corner is already solid,
// as per the earlier function // as per the earlier function
@ -435,7 +435,7 @@ nsCSSBorderRenderer::BorderColorStyleForSolidCorner(uint8_t aStyle, mozilla::css
} }
Rect Rect
nsCSSBorderRenderer::GetCornerRect(mozilla::css::Corner aCorner) nsCSSBorderRenderer::GetCornerRect(mozilla::Corner aCorner)
{ {
Point offset(0.f, 0.f); Point offset(0.f, 0.f);
@ -674,7 +674,7 @@ nsCSSBorderRenderer::GetSideClipSubPath(mozilla::Side aSide)
Point Point
nsCSSBorderRenderer::GetStraightBorderPoint(mozilla::Side aSide, nsCSSBorderRenderer::GetStraightBorderPoint(mozilla::Side aSide,
mozilla::css::Corner aCorner, mozilla::Corner aCorner,
bool* aIsUnfilled, bool* aIsUnfilled,
Float aDotOffset) Float aDotOffset)
@ -1070,7 +1070,7 @@ nsCSSBorderRenderer::GetStraightBorderPoint(mozilla::Side aSide,
void void
nsCSSBorderRenderer::GetOuterAndInnerBezier(Bezier* aOuterBezier, nsCSSBorderRenderer::GetOuterAndInnerBezier(Bezier* aOuterBezier,
Bezier* aInnerBezier, Bezier* aInnerBezier,
mozilla::css::Corner aCorner) mozilla::Corner aCorner)
{ {
// Return bezier control points for outer and inner curve for given corner. // Return bezier control points for outer and inner curve for given corner.
// //
@ -2308,7 +2308,7 @@ nsCSSBorderRenderer::DrawDottedSideSlow(mozilla::Side aSide)
void void
nsCSSBorderRenderer::DrawDashedOrDottedCorner(mozilla::Side aSide, nsCSSBorderRenderer::DrawDashedOrDottedCorner(mozilla::Side aSide,
mozilla::css::Corner aCorner) mozilla::Corner aCorner)
{ {
// Draw dashed/dotted corner with following approach. // Draw dashed/dotted corner with following approach.
// //
@ -2417,7 +2417,7 @@ nsCSSBorderRenderer::DrawDashedOrDottedCorner(mozilla::Side aSide,
void void
nsCSSBorderRenderer::DrawDottedCornerSlow(mozilla::Side aSide, nsCSSBorderRenderer::DrawDottedCornerSlow(mozilla::Side aSide,
mozilla::css::Corner aCorner) mozilla::Corner aCorner)
{ {
NS_ASSERTION(mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DOTTED, NS_ASSERTION(mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DOTTED,
"Style should be dotted."); "Style should be dotted.");
@ -2494,7 +2494,7 @@ DashedPathOverlapsRect(Rect& pathRect,
void void
nsCSSBorderRenderer::DrawDashedCornerSlow(mozilla::Side aSide, nsCSSBorderRenderer::DrawDashedCornerSlow(mozilla::Side aSide,
mozilla::css::Corner aCorner) mozilla::Corner aCorner)
{ {
NS_ASSERTION(mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DASHED, NS_ASSERTION(mBorderStyles[aSide] == NS_STYLE_BORDER_STYLE_DASHED,
"Style should be dashed."); "Style should be dashed.");
@ -2610,7 +2610,7 @@ nsCSSBorderRenderer::DrawDashedCornerSlow(mozilla::Side aSide,
void void
nsCSSBorderRenderer::DrawFallbackSolidCorner(mozilla::Side aSide, nsCSSBorderRenderer::DrawFallbackSolidCorner(mozilla::Side aSide,
mozilla::css::Corner aCorner) mozilla::Corner aCorner)
{ {
// Render too large dashed or dotted corner with solid style, to avoid hangup // Render too large dashed or dotted corner with solid style, to avoid hangup
// inside DashedCornerFinder and DottedCornerFinder. // inside DashedCornerFinder and DottedCornerFinder.
@ -2839,7 +2839,7 @@ ComputeCornerSkirtSize(Float aAlpha1, Float aAlpha2,
// seams when anti-aliased drawing is used. // seams when anti-aliased drawing is used.
static void static void
DrawBorderRadius(DrawTarget* aDrawTarget, DrawBorderRadius(DrawTarget* aDrawTarget,
mozilla::css::Corner c, mozilla::Corner c,
const Point& aOuterCorner, const Point& aInnerCorner, const Point& aOuterCorner, const Point& aInnerCorner,
const twoFloats& aCornerMultPrev, const twoFloats& aCornerMultNext, const twoFloats& aCornerMultPrev, const twoFloats& aCornerMultNext,
const Size& aCornerDims, const Size& aCornerDims,
@ -3046,8 +3046,8 @@ nsCSSBorderRenderer::DrawNoCompositeColorSolidBorder()
// Thus, the CCW corner of the next side will end up drawn here. // 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) // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
mozilla::css::Corner c = mozilla::css::Corner((i+1) % 4); mozilla::Corner c = mozilla::Corner((i+1) % 4);
mozilla::css::Corner prevCorner = mozilla::css::Corner(i); mozilla::Corner prevCorner = mozilla::Corner(i);
// i+2 and i+3 respectively. These are used to index into the corner // 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 // multiplier table, and were deduced by calculating out the long form

20
layout/base/nsCSSRenderingBorders.h
View file

@ -142,20 +142,20 @@ private:
bool AreBorderSideFinalStylesSame(uint8_t aSides); bool AreBorderSideFinalStylesSame(uint8_t aSides);
// For the given style, is the given corner a solid color? // For the given style, is the given corner a solid color?
bool IsSolidCornerStyle(uint8_t aStyle, mozilla::css::Corner aCorner); bool IsSolidCornerStyle(uint8_t aStyle, mozilla::Corner aCorner);
// For the given corner, is the given corner mergeable into one dot? // For the given corner, is the given corner mergeable into one dot?
bool IsCornerMergeable(mozilla::css::Corner aCorner); bool IsCornerMergeable(mozilla::Corner aCorner);
// For the given solid corner, what color style should be used? // For the given solid corner, what color style should be used?
BorderColorStyle BorderColorStyleForSolidCorner(uint8_t aStyle, mozilla::css::Corner aCorner); BorderColorStyle BorderColorStyleForSolidCorner(uint8_t aStyle, mozilla::Corner aCorner);
// //
// Path generation functions // Path generation functions
// //
// Get the Rect for drawing the given corner // Get the Rect for drawing the given corner
Rect GetCornerRect(mozilla::css::Corner aCorner); Rect GetCornerRect(mozilla::Corner aCorner);
// add the path for drawing the given side without any adjacent corners to the context // add the path for drawing the given side without any adjacent corners to the context
Rect GetSideClipWithoutCornersRect(mozilla::Side aSide); Rect GetSideClipWithoutCornersRect(mozilla::Side aSide);
@ -171,7 +171,7 @@ private:
// Return start or end point for dashed/dotted side // Return start or end point for dashed/dotted side
Point GetStraightBorderPoint(mozilla::Side aSide, Point GetStraightBorderPoint(mozilla::Side aSide,
mozilla::css::Corner aCorner, mozilla::Corner aCorner,
bool* aIsUnfilled, bool* aIsUnfilled,
Float aDotOffset = 0.0f); Float aDotOffset = 0.0f);
@ -179,7 +179,7 @@ private:
// corner // corner
void GetOuterAndInnerBezier(Bezier* aOuterBezier, void GetOuterAndInnerBezier(Bezier* aOuterBezier,
Bezier* aInnerBezier, Bezier* aInnerBezier,
mozilla::css::Corner aCorner); mozilla::Corner aCorner);
// Given a set of sides to fill and a color, do so in the fastest way. // Given a set of sides to fill and a color, do so in the fastest way.
// //
@ -224,19 +224,19 @@ private:
// Draw the given dashed/dotted corner // Draw the given dashed/dotted corner
void DrawDashedOrDottedCorner(mozilla::Side aSide, void DrawDashedOrDottedCorner(mozilla::Side aSide,
mozilla::css::Corner aCorner); mozilla::Corner aCorner);
// Draw the given dotted corner, each segment separately // Draw the given dotted corner, each segment separately
void DrawDottedCornerSlow(mozilla::Side aSide, void DrawDottedCornerSlow(mozilla::Side aSide,
mozilla::css::Corner aCorner); mozilla::Corner aCorner);
// Draw the given dashed corner, each dot separately // Draw the given dashed corner, each dot separately
void DrawDashedCornerSlow(mozilla::Side aSide, void DrawDashedCornerSlow(mozilla::Side aSide,
mozilla::css::Corner aCorner); mozilla::Corner aCorner);
// Draw the given dashed/dotted corner with solid style // Draw the given dashed/dotted corner with solid style
void DrawFallbackSolidCorner(mozilla::Side aSide, void DrawFallbackSolidCorner(mozilla::Side aSide,
mozilla::css::Corner aCorner); mozilla::Corner aCorner);
// Analyze if all border sides have the same width. // Analyze if all border sides have the same width.
bool AllBordersSameWidth(); bool AllBordersSameWidth();