зеркало из https://github.com/mozilla/gecko-dev.git
669 строки
24 KiB
C++
669 строки
24 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
// YY need to pass isMultiple before create called
|
|
|
|
//#include "nsFormControlFrame.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsLegendFrame.h"
|
|
#include "nsIDOMNode.h"
|
|
#include "nsIDOMHTMLFieldSetElement.h"
|
|
#include "nsIDOMHTMLLegendElement.h"
|
|
#include "nsCSSRendering.h"
|
|
//#include "nsIDOMHTMLCollection.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsISupports.h"
|
|
#include "nsIAtom.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsFrameManager.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsFont.h"
|
|
#include "nsCOMPtr.h"
|
|
#ifdef ACCESSIBILITY
|
|
#include "nsAccessibilityService.h"
|
|
#endif
|
|
#include "nsIServiceManager.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsRenderingContext.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::layout;
|
|
|
|
class nsLegendFrame;
|
|
|
|
class nsFieldSetFrame : public nsContainerFrame {
|
|
public:
|
|
NS_DECL_FRAMEARENA_HELPERS
|
|
|
|
nsFieldSetFrame(nsStyleContext* aContext);
|
|
|
|
NS_IMETHOD SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList);
|
|
|
|
NS_HIDDEN_(nscoord)
|
|
GetIntrinsicWidth(nsRenderingContext* aRenderingContext,
|
|
nsLayoutUtils::IntrinsicWidthType);
|
|
virtual nscoord GetMinWidth(nsRenderingContext* aRenderingContext);
|
|
virtual nscoord GetPrefWidth(nsRenderingContext* aRenderingContext);
|
|
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
|
|
nsSize aCBSize, nscoord aAvailableWidth,
|
|
nsSize aMargin, nsSize aBorder, nsSize aPadding,
|
|
PRUint32 aFlags) MOZ_OVERRIDE;
|
|
virtual nscoord GetBaseline() const;
|
|
virtual void DestroyFrom(nsIFrame* aDestructRoot);
|
|
|
|
NS_IMETHOD Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus);
|
|
|
|
NS_IMETHOD BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists);
|
|
|
|
void PaintBorderBackground(nsRenderingContext& aRenderingContext,
|
|
nsPoint aPt, const nsRect& aDirtyRect, PRUint32 aBGFlags);
|
|
|
|
NS_IMETHOD AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList);
|
|
NS_IMETHOD InsertFrames(ChildListID aListID,
|
|
nsIFrame* aPrevFrame,
|
|
nsFrameList& aFrameList);
|
|
NS_IMETHOD RemoveFrame(ChildListID aListID,
|
|
nsIFrame* aOldFrame);
|
|
|
|
virtual nsIAtom* GetType() const;
|
|
|
|
#ifdef ACCESSIBILITY
|
|
virtual already_AddRefed<Accessible> CreateAccessible();
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
NS_IMETHOD GetFrameName(nsAString& aResult) const {
|
|
return MakeFrameName(NS_LITERAL_STRING("FieldSet"), aResult);
|
|
}
|
|
#endif
|
|
|
|
protected:
|
|
|
|
virtual PRIntn GetSkipSides() const;
|
|
void ReparentFrameList(const nsFrameList& aFrameList);
|
|
|
|
// mLegendFrame is a nsLegendFrame or a nsHTMLScrollFrame with the
|
|
// nsLegendFrame as the scrolled frame (aka content insertion frame).
|
|
nsIFrame* mLegendFrame;
|
|
nsIFrame* mContentFrame;
|
|
nsRect mLegendRect;
|
|
nscoord mLegendSpace;
|
|
};
|
|
|
|
nsIFrame*
|
|
NS_NewFieldSetFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsFieldSetFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsFieldSetFrame)
|
|
|
|
nsFieldSetFrame::nsFieldSetFrame(nsStyleContext* aContext)
|
|
: nsContainerFrame(aContext)
|
|
{
|
|
mContentFrame = nsnull;
|
|
mLegendFrame = nsnull;
|
|
mLegendSpace = 0;
|
|
}
|
|
|
|
void
|
|
nsFieldSetFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
|
{
|
|
DestroyAbsoluteFrames(aDestructRoot);
|
|
nsContainerFrame::DestroyFrom(aDestructRoot);
|
|
}
|
|
|
|
nsIAtom*
|
|
nsFieldSetFrame::GetType() const
|
|
{
|
|
return nsGkAtoms::fieldSetFrame;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList)
|
|
{
|
|
// Get the content and legend frames.
|
|
if (!aChildList.OnlyChild()) {
|
|
NS_ASSERTION(aChildList.GetLength() == 2, "Unexpected child list");
|
|
mContentFrame = aChildList.LastChild();
|
|
mLegendFrame = aChildList.FirstChild();
|
|
} else {
|
|
mContentFrame = aChildList.FirstChild();
|
|
mLegendFrame = nsnull;
|
|
}
|
|
|
|
// Queue up the frames for the content frame
|
|
return nsContainerFrame::SetInitialChildList(kPrincipalList, aChildList);
|
|
}
|
|
|
|
class nsDisplayFieldSetBorderBackground : public nsDisplayItem {
|
|
public:
|
|
nsDisplayFieldSetBorderBackground(nsDisplayListBuilder* aBuilder,
|
|
nsFieldSetFrame* aFrame)
|
|
: nsDisplayItem(aBuilder, aFrame) {
|
|
MOZ_COUNT_CTOR(nsDisplayFieldSetBorderBackground);
|
|
}
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
virtual ~nsDisplayFieldSetBorderBackground() {
|
|
MOZ_COUNT_DTOR(nsDisplayFieldSetBorderBackground);
|
|
}
|
|
#endif
|
|
|
|
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
|
|
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames);
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx);
|
|
NS_DISPLAY_DECL_NAME("FieldSetBorderBackground", TYPE_FIELDSET_BORDER_BACKGROUND)
|
|
};
|
|
|
|
void nsDisplayFieldSetBorderBackground::HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
|
|
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames)
|
|
{
|
|
// aPt is guaranteed to be in this item's bounds. We do the hit test based on the
|
|
// frame bounds even though our background doesn't cover the whole frame.
|
|
// It's not clear whether this is correct.
|
|
aOutFrames->AppendElement(mFrame);
|
|
}
|
|
|
|
void
|
|
nsDisplayFieldSetBorderBackground::Paint(nsDisplayListBuilder* aBuilder,
|
|
nsRenderingContext* aCtx)
|
|
{
|
|
static_cast<nsFieldSetFrame*>(mFrame)->
|
|
PaintBorderBackground(*aCtx, ToReferenceFrame(),
|
|
mVisibleRect, aBuilder->GetBackgroundPaintFlags());
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists) {
|
|
// Paint our background and border in a special way.
|
|
// REVIEW: We don't really need to check frame emptiness here; if it's empty,
|
|
// the background/border display item won't do anything, and if it isn't empty,
|
|
// we need to paint the outline
|
|
if (IsVisibleForPainting(aBuilder)) {
|
|
if (GetStyleBorder()->mBoxShadow) {
|
|
nsresult rv = aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
|
|
nsDisplayBoxShadowOuter(aBuilder, this));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// don't bother checking to see if we really have a border or background.
|
|
// we usually will have a border.
|
|
nsresult rv = aLists.BorderBackground()->AppendNewToTop(new (aBuilder)
|
|
nsDisplayFieldSetBorderBackground(aBuilder, this));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = DisplayOutlineUnconditional(aBuilder, aLists);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
DO_GLOBAL_REFLOW_COUNT_DSP("nsFieldSetFrame");
|
|
}
|
|
|
|
nsDisplayListCollection contentDisplayItems;
|
|
if (mContentFrame) {
|
|
// Collect mContentFrame's display items into their own collection. We need
|
|
// to be calling BuildDisplayList on mContentFrame before mLegendFrame in
|
|
// case it contains out-of-flow frames whose placeholders are under
|
|
// mLegendFrame. However, we want mContentFrame's display items to be
|
|
// after mLegendFrame's display items in z-order, so we need to save them
|
|
// and append them later.
|
|
nsresult rv = BuildDisplayListForChild(aBuilder, mContentFrame, aDirtyRect,
|
|
contentDisplayItems);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
if (mLegendFrame) {
|
|
// The legend's background goes on our BlockBorderBackgrounds list because
|
|
// it's a block child.
|
|
nsDisplayListSet set(aLists, aLists.BlockBorderBackgrounds());
|
|
nsresult rv = BuildDisplayListForChild(aBuilder, mLegendFrame, aDirtyRect, set);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
// Put mContentFrame's display items on the master list. Note that
|
|
// this moves mContentFrame's border/background display items to our
|
|
// BorderBackground() list, which isn't really correct, but it's OK because
|
|
// mContentFrame is anonymous and can't have its own border and background.
|
|
contentDisplayItems.MoveTo(aLists);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsFieldSetFrame::PaintBorderBackground(nsRenderingContext& aRenderingContext,
|
|
nsPoint aPt, const nsRect& aDirtyRect, PRUint32 aBGFlags)
|
|
{
|
|
PRIntn skipSides = GetSkipSides();
|
|
const nsStyleBorder* borderStyle = GetStyleBorder();
|
|
|
|
nscoord topBorder = borderStyle->GetComputedBorderWidth(NS_SIDE_TOP);
|
|
nscoord yoff = 0;
|
|
nsPresContext* presContext = PresContext();
|
|
|
|
// if the border is smaller than the legend. Move the border down
|
|
// to be centered on the legend.
|
|
// FIXME: This means border-radius clamping is incorrect; we should
|
|
// override nsIFrame::GetBorderRadii.
|
|
if (topBorder < mLegendRect.height)
|
|
yoff = (mLegendRect.height - topBorder)/2;
|
|
|
|
nsRect rect(aPt.x, aPt.y + yoff, mRect.width, mRect.height - yoff);
|
|
|
|
nsCSSRendering::PaintBackground(presContext, aRenderingContext, this,
|
|
aDirtyRect, rect, aBGFlags);
|
|
|
|
nsCSSRendering::PaintBoxShadowInner(presContext, aRenderingContext,
|
|
this, rect, aDirtyRect);
|
|
|
|
if (mLegendFrame) {
|
|
|
|
// Use the rect of the legend frame, not mLegendRect, so we draw our
|
|
// border under the legend's left and right margins.
|
|
nsRect legendRect = mLegendFrame->GetRect() + aPt;
|
|
|
|
// 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.IntersectClip(clipRect);
|
|
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
|
|
aDirtyRect, rect, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState();
|
|
|
|
|
|
// draw right side
|
|
clipRect = rect;
|
|
clipRect.x = legendRect.XMost();
|
|
clipRect.width = rect.XMost() - legendRect.XMost();
|
|
clipRect.height = topBorder;
|
|
|
|
aRenderingContext.PushState();
|
|
aRenderingContext.IntersectClip(clipRect);
|
|
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
|
|
aDirtyRect, rect, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState();
|
|
|
|
|
|
// draw bottom
|
|
clipRect = rect;
|
|
clipRect.y += topBorder;
|
|
clipRect.height = mRect.height - (yoff + topBorder);
|
|
|
|
aRenderingContext.PushState();
|
|
aRenderingContext.IntersectClip(clipRect);
|
|
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
|
|
aDirtyRect, rect, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState();
|
|
} else {
|
|
|
|
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
|
|
aDirtyRect,
|
|
nsRect(aPt, mRect.Size()),
|
|
mStyleContext, skipSides);
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
nsFieldSetFrame::GetIntrinsicWidth(nsRenderingContext* aRenderingContext,
|
|
nsLayoutUtils::IntrinsicWidthType aType)
|
|
{
|
|
nscoord legendWidth = 0;
|
|
nscoord contentWidth = 0;
|
|
if (mLegendFrame) {
|
|
legendWidth =
|
|
nsLayoutUtils::IntrinsicForContainer(aRenderingContext, mLegendFrame,
|
|
aType);
|
|
}
|
|
|
|
if (mContentFrame) {
|
|
contentWidth =
|
|
nsLayoutUtils::IntrinsicForContainer(aRenderingContext, mContentFrame,
|
|
aType);
|
|
}
|
|
|
|
return NS_MAX(legendWidth, contentWidth);
|
|
}
|
|
|
|
|
|
nscoord
|
|
nsFieldSetFrame::GetMinWidth(nsRenderingContext* aRenderingContext)
|
|
{
|
|
nscoord result = 0;
|
|
DISPLAY_MIN_WIDTH(this, result);
|
|
|
|
result = GetIntrinsicWidth(aRenderingContext, nsLayoutUtils::MIN_WIDTH);
|
|
return result;
|
|
}
|
|
|
|
nscoord
|
|
nsFieldSetFrame::GetPrefWidth(nsRenderingContext* aRenderingContext)
|
|
{
|
|
nscoord result = 0;
|
|
DISPLAY_PREF_WIDTH(this, result);
|
|
|
|
result = GetIntrinsicWidth(aRenderingContext, nsLayoutUtils::PREF_WIDTH);
|
|
return result;
|
|
}
|
|
|
|
/* virtual */ nsSize
|
|
nsFieldSetFrame::ComputeSize(nsRenderingContext *aRenderingContext,
|
|
nsSize aCBSize, nscoord aAvailableWidth,
|
|
nsSize aMargin, nsSize aBorder, nsSize aPadding,
|
|
PRUint32 aFlags)
|
|
{
|
|
nsSize result =
|
|
nsContainerFrame::ComputeSize(aRenderingContext, aCBSize, aAvailableWidth,
|
|
aMargin, aBorder, aPadding, aFlags);
|
|
|
|
// Fieldsets never shrink below their min width.
|
|
|
|
// If we're a container for font size inflation, then shrink
|
|
// wrapping inside of us should not apply font size inflation.
|
|
AutoMaybeDisableFontInflation an(this);
|
|
|
|
nscoord minWidth = GetMinWidth(aRenderingContext);
|
|
if (minWidth > result.width)
|
|
result.width = minWidth;
|
|
|
|
return result;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
|
|
NS_PRECONDITION(aReflowState.ComputedWidth() != NS_INTRINSICSIZE,
|
|
"Should have a precomputed width!");
|
|
|
|
// Initialize OUT parameter
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
//------------ Handle Incremental Reflow -----------------
|
|
bool reflowContent;
|
|
bool reflowLegend;
|
|
|
|
if (aReflowState.ShouldReflowAllKids()) {
|
|
reflowContent = mContentFrame != nsnull;
|
|
reflowLegend = mLegendFrame != nsnull;
|
|
} else {
|
|
reflowContent = mContentFrame && NS_SUBTREE_DIRTY(mContentFrame);
|
|
reflowLegend = mLegendFrame && NS_SUBTREE_DIRTY(mLegendFrame);
|
|
}
|
|
|
|
// We don't allow fieldsets to break vertically. If we did, we'd
|
|
// need logic here to push and pull overflow frames.
|
|
nsSize availSize(aReflowState.ComputedWidth(), NS_UNCONSTRAINEDSIZE);
|
|
NS_ASSERTION(!mContentFrame ||
|
|
nsLayoutUtils::IntrinsicForContainer(aReflowState.rendContext,
|
|
mContentFrame,
|
|
nsLayoutUtils::MIN_WIDTH) <=
|
|
availSize.width,
|
|
"Bogus availSize.width; should be bigger");
|
|
NS_ASSERTION(!mLegendFrame ||
|
|
nsLayoutUtils::IntrinsicForContainer(aReflowState.rendContext,
|
|
mLegendFrame,
|
|
nsLayoutUtils::MIN_WIDTH) <=
|
|
availSize.width,
|
|
"Bogus availSize.width; should be bigger");
|
|
|
|
// get our border and padding
|
|
const nsMargin &borderPadding = aReflowState.mComputedBorderPadding;
|
|
nsMargin border = borderPadding - aReflowState.mComputedPadding;
|
|
|
|
// Figure out how big the legend is if there is one.
|
|
// get the legend's margin
|
|
nsMargin legendMargin(0,0,0,0);
|
|
// reflow the legend only if needed
|
|
if (reflowLegend) {
|
|
nsHTMLReflowState legendReflowState(aPresContext, aReflowState,
|
|
mLegendFrame, availSize);
|
|
|
|
nsHTMLReflowMetrics legendDesiredSize;
|
|
|
|
ReflowChild(mLegendFrame, aPresContext, legendDesiredSize, legendReflowState,
|
|
0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
|
|
#ifdef NOISY_REFLOW
|
|
printf(" returned (%d, %d)\n", legendDesiredSize.width, legendDesiredSize.height);
|
|
#endif
|
|
// figure out the legend's rectangle
|
|
legendMargin = mLegendFrame->GetUsedMargin();
|
|
mLegendRect.width = legendDesiredSize.width + legendMargin.left + legendMargin.right;
|
|
mLegendRect.height = legendDesiredSize.height + legendMargin.top + legendMargin.bottom;
|
|
mLegendRect.x = borderPadding.left;
|
|
mLegendRect.y = 0;
|
|
|
|
nscoord oldSpace = mLegendSpace;
|
|
mLegendSpace = 0;
|
|
if (mLegendRect.height > border.top) {
|
|
// center the border on the legend
|
|
mLegendSpace = mLegendRect.height - border.top;
|
|
} else {
|
|
mLegendRect.y = (border.top - mLegendRect.height)/2;
|
|
}
|
|
|
|
// if the legend space changes then we need to reflow the
|
|
// content area as well.
|
|
if (mLegendSpace != oldSpace && mContentFrame) {
|
|
reflowContent = true;
|
|
}
|
|
|
|
FinishReflowChild(mLegendFrame, aPresContext, &legendReflowState,
|
|
legendDesiredSize, 0, 0, NS_FRAME_NO_MOVE_FRAME);
|
|
} else if (!mLegendFrame) {
|
|
mLegendRect.SetEmpty();
|
|
mLegendSpace = 0;
|
|
} else {
|
|
// mLegendSpace and mLegendRect haven't changed, but we need
|
|
// the used margin when placing the legend.
|
|
legendMargin = mLegendFrame->GetUsedMargin();
|
|
}
|
|
|
|
// reflow the content frame only if needed
|
|
if (reflowContent) {
|
|
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, mContentFrame,
|
|
availSize);
|
|
// Our child is "height:100%" but we actually want its height to be reduced
|
|
// by the amount of content-height the legend is eating up, unless our
|
|
// height is unconstrained (in which case the child's will be too).
|
|
if (aReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE) {
|
|
kidReflowState.SetComputedHeight(NS_MAX(0, aReflowState.ComputedHeight() - mLegendSpace));
|
|
}
|
|
|
|
kidReflowState.mComputedMinHeight =
|
|
NS_MAX(0, aReflowState.mComputedMinHeight - mLegendSpace);
|
|
|
|
if (aReflowState.mComputedMaxHeight != NS_UNCONSTRAINEDSIZE) {
|
|
kidReflowState.mComputedMaxHeight =
|
|
NS_MAX(0, aReflowState.mComputedMaxHeight - mLegendSpace);
|
|
}
|
|
|
|
nsHTMLReflowMetrics kidDesiredSize(aDesiredSize.mFlags);
|
|
// Reflow the frame
|
|
NS_ASSERTION(kidReflowState.mComputedMargin == nsMargin(0,0,0,0),
|
|
"Margins on anonymous fieldset child not supported!");
|
|
nsPoint pt(borderPadding.left, borderPadding.top + mLegendSpace);
|
|
ReflowChild(mContentFrame, aPresContext, kidDesiredSize, kidReflowState,
|
|
pt.x, pt.y, 0, aStatus);
|
|
|
|
FinishReflowChild(mContentFrame, aPresContext, &kidReflowState,
|
|
kidDesiredSize, pt.x, pt.y, 0);
|
|
NS_FRAME_TRACE_REFLOW_OUT("FieldSet::Reflow", aStatus);
|
|
}
|
|
|
|
nsRect contentRect(0,0,0,0);
|
|
if (mContentFrame) {
|
|
// We don't support margins on mContentFrame, so our "content rect" is just
|
|
// its rect.
|
|
contentRect = mContentFrame->GetRect();
|
|
}
|
|
|
|
// use the computed width if the inner content does not fill it
|
|
if (aReflowState.ComputedWidth() > contentRect.width) {
|
|
contentRect.width = aReflowState.ComputedWidth();
|
|
}
|
|
|
|
if (mLegendFrame) {
|
|
// if the content rect is larger then the legend we can align the legend
|
|
if (contentRect.width > mLegendRect.width) {
|
|
PRInt32 align = static_cast<nsLegendFrame*>
|
|
(mLegendFrame->GetContentInsertionFrame())->GetAlign();
|
|
|
|
switch(align) {
|
|
case NS_STYLE_TEXT_ALIGN_RIGHT:
|
|
mLegendRect.x = contentRect.width - mLegendRect.width + borderPadding.left;
|
|
break;
|
|
case NS_STYLE_TEXT_ALIGN_CENTER:
|
|
// Note: rounding removed; there doesn't seem to be any need
|
|
mLegendRect.x = contentRect.width / 2 - mLegendRect.width / 2 + borderPadding.left;
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
// otherwise make place for the legend
|
|
contentRect.width = mLegendRect.width;
|
|
}
|
|
// place the legend
|
|
nsRect actualLegendRect(mLegendRect);
|
|
actualLegendRect.Deflate(legendMargin);
|
|
|
|
nsPoint curOrigin = mLegendFrame->GetPosition();
|
|
|
|
// only if the origin changed
|
|
if ((curOrigin.x != mLegendRect.x) || (curOrigin.y != mLegendRect.y)) {
|
|
mLegendFrame->SetPosition(nsPoint(actualLegendRect.x , actualLegendRect.y));
|
|
nsContainerFrame::PositionFrameView(mLegendFrame);
|
|
|
|
// We need to recursively process the legend frame's
|
|
// children since we're moving the frame after Reflow.
|
|
nsContainerFrame::PositionChildViews(mLegendFrame);
|
|
}
|
|
}
|
|
|
|
// Return our size and our result
|
|
if (aReflowState.ComputedHeight() == NS_INTRINSICSIZE) {
|
|
aDesiredSize.height = mLegendSpace +
|
|
borderPadding.TopBottom() +
|
|
contentRect.height;
|
|
} else {
|
|
nscoord min = borderPadding.TopBottom() + mLegendRect.height;
|
|
aDesiredSize.height =
|
|
aReflowState.ComputedHeight() + borderPadding.TopBottom();
|
|
if (aDesiredSize.height < min)
|
|
aDesiredSize.height = min;
|
|
}
|
|
aDesiredSize.width = contentRect.width + borderPadding.LeftRight();
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
if (mLegendFrame)
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, mLegendFrame);
|
|
if (mContentFrame)
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, mContentFrame);
|
|
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
InvalidateFrame();
|
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
|
return NS_OK;
|
|
}
|
|
|
|
PRIntn
|
|
nsFieldSetFrame::GetSkipSides() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
// aFrameList is not allowed to contain "the legend" for this fieldset
|
|
ReparentFrameList(aFrameList);
|
|
return mContentFrame->AppendFrames(aListID, aFrameList);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::InsertFrames(ChildListID aListID,
|
|
nsIFrame* aPrevFrame,
|
|
nsFrameList& aFrameList)
|
|
{
|
|
NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this ||
|
|
aPrevFrame->GetParent() == mContentFrame,
|
|
"inserting after sibling frame with different parent");
|
|
|
|
// aFrameList is not allowed to contain "the legend" for this fieldset
|
|
ReparentFrameList(aFrameList);
|
|
if (NS_UNLIKELY(aPrevFrame == mLegendFrame)) {
|
|
aPrevFrame = nsnull;
|
|
}
|
|
return mContentFrame->InsertFrames(aListID, aPrevFrame, aFrameList);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::RemoveFrame(ChildListID aListID,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
// For reference, see bug 70648, bug 276104 and bug 236071.
|
|
NS_ASSERTION(aOldFrame != mLegendFrame, "Cannot remove mLegendFrame here");
|
|
return mContentFrame->RemoveFrame(aListID, aOldFrame);
|
|
}
|
|
|
|
#ifdef ACCESSIBILITY
|
|
already_AddRefed<Accessible>
|
|
nsFieldSetFrame::CreateAccessible()
|
|
{
|
|
nsAccessibilityService* accService = nsIPresShell::AccService();
|
|
if (accService) {
|
|
return accService->CreateHTMLGroupboxAccessible(mContent,
|
|
PresContext()->PresShell());
|
|
}
|
|
|
|
return nsnull;
|
|
}
|
|
#endif
|
|
|
|
void
|
|
nsFieldSetFrame::ReparentFrameList(const nsFrameList& aFrameList)
|
|
{
|
|
nsFrameManager* frameManager = PresContext()->FrameManager();
|
|
for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {
|
|
NS_ASSERTION(mLegendFrame || e.get()->GetType() != nsGkAtoms::legendFrame,
|
|
"The fieldset's legend is not allowed in this list");
|
|
e.get()->SetParent(mContentFrame);
|
|
frameManager->ReparentStyleContext(e.get());
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
nsFieldSetFrame::GetBaseline() const
|
|
{
|
|
// We know mContentFrame is a block, so calling GetBaseline() on it will do
|
|
// the right thing (that being to return the baseline of the last line).
|
|
NS_ASSERTION(nsLayoutUtils::GetAsBlock(mContentFrame),
|
|
"Unexpected mContentFrame");
|
|
return mContentFrame->GetPosition().y + mContentFrame->GetBaseline();
|
|
}
|