--- a/gfx/2d/Types.h
+++ b/gfx/2d/Types.h
@@ -435,11 +435,24 @@ enum Corner {
static inline Corner operator++(Corner& aCorner) {
MOZ_ASSERT(aCorner >= eCornerTopLeft && aCorner <= eCornerBottomLeft,
"Out of range corner!");
aCorner = Corner(aCorner + 1);
return aCorner;
}
+// Indices into "half corner" arrays (nsStyleCorners e.g.)
+enum HalfCorner {
+ // This order is important!
+ eCornerTopLeftX = 0,
+ eCornerTopLeftY = 1,
+ eCornerTopRightX = 2,
+ eCornerTopRightY = 3,
+ eCornerBottomRightX = 4,
+ eCornerBottomRightY = 5,
+ eCornerBottomLeftX = 6,
+ eCornerBottomLeftY = 7
+};
+
} // namespace mozilla
#endif /* MOZILLA_GFX_TYPES_H_ */
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -2478,28 +2478,28 @@ nsLayoutUtils::RoundGfxRectToAppRect(con
nsRegion
nsLayoutUtils::RoundedRectIntersectRect(const nsRect& aRoundedRect,
const nscoord aRadii[8],
const nsRect& aContainedRect)
{
// rectFullHeight and rectFullWidth together will approximately contain
// the total area of the frame minus the rounded corners.
nsRect rectFullHeight = aRoundedRect;
- nscoord xDiff = std::max(aRadii[NS_CORNER_TOP_LEFT_X], aRadii[NS_CORNER_BOTTOM_LEFT_X]);
+ nscoord xDiff = std::max(aRadii[eCornerTopLeftX], aRadii[eCornerBottomLeftX]);
rectFullHeight.x += xDiff;
- rectFullHeight.width -= std::max(aRadii[NS_CORNER_TOP_RIGHT_X],
- aRadii[NS_CORNER_BOTTOM_RIGHT_X]) + xDiff;
+ rectFullHeight.width -= std::max(aRadii[eCornerTopRightX],
+ aRadii[eCornerBottomRightX]) + xDiff;
nsRect r1;
r1.IntersectRect(rectFullHeight, aContainedRect);
nsRect rectFullWidth = aRoundedRect;
- nscoord yDiff = std::max(aRadii[NS_CORNER_TOP_LEFT_Y], aRadii[NS_CORNER_TOP_RIGHT_Y]);
+ nscoord yDiff = std::max(aRadii[eCornerTopLeftY], aRadii[eCornerTopRightY]);
rectFullWidth.y += yDiff;
- rectFullWidth.height -= std::max(aRadii[NS_CORNER_BOTTOM_LEFT_Y],
- aRadii[NS_CORNER_BOTTOM_RIGHT_Y]) + yDiff;
+ rectFullWidth.height -= std::max(aRadii[eCornerBottomLeftY],
+ aRadii[eCornerBottomRightY]) + yDiff;
nsRect r2;
r2.IntersectRect(rectFullWidth, aContainedRect);
nsRegion result;
result.Or(r1, r2);
return result;
}
@@ -2571,27 +2571,27 @@ nsLayoutUtils::RoundedRectIntersectsRect
insets.right = aRoundedRect.XMost() - aTestRect.x;
insets.bottom = aRoundedRect.YMost() - aTestRect.y;
insets.left = aTestRect.XMost() - aRoundedRect.x;
// Check whether the bottom-right corner of aTestRect is inside the
// top left corner of aBounds when rounded by aRadii, etc. If any
// corner is not, then fail; otherwise succeed.
return CheckCorner(insets.left, insets.top,
- aRadii[NS_CORNER_TOP_LEFT_X],
- aRadii[NS_CORNER_TOP_LEFT_Y]) &&
+ aRadii[eCornerTopLeftX],
+ aRadii[eCornerTopLeftY]) &&
CheckCorner(insets.right, insets.top,
- aRadii[NS_CORNER_TOP_RIGHT_X],
- aRadii[NS_CORNER_TOP_RIGHT_Y]) &&
+ aRadii[eCornerTopRightX],
+ aRadii[eCornerTopRightY]) &&
CheckCorner(insets.right, insets.bottom,
- aRadii[NS_CORNER_BOTTOM_RIGHT_X],
- aRadii[NS_CORNER_BOTTOM_RIGHT_Y]) &&
+ aRadii[eCornerBottomRightX],
+ aRadii[eCornerBottomRightY]) &&
CheckCorner(insets.left, insets.bottom,
- aRadii[NS_CORNER_BOTTOM_LEFT_X],
- aRadii[NS_CORNER_BOTTOM_LEFT_Y]);
+ aRadii[eCornerBottomLeftX],
+ aRadii[eCornerBottomLeftY]);
}
nsRect
nsLayoutUtils::MatrixTransformRect(const nsRect &aBounds,
const Matrix4x4 &aMatrix, float aFactor)
{
RectDouble image = RectDouble(NSAppUnitsToDoublePixels(aBounds.x, aFactor),
NSAppUnitsToDoublePixels(aBounds.y, aFactor),
@@ -6798,24 +6798,24 @@ static bool IsCornerAdjacentToSide(uint8
return aSide == aCorner || aSide == ((aCorner - 1)&3);
}
/* static */ bool
nsLayoutUtils::HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
Side aSide)
{
- static_assert(NS_CORNER_TOP_LEFT_X/2 == eCornerTopLeft, "Check for Non Zero on side");
- static_assert(NS_CORNER_TOP_LEFT_Y/2 == eCornerTopLeft, "Check for Non Zero on side");
- static_assert(NS_CORNER_TOP_RIGHT_X/2 == eCornerTopRight, "Check for Non Zero on side");
- static_assert(NS_CORNER_TOP_RIGHT_Y/2 == eCornerTopRight, "Check for Non Zero on side");
- static_assert(NS_CORNER_BOTTOM_RIGHT_X/2 == eCornerBottomRight, "Check for Non Zero on side");
- static_assert(NS_CORNER_BOTTOM_RIGHT_Y/2 == eCornerBottomRight, "Check for Non Zero on side");
- static_assert(NS_CORNER_BOTTOM_LEFT_X/2 == eCornerBottomLeft, "Check for Non Zero on side");
- static_assert(NS_CORNER_BOTTOM_LEFT_Y/2 == eCornerBottomLeft, "Check for Non Zero on side");
+ static_assert(eCornerTopLeftX/2 == eCornerTopLeft, "Check for Non Zero on side");
+ static_assert(eCornerTopLeftY/2 == eCornerTopLeft, "Check for Non Zero on side");
+ static_assert(eCornerTopRightX/2 == eCornerTopRight, "Check for Non Zero on side");
+ static_assert(eCornerTopRightY/2 == eCornerTopRight, "Check for Non Zero on side");
+ static_assert(eCornerBottomRightX/2 == eCornerBottomRight, "Check for Non Zero on side");
+ static_assert(eCornerBottomRightY/2 == eCornerBottomRight, "Check for Non Zero on side");
+ static_assert(eCornerBottomLeftX/2 == eCornerBottomLeft, "Check for Non Zero on side");
+ static_assert(eCornerBottomLeftY/2 == eCornerBottomLeft, "Check for Non Zero on side");
NS_FOR_CSS_HALF_CORNERS(corner) {
// corner is a "half corner" value, so dividing by two gives us a
// "full corner" value.
if (NonZeroStyleCoord(aCorners.Get(corner)) &&
IsCornerAdjacentToSide(corner/2, aSide))
return true;
}
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -1266,41 +1266,41 @@ nsIFrame::ComputeBorderRadii(const nsSty
}
} else {
NS_NOTREACHED("ComputeBorderRadii: bad unit");
aRadii[i] = 0;
}
}
if (aSkipSides.Top()) {
- aRadii[NS_CORNER_TOP_LEFT_X] = 0;
- aRadii[NS_CORNER_TOP_LEFT_Y] = 0;
- aRadii[NS_CORNER_TOP_RIGHT_X] = 0;
- aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;
+ aRadii[eCornerTopLeftX] = 0;
+ aRadii[eCornerTopLeftY] = 0;
+ aRadii[eCornerTopRightX] = 0;
+ aRadii[eCornerTopRightY] = 0;
}
if (aSkipSides.Right()) {
- aRadii[NS_CORNER_TOP_RIGHT_X] = 0;
- aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;
- aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;
- aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;
+ aRadii[eCornerTopRightX] = 0;
+ aRadii[eCornerTopRightY] = 0;
+ aRadii[eCornerBottomRightX] = 0;
+ aRadii[eCornerBottomRightY] = 0;
}
if (aSkipSides.Bottom()) {
- aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;
- aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;
- aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;
- aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;
+ aRadii[eCornerBottomRightX] = 0;
+ aRadii[eCornerBottomRightY] = 0;
+ aRadii[eCornerBottomLeftX] = 0;
+ aRadii[eCornerBottomLeftY] = 0;
}
if (aSkipSides.Left()) {
- aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;
- aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;
- aRadii[NS_CORNER_TOP_LEFT_X] = 0;
- aRadii[NS_CORNER_TOP_LEFT_Y] = 0;
+ aRadii[eCornerBottomLeftX] = 0;
+ aRadii[eCornerBottomLeftY] = 0;
+ aRadii[eCornerTopLeftX] = 0;
+ aRadii[eCornerTopLeftY] = 0;
}
// css3-background specifies this algorithm for reducing
// corner radii when they are too big.
bool haveRadius = false;
double ratio = 1.0f;
NS_FOR_CSS_SIDES(side) {
uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, true);
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -5719,36 +5719,36 @@ ScrollFrameHelper::GetBorderRadii(const
// Since we can use GetActualScrollbarSizes (rather than
// GetDesiredScrollbarSizes) since this doesn't affect reflow, we
// probably should.
nsMargin sb = GetActualScrollbarSizes();
nsMargin border = mOuter->GetUsedBorder();
if (sb.left > 0 || sb.top > 0) {
ReduceRadii(border.left, border.top,
- aRadii[NS_CORNER_TOP_LEFT_X],
- aRadii[NS_CORNER_TOP_LEFT_Y]);
+ aRadii[eCornerTopLeftX],
+ aRadii[eCornerTopLeftY]);
}
if (sb.top > 0 || sb.right > 0) {
ReduceRadii(border.right, border.top,
- aRadii[NS_CORNER_TOP_RIGHT_X],
- aRadii[NS_CORNER_TOP_RIGHT_Y]);
+ aRadii[eCornerTopRightX],
+ aRadii[eCornerTopRightY]);
}
if (sb.right > 0 || sb.bottom > 0) {
ReduceRadii(border.right, border.bottom,
- aRadii[NS_CORNER_BOTTOM_RIGHT_X],
- aRadii[NS_CORNER_BOTTOM_RIGHT_Y]);
+ aRadii[eCornerBottomRightX],
+ aRadii[eCornerBottomRightY]);
}
if (sb.bottom > 0 || sb.left > 0) {
ReduceRadii(border.left, border.bottom,
- aRadii[NS_CORNER_BOTTOM_LEFT_X],
- aRadii[NS_CORNER_BOTTOM_LEFT_Y]);
+ aRadii[eCornerBottomLeftX],
+ aRadii[eCornerBottomLeftY]);
}
return true;
}
static nscoord
SnapCoord(nscoord aCoord, double aRes, nscoord aAppUnitsPerPixel)
{
--- a/layout/painting/DisplayItemClip.cpp
+++ b/layout/painting/DisplayItemClip.cpp
@@ -198,59 +198,59 @@ DisplayItemClip::IsRectClippedByRoundedC
return false;
nsRect rect;
rect.IntersectRect(aRect, NonRoundedIntersection());
for (uint32_t i = 0, iEnd = mRoundedClipRects.Length();
i < iEnd; ++i) {
const RoundedRect &rr = mRoundedClipRects[i];
// top left
- if (rect.x < rr.mRect.x + rr.mRadii[NS_CORNER_TOP_LEFT_X] &&
- rect.y < rr.mRect.y + rr.mRadii[NS_CORNER_TOP_LEFT_Y]) {
- if (!IsInsideEllipse(rr.mRadii[NS_CORNER_TOP_LEFT_X],
- rr.mRect.x + rr.mRadii[NS_CORNER_TOP_LEFT_X],
+ if (rect.x < rr.mRect.x + rr.mRadii[eCornerTopLeftX] &&
+ rect.y < rr.mRect.y + rr.mRadii[eCornerTopLeftY]) {
+ if (!IsInsideEllipse(rr.mRadii[eCornerTopLeftX],
+ rr.mRect.x + rr.mRadii[eCornerTopLeftX],
rect.x,
- rr.mRadii[NS_CORNER_TOP_LEFT_Y],
- rr.mRect.y + rr.mRadii[NS_CORNER_TOP_LEFT_Y],
+ rr.mRadii[eCornerTopLeftY],
+ rr.mRect.y + rr.mRadii[eCornerTopLeftY],
rect.y)) {
return true;
}
}
// top right
- if (rect.XMost() > rr.mRect.XMost() - rr.mRadii[NS_CORNER_TOP_RIGHT_X] &&
- rect.y < rr.mRect.y + rr.mRadii[NS_CORNER_TOP_RIGHT_Y]) {
- if (!IsInsideEllipse(rr.mRadii[NS_CORNER_TOP_RIGHT_X],
- rr.mRect.XMost() - rr.mRadii[NS_CORNER_TOP_RIGHT_X],
+ if (rect.XMost() > rr.mRect.XMost() - rr.mRadii[eCornerTopRightX] &&
+ rect.y < rr.mRect.y + rr.mRadii[eCornerTopRightY]) {
+ if (!IsInsideEllipse(rr.mRadii[eCornerTopRightX],
+ rr.mRect.XMost() - rr.mRadii[eCornerTopRightX],
rect.XMost(),
- rr.mRadii[NS_CORNER_TOP_RIGHT_Y],
- rr.mRect.y + rr.mRadii[NS_CORNER_TOP_RIGHT_Y],
+ rr.mRadii[eCornerTopRightY],
+ rr.mRect.y + rr.mRadii[eCornerTopRightY],
rect.y)) {
return true;
}
}
// bottom left
- if (rect.x < rr.mRect.x + rr.mRadii[NS_CORNER_BOTTOM_LEFT_X] &&
- rect.YMost() > rr.mRect.YMost() - rr.mRadii[NS_CORNER_BOTTOM_LEFT_Y]) {
- if (!IsInsideEllipse(rr.mRadii[NS_CORNER_BOTTOM_LEFT_X],
- rr.mRect.x + rr.mRadii[NS_CORNER_BOTTOM_LEFT_X],
+ if (rect.x < rr.mRect.x + rr.mRadii[eCornerBottomLeftX] &&
+ rect.YMost() > rr.mRect.YMost() - rr.mRadii[eCornerBottomLeftY]) {
+ if (!IsInsideEllipse(rr.mRadii[eCornerBottomLeftX],
+ rr.mRect.x + rr.mRadii[eCornerBottomLeftX],
rect.x,
- rr.mRadii[NS_CORNER_BOTTOM_LEFT_Y],
- rr.mRect.YMost() - rr.mRadii[NS_CORNER_BOTTOM_LEFT_Y],
+ rr.mRadii[eCornerBottomLeftY],
+ rr.mRect.YMost() - rr.mRadii[eCornerBottomLeftY],
rect.YMost())) {
return true;
}
}
// bottom right
- if (rect.XMost() > rr.mRect.XMost() - rr.mRadii[NS_CORNER_BOTTOM_RIGHT_X] &&
- rect.YMost() > rr.mRect.YMost() - rr.mRadii[NS_CORNER_BOTTOM_RIGHT_Y]) {
- if (!IsInsideEllipse(rr.mRadii[NS_CORNER_BOTTOM_RIGHT_X],
- rr.mRect.XMost() - rr.mRadii[NS_CORNER_BOTTOM_RIGHT_X],
+ if (rect.XMost() > rr.mRect.XMost() - rr.mRadii[eCornerBottomRightX] &&
+ rect.YMost() > rr.mRect.YMost() - rr.mRadii[eCornerBottomRightY]) {
+ if (!IsInsideEllipse(rr.mRadii[eCornerBottomRightX],
+ rr.mRect.XMost() - rr.mRadii[eCornerBottomRightX],
rect.XMost(),
- rr.mRadii[NS_CORNER_BOTTOM_RIGHT_Y],
- rr.mRect.YMost() - rr.mRadii[NS_CORNER_BOTTOM_RIGHT_Y],
+ rr.mRadii[eCornerBottomRightY],
+ rr.mRect.YMost() - rr.mRadii[eCornerBottomRightY],
rect.YMost())) {
return true;
}
}
}
return false;
}
--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -630,24 +630,24 @@ BoxDecorationRectForBackground(nsIFrame*
nsCSSRendering::ComputePixelRadii(const nscoord *aAppUnitsRadii,
nscoord aAppUnitsPerPixel,
RectCornerRadii *oBorderRadii)
{
Float radii[8];
NS_FOR_CSS_HALF_CORNERS(corner)
radii[corner] = Float(aAppUnitsRadii[corner]) / aAppUnitsPerPixel;
- (*oBorderRadii)[C_TL] = Size(radii[NS_CORNER_TOP_LEFT_X],
- radii[NS_CORNER_TOP_LEFT_Y]);
- (*oBorderRadii)[C_TR] = Size(radii[NS_CORNER_TOP_RIGHT_X],
- radii[NS_CORNER_TOP_RIGHT_Y]);
- (*oBorderRadii)[C_BR] = Size(radii[NS_CORNER_BOTTOM_RIGHT_X],
- radii[NS_CORNER_BOTTOM_RIGHT_Y]);
- (*oBorderRadii)[C_BL] = Size(radii[NS_CORNER_BOTTOM_LEFT_X],
- radii[NS_CORNER_BOTTOM_LEFT_Y]);
+ (*oBorderRadii)[C_TL] = Size(radii[eCornerTopLeftX],
+ radii[eCornerTopLeftY]);
+ (*oBorderRadii)[C_TR] = Size(radii[eCornerTopRightX],
+ radii[eCornerTopRightY]);
+ (*oBorderRadii)[C_BR] = Size(radii[eCornerBottomRightX],
+ radii[eCornerBottomRightY]);
+ (*oBorderRadii)[C_BL] = Size(radii[eCornerBottomLeftX],
+ radii[eCornerBottomLeftY]);
}
DrawResult
nsCSSRendering::PaintBorder(nsPresContext* aPresContext,
nsRenderingContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -4251,29 +4251,29 @@ nsDisplayBorder::CalculateBounds(const n
}
if (border.left > 0) {
result.OrWith(nsRect(borderBounds.X(), borderBounds.Y(), border.left, borderBounds.Height()));
}
nscoord radii[8];
if (mFrame->GetBorderRadii(radii)) {
if (border.left > 0 || border.top > 0) {
- nsSize cornerSize(radii[NS_CORNER_TOP_LEFT_X], radii[NS_CORNER_TOP_LEFT_Y]);
+ nsSize cornerSize(radii[eCornerTopLeftX], radii[eCornerTopLeftY]);
result.OrWith(nsRect(borderBounds.TopLeft(), cornerSize));
}
if (border.top > 0 || border.right > 0) {
- nsSize cornerSize(radii[NS_CORNER_TOP_RIGHT_X], radii[NS_CORNER_TOP_RIGHT_Y]);
+ nsSize cornerSize(radii[eCornerTopRightX], radii[eCornerTopRightY]);
result.OrWith(nsRect(borderBounds.TopRight() - nsPoint(cornerSize.width, 0), cornerSize));
}
if (border.right > 0 || border.bottom > 0) {
- nsSize cornerSize(radii[NS_CORNER_BOTTOM_RIGHT_X], radii[NS_CORNER_BOTTOM_RIGHT_Y]);
+ nsSize cornerSize(radii[eCornerBottomRightX], radii[eCornerBottomRightY]);
result.OrWith(nsRect(borderBounds.BottomRight() - nsPoint(cornerSize.width, cornerSize.height), cornerSize));
}
if (border.bottom > 0 || border.left > 0) {
- nsSize cornerSize(radii[NS_CORNER_BOTTOM_LEFT_X], radii[NS_CORNER_BOTTOM_LEFT_Y]);
+ nsSize cornerSize(radii[eCornerBottomLeftX], radii[eCornerBottomLeftY]);
result.OrWith(nsRect(borderBounds.BottomLeft() - nsPoint(0, cornerSize.height), cornerSize));
}
}
return result;
}
}
--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -11,26 +11,16 @@
#include "gfxRect.h"
#include "nsFont.h"
#include "X11UndefineNone.h"
// XXX fold this into nsStyleContext and group by nsStyleXXX struct
namespace mozilla {
-// Indices into "half corner" arrays (nsStyleCorners e.g.)
-#define NS_CORNER_TOP_LEFT_X 0
-#define NS_CORNER_TOP_LEFT_Y 1
-#define NS_CORNER_TOP_RIGHT_X 2
-#define NS_CORNER_TOP_RIGHT_Y 3
-#define NS_CORNER_BOTTOM_RIGHT_X 4
-#define NS_CORNER_BOTTOM_RIGHT_Y 5
-#define NS_CORNER_BOTTOM_LEFT_X 6
-#define NS_CORNER_BOTTOM_LEFT_Y 7
-
#define NS_FOR_CSS_HALF_CORNERS(var_) for (int32_t var_ = 0; var_ < 8; ++var_)
// The results of these conversion macros are exhaustively checked in
// nsStyleCoord.cpp.
// Arguments must not have side effects.
#define NS_HALF_CORNER_IS_X(var_) (!((var_)%2))
#define NS_HALF_TO_FULL_CORNER(var_) ((var_)/2)
--- a/layout/style/nsStyleCoord.cpp
+++ b/layout/style/nsStyleCoord.cpp
@@ -338,52 +338,52 @@ CASE(eSideTop, false);
CASE(eSideRight, true);
CASE(eSideBottom, false);
CASE(eSideLeft, true);
#undef CASE
#define CASE(corner, result) \
static_assert(NS_HALF_CORNER_IS_X(corner) == result, \
"NS_HALF_CORNER_IS_X is wrong")
-CASE(NS_CORNER_TOP_LEFT_X, true);
-CASE(NS_CORNER_TOP_LEFT_Y, false);
-CASE(NS_CORNER_TOP_RIGHT_X, true);
-CASE(NS_CORNER_TOP_RIGHT_Y, false);
-CASE(NS_CORNER_BOTTOM_RIGHT_X, true);
-CASE(NS_CORNER_BOTTOM_RIGHT_Y, false);
-CASE(NS_CORNER_BOTTOM_LEFT_X, true);
-CASE(NS_CORNER_BOTTOM_LEFT_Y, false);
+CASE(eCornerTopLeftX, true);
+CASE(eCornerTopLeftY, false);
+CASE(eCornerTopRightX, true);
+CASE(eCornerTopRightY, false);
+CASE(eCornerBottomRightX, true);
+CASE(eCornerBottomRightY, false);
+CASE(eCornerBottomLeftX, true);
+CASE(eCornerBottomLeftY, false);
#undef CASE
// Validation of NS_HALF_TO_FULL_CORNER.
#define CASE(corner, result) \
static_assert(NS_HALF_TO_FULL_CORNER(corner) == result, \
"NS_HALF_TO_FULL_CORNER is wrong")
-CASE(NS_CORNER_TOP_LEFT_X, eCornerTopLeft);
-CASE(NS_CORNER_TOP_LEFT_Y, eCornerTopLeft);
-CASE(NS_CORNER_TOP_RIGHT_X, eCornerTopRight);
-CASE(NS_CORNER_TOP_RIGHT_Y, eCornerTopRight);
-CASE(NS_CORNER_BOTTOM_RIGHT_X, eCornerBottomRight);
-CASE(NS_CORNER_BOTTOM_RIGHT_Y, eCornerBottomRight);
-CASE(NS_CORNER_BOTTOM_LEFT_X, eCornerBottomLeft);
-CASE(NS_CORNER_BOTTOM_LEFT_Y, eCornerBottomLeft);
+CASE(eCornerTopLeftX, eCornerTopLeft);
+CASE(eCornerTopLeftY, eCornerTopLeft);
+CASE(eCornerTopRightX, eCornerTopRight);
+CASE(eCornerTopRightY, eCornerTopRight);
+CASE(eCornerBottomRightX, eCornerBottomRight);
+CASE(eCornerBottomRightY, eCornerBottomRight);
+CASE(eCornerBottomLeftX, eCornerBottomLeft);
+CASE(eCornerBottomLeftY, eCornerBottomLeft);
#undef CASE
// Validation of NS_FULL_TO_HALF_CORNER.
#define CASE(corner, vert, result) \
static_assert(NS_FULL_TO_HALF_CORNER(corner, vert) == result, \
"NS_FULL_TO_HALF_CORNER is wrong")
-CASE(eCornerTopLeft, false, NS_CORNER_TOP_LEFT_X);
-CASE(eCornerTopLeft, true, NS_CORNER_TOP_LEFT_Y);
-CASE(eCornerTopRight, false, NS_CORNER_TOP_RIGHT_X);
-CASE(eCornerTopRight, true, NS_CORNER_TOP_RIGHT_Y);
-CASE(eCornerBottomRight, false, NS_CORNER_BOTTOM_RIGHT_X);
-CASE(eCornerBottomRight, true, NS_CORNER_BOTTOM_RIGHT_Y);
-CASE(eCornerBottomLeft, false, NS_CORNER_BOTTOM_LEFT_X);
-CASE(eCornerBottomLeft, true, NS_CORNER_BOTTOM_LEFT_Y);
+CASE(eCornerTopLeft, false, eCornerTopLeftX);
+CASE(eCornerTopLeft, true, eCornerTopLeftY);
+CASE(eCornerTopRight, false, eCornerTopRightX);
+CASE(eCornerTopRight, true, eCornerTopRightY);
+CASE(eCornerBottomRight, false, eCornerBottomRightX);
+CASE(eCornerBottomRight, true, eCornerBottomRightY);
+CASE(eCornerBottomLeft, false, eCornerBottomLeftX);
+CASE(eCornerBottomLeft, true, eCornerBottomLeftY);
#undef CASE
// Validation of NS_SIDE_TO_{FULL,HALF}_CORNER.
#define CASE(side, second, result) \
static_assert(NS_SIDE_TO_FULL_CORNER(side, second) == result, \
"NS_SIDE_TO_FULL_CORNER is wrong")
CASE(eSideTop, false, eCornerTopLeft);
CASE(eSideTop, true, eCornerTopRight);
@@ -396,28 +396,28 @@ CASE(eSideBottom, true, eCornerBottomLe
CASE(eSideLeft, false, eCornerBottomLeft);
CASE(eSideLeft, true, eCornerTopLeft);
#undef CASE
#define CASE(side, second, parallel, result) \
static_assert(NS_SIDE_TO_HALF_CORNER(side, second, parallel) == result, \
"NS_SIDE_TO_HALF_CORNER is wrong")
-CASE(eSideTop, false, true, NS_CORNER_TOP_LEFT_X);
-CASE(eSideTop, false, false, NS_CORNER_TOP_LEFT_Y);
-CASE(eSideTop, true, true, NS_CORNER_TOP_RIGHT_X);
-CASE(eSideTop, true, false, NS_CORNER_TOP_RIGHT_Y);
+CASE(eSideTop, false, true, eCornerTopLeftX);
+CASE(eSideTop, false, false, eCornerTopLeftY);
+CASE(eSideTop, true, true, eCornerTopRightX);
+CASE(eSideTop, true, false, eCornerTopRightY);
-CASE(eSideRight, false, false, NS_CORNER_TOP_RIGHT_X);
-CASE(eSideRight, false, true, NS_CORNER_TOP_RIGHT_Y);
-CASE(eSideRight, true, false, NS_CORNER_BOTTOM_RIGHT_X);
-CASE(eSideRight, true, true, NS_CORNER_BOTTOM_RIGHT_Y);
+CASE(eSideRight, false, false, eCornerTopRightX);
+CASE(eSideRight, false, true, eCornerTopRightY);
+CASE(eSideRight, true, false, eCornerBottomRightX);
+CASE(eSideRight, true, true, eCornerBottomRightY);
-CASE(eSideBottom, false, true, NS_CORNER_BOTTOM_RIGHT_X);
-CASE(eSideBottom, false, false, NS_CORNER_BOTTOM_RIGHT_Y);
-CASE(eSideBottom, true, true, NS_CORNER_BOTTOM_LEFT_X);
-CASE(eSideBottom, true, false, NS_CORNER_BOTTOM_LEFT_Y);
+CASE(eSideBottom, false, true, eCornerBottomRightX);
+CASE(eSideBottom, false, false, eCornerBottomRightY);
+CASE(eSideBottom, true, true, eCornerBottomLeftX);
+CASE(eSideBottom, true, false, eCornerBottomLeftY);
-CASE(eSideLeft, false, false, NS_CORNER_BOTTOM_LEFT_X);
-CASE(eSideLeft, false, true, NS_CORNER_BOTTOM_LEFT_Y);
-CASE(eSideLeft, true, false, NS_CORNER_TOP_LEFT_X);
-CASE(eSideLeft, true, true, NS_CORNER_TOP_LEFT_Y);
+CASE(eSideLeft, false, false, eCornerBottomLeftX);
+CASE(eSideLeft, false, true, eCornerBottomLeftY);
+CASE(eSideLeft, true, false, eCornerTopLeftX);
+CASE(eSideLeft, true, true, eCornerTopLeftY);
#undef CASE