--- a/gfx/public/gfxCore.h
+++ b/gfx/public/gfxCore.h
@@ -36,20 +36,25 @@
* ***** END LICENSE BLOCK ***** */
#ifndef gfxCore_h__
#define gfxCore_h__
#include "nscore.h"
// Side constants for use in various places
-#define NS_SIDE_TOP 0
-#define NS_SIDE_RIGHT 1
-#define NS_SIDE_BOTTOM 2
-#define NS_SIDE_LEFT 3
+namespace mozilla {
+ namespace css {
+ enum Side {eSideTop, eSideRight, eSideBottom, eSideLeft};
+ }
+}
+#define NS_SIDE_TOP mozilla::css::eSideTop
+#define NS_SIDE_RIGHT mozilla::css::eSideRight
+#define NS_SIDE_BOTTOM mozilla::css::eSideBottom
+#define NS_SIDE_LEFT mozilla::css::eSideLeft
#if defined(MOZ_ENABLE_LIBXUL) || !defined(MOZILLA_INTERNAL_API)
# define NS_GFX
# define NS_GFX_(type) type
# define NS_GFX_STATIC_MEMBER_(type) type
#elif defined(_IMPL_NS_GFX)
# define NS_GFX NS_EXPORT
# define NS_GFX_(type) NS_EXPORT_(type)
--- a/gfx/public/nsMargin.h
+++ b/gfx/public/nsMargin.h
@@ -59,29 +59,25 @@ struct nsMargin {
nscoord aRight, nscoord aBottom) {left += aLeft; top += aTop;
right += aRight; bottom += aBottom;}
nscoord LeftRight() const { return left + right; }
nscoord TopBottom() const { return top + bottom; }
nsPoint TopLeft() const { return nsPoint(left, top); }
-#if (NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3)
- nscoord& side(PRUint8 aSide) {
+ nscoord& side(mozilla::css::Side aSide) {
NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
return *(&top + aSide);
}
- nscoord side(PRUint8 aSide) const {
+ nscoord side(mozilla::css::Side aSide) const {
NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
return *(&top + aSide);
}
-#else
-#error "Somebody changed the side constants."
-#endif
// Overloaded operators. Note that '=' isn't defined so we'll get the
// compiler generated default assignment operator
PRBool operator==(const nsMargin& aMargin) const {
return (PRBool) ((left == aMargin.left) && (top == aMargin.top) &&
(right == aMargin.right) && (bottom == aMargin.bottom));
}
PRBool operator!=(const nsMargin& aMargin) const {
@@ -123,22 +119,22 @@ struct nsIntMargin {
PRInt32 aRight, PRInt32 aBottom) {left = aLeft; top = aTop;
right = aRight; bottom = aBottom;}
PRInt32 LeftRight() const { return left + right; }
PRInt32 TopBottom() const { return top + bottom; }
nsPoint TopLeft() const { return nsPoint(left, top); }
- PRInt32& side(PRUint8 aSide) {
+ PRInt32& side(mozilla::css::Side aSide) {
NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
return *(&top + aSide);
}
- PRInt32 side(PRUint8 aSide) const {
+ PRInt32 side(mozilla::css::Side aSide) const {
NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
return *(&top + aSide);
}
PRBool operator!=(const nsIntMargin& aMargin) const {
return (PRBool) ((left != aMargin.left) || (top != aMargin.top) ||
(right != aMargin.right) || (bottom != aMargin.bottom));
}
--- a/gfx/src/nsRect.cpp
+++ b/gfx/src/nsRect.cpp
@@ -33,16 +33,20 @@
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsRect.h"
#include "nsString.h"
#include "nsIDeviceContext.h"
+#include "prlog.h"
+
+// the mozilla::css::Side sequence must match the nsMargin nscoord sequence
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
// Containment
PRBool nsRect::Contains(nscoord aX, nscoord aY) const
{
return (PRBool) ((aX >= x) && (aY >= y) &&
(aX < XMost()) && (aY < YMost()));
}
--- a/gfx/thebes/public/gfxRect.h
+++ b/gfx/thebes/public/gfxRect.h
@@ -35,30 +35,47 @@
*
* ***** END LICENSE BLOCK ***** */
#ifndef GFX_RECT_H
#define GFX_RECT_H
#include "gfxTypes.h"
#include "gfxPoint.h"
+#include "gfxCore.h"
#include "nsDebug.h"
-struct THEBES_API gfxCorner {
- typedef int Corner;
- enum {
- // this order is important!
- TOP_LEFT = 0,
- TOP_RIGHT = 1,
- BOTTOM_RIGHT = 2,
- BOTTOM_LEFT = 3,
- NUM_CORNERS = 4
- };
-};
+namespace mozilla {
+ namespace css {
+ enum Corner {
+ // this order is important!
+ eCornerTopLeft = 0,
+ eCornerTopRight = 1,
+ eCornerBottomRight = 2,
+ eCornerBottomLeft = 3,
+ eNumCorners = 4
+ };
+ }
+}
+#define NS_CORNER_TOP_LEFT mozilla::css::eCornerTopLeft
+#define NS_CORNER_TOP_RIGHT mozilla::css::eCornerTopRight
+#define NS_CORNER_BOTTOM_RIGHT mozilla::css::eCornerBottomRight
+#define NS_CORNER_BOTTOM_LEFT mozilla::css::eCornerBottomLeft
+#define NS_NUM_CORNERS mozilla::css::eNumCorners
+#define NS_FOR_CSS_CORNERS(var_) \
+ for (mozilla::css::Corner var_ = NS_CORNER_TOP_LEFT; \
+ var_ <= NS_CORNER_BOTTOM_LEFT; \
+ var_++)
+
+static inline mozilla::css::Corner operator++(mozilla::css::Corner& corner, int) {
+ NS_PRECONDITION(corner < NS_CORNER_TOP_LEFT, "Out of range corner");
+ corner = mozilla::css::Corner(corner + 1);
+ return corner;
+}
struct THEBES_API gfxRect {
// pt? point?
gfxPoint pos;
gfxSize size;
gfxRect() {}
gfxRect(const gfxRect& s) : pos(s.pos), size(s.size) {}
@@ -159,29 +176,55 @@ struct THEBES_API gfxRect {
void RoundOut();
// grabbing specific points
gfxPoint TopLeft() const { return gfxPoint(pos); }
gfxPoint TopRight() const { return pos + gfxSize(size.width, 0.0); }
gfxPoint BottomLeft() const { return pos + gfxSize(0.0, size.height); }
gfxPoint BottomRight() const { return pos + size; }
- gfxPoint Corner(gfxCorner::Corner corner) const {
+ gfxPoint AtCorner(mozilla::css::Corner corner) const {
switch (corner) {
- case gfxCorner::TOP_LEFT: return TopLeft();
- case gfxCorner::TOP_RIGHT: return TopRight();
- case gfxCorner::BOTTOM_LEFT: return BottomLeft();
- case gfxCorner::BOTTOM_RIGHT: return BottomRight();
+ case NS_CORNER_TOP_LEFT: return TopLeft();
+ case NS_CORNER_TOP_RIGHT: return TopRight();
+ case NS_CORNER_BOTTOM_RIGHT: return BottomRight();
+ case NS_CORNER_BOTTOM_LEFT: return BottomLeft();
default:
NS_ERROR("Invalid corner!");
break;
}
return gfxPoint(0.0, 0.0);
}
+ gfxPoint CCWCorner(mozilla::css::Side side) const {
+ switch (side) {
+ case NS_SIDE_TOP: return TopLeft();
+ case NS_SIDE_RIGHT: return TopRight();
+ case NS_SIDE_BOTTOM: return BottomRight();
+ case NS_SIDE_LEFT: return BottomLeft();
+ default:
+ NS_ERROR("Invalid side!");
+ break;
+ }
+ return gfxPoint(0.0, 0.0);
+ }
+
+ gfxPoint CWCorner(mozilla::css::Side side) const {
+ switch (side) {
+ case NS_SIDE_TOP: return TopRight();
+ case NS_SIDE_RIGHT: return BottomRight();
+ case NS_SIDE_BOTTOM: return BottomLeft();
+ case NS_SIDE_LEFT: return TopLeft();
+ default:
+ NS_ERROR("Invalid side!");
+ break;
+ }
+ return gfxPoint(0.0, 0.0);
+ }
+
/* Conditions this border to Cairo's max coordinate space.
* The caller can check IsEmpty() after Condition() -- if it's TRUE,
* the caller can possibly avoid doing any extra rendering.
*/
void Condition();
void Scale(gfxFloat k) {
NS_ASSERTION(k >= 0.0, "Invalid (negative) scale factor");
@@ -205,52 +248,52 @@ struct THEBES_API gfxRect {
pos.x /= k;
pos.y /= k;
size.width /= k;
size.height /= k;
}
};
struct THEBES_API gfxCornerSizes {
- gfxSize sizes[gfxCorner::NUM_CORNERS];
+ gfxSize sizes[NS_NUM_CORNERS];
gfxCornerSizes () { }
gfxCornerSizes (gfxFloat v) {
- for (int i = 0; i < gfxCorner::NUM_CORNERS; i++)
+ for (int i = 0; i < NS_NUM_CORNERS; i++)
sizes[i].SizeTo(v, v);
}
gfxCornerSizes (gfxFloat tl, gfxFloat tr, gfxFloat br, gfxFloat bl) {
- sizes[gfxCorner::TOP_LEFT].SizeTo(tl, tl);
- sizes[gfxCorner::TOP_RIGHT].SizeTo(tr, tr);
- sizes[gfxCorner::BOTTOM_RIGHT].SizeTo(br, br);
- sizes[gfxCorner::BOTTOM_LEFT].SizeTo(bl, bl);
+ sizes[NS_CORNER_TOP_LEFT].SizeTo(tl, tl);
+ sizes[NS_CORNER_TOP_RIGHT].SizeTo(tr, tr);
+ sizes[NS_CORNER_BOTTOM_RIGHT].SizeTo(br, br);
+ sizes[NS_CORNER_BOTTOM_LEFT].SizeTo(bl, bl);
}
gfxCornerSizes (const gfxSize& tl, const gfxSize& tr, const gfxSize& br, const gfxSize& bl) {
- sizes[gfxCorner::TOP_LEFT] = tl;
- sizes[gfxCorner::TOP_RIGHT] = tr;
- sizes[gfxCorner::BOTTOM_RIGHT] = br;
- sizes[gfxCorner::BOTTOM_LEFT] = bl;
+ sizes[NS_CORNER_TOP_LEFT] = tl;
+ sizes[NS_CORNER_TOP_RIGHT] = tr;
+ sizes[NS_CORNER_BOTTOM_RIGHT] = br;
+ sizes[NS_CORNER_BOTTOM_LEFT] = bl;
}
- const gfxSize& operator[] (gfxCorner::Corner index) const {
+ const gfxSize& operator[] (mozilla::css::Corner index) const {
return sizes[index];
}
- gfxSize& operator[] (gfxCorner::Corner index) {
+ gfxSize& operator[] (mozilla::css::Corner index) {
return sizes[index];
}
- const gfxSize TopLeft() const { return sizes[gfxCorner::TOP_LEFT]; }
- gfxSize& TopLeft() { return sizes[gfxCorner::TOP_LEFT]; }
+ const gfxSize TopLeft() const { return sizes[NS_CORNER_TOP_LEFT]; }
+ gfxSize& TopLeft() { return sizes[NS_CORNER_TOP_LEFT]; }
- const gfxSize TopRight() const { return sizes[gfxCorner::TOP_RIGHT]; }
- gfxSize& TopRight() { return sizes[gfxCorner::TOP_RIGHT]; }
+ const gfxSize TopRight() const { return sizes[NS_CORNER_TOP_RIGHT]; }
+ gfxSize& TopRight() { return sizes[NS_CORNER_TOP_RIGHT]; }
- const gfxSize BottomLeft() const { return sizes[gfxCorner::BOTTOM_LEFT]; }
- gfxSize& BottomLeft() { return sizes[gfxCorner::BOTTOM_LEFT]; }
+ const gfxSize BottomLeft() const { return sizes[NS_CORNER_BOTTOM_LEFT]; }
+ gfxSize& BottomLeft() { return sizes[NS_CORNER_BOTTOM_LEFT]; }
- const gfxSize BottomRight() const { return sizes[gfxCorner::BOTTOM_RIGHT]; }
- gfxSize& BottomRight() { return sizes[gfxCorner::BOTTOM_RIGHT]; }
+ const gfxSize BottomRight() const { return sizes[NS_CORNER_BOTTOM_RIGHT]; }
+ gfxSize& BottomRight() { return sizes[NS_CORNER_BOTTOM_RIGHT]; }
};
#endif /* GFX_RECT_H */
--- a/gfx/thebes/src/gfxContext.cpp
+++ b/gfx/thebes/src/gfxContext.cpp
@@ -888,31 +888,31 @@ gfxContext::RoundedRectangle(const gfxRe
{ -1, 0 },
{ 0, +1 } };
twoFloats *cornerMults = draw_clockwise ? cwCornerMults : ccwCornerMults;
gfxPoint pc, p0, p1, p2, p3;
if (draw_clockwise)
- cairo_move_to(mCairo, rect.pos.x + corners[gfxCorner::TOP_LEFT].width, rect.pos.y);
+ cairo_move_to(mCairo, rect.pos.x + corners[NS_CORNER_TOP_LEFT].width, rect.pos.y);
else
- cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[gfxCorner::TOP_RIGHT].width, rect.pos.y);
+ cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[NS_CORNER_TOP_RIGHT].width, rect.pos.y);
- for (int i = 0; i < gfxCorner::NUM_CORNERS; i++) {
+ NS_FOR_CSS_CORNERS(i) {
// the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
- int c = draw_clockwise ? ((i+1) % 4) : ((4-i) % 4);
+ mozilla::css::Corner c = mozilla::css::Corner(draw_clockwise ? ((i+1) % 4) : ((4-i) % 4));
// 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 i2 = (i+2) % 4;
int i3 = (i+3) % 4;
- pc = rect.Corner(c);
+ pc = rect.AtCorner(c);
if (corners[c].width > 0.0 && corners[c].height > 0.0) {
p0.x = pc.x + cornerMults[i].a * corners[c].width;
p0.y = pc.y + cornerMults[i].b * corners[c].height;
p3.x = pc.x + cornerMults[i3].a * corners[c].width;
p3.y = pc.y + cornerMults[i3].b * corners[c].height;
--- a/layout/base/nsCSSRendering.cpp
+++ b/layout/base/nsCSSRendering.cpp
@@ -371,17 +371,17 @@ static void DrawBorderImageComponent(nsI
const nsRect& aFill,
const nsIntRect& aSrc,
PRUint8 aHFill,
PRUint8 aVFill,
const nsSize& aUnitSize,
const nsStyleBorder& aStyleBorder,
PRUint8 aIndex);
-static nscolor MakeBevelColor(PRIntn whichSide, PRUint8 style,
+static nscolor MakeBevelColor(mozilla::css::Side whichSide, PRUint8 style,
nscolor aBackgroundColor,
nscolor aBorderColor);
static InlineBackgroundData* gInlineBGData = nsnull;
// Initialize any static variables used by nsCSSRendering.
nsresult nsCSSRendering::Init()
{
@@ -399,17 +399,17 @@ void nsCSSRendering::Shutdown()
delete gInlineBGData;
gInlineBGData = nsnull;
}
/**
* Make a bevel color
*/
static nscolor
-MakeBevelColor(PRIntn whichSide, PRUint8 style,
+MakeBevelColor(mozilla::css::Side whichSide, PRUint8 style,
nscolor aBackgroundColor, nscolor aBorderColor)
{
nscolor colors[2];
nscolor theColor;
// Given a background color and a border color
// calculate the color used for the shading
@@ -1471,17 +1471,17 @@ nsCSSRendering::PaintBackground(nsPresCo
PaintBackgroundWithSC(aPresContext, aRenderingContext, aForFrame,
aDirtyRect, aBorderArea, sc,
*aForFrame->GetStyleBorder(), aFlags,
aBGClipRect);
}
static PRBool
-IsOpaqueBorderEdge(const nsStyleBorder& aBorder, PRUint32 aSide)
+IsOpaqueBorderEdge(const nsStyleBorder& aBorder, mozilla::css::Side aSide)
{
if (aBorder.GetActualBorder().side(aSide) == 0)
return PR_TRUE;
switch (aBorder.GetBorderStyle(aSide)) {
case NS_STYLE_BORDER_STYLE_SOLID:
case NS_STYLE_BORDER_STYLE_GROOVE:
case NS_STYLE_BORDER_STYLE_RIDGE:
case NS_STYLE_BORDER_STYLE_INSET:
@@ -1513,17 +1513,17 @@ IsOpaqueBorderEdge(const nsStyleBorder&
/**
* Returns true if all border edges are either missing or opaque.
*/
static PRBool
IsOpaqueBorder(const nsStyleBorder& aBorder)
{
if (aBorder.mBorderColors)
return PR_FALSE;
- for (PRUint32 i = 0; i < 4; ++i) {
+ NS_FOR_CSS_SIDES(i) {
if (!IsOpaqueBorderEdge(aBorder, i))
return PR_FALSE;
}
return PR_TRUE;
}
static inline void
SetupDirtyRects(const nsRect& aBGClipArea, const nsRect& aCallerDirtyRect,
@@ -3076,17 +3076,17 @@ nsCSSRendering::DrawTableBorderSegment(n
DrawSolidBorderSegment(aContext, aBorder, twipsPerPixel, aStartBevelSide, aStartBevelOffset,
aEndBevelSide, aEndBevelOffset);
}
else {
nscoord startBevel = (aStartBevelOffset > 0)
? RoundFloatToPixel(0.5f * (float)aStartBevelOffset, twipsPerPixel, PR_TRUE) : 0;
nscoord endBevel = (aEndBevelOffset > 0)
? RoundFloatToPixel(0.5f * (float)aEndBevelOffset, twipsPerPixel, PR_TRUE) : 0;
- PRUint8 ridgeGrooveSide = (horizontal) ? NS_SIDE_TOP : NS_SIDE_LEFT;
+ mozilla::css::Side ridgeGrooveSide = (horizontal) ? NS_SIDE_TOP : NS_SIDE_LEFT;
// FIXME: In theory, this should use the visited-dependent
// background color, but I don't care.
aContext.SetColor (
MakeBevelColor(ridgeGrooveSide, ridgeGroove, aBGColor->mBackgroundColor, aBorderColor));
nsRect rect(aBorder);
nscoord half;
if (horizontal) { // top, bottom
half = RoundFloatToPixel(0.5f * (float)aBorder.height, twipsPerPixel);
--- a/layout/base/nsCSSRenderingBorders.cpp
+++ b/layout/base/nsCSSRenderingBorders.cpp
@@ -92,18 +92,18 @@
*/
static void ComputeBorderCornerDimensions(const gfxRect& aOuterRect,
const gfxRect& aInnerRect,
const gfxCornerSizes& aRadii,
gfxCornerSizes *aDimsResult);
// given a side index, get the previous and next side index
-#define NEXT_SIDE(_s) (((_s) + 1) & 3)
-#define PREV_SIDE(_s) (((_s) + 3) & 3)
+#define NEXT_SIDE(_s) mozilla::css::Side(((_s) + 1) & 3)
+#define PREV_SIDE(_s) mozilla::css::Side(((_s) + 3) & 3)
// from the given base color and the background color, turn
// color into a color for the given border pattern style
static gfxRGBA MakeBorderColor(const gfxRGBA& aColor,
const gfxRGBA& aBackgroundColor,
BorderColorStyle aBorderColorStyle);
@@ -132,20 +132,20 @@ CheckFourFloatsEqual(const gfxFloat *val
static bool
IsZeroSize(const gfxSize& sz) {
return sz.width == 0.0 || sz.height == 0.0;
}
static bool
AllCornersZeroSize(const gfxCornerSizes& corners) {
- return IsZeroSize(corners[0]) &&
- IsZeroSize(corners[1]) &&
- IsZeroSize(corners[2]) &&
- IsZeroSize(corners[3]);
+ return IsZeroSize(corners[NS_CORNER_TOP_LEFT]) &&
+ IsZeroSize(corners[NS_CORNER_TOP_RIGHT]) &&
+ IsZeroSize(corners[NS_CORNER_BOTTOM_RIGHT]) &&
+ IsZeroSize(corners[NS_CORNER_BOTTOM_LEFT]);
}
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,
@@ -281,88 +281,88 @@ nsCSSBorderRenderer::AreBorderSideFinalS
return ((aSides & ~(SIDE_BIT_TOP | SIDE_BIT_LEFT)) == 0 ||
(aSides & ~(SIDE_BIT_BOTTOM | SIDE_BIT_RIGHT)) == 0);
}
return PR_TRUE;
}
PRBool
-nsCSSBorderRenderer::IsSolidCornerStyle(PRUint8 aStyle, gfxCorner::Corner aCorner)
+nsCSSBorderRenderer::IsSolidCornerStyle(PRUint8 aStyle, mozilla::css::Corner aCorner)
{
switch (aStyle) {
case NS_STYLE_BORDER_STYLE_DOTTED:
case NS_STYLE_BORDER_STYLE_DASHED:
case NS_STYLE_BORDER_STYLE_SOLID:
return PR_TRUE;
case NS_STYLE_BORDER_STYLE_INSET:
case NS_STYLE_BORDER_STYLE_OUTSET:
- return (aCorner == gfxCorner::TOP_LEFT || aCorner == gfxCorner::BOTTOM_RIGHT);
+ return (aCorner == NS_CORNER_TOP_LEFT || aCorner == NS_CORNER_BOTTOM_RIGHT);
case NS_STYLE_BORDER_STYLE_GROOVE:
case NS_STYLE_BORDER_STYLE_RIDGE:
- return mOneUnitBorder && (aCorner == gfxCorner::TOP_LEFT || aCorner == gfxCorner::BOTTOM_RIGHT);
+ return mOneUnitBorder && (aCorner == NS_CORNER_TOP_LEFT || aCorner == NS_CORNER_BOTTOM_RIGHT);
case NS_STYLE_BORDER_STYLE_DOUBLE:
return mOneUnitBorder;
default:
return PR_FALSE;
}
}
BorderColorStyle
-nsCSSBorderRenderer::BorderColorStyleForSolidCorner(PRUint8 aStyle, gfxCorner::Corner aCorner)
+nsCSSBorderRenderer::BorderColorStyleForSolidCorner(PRUint8 aStyle, mozilla::css::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_DOTTED:
case NS_STYLE_BORDER_STYLE_DASHED:
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 == gfxCorner::TOP_LEFT)
+ if (aCorner == NS_CORNER_TOP_LEFT)
return BorderColorStyleDark;
- else if (aCorner == gfxCorner::BOTTOM_RIGHT)
+ else if (aCorner == NS_CORNER_BOTTOM_RIGHT)
return BorderColorStyleLight;
break;
case NS_STYLE_BORDER_STYLE_OUTSET:
case NS_STYLE_BORDER_STYLE_RIDGE:
- if (aCorner == gfxCorner::TOP_LEFT)
+ if (aCorner == NS_CORNER_TOP_LEFT)
return BorderColorStyleLight;
- else if (aCorner == gfxCorner::BOTTOM_RIGHT)
+ else if (aCorner == NS_CORNER_BOTTOM_RIGHT)
return BorderColorStyleDark;
break;
}
return BorderColorStyleNone;
}
void
-nsCSSBorderRenderer::DoCornerSubPath(PRUint8 aCorner)
+nsCSSBorderRenderer::DoCornerSubPath(mozilla::css::Corner aCorner)
{
gfxPoint offset(0.0, 0.0);
if (aCorner == C_TR || aCorner == C_BR)
offset.x = mOuterRect.size.width - mBorderCornerDimensions[aCorner].width;
if (aCorner == C_BR || aCorner == C_BL)
offset.y = mOuterRect.size.height - mBorderCornerDimensions[aCorner].height;
mContext->Rectangle(gfxRect(mOuterRect.pos + offset,
mBorderCornerDimensions[aCorner]));
}
void
-nsCSSBorderRenderer::DoSideClipWithoutCornersSubPath(PRUint8 aSide)
+nsCSSBorderRenderer::DoSideClipWithoutCornersSubPath(mozilla::css::Side aSide)
{
gfxPoint offset(0.0, 0.0);
// 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.
@@ -377,17 +377,18 @@ nsCSSBorderRenderer::DoSideClipWithoutCo
} else if (aSide == NS_SIDE_LEFT) {
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.
- gfxSize sideCornerSum = mBorderCornerDimensions[aSide] + mBorderCornerDimensions[NEXT_SIDE(aSide)];
+ gfxSize sideCornerSum = mBorderCornerDimensions[mozilla::css::Corner(aSide)]
+ + mBorderCornerDimensions[mozilla::css::Corner(NEXT_SIDE(aSide))];
gfxRect rect(mOuterRect.pos + offset,
mOuterRect.size - sideCornerSum);
if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
rect.size.height = mBorderWidths[aSide];
else
rect.size.width = mBorderWidths[aSide];
@@ -430,17 +431,17 @@ MaybeMoveToMidPoint(gfxPoint& aP0, gfxPo
if (ps.x != 0.0 && ps.y != 0.0) {
gfxFloat k = NS_MIN((aMidPoint.x - aP0.x) / ps.x,
(aMidPoint.y - aP1.y) / ps.y);
aP1 = aP0 + ps * k;
}
}
void
-nsCSSBorderRenderer::DoSideClipSubPath(PRUint8 aSide)
+nsCSSBorderRenderer::DoSideClipSubPath(mozilla::css::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
@@ -454,50 +455,50 @@ nsCSSBorderRenderer::DoSideClipSubPath(P
PRBool isDashed = IS_DASHED_OR_DOTTED(mBorderStyles[aSide]);
PRBool startIsDashed = IS_DASHED_OR_DOTTED(mBorderStyles[PREV_SIDE(aSide)]);
PRBool endIsDashed = IS_DASHED_OR_DOTTED(mBorderStyles[NEXT_SIDE(aSide)]);
#undef IS_DASHED_OR_DOTTED
SideClipType startType = SIDE_CLIP_TRAPEZOID;
SideClipType endType = SIDE_CLIP_TRAPEZOID;
- if (!IsZeroSize(mBorderRadii[aSide]))
+ if (!IsZeroSize(mBorderRadii[mozilla::css::Corner(aSide)]))
startType = SIDE_CLIP_TRAPEZOID_FULL;
else if (startIsDashed && isDashed)
startType = SIDE_CLIP_RECTANGLE;
- if (!IsZeroSize(mBorderRadii[NEXT_SIDE(aSide)]))
+ if (!IsZeroSize(mBorderRadii[mozilla::css::Corner(NEXT_SIDE(aSide))]))
endType = SIDE_CLIP_TRAPEZOID_FULL;
else if (endIsDashed && isDashed)
endType = SIDE_CLIP_RECTANGLE;
gfxPoint midPoint = mInnerRect.pos + mInnerRect.size / 2.0;
- start[0] = mOuterRect.Corner(aSide);
- start[1] = mInnerRect.Corner(aSide);
+ start[0] = mOuterRect.CCWCorner(aSide);
+ start[1] = mInnerRect.CCWCorner(aSide);
- end[0] = mOuterRect.Corner(NEXT_SIDE(aSide));
- end[1] = mInnerRect.Corner(NEXT_SIDE(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) {
if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
- start[1] = gfxPoint(mOuterRect.Corner(aSide).x, mInnerRect.Corner(aSide).y);
+ start[1] = gfxPoint(mOuterRect.CCWCorner(aSide).x, mInnerRect.CCWCorner(aSide).y);
else
- start[1] = gfxPoint(mInnerRect.Corner(aSide).x, mOuterRect.Corner(aSide).y);
+ start[1] = gfxPoint(mInnerRect.CCWCorner(aSide).x, mOuterRect.CCWCorner(aSide).y);
}
if (endType == SIDE_CLIP_TRAPEZOID_FULL) {
MaybeMoveToMidPoint(end[0], end[1], midPoint);
} else if (endType == SIDE_CLIP_RECTANGLE) {
if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
- end[0] = gfxPoint(mInnerRect.Corner(NEXT_SIDE(aSide)).x, mOuterRect.Corner(NEXT_SIDE(aSide)).y);
+ end[0] = gfxPoint(mInnerRect.CWCorner(aSide).x, mOuterRect.CWCorner(aSide).y);
else
- end[0] = gfxPoint(mOuterRect.Corner(NEXT_SIDE(aSide)).x, mInnerRect.Corner(NEXT_SIDE(aSide)).y);
+ end[0] = gfxPoint(mOuterRect.CWCorner(aSide).x, mInnerRect.CWCorner(aSide).y);
}
mContext->MoveTo(start[0]);
mContext->LineTo(end[0]);
mContext->LineTo(end[1]);
mContext->LineTo(start[1]);
mContext->ClosePath();
}
@@ -904,17 +905,17 @@ nsCSSBorderRenderer::DrawBorderSides(PRI
ComputeInnerRadii(radii, borderWidths[i], &radii);
// And now soRect is the same as siRect, for the next line in.
soRect = siRect;
}
}
void
-nsCSSBorderRenderer::DrawDashedSide(PRUint8 aSide)
+nsCSSBorderRenderer::DrawDashedSide(mozilla::css::Side aSide)
{
gfxFloat dashWidth;
gfxFloat dash[2];
PRUint8 style = mBorderStyles[aSide];
gfxFloat borderWidth = mBorderWidths[aSide];
nscolor borderColor = mBorderColors[aSide];
@@ -949,18 +950,18 @@ nsCSSBorderRenderer::DrawDashedSide(PRUi
NS_ERROR("DrawDashedSide called with style other than DASHED or DOTTED; someone's not playing nice");
return;
}
SF("dash: %f %f\n", dash[0], dash[1]);
mContext->SetDash(dash, 2, 0.0);
- gfxPoint start = mOuterRect.Corner(aSide);
- gfxPoint end = mOuterRect.Corner(NEXT_SIDE(aSide));
+ gfxPoint start = mOuterRect.CCWCorner(aSide);
+ gfxPoint end = mOuterRect.CWCorner(aSide);
if (aSide == NS_SIDE_TOP) {
start.x += mBorderCornerDimensions[C_TL].width;
end.x -= mBorderCornerDimensions[C_TR].width;
start.y += borderWidth / 2.0;
end.y += borderWidth / 2.0;
} else if (aSide == NS_SIDE_RIGHT) {
@@ -1076,32 +1077,32 @@ nsCSSBorderRenderer::DrawBorders()
* If we have a 1px-wide border, the corners are going to be
* negligible, so don't bother doing anything fancy. Just extend
* the top and bottom borders to the right 1px and the left border
* to the bottom 1px. We do this by twiddling the corner dimensions,
* which causes the right to happen later on. Only do this if we have
* a 1.0 unit border all around and no border radius.
*/
- for (int corner = 0; corner < gfxCorner::NUM_CORNERS; corner++) {
- const PRIntn sides[2] = { corner, PREV_SIDE(corner) };
+ NS_FOR_CSS_CORNERS(corner) {
+ const mozilla::css::Side sides[2] = { mozilla::css::Side(corner), PREV_SIDE(corner) };
if (!IsZeroSize(mBorderRadii[corner]))
continue;
if (mBorderWidths[sides[0]] == 1.0 && mBorderWidths[sides[1]] == 1.0) {
- if (corner == gfxCorner::TOP_LEFT || corner == gfxCorner::TOP_RIGHT)
+ if (corner == NS_CORNER_TOP_LEFT || corner == NS_CORNER_TOP_RIGHT)
mBorderCornerDimensions[corner].width = 0.0;
else
mBorderCornerDimensions[corner].height = 0.0;
}
}
// First, the corners
- for (int corner = 0; corner < gfxCorner::NUM_CORNERS; corner++) {
+ NS_FOR_CSS_CORNERS(corner) {
// if there's no corner, don't do all this work for it
if (IsZeroSize(mBorderCornerDimensions[corner]))
continue;
const PRIntn sides[2] = { corner, PREV_SIDE(corner) };
PRIntn sideBits = (1 << sides[0]) | (1 << sides[1]);
PRBool simpleCornerStyle = mCompositeColors[sides[0]] == NULL &&
@@ -1145,17 +1146,17 @@ nsCSSBorderRenderer::DrawBorders()
// avoid the temporary, but that situation doesn't happen all
// that often in practice (we double buffer to no-alpha
// surfaces).
mContext->PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
mContext->SetOperator(gfxContext::OPERATOR_ADD);
for (int cornerSide = 0; cornerSide < 2; cornerSide++) {
- PRUint8 side = sides[cornerSide];
+ mozilla::css::Side side = mozilla::css::Side(sides[cornerSide]);
PRUint8 style = mBorderStyles[side];
SF("corner: %d cornerSide: %d side: %d style: %d\n", corner, cornerSide, side, style);
mContext->Save();
mContext->NewPath();
DoSideClipSubPath(side);
--- a/layout/base/nsCSSRenderingBorders.h
+++ b/layout/base/nsCSSRenderingBorders.h
@@ -54,20 +54,20 @@
//some shorthand for side bits
#define SIDE_BIT_TOP (1 << NS_SIDE_TOP)
#define SIDE_BIT_RIGHT (1 << NS_SIDE_RIGHT)
#define SIDE_BIT_BOTTOM (1 << NS_SIDE_BOTTOM)
#define SIDE_BIT_LEFT (1 << NS_SIDE_LEFT)
#define SIDE_BITS_ALL (SIDE_BIT_TOP|SIDE_BIT_RIGHT|SIDE_BIT_BOTTOM|SIDE_BIT_LEFT)
-#define C_TL (gfxCorner::TOP_LEFT)
-#define C_TR (gfxCorner::TOP_RIGHT)
-#define C_BR (gfxCorner::BOTTOM_RIGHT)
-#define C_BL (gfxCorner::BOTTOM_LEFT)
+#define C_TL NS_CORNER_TOP_LEFT
+#define C_TR NS_CORNER_TOP_RIGHT
+#define C_BR NS_CORNER_BOTTOM_RIGHT
+#define C_BL NS_CORNER_BOTTOM_LEFT
/*
* Helper class that handles border rendering.
*
* appUnitsPerPixel -- current value of AUPP
* destContext -- the gfxContext to which the border should be rendered
* outsideRect -- the rectangle on the outer edge of the border
*
@@ -136,39 +136,39 @@ struct nsCSSBorderRenderer {
PRPackedBool mOneUnitBorder;
PRPackedBool mNoBorderRadius;
// For all the sides in the bitmask, would they be rendered
// in an identical color and style?
PRBool AreBorderSideFinalStylesSame(PRUint8 aSides);
// For the given style, is the given corner a solid color?
- PRBool IsSolidCornerStyle(PRUint8 aStyle, gfxCorner::Corner aCorner);
+ PRBool IsSolidCornerStyle(PRUint8 aStyle, mozilla::css::Corner aCorner);
// For the given solid corner, what color style should be used?
- BorderColorStyle BorderColorStyleForSolidCorner(PRUint8 aStyle, gfxCorner::Corner aCorner);
+ BorderColorStyle BorderColorStyleForSolidCorner(PRUint8 aStyle, mozilla::css::Corner aCorner);
//
// Path generation functions
//
// add the path for drawing the given corner to the context
- void DoCornerSubPath(PRUint8 aCorner);
+ void DoCornerSubPath(mozilla::css::Corner aCorner);
// add the path for drawing the given side without any adjacent corners to the context
- void DoSideClipWithoutCornersSubPath(PRUint8 aSide);
+ void DoSideClipWithoutCornersSubPath(mozilla::css::Side aSide);
// Create a clip path for the wedge that this side of
// the border should take up. This is only called
// when we're drawing separate border sides, so we know
// that ADD compositing is taking place.
//
// This code needs to make sure that the individual pieces
// don't ever (mathematically) overlap; the pixel overlap
// is taken care of by the ADD compositing.
- void DoSideClipSubPath(PRUint8 aSide);
+ void DoSideClipSubPath(mozilla::css::Side aSide);
// Given a set of sides to fill and a color, do so in the fastest way.
//
// Stroke tends to be faster for smaller borders because it doesn't go
// through the tessellator, which has initialization overhead. If
// we're rendering all sides, we can use stroke at any thickness; we
// also do TL/BR pairs at 1px thickness using stroke.
//
@@ -191,17 +191,17 @@ struct nsCSSBorderRenderer {
// draw the border for the given sides, using the style of the first side
// present in the bitmask
void DrawBorderSides (PRIntn aSides);
// function used by the above to handle -moz-border-colors
void DrawBorderSidesCompositeColors(PRIntn aSides, const nsBorderColors *compositeColors);
// draw the given dashed side
- void DrawDashedSide (PRUint8 aSide);
+ void DrawDashedSide (mozilla::css::Side aSide);
// draw the entire border
void DrawBorders ();
// utility function used for background painting as well as borders
static void ComputeInnerRadii(const gfxCornerSizes& aRadii,
const gfxFloat *aBorderSizes,
gfxCornerSizes *aInnerRadiiRet);
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -3154,33 +3154,33 @@ nsLayoutUtils::HasNonZeroCorner(const ns
NS_FOR_CSS_HALF_CORNERS(corner) {
if (NonZeroStyleCoord(aCorners.Get(corner)))
return PR_TRUE;
}
return PR_FALSE;
}
// aCorner is a "full corner" value, i.e. NS_CORNER_TOP_LEFT etc
-static PRBool IsCornerAdjacentToSide(PRUint8 aCorner, PRUint8 aSide)
+static PRBool IsCornerAdjacentToSide(PRUint8 aCorner, mozilla::css::Side aSide)
{
- PR_STATIC_ASSERT(NS_SIDE_TOP == NS_CORNER_TOP_LEFT);
- PR_STATIC_ASSERT(NS_SIDE_RIGHT == NS_CORNER_TOP_RIGHT);
- PR_STATIC_ASSERT(NS_SIDE_BOTTOM == NS_CORNER_BOTTOM_RIGHT);
- PR_STATIC_ASSERT(NS_SIDE_LEFT == NS_CORNER_BOTTOM_LEFT);
- PR_STATIC_ASSERT(NS_SIDE_TOP == ((NS_CORNER_TOP_RIGHT - 1)&3));
- PR_STATIC_ASSERT(NS_SIDE_RIGHT == ((NS_CORNER_BOTTOM_RIGHT - 1)&3));
- PR_STATIC_ASSERT(NS_SIDE_BOTTOM == ((NS_CORNER_BOTTOM_LEFT - 1)&3));
- PR_STATIC_ASSERT(NS_SIDE_LEFT == ((NS_CORNER_TOP_LEFT - 1)&3));
+ PR_STATIC_ASSERT((int)NS_SIDE_TOP == NS_CORNER_TOP_LEFT);
+ PR_STATIC_ASSERT((int)NS_SIDE_RIGHT == NS_CORNER_TOP_RIGHT);
+ PR_STATIC_ASSERT((int)NS_SIDE_BOTTOM == NS_CORNER_BOTTOM_RIGHT);
+ PR_STATIC_ASSERT((int)NS_SIDE_LEFT == NS_CORNER_BOTTOM_LEFT);
+ PR_STATIC_ASSERT((int)NS_SIDE_TOP == ((NS_CORNER_TOP_RIGHT - 1)&3));
+ PR_STATIC_ASSERT((int)NS_SIDE_RIGHT == ((NS_CORNER_BOTTOM_RIGHT - 1)&3));
+ PR_STATIC_ASSERT((int)NS_SIDE_BOTTOM == ((NS_CORNER_BOTTOM_LEFT - 1)&3));
+ PR_STATIC_ASSERT((int)NS_SIDE_LEFT == ((NS_CORNER_TOP_LEFT - 1)&3));
return aSide == aCorner || aSide == ((aCorner - 1)&3);
}
/* static */ PRBool
nsLayoutUtils::HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
- PRUint8 aSide)
+ mozilla::css::Side aSide)
{
PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT_X/2 == NS_CORNER_TOP_LEFT);
PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT_Y/2 == NS_CORNER_TOP_LEFT);
PR_STATIC_ASSERT(NS_CORNER_TOP_RIGHT_X/2 == NS_CORNER_TOP_RIGHT);
PR_STATIC_ASSERT(NS_CORNER_TOP_RIGHT_Y/2 == NS_CORNER_TOP_RIGHT);
PR_STATIC_ASSERT(NS_CORNER_BOTTOM_RIGHT_X/2 == NS_CORNER_BOTTOM_RIGHT);
PR_STATIC_ASSERT(NS_CORNER_BOTTOM_RIGHT_Y/2 == NS_CORNER_BOTTOM_RIGHT);
PR_STATIC_ASSERT(NS_CORNER_BOTTOM_LEFT_X/2 == NS_CORNER_BOTTOM_LEFT);
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -1028,17 +1028,17 @@ public:
*/
static PRBool HasNonZeroCorner(const nsStyleCorners& aCorners);
/**
* Determine if there is any corner radius on corners adjacent to the
* given side.
*/
static PRBool HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
- PRUint8 aSide);
+ mozilla::css::Side aSide);
/**
* Determine if a widget is likely to require transparency or translucency.
* @param aBackgroundFrame The frame that the background is set on. For
* <window>s, this will be the canvas frame.
* @param aCSSRootFrame The frame that holds CSS properties affecting
* the widget's transparency. For menupopups,
* aBackgroundFrame and aCSSRootFrame will be the
--- a/layout/base/nsStyleConsts.h
+++ b/layout/base/nsStyleConsts.h
@@ -37,36 +37,36 @@
*
* ***** END LICENSE BLOCK ***** */
/* constants used in the style struct data provided by nsStyleContext */
#ifndef nsStyleConsts_h___
#define nsStyleConsts_h___
+#include "gfxRect.h"
#include "nsFont.h"
// cairo doesn't support invert
// #define GFX_HAS_INVERT
// XXX fold this into nsStyleContext and group by nsStyleXXX struct
// Indices into border/padding/margin arrays
-#define NS_SIDE_TOP 0
-#define NS_SIDE_RIGHT 1
-#define NS_SIDE_BOTTOM 2
-#define NS_SIDE_LEFT 3
+#define NS_SIDE_TOP mozilla::css::eSideTop
+#define NS_SIDE_RIGHT mozilla::css::eSideRight
+#define NS_SIDE_BOTTOM mozilla::css::eSideBottom
+#define NS_SIDE_LEFT mozilla::css::eSideLeft
-#define NS_FOR_CSS_SIDES(var_) for (PRInt32 var_ = 0; var_ < 4; ++var_)
-
-// Indices into "full corner" arrays (nsCSSCornerSizes e.g.)
-#define NS_CORNER_TOP_LEFT 0
-#define NS_CORNER_TOP_RIGHT 1
-#define NS_CORNER_BOTTOM_RIGHT 2
-#define NS_CORNER_BOTTOM_LEFT 3
+#define NS_FOR_CSS_SIDES(var_) for (mozilla::css::Side var_ = NS_SIDE_TOP; var_ <= NS_SIDE_LEFT; var_++)
+static inline mozilla::css::Side operator++(mozilla::css::Side& side, int) {
+ NS_PRECONDITION(side < NS_SIDE_LEFT, "Out of range side");
+ side = mozilla::css::Side(side + 1);
+ return side;
+}
#define NS_FOR_CSS_FULL_CORNERS(var_) for (PRInt32 var_ = 0; var_ < 4; ++var_)
// 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
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -599,17 +599,17 @@ nsContainerFrame::DoInlineIntrinsicWidth
nsLayoutUtils::IntrinsicWidthType aType)
{
if (GetPrevInFlow())
return; // Already added.
NS_PRECONDITION(aType == nsLayoutUtils::MIN_WIDTH ||
aType == nsLayoutUtils::PREF_WIDTH, "bad type");
- PRUint8 startSide, endSide;
+ mozilla::css::Side startSide, endSide;
if (GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR) {
startSide = NS_SIDE_LEFT;
endSide = NS_SIDE_RIGHT;
} else {
startSide = NS_SIDE_RIGHT;
endSide = NS_SIDE_LEFT;
}
--- a/layout/style/nsCSSStruct.cpp
+++ b/layout/style/nsCSSStruct.cpp
@@ -52,16 +52,17 @@
#include "nsCSSProps.h"
#include "nsFont.h"
#include "nsStyleConsts.h"
#include "nsCOMPtr.h"
#include "nsReadableUtils.h"
#include "nsPrintfCString.h"
+#include "prlog.h"
// --- nsCSSFont -----------------
nsCSSFont::nsCSSFont(void)
{
MOZ_COUNT_CTOR(nsCSSFont);
}
@@ -168,19 +169,17 @@ nsCSSRect::~nsCSSRect()
void nsCSSRect::SetAllSidesTo(const nsCSSValue& aValue)
{
mTop = aValue;
mRight = aValue;
mBottom = aValue;
mLeft = aValue;
}
-#if (NS_SIDE_TOP != 0) || (NS_SIDE_RIGHT != 1) || (NS_SIDE_BOTTOM != 2) || (NS_SIDE_LEFT != 3)
-#error "Somebody changed the side constants."
-#endif
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
/* static */ const nsCSSRect::side_type nsCSSRect::sides[4] = {
&nsCSSRect::mTop,
&nsCSSRect::mRight,
&nsCSSRect::mBottom,
&nsCSSRect::mLeft,
};
@@ -208,20 +207,18 @@ nsCSSCornerSizes::~nsCSSCornerSizes()
void
nsCSSCornerSizes::Reset()
{
NS_FOR_CSS_FULL_CORNERS(corner) {
this->GetFullCorner(corner).Reset();
}
}
-#if NS_CORNER_TOP_LEFT != 0 || NS_CORNER_TOP_RIGHT != 1 || \
- NS_CORNER_BOTTOM_RIGHT != 2 || NS_CORNER_BOTTOM_LEFT != 3
-#error "Somebody changed the corner constants."
-#endif
+PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 && \
+ NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3);
/* static */ const nsCSSCornerSizes::corner_type
nsCSSCornerSizes::corners[4] = {
&nsCSSCornerSizes::mTopLeft,
&nsCSSCornerSizes::mTopRight,
&nsCSSCornerSizes::mBottomRight,
&nsCSSCornerSizes::mBottomLeft,
};
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -3303,17 +3303,17 @@ nsComputedDOMStyle::GetROCSSValueList(PR
nsDOMCSSValueList *valueList = new nsDOMCSSValueList(aCommaDelimited,
PR_TRUE);
NS_ASSERTION(valueList != 0, "ran out of memory");
return valueList;
}
nsresult
-nsComputedDOMStyle::GetOffsetWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetOffsetWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
const nsStyleDisplay* display = GetStyleDisplay();
AssertFlushedPendingReflows();
nsresult rv = NS_OK;
switch (display->mPosition) {
case NS_STYLE_POSITION_STATIC:
@@ -3330,17 +3330,17 @@ nsComputedDOMStyle::GetOffsetWidthFor(PR
NS_ERROR("Invalid position");
break;
}
return rv;
}
nsresult
-nsComputedDOMStyle::GetAbsoluteOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetAbsoluteOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
nsIFrame* container = GetContainingBlockFor(mOuterFrame);
if (container) {
nsMargin margin = mOuterFrame->GetUsedMargin();
nsMargin border = container->GetUsedBorder();
@@ -3390,25 +3390,21 @@ nsComputedDOMStyle::GetAbsoluteOffset(PR
} else {
// XXX no frame. This property makes no sense
val->SetAppUnits(0);
}
return CallQueryInterface(val, aValue);
}
-
-#if (NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3)
-#define NS_OPPOSITE_SIDE(s_) (((s_) + 2) & 3)
-#else
-#error "Somebody changed the side constants."
-#endif
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
+#define NS_OPPOSITE_SIDE(s_) mozilla::css::Side(((s_) + 2) & 3)
nsresult
-nsComputedDOMStyle::GetRelativeOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetRelativeOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
const nsStylePosition* positionData = GetStylePosition();
PRInt32 sign = 1;
nsStyleCoord coord = positionData->mOffset.Get(aSide);
@@ -3429,29 +3425,29 @@ nsComputedDOMStyle::GetRelativeOffset(PR
}
val->SetAppUnits(sign * StyleCoordToNSCoord(coord, baseGetter, 0));
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetStaticOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetStaticOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
SetValueToCoord(val, GetStylePosition()->mOffset.Get(aSide));
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetPaddingWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetPaddingWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
if (!mInnerFrame) {
SetValueToCoord(val, GetStylePadding()->mPadding.Get(aSide));
} else {
AssertFlushedPendingReflows();
@@ -3489,17 +3485,17 @@ nsComputedDOMStyle::GetLineHeightCoord(n
aCoord = NSToCoordRound((float(aCoord) *
(float(font->mSize) / float(font->mFont.size))) /
mPresShell->GetPresContext()->TextZoom());
return PR_TRUE;
}
nsresult
-nsComputedDOMStyle::GetBorderColorsFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderColorsFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
const nsStyleBorder *border = GetStyleBorder();
if (border->mBorderColors) {
nsBorderColors* borderColors = border->mBorderColors[aSide];
if (borderColors) {
nsDOMCSSValueList *valueList = GetROCSSValueList(PR_FALSE);
NS_ENSURE_TRUE(valueList, NS_ERROR_OUT_OF_MEMORY);
@@ -3536,17 +3532,17 @@ nsComputedDOMStyle::GetBorderColorsFor(P
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
val->SetIdent(eCSSKeyword_none);
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetBorderWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
nscoord width;
if (mInnerFrame) {
AssertFlushedPendingReflows();
width = mInnerFrame->GetUsedBorder().side(aSide);
@@ -3554,17 +3550,17 @@ nsComputedDOMStyle::GetBorderWidthFor(PR
width = GetStyleBorder()->GetActualBorderWidth(aSide);
}
val->SetAppUnits(width);
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetBorderColorFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderColorFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
nscolor color;
PRBool foreground;
GetStyleBorder()->GetBorderColor(aSide, color, foreground);
if (foreground) {
@@ -3576,34 +3572,34 @@ nsComputedDOMStyle::GetBorderColorFor(PR
delete val;
return rv;
}
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetMarginWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetMarginWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
if (!mInnerFrame) {
SetValueToCoord(val, GetStyleMargin()->mMargin.Get(aSide));
} else {
AssertFlushedPendingReflows();
val->SetAppUnits(mInnerFrame->GetUsedMargin().side(aSide));
}
return CallQueryInterface(val, aValue);
}
nsresult
-nsComputedDOMStyle::GetBorderStyleFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderStyleFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
{
nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
val->SetIdent(
nsCSSProps::ValueToKeywordEnum(GetStyleBorder()->GetBorderStyle(aSide),
nsCSSProps::kBorderStyleKTable));
--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -111,35 +111,35 @@ private:
}
#include "nsStyleStructList.h"
#undef STYLE_STRUCT
nsresult GetEllipseRadii(const nsStyleCorners& aRadius,
PRUint8 aFullCorner,
nsIDOMCSSValue** aValue);
- nsresult GetOffsetWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetOffsetWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetAbsoluteOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetAbsoluteOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetRelativeOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetRelativeOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetStaticOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetStaticOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetPaddingWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetPaddingWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetBorderColorsFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetBorderColorsFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetBorderStyleFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetBorderStyleFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetBorderWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetBorderWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetBorderColorFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetBorderColorFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
- nsresult GetMarginWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+ nsresult GetMarginWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
PRBool GetLineHeightCoord(nscoord& aCoord);
nsresult GetCSSShadowArray(nsCSSShadowArray* aArray,
const nscolor& aDefaultColor,
PRBool aIsBoxShadow,
nsIDOMCSSValue** aValue);
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -2304,17 +2304,17 @@ nsRuleNode::SetDefaultOnRoot(const nsSty
* input).
*/
void
nsRuleNode::AdjustLogicalBoxProp(nsStyleContext* aContext,
const nsCSSValue& aLTRSource,
const nsCSSValue& aRTLSource,
const nsCSSValue& aLTRLogicalValue,
const nsCSSValue& aRTLLogicalValue,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
nsCSSRect& aValueRect,
PRBool& aCanStoreInRuleTree)
{
PRBool LTRlogical = aLTRSource.GetUnit() == eCSSUnit_Enumerated &&
aLTRSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;
PRBool RTLlogical = aRTLSource.GetUnit() == eCSSUnit_Enumerated &&
aRTLSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;
if (LTRlogical || RTLlogical) {
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -644,17 +644,17 @@ protected:
nscoord aMinFontSize,
nsStyleFont* aFont);
void AdjustLogicalBoxProp(nsStyleContext* aContext,
const nsCSSValue& aLTRSource,
const nsCSSValue& aRTLSource,
const nsCSSValue& aLTRLogicalValue,
const nsCSSValue& aRTLLogicalValue,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
nsCSSRect& aValueRect,
PRBool& aCanStoreInRuleTree);
inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID, const nsRuleDataStruct& aRuleDataStruct);
const void* GetParentData(const nsStyleStructID aSID);
#define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_) \
const nsStyle##name_* GetParent##name_();
--- a/layout/style/nsStyleAnimation.cpp
+++ b/layout/style/nsStyleAnimation.cpp
@@ -1231,17 +1231,17 @@ StyleDataAtOffset(const void* aStyleStru
inline void*
StyleDataAtOffset(void* aStyleStruct, ptrdiff_t aOffset)
{
return reinterpret_cast<char*>(aStyleStruct) + aOffset;
}
static void
ExtractBorderColor(nsStyleContext* aStyleContext, const void* aStyleBorder,
- PRUint8 aSide, nsStyleAnimation::Value& aComputedValue)
+ mozilla::css::Side aSide, nsStyleAnimation::Value& aComputedValue)
{
nscolor color;
PRBool foreground;
static_cast<const nsStyleBorder*>(aStyleBorder)->
GetBorderColor(aSide, color, foreground);
if (foreground) {
// FIXME: should add test for this
color = aStyleContext->GetStyleColor()->mColor;
@@ -1663,17 +1663,17 @@ nsStyleAnimation::ExtractComputedValue(n
PR_STATIC_ASSERT(eStyleAnimType_Sides_Right - eStyleAnimType_Sides_Top
== NS_SIDE_RIGHT);
PR_STATIC_ASSERT(eStyleAnimType_Sides_Bottom - eStyleAnimType_Sides_Top
== NS_SIDE_BOTTOM);
PR_STATIC_ASSERT(eStyleAnimType_Sides_Left - eStyleAnimType_Sides_Top
== NS_SIDE_LEFT);
const nsStyleCoord &coord = static_cast<const nsStyleSides*>(
StyleDataAtOffset(styleStruct, ssOffset))->
- Get(animType - eStyleAnimType_Sides_Top);
+ Get(mozilla::css::Side(animType - eStyleAnimType_Sides_Top));
return StyleCoordToValue(coord, aComputedValue);
}
case eStyleAnimType_Corner_TopLeft:
case eStyleAnimType_Corner_TopRight:
case eStyleAnimType_Corner_BottomRight:
case eStyleAnimType_Corner_BottomLeft: {
PR_STATIC_ASSERT(0 == NS_CORNER_TOP_LEFT);
PR_STATIC_ASSERT(eStyleAnimType_Corner_TopRight -
--- a/layout/style/nsStyleCoord.h
+++ b/layout/style/nsStyleCoord.h
@@ -129,33 +129,31 @@ public:
class nsStyleSides {
public:
nsStyleSides(void);
// nsStyleSides& operator=(const nsStyleSides& aCopy); // use compiler's version
PRBool operator==(const nsStyleSides& aOther) const;
PRBool operator!=(const nsStyleSides& aOther) const;
- // aSide is always one of NS_SIDE_* defined in nsStyleConsts.h
-
- inline nsStyleUnit GetUnit(PRUint8 aSide) const;
+ inline nsStyleUnit GetUnit(mozilla::css::Side aSide) const;
inline nsStyleUnit GetLeftUnit(void) const;
inline nsStyleUnit GetTopUnit(void) const;
inline nsStyleUnit GetRightUnit(void) const;
inline nsStyleUnit GetBottomUnit(void) const;
- inline nsStyleCoord Get(PRUint8 aSide) const;
+ inline nsStyleCoord Get(mozilla::css::Side aSide) const;
inline nsStyleCoord GetLeft() const;
inline nsStyleCoord GetTop() const;
inline nsStyleCoord GetRight() const;
inline nsStyleCoord GetBottom() const;
void Reset(void);
- inline void Set(PRUint8 aSide, const nsStyleCoord& aCoord);
+ inline void Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord);
inline void SetLeft(const nsStyleCoord& aCoord);
inline void SetTop(const nsStyleCoord& aCoord);
inline void SetRight(const nsStyleCoord& aCoord);
inline void SetBottom(const nsStyleCoord& aCoord);
protected:
PRUint8 mUnits[4];
nsStyleUnion mValues[4];
@@ -281,17 +279,17 @@ inline void nsStyleCoord::GetUnionValue(
// -------------------------
// nsStyleSides inlines
//
inline PRBool nsStyleSides::operator!=(const nsStyleSides& aOther) const
{
return !((*this) == aOther);
}
-inline nsStyleUnit nsStyleSides::GetUnit(PRUint8 aSide) const
+inline nsStyleUnit nsStyleSides::GetUnit(mozilla::css::Side aSide) const
{
return (nsStyleUnit)mUnits[aSide];
}
inline nsStyleUnit nsStyleSides::GetLeftUnit(void) const
{
return GetUnit(NS_SIDE_LEFT);
}
@@ -306,17 +304,17 @@ inline nsStyleUnit nsStyleSides::GetRigh
return GetUnit(NS_SIDE_RIGHT);
}
inline nsStyleUnit nsStyleSides::GetBottomUnit(void) const
{
return GetUnit(NS_SIDE_BOTTOM);
}
-inline nsStyleCoord nsStyleSides::Get(PRUint8 aSide) const
+inline nsStyleCoord nsStyleSides::Get(mozilla::css::Side aSide) const
{
return nsStyleCoord(mValues[aSide], nsStyleUnit(mUnits[aSide]));
}
inline nsStyleCoord nsStyleSides::GetLeft() const
{
return Get(NS_SIDE_LEFT);
}
@@ -331,17 +329,17 @@ inline nsStyleCoord nsStyleSides::GetRig
return Get(NS_SIDE_RIGHT);
}
inline nsStyleCoord nsStyleSides::GetBottom() const
{
return Get(NS_SIDE_BOTTOM);
}
-inline void nsStyleSides::Set(PRUint8 aSide, const nsStyleCoord& aCoord)
+inline void nsStyleSides::Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord)
{
mUnits[aSide] = aCoord.GetUnit();
aCoord.GetUnionValue(mValues[aSide]);
}
inline void nsStyleSides::SetLeft(const nsStyleCoord& aCoord)
{
Set(NS_SIDE_LEFT, aCoord);
--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -61,16 +61,17 @@
#include "nsCOMArray.h"
#include "nsTArray.h"
#include "nsIAtom.h"
#include "nsIURI.h"
#include "nsCSSValue.h"
#include "nsStyleTransformMatrix.h"
#include "nsAlgorithm.h"
#include "imgIRequest.h"
+#include "gfxRect.h"
class nsIFrame;
class imgIRequest;
class imgIContainer;
// Includes nsStyleStructID.
#include "nsStyleStructFwd.h"
@@ -732,44 +733,44 @@ struct nsStyleBorder {
if (!mBorderColors) {
mBorderColors = new nsBorderColors*[4];
if (mBorderColors)
for (PRInt32 i = 0; i < 4; i++)
mBorderColors[i] = nsnull;
}
}
- void ClearBorderColors(PRUint8 aSide) {
+ void ClearBorderColors(mozilla::css::Side aSide) {
if (mBorderColors && mBorderColors[aSide]) {
delete mBorderColors[aSide];
mBorderColors[aSide] = nsnull;
}
}
// Return whether aStyle is a visible style. Invisible styles cause
// the relevant computed border width to be 0.
// Note that this does *not* consider the effects of 'border-image':
// if border-style is none, but there is a loaded border image,
// HasVisibleStyle will be false even though there *is* a border.
- PRBool HasVisibleStyle(PRUint8 aSide)
+ PRBool HasVisibleStyle(mozilla::css::Side aSide)
{
return IsVisibleBorderStyle(GetBorderStyle(aSide));
}
// aBorderWidth is in twips
- void SetBorderWidth(PRUint8 aSide, nscoord aBorderWidth)
+ void SetBorderWidth(mozilla::css::Side aSide, nscoord aBorderWidth)
{
nscoord roundedWidth =
NS_ROUND_BORDER_TO_PIXELS(aBorderWidth, mTwipsPerPixel);
mBorder.side(aSide) = roundedWidth;
if (HasVisibleStyle(aSide))
mComputedBorder.side(aSide) = roundedWidth;
}
- void SetBorderImageWidthOverride(PRUint8 aSide, nscoord aBorderWidth)
+ void SetBorderImageWidthOverride(mozilla::css::Side aSide, nscoord aBorderWidth)
{
mBorderImageWidth.side(aSide) =
NS_ROUND_BORDER_TO_PIXELS(aBorderWidth, mTwipsPerPixel);
}
// Get the actual border, in twips. (If there is no border-image
// loaded, this is the same as GetComputedBorder. If there is a
// border-image loaded, it uses the border-image width overrides if
@@ -784,54 +785,54 @@ struct nsStyleBorder {
{
return mComputedBorder;
}
// Get the actual border width for a particular side, in appunits. Note that
// this is zero if and only if there is no border to be painted for this
// side. That is, this value takes into account the border style and the
// value is rounded to the nearest device pixel by NS_ROUND_BORDER_TO_PIXELS.
- nscoord GetActualBorderWidth(PRUint8 aSide) const
+ nscoord GetActualBorderWidth(mozilla::css::Side aSide) const
{
return GetActualBorder().side(aSide);
}
- PRUint8 GetBorderStyle(PRUint8 aSide) const
+ PRUint8 GetBorderStyle(mozilla::css::Side aSide) const
{
NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
return (mBorderStyle[aSide] & BORDER_STYLE_MASK);
}
- void SetBorderStyle(PRUint8 aSide, PRUint8 aStyle)
+ void SetBorderStyle(mozilla::css::Side aSide, PRUint8 aStyle)
{
NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
mBorderStyle[aSide] &= ~BORDER_STYLE_MASK;
mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK);
mComputedBorder.side(aSide) =
(HasVisibleStyle(aSide) ? mBorder.side(aSide) : 0);
}
// Defined in nsStyleStructInlines.h
inline PRBool IsBorderImageLoaded() const;
inline nsresult RequestDecode();
- void GetBorderColor(PRUint8 aSide, nscolor& aColor,
+ void GetBorderColor(mozilla::css::Side aSide, nscolor& aColor,
PRBool& aForeground) const
{
aForeground = PR_FALSE;
NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0)
aColor = mBorderColor[aSide];
else if (mBorderStyle[aSide] & BORDER_COLOR_FOREGROUND)
aForeground = PR_TRUE;
else
NS_NOTREACHED("OUTLINE_COLOR_INITIAL should not be set here");
}
- void SetBorderColor(PRUint8 aSide, nscolor aColor)
+ void SetBorderColor(mozilla::css::Side aSide, nscolor aColor)
{
NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
mBorderColor[aSide] = aColor;
mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
}
// These are defined in nsStyleStructInlines.h
inline void SetBorderImage(imgIRequest* aImage);
@@ -860,17 +861,17 @@ struct nsStyleBorder {
nsBorderColors* last = mBorderColors[aIndex];
while (last->mNext)
last = last->mNext;
last->mNext = colorEntry;
}
mBorderStyle[aIndex] &= ~BORDER_COLOR_SPECIAL;
}
- void SetBorderToForeground(PRUint8 aSide)
+ void SetBorderToForeground(mozilla::css::Side aSide)
{
NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
mBorderStyle[aSide] |= BORDER_COLOR_FOREGROUND;
}
protected:
// mComputedBorder holds the CSS2.1 computed border-width values. In
--- a/layout/tables/celldata.h
+++ b/layout/tables/celldata.h
@@ -34,16 +34,17 @@
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef CellData_h__
#define CellData_h__
#include "nsISupports.h"
#include "nsCoord.h"
+#include "gfxCore.h"
class nsTableCellFrame;
class nsCellMap;
class BCCellData;
#define MAX_ROWSPAN 8190 // the cellmap can not handle more
#define MAX_COLSPAN 1000 // limit as IE and opera do
@@ -222,21 +223,21 @@ public:
nscoord GetTopEdge(BCBorderOwner& aOwner,
PRBool& aStart) const;
void SetTopEdge(BCBorderOwner aOwner,
nscoord aSize,
PRBool aStart);
- BCPixelSize GetCorner(PRUint8& aCornerOwner,
+ BCPixelSize GetCorner(mozilla::css::Side& aCornerOwner,
PRPackedBool& aBevel) const;
void SetCorner(BCPixelSize aSubSize,
- PRUint8 aOwner,
+ mozilla::css::Side aOwner,
PRBool aBevel);
PRBool IsLeftStart() const;
void SetLeftStart(PRBool aValue);
PRBool IsTopStart() const;
@@ -250,17 +251,17 @@ protected:
// dominant plane (for example, if corner is
// owned by the segment to its top or bottom,
// then the size is the max of the border
// sizes of the segments to its left or right.
unsigned mLeftOwner: 4; // owner of left border
unsigned mTopOwner: 4; // owner of top border
unsigned mLeftStart: 1; // set if this is the start of a vertical border segment
unsigned mTopStart: 1; // set if this is the start of a horizontal border segment
- unsigned mCornerSide: 2; // side of the owner of the upper left corner relative to the corner
+ mozilla::css::Side mCornerSide: 2; // side of the owner of the upper left corner relative to the corner
unsigned mCornerBevel: 1; // is the corner beveled (only two segments, perpendicular, not dashed or dotted).
};
// BCCellData entries replace CellData entries in the cell map if the border collapsing model is in
// effect. BCData for a row and col entry contains the left and top borders of cell at that row and
// col and the corner connecting the two. The right borders of the cells in the last col and the bottom
// borders of the last row are stored in separate BCData entries in the cell map.
class BCCellData : public CellData
@@ -411,17 +412,18 @@ inline void CellData::SetOverlap(PRBool
}
}
}
inline BCData::BCData()
{
mLeftOwner = mTopOwner = eCellOwner;
mLeftStart = mTopStart = 1;
- mLeftSize = mCornerSide = mCornerSubSize = mTopSize = 0;
+ mLeftSize = mCornerSubSize = mTopSize = 0;
+ mCornerSide = NS_SIDE_TOP;
mCornerBevel = PR_FALSE;
}
inline BCData::~BCData()
{
}
inline nscoord BCData::GetLeftEdge(BCBorderOwner& aOwner,
@@ -455,26 +457,26 @@ inline void BCData::SetTopEdge(BCBorderO
nscoord aSize,
PRBool aStart)
{
mTopOwner = aOwner;
mTopSize = (aSize > MAX_BORDER_WIDTH) ? MAX_BORDER_WIDTH : aSize;
mTopStart = aStart;
}
-inline BCPixelSize BCData::GetCorner(PRUint8& aOwnerSide,
+inline BCPixelSize BCData::GetCorner(mozilla::css::Side& aOwnerSide,
PRPackedBool& aBevel) const
{
aOwnerSide = mCornerSide;
aBevel = (PRBool)mCornerBevel;
return mCornerSubSize;
}
inline void BCData::SetCorner(BCPixelSize aSubSize,
- PRUint8 aOwnerSide,
+ mozilla::css::Side aOwnerSide,
PRBool aBevel)
{
mCornerSubSize = aSubSize;
mCornerSide = aOwnerSide;
mCornerBevel = aBevel;
}
inline PRBool BCData::IsLeftStart() const
--- a/layout/tables/nsCellMap.cpp
+++ b/layout/tables/nsCellMap.cpp
@@ -737,17 +737,17 @@ nsTableCellMap::Dump(char* aString) cons
while (cellMap) {
cellMap->Dump(nsnull != mBCInfo);
cellMap = cellMap->GetNextSibling();
}
if (nsnull != mBCInfo) {
printf("***** bottom borders *****\n");
nscoord size;
BCBorderOwner owner;
- PRUint8 side;
+ mozilla::css::Side side;
PRBool segStart;
PRPackedBool bevel;
PRInt32 colIndex;
PRInt32 numCols = mBCInfo->mBottomBorders.Length();
for (PRInt32 i = 0; i <= 2; i++) {
printf("\n ");
for (colIndex = 0; colIndex < numCols; colIndex++) {
@@ -977,17 +977,17 @@ nsTableCellMap::SetNotTopStart(PRUint8
}
}
// store the aSide border segment at coord = (aRowIndex, aColIndex). For top/left, store
// the info at coord. For bottom/left store it at the adjacent location so that it is
// top/left at that location. If the new location is at the right or bottom edge of the
// table, then store it one of the special arrays (right most borders, bottom most borders).
void
-nsTableCellMap::SetBCBorderEdge(PRUint8 aSide,
+nsTableCellMap::SetBCBorderEdge(mozilla::css::Side aSide,
nsCellMap& aCellMap,
PRUint32 aCellMapStart,
PRUint32 aRowIndex,
PRUint32 aColIndex,
PRUint32 aLength,
BCBorderOwner aOwner,
nscoord aSize,
PRBool aChanged)
@@ -1073,17 +1073,17 @@ nsTableCellMap::SetBCBorderEdge(PRUint8
// (aRowIndex, aColIndex). For eTopRight, store it in the entry to the right where
// it would be top left. For eBottomRight, store it in the entry to the bottom. etc.
void
nsTableCellMap::SetBCBorderCorner(Corner aCorner,
nsCellMap& aCellMap,
PRUint32 aCellMapStart,
PRUint32 aRowIndex,
PRUint32 aColIndex,
- PRUint8 aOwner,
+ mozilla::css::Side aOwner,
nscoord aSubSize,
PRBool aBevel,
PRBool aIsBottomRight)
{
if (!mBCInfo) ABORT0();
if (aIsBottomRight) {
mBCInfo->mLowerRightCorner.SetCorner(aSubSize, aOwner, aBevel);
@@ -2563,17 +2563,17 @@ void nsCellMap::Dump(PRBool aIsBorderCol
}
} else {
printf("---- ");
}
}
if (aIsBorderCollapse) {
nscoord size;
BCBorderOwner owner;
- PRUint8 side;
+ mozilla::css::Side side;
PRBool segStart;
PRPackedBool bevel;
for (PRInt32 i = 0; i <= 2; i++) {
printf("\n ");
for (colIndex = 0; colIndex < colCount; colIndex++) {
BCCellData* cd = (BCCellData *)row[colIndex];
if (cd) {
if (0 == i) {
--- a/layout/tables/nsCellMap.h
+++ b/layout/tables/nsCellMap.h
@@ -230,32 +230,32 @@ public:
void ExpandZeroColSpans();
void SetNotTopStart(PRUint8 aSide,
nsCellMap& aCellMap,
PRUint32 aYPos,
PRUint32 aXPos,
PRBool aIsLowerRight = PR_FALSE);
- void SetBCBorderEdge(PRUint8 aEdge,
+ void SetBCBorderEdge(mozilla::css::Side aEdge,
nsCellMap& aCellMap,
PRUint32 aCellMapStart,
PRUint32 aYPos,
PRUint32 aXPos,
PRUint32 aLength,
BCBorderOwner aOwner,
nscoord aSize,
PRBool aChanged);
void SetBCBorderCorner(Corner aCorner,
nsCellMap& aCellMap,
PRUint32 aCellMapStart,
PRUint32 aYPos,
PRUint32 aXPos,
- PRUint8 aOwner,
+ mozilla::css::Side aOwner,
nscoord aSubSize,
PRBool aBevel,
PRBool aIsBottomRight = PR_FALSE);
/** dump a representation of the cell map to stdout for debugging */
#ifdef NS_DEBUG
void Dump(char* aString = nsnull) const;
#endif
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -1107,32 +1107,32 @@ nsBCTableCellFrame::GetBorderWidth(nsMar
aBorder.top = BC_BORDER_BOTTOM_HALF_COORD(aPixelsToTwips, mTopBorder);
aBorder.right = BC_BORDER_LEFT_HALF_COORD(aPixelsToTwips, mRightBorder);
aBorder.bottom = BC_BORDER_TOP_HALF_COORD(aPixelsToTwips, mBottomBorder);
aBorder.left = BC_BORDER_RIGHT_HALF_COORD(aPixelsToTwips, mLeftBorder);
return &aBorder;
}
BCPixelSize
-nsBCTableCellFrame::GetBorderWidth(PRUint8 aSide) const
+nsBCTableCellFrame::GetBorderWidth(mozilla::css::Side aSide) const
{
switch(aSide) {
case NS_SIDE_TOP:
return BC_BORDER_BOTTOM_HALF(mTopBorder);
case NS_SIDE_RIGHT:
return BC_BORDER_LEFT_HALF(mRightBorder);
case NS_SIDE_BOTTOM:
return BC_BORDER_TOP_HALF(mBottomBorder);
default:
return BC_BORDER_RIGHT_HALF(mLeftBorder);
}
}
void
-nsBCTableCellFrame::SetBorderWidth(PRUint8 aSide,
+nsBCTableCellFrame::SetBorderWidth(mozilla::css::Side aSide,
BCPixelSize aValue)
{
switch(aSide) {
case NS_SIDE_TOP:
mTopBorder = aValue;
break;
case NS_SIDE_RIGHT:
mRightBorder = aValue;
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -313,20 +313,20 @@ public:
virtual nsIAtom* GetType() const;
virtual nsMargin GetUsedBorder() const;
// Get the *inner half of the border only*, in twips.
virtual nsMargin* GetBorderWidth(nsMargin& aBorder) const;
// Get the *inner half of the border only*, in pixels.
- BCPixelSize GetBorderWidth(PRUint8 aSide) const;
+ BCPixelSize GetBorderWidth(mozilla::css::Side aSide) const;
// Set the full (both halves) width of the border
- void SetBorderWidth(PRUint8 aSide, BCPixelSize aPixelValue);
+ void SetBorderWidth(mozilla::css::Side aSide, BCPixelSize aPixelValue);
virtual void GetSelfOverflow(nsRect& aOverflowArea);
#ifdef DEBUG
NS_IMETHOD GetFrameName(nsAString& aResult) const;
#endif
virtual void PaintBackground(nsIRenderingContext& aRenderingContext,
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -3893,18 +3893,18 @@ struct BCMapCellInfo
nsTableFrame* mTableFrame;
PRInt32 mNumTableRows;
PRInt32 mNumTableCols;
BCPropertyData* mTableBCData;
// storage of table ltr information, the border collapse code swaps the sides
// to account for rtl tables, this is done through mStartSide and mEndSide
PRPackedBool mTableIsLTR;
- PRUint8 mStartSide;
- PRUint8 mEndSide;
+ mozilla::css::Side mStartSide;
+ mozilla::css::Side mEndSide;
// a cell can only belong to one rowgroup
nsTableRowGroupFrame* mRowGroup;
// a cell with a rowspan has a top and a bottom row, and rows in between
nsTableRowFrame* mTopRow;
nsTableRowFrame* mBottomRow;
nsTableRowFrame* mCurrentRowFrame;
@@ -4395,17 +4395,17 @@ static PRUint8 styleToPriority[13] = { 0
* @param aFrame - query the info for this frame
* @param aSide - the side of the frame
* @param aStyle - the border style
* @param aColor - the border color
* @param aTableIsLTR - table direction is LTR
*/
static void
GetColorAndStyle(const nsIFrame* aFrame,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
PRUint8& aStyle,
nscolor& aColor,
PRBool aTableIsLTR)
{
NS_PRECONDITION(aFrame, "null frame");
// initialize out arg
aColor = 0;
const nsStyleBorder* styleData = aFrame->GetStyleBorder();
@@ -4431,17 +4431,17 @@ GetColorAndStyle(const nsIFrame* aFrame
* @param aFrame - query the info for this frame
* @param aSide - the side of the frame
* @param aStyle - the border style
* @param aColor - the border color
* @param aTableIsLTR - table direction is LTR
*/
static void
GetPaintStyleInfo(const nsIFrame* aFrame,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
PRUint8& aStyle,
nscolor& aColor,
PRBool aTableIsLTR)
{
GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
if (NS_STYLE_BORDER_STYLE_INSET == aStyle) {
aStyle = NS_STYLE_BORDER_STYLE_RIDGE;
}
@@ -4457,17 +4457,17 @@ GetPaintStyleInfo(const nsIFrame* aFram
* @param aStyle - the border style
* @param aColor - the border color
* @param aTableIsLTR - table direction is LTR
* @param aWidth - the border width in px.
* @param aTwipsToPixels - conversion factor from twips to pixel
*/
static void
GetColorAndStyle(const nsIFrame* aFrame,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
PRUint8& aStyle,
nscolor& aColor,
PRBool aTableIsLTR,
BCPixelSize& aWidth)
{
GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
if ((NS_STYLE_BORDER_STYLE_NONE == aStyle) ||
(NS_STYLE_BORDER_STYLE_HIDDEN == aStyle)) {
@@ -4605,17 +4605,17 @@ CompareBorders(PRBool aIsCo
static BCCellBorder
CompareBorders(const nsIFrame* aTableFrame,
const nsIFrame* aColGroupFrame,
const nsIFrame* aColFrame,
const nsIFrame* aRowGroupFrame,
const nsIFrame* aRowFrame,
const nsIFrame* aCellFrame,
PRBool aTableIsLTR,
- PRUint8 aSide,
+ mozilla::css::Side aSide,
PRBool aAja)
{
BCCellBorder border, tempBorder;
PRBool horizontal = (NS_SIDE_TOP == aSide) || (NS_SIDE_BOTTOM == aSide);
// start with the table as dominant if present
if (aTableFrame) {
GetColorAndStyle(aTableFrame, aSide, border.style, border.color, aTableIsLTR, border.width);
@@ -4666,62 +4666,62 @@ CompareBorders(const nsIFrame* aTableFr
GetColorAndStyle(aCellFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
tempBorder.owner = (aAja) ? eAjaCellOwner : eCellOwner;
border = CompareBorders(!CELL_CORNER, border, tempBorder, PR_FALSE);
}
return border;
}
static PRBool
-Perpendicular(PRUint8 aSide1,
- PRUint8 aSide2)
+Perpendicular(mozilla::css::Side aSide1,
+ mozilla::css::Side aSide2)
{
switch (aSide1) {
case NS_SIDE_TOP:
return (NS_SIDE_BOTTOM != aSide2);
case NS_SIDE_RIGHT:
return (NS_SIDE_LEFT != aSide2);
case NS_SIDE_BOTTOM:
return (NS_SIDE_TOP != aSide2);
default: // NS_SIDE_LEFT
return (NS_SIDE_RIGHT != aSide2);
}
}
// XXX allocate this as number-of-cols+1 instead of number-of-cols+1 * number-of-rows+1
struct BCCornerInfo
{
- BCCornerInfo() { ownerColor = 0; ownerWidth = subWidth = ownerSide = ownerElem = subSide =
- subElem = hasDashDot = numSegs = bevel = 0;
+ BCCornerInfo() { ownerColor = 0; ownerWidth = subWidth = ownerElem = subSide =
+ subElem = hasDashDot = numSegs = bevel = 0; ownerSide = NS_SIDE_TOP;
ownerStyle = 0xFF; subStyle = NS_STYLE_BORDER_STYLE_SOLID; }
- void Set(PRUint8 aSide,
+ void Set(mozilla::css::Side aSide,
BCCellBorder border);
- void Update(PRUint8 aSide,
+ void Update(mozilla::css::Side aSide,
BCCellBorder border);
nscolor ownerColor; // color of borderOwner
PRUint16 ownerWidth; // pixel width of borderOwner
PRUint16 subWidth; // pixel width of the largest border intersecting the border perpendicular
// to ownerSide
- PRUint32 ownerSide:2; // side (e.g NS_SIDE_TOP, NS_SIDE_RIGHT, etc) of the border owning
+ mozilla::css::Side ownerSide:2; // side (e.g NS_SIDE_TOP, NS_SIDE_RIGHT, etc) of the border owning
// the corner relative to the corner
PRUint32 ownerElem:3; // elem type (e.g. eTable, eGroup, etc) owning the corner
PRUint32 ownerStyle:8; // border style of ownerElem
PRUint32 subSide:2; // side of border with subWidth relative to the corner
PRUint32 subElem:3; // elem type (e.g. eTable, eGroup, etc) of sub owner
PRUint32 subStyle:8; // border style of subElem
PRUint32 hasDashDot:1; // does a dashed, dotted segment enter the corner, they cannot be beveled
PRUint32 numSegs:3; // number of segments entering corner
PRUint32 bevel:1; // is the corner beveled (uses the above two fields together with subWidth)
PRUint32 unused:1;
};
void
-BCCornerInfo::Set(PRUint8 aSide,
+BCCornerInfo::Set(mozilla::css::Side aSide,
BCCellBorder aBorder)
{
ownerElem = aBorder.owner;
ownerStyle = aBorder.style;
ownerWidth = aBorder.width;
ownerColor = aBorder.color;
ownerSide = aSide;
hasDashDot = 0;
@@ -4735,32 +4735,32 @@ BCCornerInfo::Set(PRUint8 aSide,
subWidth = 0;
// the following will get set later
subSide = ((aSide == NS_SIDE_LEFT) || (aSide == NS_SIDE_RIGHT)) ? NS_SIDE_TOP : NS_SIDE_LEFT;
subElem = eTableOwner;
subStyle = NS_STYLE_BORDER_STYLE_SOLID;
}
void
-BCCornerInfo::Update(PRUint8 aSide,
+BCCornerInfo::Update(mozilla::css::Side aSide,
BCCellBorder aBorder)
{
PRBool existingWins = PR_FALSE;
if (0xFF == ownerStyle) { // initial value indiating that it hasn't been set yet
Set(aSide, aBorder);
}
else {
PRBool horizontal = (NS_SIDE_LEFT == aSide) || (NS_SIDE_RIGHT == aSide); // relative to the corner
BCCellBorder oldBorder, tempBorder;
oldBorder.owner = (BCBorderOwner) ownerElem;
oldBorder.style = ownerStyle;
oldBorder.width = ownerWidth;
oldBorder.color = ownerColor;
- PRUint8 oldSide = ownerSide;
+ mozilla::css::Side oldSide = ownerSide;
tempBorder = CompareBorders(CELL_CORNER, oldBorder, aBorder, horizontal, &existingWins);
ownerElem = tempBorder.owner;
ownerStyle = tempBorder.style;
ownerWidth = tempBorder.width;
ownerColor = tempBorder.color;
if (existingWins) { // existing corner is dominant
@@ -5524,17 +5524,17 @@ nsTableFrame::CalcBCBorders()
info.SetTableTopLeftContBCBorder();
}
else {
// see if the top border needs to be the start of a segment due to a
// vertical border owning the corner
if (info.mColIndex > 0) {
BCData& data = info.mCellData->mData;
if (!data.IsTopStart()) {
- PRUint8 cornerSide;
+ mozilla::css::Side cornerSide;
PRPackedBool bevel;
data.GetCorner(cornerSide, bevel);
if ((NS_SIDE_TOP == cornerSide) || (NS_SIDE_BOTTOM == cornerSide)) {
data.SetTopStart(PR_TRUE);
}
}
}
}
@@ -5926,17 +5926,17 @@ struct BCVerticalSeg
nsTableRowGroupFrame* mFirstRowGroup; // row group at the start of the segment
nsTableRowFrame* mFirstRow; // row at the start of the segment
nsTableCellFrame* mLastCell; // cell at the current end of the
// segment
PRUint8 mOwner; // owner of the border, defines the
// style
- PRUint8 mTopBevelSide; // direction to bevel at the top
+ mozilla::css::Side mTopBevelSide; // direction to bevel at the top
nscoord mTopBevelOffset; // how much to bevel at the top
BCPixelSize mBottomHorSegHeight; // height of the crossing
//horizontal border
nscoord mBottomOffset; // how much longer is the segment due
// to the horizontal border, by this
// amount the next segment needs to be
// shifted.
PRBool mIsBottomBevel; // should we bevel at the bottom
@@ -5957,20 +5957,20 @@ struct BCHorizontalSeg
void Paint(BCPaintBorderIterator& aIter,
nsIRenderingContext& aRenderingContext);
nscoord mOffsetX; // x-offset with respect to the table edge
nscoord mOffsetY; // y-offset with respect to the table edge
nscoord mLength; // horizontal length including corners
BCPixelSize mWidth; // border width in pixels
nscoord mLeftBevelOffset; // how much to bevel at the left
- PRUint8 mLeftBevelSide; // direction to bevel at the left
- PRBool mIsRightBevel; // should we bevel at the right end
+ mozilla::css::Side mLeftBevelSide; // direction to bevel at the left
+ PRBool mIsRightBevel; // should we bevel at the right end
nscoord mRightBevelOffset; // how much to bevel at the right
- PRUint8 mRightBevelSide; // direction to bevel at the right
+ mozilla::css::Side mRightBevelSide; // direction to bevel at the right
nscoord mEndOffset; // how much longer is the segment due
// to the vertical border, by this
// amount the next segment needs to be
// shifted.
PRUint8 mOwner; // owner of the border, defines the
// style
nsTableCellFrame* mFirstCell; // cell at the start of the segment
nsTableCellFrame* mAjaCell; // neighboring cell to the first cell
@@ -6462,17 +6462,17 @@ BCPaintBorderIterator::Next()
* @param aCornerOwnerSide - which side owns the corner
* @param aCornerSubWidth - how wide is the nonwinning side of the corner
* @param aHorWidth - how wide is the horizontal edge of the corner
* @param aIsStartOfSeg - does this corner start a new segment
* @param aIsBevel - is this corner beveled
* @return - offset in twips
*/
static nscoord
-CalcVerCornerOffset(PRUint8 aCornerOwnerSide,
+CalcVerCornerOffset(mozilla::css::Side aCornerOwnerSide,
BCPixelSize aCornerSubWidth,
BCPixelSize aHorWidth,
PRBool aIsStartOfSeg,
PRBool aIsBevel)
{
nscoord offset = 0;
// XXX These should be replaced with appropriate side-specific macros (which?)
BCPixelSize smallHalf, largeHalf;
@@ -6503,17 +6503,17 @@ CalcVerCornerOffset(PRUint8 aCornerO
* @param aCornerSubWidth - how wide is the nonwinning side of the corner
* @param aVerWidth - how wide is the vertical edge of the corner
* @param aIsStartOfSeg - does this corner start a new segment
* @param aIsBevel - is this corner beveled
* @param aTableIsLTR - direction, the computation depends on ltr or rtl
* @return - offset in twips
*/
static nscoord
-CalcHorCornerOffset(PRUint8 aCornerOwnerSide,
+CalcHorCornerOffset(mozilla::css::Side aCornerOwnerSide,
BCPixelSize aCornerSubWidth,
BCPixelSize aVerWidth,
PRBool aIsStartOfSeg,
PRBool aIsBevel,
PRBool aTableIsLTR)
{
nscoord offset = 0;
// XXX These should be replaced with appropriate side-specific macros (which?)
@@ -6549,17 +6549,18 @@ CalcHorCornerOffset(PRUint8 aCornerO
}
return nsPresContext::CSSPixelsToAppUnits(offset);
}
BCVerticalSeg::BCVerticalSeg()
{
mCol = nsnull;
mFirstCell = mLastCell = mAjaCell = nsnull;
- mOffsetX = mOffsetY = mLength = mWidth = mTopBevelOffset = mTopBevelSide = 0;
+ mOffsetX = mOffsetY = mLength = mWidth = mTopBevelOffset = 0;
+ mTopBevelSide = NS_SIDE_TOP;
mOwner = eCellOwner;
}
/**
* Start a new vertical segment
* @param aIter - iterator containing the structural information
* @param aBorderOwner - determines the border style
* @param aVerSegWidth - the width of segment in pixel
@@ -6567,17 +6568,17 @@ BCVerticalSeg::BCVerticalSeg()
* at the start
*/
void
BCVerticalSeg::Start(BCPaintBorderIterator& aIter,
BCBorderOwner aBorderOwner,
BCPixelSize aVerSegWidth,
BCPixelSize aHorSegHeight)
{
- PRUint8 ownerSide = 0;
+ mozilla::css::Side ownerSide = NS_SIDE_TOP;
PRPackedBool bevel = PR_FALSE;
nscoord cornerSubWidth = (aIter.mBCData) ?
aIter.mBCData->GetCorner(ownerSide, bevel) : 0;
PRBool topBevel = (aVerSegWidth > 0) ? bevel : PR_FALSE;
BCPixelSize maxHorSegHeight = PR_MAX(aIter.mPrevHorSegHeight, aHorSegHeight);
@@ -6630,17 +6631,17 @@ BCVerticalSeg::Initialize(BCPaintBorderI
* @param aIter - iterator containing the structural information
* @param aHorSegHeight - the width of the horizontal segment joining the corner
* at the start
*/
void
BCVerticalSeg::GetBottomCorner(BCPaintBorderIterator& aIter,
BCPixelSize aHorSegHeight)
{
- PRUint8 ownerSide = 0;
+ mozilla::css::Side ownerSide = NS_SIDE_TOP;
nscoord cornerSubWidth = 0;
PRPackedBool bevel = PR_FALSE;
if (aIter.mBCData) {
cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
}
mIsBottomBevel = (mWidth > 0) ? bevel : PR_FALSE;
mBottomHorSegHeight = PR_MAX(aIter.mPrevHorSegHeight, aHorSegHeight);
mBottomOffset = CalcVerCornerOffset(ownerSide, cornerSubWidth,
@@ -6657,17 +6658,17 @@ BCVerticalSeg::GetBottomCorner(BCPaintBo
* at the start
*/
void
BCVerticalSeg::Paint(BCPaintBorderIterator& aIter,
nsIRenderingContext& aRenderingContext,
BCPixelSize aHorSegHeight)
{
// get the border style, color and paint the segment
- PRUint8 side = (aIter.IsDamageAreaRightMost()) ? NS_SIDE_RIGHT :
+ mozilla::css::Side side = (aIter.IsDamageAreaRightMost()) ? NS_SIDE_RIGHT :
NS_SIDE_LEFT;
PRInt32 relColIndex = aIter.GetRelativeColIndex();
nsTableColFrame* col = mCol; if (!col) ABORT0();
nsTableCellFrame* cell = mFirstCell; // ???
nsIFrame* owner = nsnull;
PRUint8 style = NS_STYLE_BORDER_STYLE_SOLID;
nscolor color = 0xFFFFFFFF;
@@ -6720,19 +6721,19 @@ BCVerticalSeg::Paint(BCPaintBorderIterat
}
BCPixelSize smallHalf, largeHalf;
DivideBCBorderSize(mWidth, smallHalf, largeHalf);
nsRect segRect(mOffsetX - nsPresContext::CSSPixelsToAppUnits(largeHalf),
mOffsetY,
nsPresContext::CSSPixelsToAppUnits(mWidth), mLength);
nscoord bottomBevelOffset = (mIsBottomBevel) ?
nsPresContext::CSSPixelsToAppUnits(mBottomHorSegHeight) : 0;
- PRUint8 bottomBevelSide = ((aHorSegHeight > 0) ^ !aIter.mTableIsLTR) ?
+ mozilla::css::Side bottomBevelSide = ((aHorSegHeight > 0) ^ !aIter.mTableIsLTR) ?
NS_SIDE_RIGHT : NS_SIDE_LEFT;
- PRUint8 topBevelSide = ((mTopBevelSide == NS_SIDE_RIGHT) ^ !aIter.mTableIsLTR)?
+ mozilla::css::Side topBevelSide = ((mTopBevelSide == NS_SIDE_RIGHT) ^ !aIter.mTableIsLTR)?
NS_SIDE_RIGHT : NS_SIDE_LEFT;
nsCSSRendering::DrawTableBorderSegment(aRenderingContext, style, color,
aIter.mTableBgColor, segRect,
nsPresContext::AppUnitsPerCSSPixel(),
topBevelSide, mTopBevelOffset,
bottomBevelSide, bottomBevelOffset);
}
@@ -6753,33 +6754,33 @@ BCVerticalSeg::IncludeCurrentBorder(BCPa
{
mLastCell = aIter.mCell;
mLength += aIter.mRow->GetRect().height;
}
BCHorizontalSeg::BCHorizontalSeg()
{
mOffsetX = mOffsetY = mLength = mWidth = mLeftBevelOffset = 0;
- mLeftBevelSide = 0;
+ mLeftBevelSide = NS_SIDE_TOP;
mFirstCell = mAjaCell = nsnull;
}
/** Initialize a horizontal border segment for painting
* @param aIter - iterator storing the current and adjacent frames
* @param aBorderOwner - which frame owns the border
* @param aBottomVerSegWidth - vertical segment width coming from up
* @param aHorSegHeight - the height of the segment
+ */
void
BCHorizontalSeg::Start(BCPaintBorderIterator& aIter,
BCBorderOwner aBorderOwner,
BCPixelSize aBottomVerSegWidth,
BCPixelSize aHorSegHeight)
{
- PRUint8 cornerOwnerSide = 0;
+ mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
PRPackedBool bevel = PR_FALSE;
mOwner = aBorderOwner;
nscoord cornerSubWidth = (aIter.mBCData) ?
aIter.mBCData->GetCorner(cornerOwnerSide,
bevel) : 0;
PRBool leftBevel = (aHorSegHeight > 0) ? bevel : PR_FALSE;
@@ -6810,17 +6811,17 @@ BCHorizontalSeg::Start(BCPaintBorderIter
* @param aIter - iterator containing the structural information
* @param aLeftSegWidth - the width of the vertical segment joining the corner
* at the start
*/
void
BCHorizontalSeg::GetRightCorner(BCPaintBorderIterator& aIter,
BCPixelSize aLeftSegWidth)
{
- PRUint8 ownerSide = 0;
+ mozilla::css::Side ownerSide = NS_SIDE_TOP;
nscoord cornerSubWidth = 0;
PRPackedBool bevel = PR_FALSE;
if (aIter.mBCData) {
cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
}
mIsRightBevel = (mWidth > 0) ? bevel : 0;
PRInt32 relColIndex = aIter.GetRelativeColIndex();
@@ -6838,17 +6839,17 @@ BCHorizontalSeg::GetRightCorner(BCPaintB
* @param aIter - iterator containing the structural information
* @param aRenderingContext - the rendering context
*/
void
BCHorizontalSeg::Paint(BCPaintBorderIterator& aIter,
nsIRenderingContext& aRenderingContext)
{
// get the border style, color and paint the segment
- PRUint8 side = (aIter.IsDamageAreaBottomMost()) ? NS_SIDE_BOTTOM :
+ mozilla::css::Side side = (aIter.IsDamageAreaBottomMost()) ? NS_SIDE_BOTTOM :
NS_SIDE_TOP;
nsIFrame* rg = aIter.mRg; if (!rg) ABORT0();
nsIFrame* row = aIter.mRow; if (!row) ABORT0();
nsIFrame* cell = mFirstCell;
nsIFrame* col;
nsIFrame* owner = nsnull;
PRUint8 style = NS_STYLE_BORDER_STYLE_SOLID;
@@ -6963,17 +6964,17 @@ BCPaintBorderIterator::StoreColumnWidth(
}
}
/**
* Determine if a vertical segment owns the corder
*/
PRBool
BCPaintBorderIterator::VerticalSegmentOwnsCorner()
{
- PRUint8 cornerOwnerSide = 0;
+ mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
PRPackedBool bevel = PR_FALSE;
nscoord cornerSubWidth;
cornerSubWidth = (mBCData) ? mBCData->GetCorner(cornerOwnerSide, bevel) : 0;
// unitialized ownerside, bevel
return (NS_SIDE_TOP == cornerOwnerSide) ||
(NS_SIDE_BOTTOM == cornerOwnerSide);
}
