nsMargin*
nsTableCellFrame::GetBorderWidth(float aPixelsToTwips,
nsMargin& aBorder) const
{
aBorder = GetStyleBorder()->GetBorder();
return &aBorder;
}
NS_IMETHODIMP
nsBox::GetBorder(nsMargin& aMargin)
{
aMargin.SizeTo(0,0,0,0);
const nsStyleDisplay* disp = GetStyleDisplay();
if (disp->mAppearance && gTheme) {
// Go to the theme for the border.
nsPresContext *context = PresContext();
if (gTheme->ThemeSupportsWidget(context, this, disp->mAppearance)) {
nsIntMargin margin(0, 0, 0, 0);
gTheme->GetWidgetBorder(context->DeviceContext(), this,
disp->mAppearance, &margin);
aMargin.top = context->DevPixelsToAppUnits(margin.top);
aMargin.right = context->DevPixelsToAppUnits(margin.right);
aMargin.bottom = context->DevPixelsToAppUnits(margin.bottom);
aMargin.left = context->DevPixelsToAppUnits(margin.left);
return NS_OK;
}
}
aMargin = GetStyleBorder()->GetActualBorder();
return NS_OK;
}
/* virtual */ PRBool
nsInlineFrame::IsSelfEmpty()
{
#if 0
// I used to think inline frames worked this way, but it seems they
// don't. At least not in our codebase.
if (GetPresContext()->CompatibilityMode() == eCompatibility_FullStandards) {
return PR_FALSE;
}
#endif
const nsStyleMargin* margin = GetStyleMargin();
const nsStyleBorder* border = GetStyleBorder();
const nsStylePadding* padding = GetStylePadding();
// XXX Top and bottom removed, since they shouldn't affect things, but this
// doesn't really match with nsLineLayout.cpp's setting of
// ZeroEffectiveSpanBox, anymore, so what should this really be?
PRBool haveRight =
border->GetActualBorderWidth(NS_SIDE_RIGHT) != 0 ||
!IsPaddingZero(padding->mPadding.GetRightUnit(),
padding->mPadding.GetRight()) ||
!IsMarginZero(margin->mMargin.GetRightUnit(),
margin->mMargin.GetRight());
PRBool haveLeft =
border->GetActualBorderWidth(NS_SIDE_LEFT) != 0 ||
!IsPaddingZero(padding->mPadding.GetLeftUnit(),
padding->mPadding.GetLeft()) ||
!IsMarginZero(margin->mMargin.GetLeftUnit(),
margin->mMargin.GetLeft());
if (haveLeft || haveRight) {
if (GetStateBits() & NS_FRAME_IS_SPECIAL) {
PRBool haveStart, haveEnd;
if (NS_STYLE_DIRECTION_LTR == GetStyleVisibility()->mDirection) {
haveStart = haveLeft;
haveEnd = haveRight;
} else {
haveStart = haveRight;
haveEnd = haveLeft;
}
// For special frames, ignore things we know we'll skip in GetSkipSides.
// XXXbz should we be doing this for non-special frames too, in a more
// general way?
// Get the first continuation eagerly, as a performance optimization, to
// avoid having to get it twice..
nsIFrame* firstCont = GetFirstContinuation();
return
(!haveStart || nsLayoutUtils::FrameIsInLastPartOfIBSplit(firstCont)) &&
(!haveEnd || nsLayoutUtils::FrameIsInFirstPartOfIBSplit(firstCont));
}
return PR_FALSE;
}
return PR_TRUE;
}
//------------------------------------------------------------------------------
void
nsPageFrame::PaintPageContent(nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt) {
nsIFrame* pageContentFrame = mFrames.FirstChild();
nsRect rect = aDirtyRect;
float scale = PresContext()->GetPageScale();
aRenderingContext.PushState();
nsPoint framePos = aPt + pageContentFrame->GetOffsetTo(this);
aRenderingContext.Translate(framePos.x, framePos.y);
// aPt translates to coords relative to this, then margins translate to
// pageContentFrame's coords
rect -= framePos;
aRenderingContext.Scale(scale, scale);
rect.ScaleRoundOut(1.0f / scale);
// Make sure we don't draw where we aren't supposed to draw, especially
// when printing selection
nsRect clipRect(nsPoint(0, 0), pageContentFrame->GetSize());
// Note: this computation matches how we compute maxSize.height
// in nsPageFrame::Reflow
nscoord expectedPageContentHeight =
NSToCoordCeil((GetSize().height - mPD->mReflowMargin.TopBottom()) / scale);
if (clipRect.height > expectedPageContentHeight) {
// We're doing print-selection, with one long page-content frame.
// Clip to the appropriate page-content slice for the current page.
NS_ASSERTION(mPageNum > 0, "page num should be positive");
clipRect.y = expectedPageContentHeight * (mPageNum - 1);
clipRect.height = expectedPageContentHeight;
NS_ASSERTION(clipRect.y < pageContentFrame->GetSize().height,
"Should be clipping to region inside the page content bounds");
}
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
const nsStyleBorder* border = GetStyleBorder();
const nsStylePadding* padding = GetStylePadding();
nsRect backgroundRect = nsRect(nsPoint(0, 0), pageContentFrame->GetSize());
nsCSSRendering::PaintBackground(PresContext(), aRenderingContext, this,
rect, backgroundRect, *border, *padding,
PR_TRUE);
nsLayoutUtils::PaintFrame(&aRenderingContext, pageContentFrame,
nsRegion(rect), NS_RGBA(0,0,0,0));
aRenderingContext.PopState();
}
NS_IMETHODIMP
nsFileControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
// box-shadow
if (GetStyleBorder()->mBoxShadow) {
nsresult rv = aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
nsDisplayBoxShadowOuter(aBuilder, this));
NS_ENSURE_SUCCESS(rv, rv);
}
// Our background is inherited to the text input, and we don't really want to
// paint it or out padding and borders (which we never have anyway, per
// styles in forms.css) -- doing it just makes us look ugly in some cases and
// has no effect in others.
nsDisplayListCollection tempList;
nsresult rv = nsBlockFrame::BuildDisplayList(aBuilder, aDirtyRect, tempList);
if (NS_FAILED(rv))
return rv;
tempList.BorderBackground()->DeleteAll();
// Clip height only
nsRect clipRect(aBuilder->ToReferenceFrame(this), GetSize());
clipRect.width = GetVisualOverflowRect().XMost();
nscoord radii[8] = {0, 0, 0, 0, 0, 0, 0, 0};
rv = OverflowClip(aBuilder, tempList, aLists, clipRect, radii);
NS_ENSURE_SUCCESS(rv, rv);
// Disabled file controls don't pass mouse events to their children, so we
// put an invisible item in the display list above the children
// just to catch events
nsEventStates eventStates = mContent->AsElement()->State();
if (eventStates.HasState(NS_EVENT_STATE_DISABLED) && IsVisibleForPainting(aBuilder)) {
rv = aLists.Content()->AppendNewToTop(
new (aBuilder) nsDisplayEventReceiver(aBuilder, this));
if (NS_FAILED(rv))
return rv;
}
return DisplaySelectionOverlay(aBuilder, aLists.Content());
}
NS_IMETHODIMP
nsHTMLButtonControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
nsDisplayList onTop;
if (IsVisibleForPainting(aBuilder)) {
nsresult rv = mRenderer.DisplayButton(aBuilder, aLists.BorderBackground(), &onTop);
NS_ENSURE_SUCCESS(rv, rv);
}
nsDisplayListCollection set;
// Do not allow the child subtree to receive events.
if (!aBuilder->IsForEventDelivery()) {
nsresult rv =
BuildDisplayListForChild(aBuilder, mFrames.FirstChild(), aDirtyRect, set,
DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT);
NS_ENSURE_SUCCESS(rv, rv);
// That should put the display items in set.Content()
}
// Put the foreground outline and focus rects on top of the children
set.Content()->AppendToTop(&onTop);
// clips to our padding box for <input>s but not <button>s, unless
// they have non-visible overflow..
if (IsInput() || GetStyleDisplay()->mOverflowX != NS_STYLE_OVERFLOW_VISIBLE) {
nsMargin border = GetStyleBorder()->GetActualBorder();
nsRect rect(aBuilder->ToReferenceFrame(this), GetSize());
rect.Deflate(border);
nsresult rv = OverflowClip(aBuilder, set, aLists, rect);
NS_ENSURE_SUCCESS(rv, rv);
} else {
set.MoveTo(aLists);
}
nsresult rv = DisplayOutline(aBuilder, aLists);
NS_ENSURE_SUCCESS(rv, rv);
// to draw border when selected in editor
return DisplaySelectionOverlay(aBuilder, aLists);
}
NS_IMETHODIMP
nsTableCellFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags)
{
NS_ENSURE_TRUE(aPresContext, NS_ERROR_NULL_POINTER);
PRBool isVisible;
if (NS_SUCCEEDED(IsVisibleForPainting(aPresContext, aRenderingContext, PR_FALSE, &isVisible)) && !isVisible) {
return NS_OK;
}
PRBool paintChildren = PR_TRUE;
if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer) {
const nsStyleBorder* myBorder = nsnull;
const nsStylePadding* myPadding = nsnull;
const nsStyleTableBorder* cellTableStyle = nsnull;
const nsStyleVisibility* vis = GetStyleVisibility();
if (vis->IsVisible()) {
myBorder = GetStyleBorder();
myPadding = GetStylePadding();
cellTableStyle = GetStyleTableBorder();
// draw the border & background only when there is content or showing empty cells
if (NS_STYLE_TABLE_EMPTY_CELLS_HIDE != cellTableStyle->mEmptyCells ||
!GetContentEmpty()) {
PaintUnderlay(*aPresContext, aRenderingContext, aDirtyRect, aFlags,
*myBorder, *myPadding, *cellTableStyle);
}
// Paint outline
nsRect rect(0, 0, mRect.width, mRect.height);
const nsStyleOutline* myOutline = GetStyleOutline();
nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *myBorder, *myOutline,
mStyleContext, 0);
const nsStyleBackground* myColor = GetStyleBackground();
DecorateForSelection(aPresContext, aRenderingContext,myColor); //ignore return value
}
paintChildren = !(aFlags & NS_PAINT_FLAG_TABLE_CELL_BG_PASS);
//flags were for us; remove them for our children
aFlags &= ~ (NS_PAINT_FLAG_TABLE_CELL_BG_PASS | NS_PAINT_FLAG_TABLE_BG_PAINT);
}
#ifdef DEBUG
// for debug...
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
aRenderingContext.SetColor(NS_RGB(0, 0, 128));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
}
#endif
// paint the children unless we've been told not to
if (paintChildren) {
const nsStyleDisplay* disp = GetStyleDisplay();
// if the cell originates in a row and/or col that is collapsed, the
// bottom and/or right portion of the cell is painted by translating
// the rendering context.
nsPoint offset;
GetCollapseOffset(offset);
PRBool pushed = PR_FALSE;
if ((0 != offset.x) || (0 != offset.y)) {
aRenderingContext.PushState();
pushed = PR_TRUE;
aRenderingContext.Translate(offset.x, offset.y);
aRenderingContext.SetClipRect(nsRect(-offset.x, -offset.y, mRect.width, mRect.height),
nsClipCombine_kIntersect);
}
else {
// XXXldb HIDDEN should really create a scrollframe,
// but use |IsTableClip| here since it doesn't.
if (disp->IsTableClip() ||
(HasPctOverHeight() && eCompatibility_NavQuirks == aPresContext->CompatibilityMode())) {
aRenderingContext.PushState();
pushed = PR_TRUE;
SetOverflowClipRect(aRenderingContext);
}
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer, aFlags);
if (pushed) {
aRenderingContext.PopState();
}
}
DO_GLOBAL_REFLOW_COUNT_DSP_J("nsTableCellFrame", &aRenderingContext, 0);
return NS_OK;
/*nsFrame::Paint(aPresContext,
aRenderingContext,
aDirtyRect,
aWhichLayer);*/
}
void
nsGroupBoxFrame::PaintBorderBackground(nsIRenderingContext& aRenderingContext,
nsPoint aPt, const nsRect& aDirtyRect) {
PRIntn skipSides = 0;
const nsStyleBorder* borderStyleData = GetStyleBorder();
const nsMargin& border = borderStyleData->GetActualBorder();
nscoord yoff = 0;
nsPresContext* presContext = PresContext();
nsRect groupRect;
nsIBox* groupBox = GetCaptionBox(presContext, groupRect);
if (groupBox) {
// if the border is smaller than the legend. Move the border down
// to be centered on the legend.
nsMargin groupMargin;
groupBox->GetStyleMargin()->GetMargin(groupMargin);
groupRect.Inflate(groupMargin);
if (border.top < groupRect.height)
yoff = (groupRect.height - border.top)/2 + groupRect.y;
}
nsRect rect(aPt.x, aPt.y + yoff, mRect.width, mRect.height - yoff);
groupRect += aPt;
nsCSSRendering::PaintBackground(presContext, aRenderingContext, this,
aDirtyRect, rect, 0);
if (groupBox) {
// we should probably use PaintBorderEdges to do this but for now just use clipping
// to achieve the same effect.
// draw left side
nsRect clipRect(rect);
clipRect.width = groupRect.x - rect.x;
clipRect.height = border.top;
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyleData,
mStyleContext, skipSides);
aRenderingContext.PopState();
// draw right side
clipRect = rect;
clipRect.x = groupRect.XMost();
clipRect.width = rect.XMost() - groupRect.XMost();
clipRect.height = border.top;
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyleData,
mStyleContext, skipSides);
aRenderingContext.PopState();
// draw bottom
clipRect = rect;
clipRect.y += border.top;
clipRect.height = mRect.height - (yoff + border.top);
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyleData,
mStyleContext, skipSides);
aRenderingContext.PopState();
} else {
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, nsRect(aPt, GetSize()),
*borderStyleData, mStyleContext, skipSides);
}
}
// this is identical to nsHTMLContainerFrame::Paint except for the background and border.
NS_IMETHODIMP
nsFieldSetFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
nsFramePaintLayer aWhichLayer,
PRUint32 aFlags)
{
if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer) {
// Paint our background and border
PRBool isVisible;
if (NS_SUCCEEDED(IsVisibleForPainting(aPresContext, aRenderingContext, PR_TRUE, &isVisible)) &&
isVisible && mRect.width && mRect.height) {
PRIntn skipSides = GetSkipSides();
const nsStyleBorder* borderStyle = GetStyleBorder();
const nsStylePadding* paddingStyle = GetStylePadding();
nscoord topBorder = borderStyle->GetBorderWidth(NS_SIDE_TOP);
nscoord yoff = 0;
// if the border is smaller than the legend. Move the border down
// to be centered on the legend.
if (topBorder < mLegendRect.height)
yoff = (mLegendRect.height - topBorder)/2;
nsRect rect(0, yoff, mRect.width, mRect.height - yoff);
nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyle,
*paddingStyle, PR_TRUE);
if (mLegendFrame) {
// Use the rect of the legend frame, not mLegendRect, so we draw our
// border under the legend's left and right margins.
const nsRect & legendRect = mLegendFrame->GetRect();
// we should probably use PaintBorderEdges to do this but for now just use clipping
// to achieve the same effect.
// draw left side
nsRect clipRect(rect);
clipRect.width = legendRect.x - rect.x;
clipRect.height = topBorder;
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyle, mStyleContext, skipSides);
aRenderingContext.PopState();
// draw right side
clipRect = rect;
clipRect.x = legendRect.x + legendRect.width;
clipRect.width -= (legendRect.x + legendRect.width);
clipRect.height = topBorder;
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyle, mStyleContext, skipSides);
aRenderingContext.PopState();
// draw bottom
clipRect = rect;
clipRect.y += topBorder;
clipRect.height = mRect.height - (yoff + topBorder);
aRenderingContext.PushState();
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect);
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect, rect, *borderStyle, mStyleContext, skipSides);
aRenderingContext.PopState();
} else {
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect,
nsRect(0,0,mRect.width, mRect.height),
*borderStyle, mStyleContext, skipSides);
}
}
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer);
#ifdef DEBUG
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
if (HasView()) {
aRenderingContext.SetColor(NS_RGB(0,0,255));
}
else {
aRenderingContext.SetColor(NS_RGB(255,0,0));
}
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
}
#endif
DO_GLOBAL_REFLOW_COUNT_DSP("nsFieldSetFrame", &aRenderingContext);
return NS_OK;
}