b23e7af50b
the printing of headers and footers. Printing of selection is implemented by the frames figuring out if they are in the selection and painting if they or not they they don't paint. This also only allows the printing of the first page of selections, alothough it is well documented where this is implemeted so it can be removed. Bugs 63426, 31218, 61075 r=dcone,kmcclusk,erik,buster sr=waterson git-svn-id: svn://10.0.0.236/trunk@85624 18797224-902f-48f8-a5cc-f745e15eee43
640 lines
23 KiB
C++
640 lines
23 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
|
|
// YY need to pass isMultiple before create called
|
|
|
|
//#include "nsFormControlFrame.h"
|
|
#include "nsHTMLContainerFrame.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 "nsIPresContext.h"
|
|
#include "nsIHTMLContent.h"
|
|
#include "nsHTMLIIDs.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsHTMLAtoms.h"
|
|
#include "nsIStyleContext.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsStyleUtil.h"
|
|
#include "nsFont.h"
|
|
#include "nsCOMPtr.h"
|
|
|
|
static NS_DEFINE_IID(kLegendFrameCID, NS_LEGEND_FRAME_CID);
|
|
|
|
class nsLegendFrame;
|
|
|
|
class nsFieldSetFrame : public nsHTMLContainerFrame {
|
|
public:
|
|
|
|
nsFieldSetFrame();
|
|
|
|
NS_IMETHOD SetInitialChildList(nsIPresContext* aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aChildList);
|
|
|
|
NS_IMETHOD Reflow(nsIPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus);
|
|
|
|
NS_METHOD Paint(nsIPresContext* aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsFramePaintLayer aWhichLayer);
|
|
|
|
NS_IMETHOD AppendFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD InsertFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD RemoveFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame);
|
|
NS_IMETHOD ReplaceFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame,
|
|
nsIFrame* aNewFrame);
|
|
#ifdef DEBUG
|
|
NS_IMETHOD GetFrameName(nsString& aResult) const {
|
|
return MakeFrameName("FieldSet", aResult);
|
|
}
|
|
#endif
|
|
|
|
protected:
|
|
|
|
virtual PRIntn GetSkipSides() const;
|
|
|
|
nsIFrame* mLegendFrame;
|
|
nsIFrame* mContentFrame;
|
|
nsRect mLegendRect;
|
|
nscoord mLegendSpace;
|
|
};
|
|
|
|
nsresult
|
|
NS_NewFieldSetFrame(nsIPresShell* aPresShell, nsIFrame** aNewFrame, PRUint32 aStateFlags )
|
|
{
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
if (nsnull == aNewFrame) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
nsFieldSetFrame* it = new (aPresShell) nsFieldSetFrame;
|
|
if (!it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// set the state flags (if any are provided)
|
|
nsFrameState state;
|
|
it->GetFrameState( &state );
|
|
state |= aStateFlags;
|
|
it->SetFrameState( state );
|
|
|
|
*aNewFrame = it;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsFieldSetFrame::nsFieldSetFrame()
|
|
: nsHTMLContainerFrame()
|
|
{
|
|
mContentFrame = nsnull;
|
|
mLegendFrame = nsnull;
|
|
mLegendSpace = 0;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::SetInitialChildList(nsIPresContext* aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aChildList)
|
|
{
|
|
|
|
// get the content and legend frames.
|
|
mContentFrame = aChildList;
|
|
mContentFrame->GetNextSibling(&mLegendFrame);
|
|
|
|
// Queue up the frames for the content frame
|
|
return nsHTMLContainerFrame::SetInitialChildList(aPresContext, nsnull, aChildList);
|
|
}
|
|
|
|
// this is identical to nsHTMLContainerFrame::Paint except for the background and border.
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::Paint(nsIPresContext* aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsFramePaintLayer aWhichLayer)
|
|
{
|
|
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 nsStyleColor* color =
|
|
(const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color);
|
|
const nsStyleSpacing* spacing =
|
|
(const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing);
|
|
|
|
nsMargin border;
|
|
if (!spacing->GetBorder(border)) {
|
|
NS_NOTYETIMPLEMENTED("percentage border");
|
|
}
|
|
|
|
nscoord yoff = 0;
|
|
|
|
// if the border is smaller than the legend. Move the border down
|
|
// to be centered on the legend.
|
|
if (border.top < mLegendRect.height)
|
|
yoff = (mLegendRect.height - border.top)/2;
|
|
|
|
nsRect rect(0, yoff, mRect.width, mRect.height - yoff);
|
|
|
|
nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *color, *spacing, 0, 0);
|
|
|
|
|
|
if (mLegendFrame) {
|
|
|
|
// we should probably use PaintBorderEdges to do this but for now just use clipping
|
|
// to achieve the same effect.
|
|
PRBool clipState;
|
|
|
|
// draw left side
|
|
nsRect clipRect(rect);
|
|
clipRect.width = mLegendRect.x - rect.x;
|
|
clipRect.height = border.top;
|
|
|
|
aRenderingContext.PushState();
|
|
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState);
|
|
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *spacing, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState(clipState);
|
|
|
|
|
|
// draw right side
|
|
clipRect = rect;
|
|
clipRect.x = mLegendRect.x + mLegendRect.width;
|
|
clipRect.width -= (mLegendRect.x + mLegendRect.width);
|
|
clipRect.height = border.top;
|
|
|
|
aRenderingContext.PushState();
|
|
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState);
|
|
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *spacing, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState(clipState);
|
|
|
|
|
|
// draw bottom
|
|
|
|
clipRect = rect;
|
|
clipRect.y += border.top;
|
|
clipRect.height = mRect.height - (yoff + border.top);
|
|
|
|
aRenderingContext.PushState();
|
|
aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState);
|
|
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *spacing, mStyleContext, skipSides);
|
|
|
|
aRenderingContext.PopState(clipState);
|
|
} else {
|
|
|
|
|
|
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *spacing, mStyleContext, skipSides);
|
|
}
|
|
}
|
|
}
|
|
|
|
PaintChildren(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer);
|
|
|
|
#ifdef DEBUG
|
|
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
|
|
nsIView* view;
|
|
GetView(aPresContext, &view);
|
|
if (nsnull != view) {
|
|
aRenderingContext.SetColor(NS_RGB(0,0,255));
|
|
}
|
|
else {
|
|
aRenderingContext.SetColor(NS_RGB(255,0,0));
|
|
}
|
|
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
|
|
}
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::Reflow(nsIPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame", aReflowState.reason);
|
|
|
|
// Initialize OUT parameter
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
//------------ Handle Incremental Reflow -----------------
|
|
nsIFrame* incrementalChild = nsnull;
|
|
PRBool reflowContent = PR_TRUE;
|
|
PRBool reflowLegend = PR_TRUE;
|
|
nsReflowReason reason = aReflowState.reason;
|
|
|
|
if ( aReflowState.reason == eReflowReason_Incremental ) {
|
|
nsIReflowCommand::ReflowType reflowType;
|
|
aReflowState.reflowCommand->GetType(reflowType);
|
|
|
|
// See if it's targeted at us
|
|
nsIFrame* targetFrame;
|
|
aReflowState.reflowCommand->GetTarget(targetFrame);
|
|
|
|
if (this == targetFrame) {
|
|
switch (reflowType) {
|
|
|
|
case nsIReflowCommand::StyleChanged:
|
|
{
|
|
nsHTMLReflowState newState(aReflowState);
|
|
newState.reason = eReflowReason_StyleChange;
|
|
return Reflow(aPresContext, aDesiredSize, newState, aStatus);
|
|
}
|
|
break;
|
|
|
|
// if its a dirty type then reflow us with a dirty reflow
|
|
case nsIReflowCommand::ReflowDirty:
|
|
{
|
|
nsHTMLReflowState newState(aReflowState);
|
|
newState.reason = eReflowReason_Dirty;
|
|
return Reflow(aPresContext, aDesiredSize, newState, aStatus);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
NS_ERROR("Unexpected Reflow Type");
|
|
}
|
|
} else {
|
|
aReflowState.reflowCommand->GetNext(incrementalChild);
|
|
|
|
reflowContent = PR_FALSE;
|
|
reflowLegend = PR_FALSE;
|
|
|
|
if (incrementalChild == mLegendFrame)
|
|
reflowLegend = PR_TRUE;
|
|
else if (incrementalChild == mContentFrame)
|
|
reflowContent = PR_TRUE;
|
|
}
|
|
}
|
|
|
|
// if dirty then check dirty flags
|
|
if (reason == eReflowReason_Dirty)
|
|
{
|
|
if (reflowContent) {
|
|
nsFrameState state;
|
|
mContentFrame->GetFrameState(&state);
|
|
reflowContent = (state & NS_FRAME_IS_DIRTY) || (state & NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
}
|
|
|
|
if (reflowLegend) {
|
|
nsFrameState state;
|
|
mLegendFrame->GetFrameState(&state);
|
|
reflowLegend = (state & NS_FRAME_IS_DIRTY) || (state & NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
}
|
|
}
|
|
|
|
// availSize could have unconstrained values, don't perform any addition on them
|
|
nsSize availSize(aReflowState.mComputedWidth, aReflowState.availableHeight);
|
|
|
|
// get our border and padding
|
|
const nsMargin &borderPadding = aReflowState.mComputedBorderPadding;
|
|
const nsMargin &padding = aReflowState.mComputedPadding;
|
|
nsMargin border = borderPadding - padding;
|
|
|
|
// 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 (mLegendFrame) {
|
|
const nsStyleSpacing* legendSpacing;
|
|
mLegendFrame->GetStyleData(eStyleStruct_Spacing,
|
|
(const nsStyleStruct*&) legendSpacing);
|
|
legendSpacing->GetMargin(legendMargin);
|
|
|
|
if (reflowLegend) {
|
|
nsHTMLReflowState legendReflowState(aPresContext, aReflowState,
|
|
mLegendFrame, nsSize(NS_INTRINSICSIZE,NS_INTRINSICSIZE));
|
|
|
|
// always give the legend as much size as it needs
|
|
legendReflowState.mComputedWidth = NS_INTRINSICSIZE;
|
|
legendReflowState.mComputedHeight = NS_INTRINSICSIZE;
|
|
legendReflowState.reason = reason;
|
|
|
|
nsHTMLReflowMetrics legendDesiredSize(0,0);
|
|
|
|
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);
|
|
if (legendDesiredSize.maxElementSize)
|
|
printf(" and maxES (%d, %d)\n",
|
|
legendDesiredSize.maxElementSize->width, legendDesiredSize.maxElementSize->height);
|
|
#endif
|
|
// figure out the legend's rectangle
|
|
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 - borderPadding.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) {
|
|
if (reflowContent == PR_FALSE || reason == eReflowReason_Dirty) {
|
|
reflowContent = PR_TRUE;
|
|
reason = eReflowReason_Resize;
|
|
}
|
|
}
|
|
|
|
// if we are contrained then remove the legend from our available height.
|
|
if (NS_INTRINSICSIZE != availSize.height) {
|
|
if (availSize.height >= mLegendSpace)
|
|
availSize.height -= mLegendSpace;
|
|
}
|
|
|
|
// don't get any smaller than the legend
|
|
if (NS_INTRINSICSIZE != availSize.width) {
|
|
if (availSize.width < mLegendRect.width)
|
|
availSize.width = mLegendRect.width;
|
|
}
|
|
|
|
FinishReflowChild(mLegendFrame, aPresContext, legendDesiredSize, 0, 0, NS_FRAME_NO_MOVE_FRAME);
|
|
|
|
}
|
|
}
|
|
|
|
nsRect contentRect;
|
|
|
|
// reflow the content frame only if needed
|
|
if (mContentFrame) {
|
|
if (reflowContent) {
|
|
availSize.width = aReflowState.mComputedWidth;
|
|
|
|
#if 0
|
|
if (aReflowState.mComputedHeight != NS_INTRINSICSIZE) {
|
|
availSize.height = aReflowState.mComputedHeight - mLegendSpace;
|
|
} else {
|
|
availSize.height = NS_INTRINSICSIZE;
|
|
}
|
|
#endif
|
|
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, mContentFrame,
|
|
availSize);
|
|
|
|
kidReflowState.reason = reason;
|
|
|
|
nsHTMLReflowMetrics kidDesiredSize(0,0);
|
|
|
|
// Reflow the frame
|
|
ReflowChild(mContentFrame, aPresContext, kidDesiredSize, kidReflowState,
|
|
kidReflowState.mComputedMargin.left, kidReflowState.mComputedMargin.top,
|
|
0, aStatus);
|
|
#ifdef NOISY_REFLOW
|
|
printf(" returned (%d, %d)\n", kidDesiredSize.width, kidDesiredSize.height);
|
|
if (kidDesiredSize.maxElementSize)
|
|
printf(" and maxES (%d, %d)\n",
|
|
kidDesiredSize.maxElementSize->width, kidDesiredSize.maxElementSize->height);
|
|
#endif
|
|
|
|
/*
|
|
printf("*** %p computedHgt: %d ", this, aReflowState.mComputedHeight);
|
|
printf("Reason: ");
|
|
switch (aReflowState.reason) {
|
|
case eReflowReason_Initial:printf("Initil");break;
|
|
case eReflowReason_Incremental:printf("Increm");break;
|
|
case eReflowReason_Resize: printf("Resize"); break;
|
|
case eReflowReason_StyleChange:printf("eReflowReason_StyleChange");break;
|
|
}
|
|
*/
|
|
|
|
// set the rect. make sure we add the margin back in.
|
|
contentRect.SetRect(borderPadding.left,borderPadding.top + mLegendSpace,kidDesiredSize.width ,kidDesiredSize.height);
|
|
if (aReflowState.mComputedHeight != NS_INTRINSICSIZE &&
|
|
borderPadding.top + mLegendSpace+kidDesiredSize.height > aReflowState.mComputedHeight) {
|
|
kidDesiredSize.height = aReflowState.mComputedHeight-(borderPadding.top + mLegendSpace);
|
|
}
|
|
|
|
FinishReflowChild(mContentFrame, aPresContext, kidDesiredSize, contentRect.x, contentRect.y, 0);
|
|
|
|
nsFrameState kidState;
|
|
mContentFrame->GetFrameState(&kidState);
|
|
|
|
// printf("width: %d, height: %d\n", desiredSize.mCombinedArea.width, desiredSize.mCombinedArea.height);
|
|
|
|
/*
|
|
if (kidState & NS_FRAME_OUTSIDE_CHILDREN) {
|
|
mState |= NS_FRAME_OUTSIDE_CHILDREN;
|
|
aDesiredSize.mOverflowArea.width += borderPadding.left + borderPadding.right;
|
|
aDesiredSize.mOverflowArea.height += borderPadding.top + borderPadding.bottom + mLegendSpace;
|
|
}
|
|
*/
|
|
|
|
NS_FRAME_TRACE_REFLOW_OUT("FieldSet::Reflow", aStatus);
|
|
|
|
} else {
|
|
// if we don't need to reflow just get the old size
|
|
mContentFrame->GetRect(contentRect);
|
|
const nsStyleSpacing* spacing;
|
|
mContentFrame->GetStyleData(eStyleStruct_Spacing,
|
|
(const nsStyleStruct*&) spacing);
|
|
|
|
nsMargin m(0,0,0,0);
|
|
spacing->GetMargin(m);
|
|
contentRect.Inflate(m);
|
|
}
|
|
}
|
|
|
|
if (mLegendFrame) {
|
|
if (contentRect.width > mLegendRect.width) {
|
|
PRInt32 align = ((nsLegendFrame*)mLegendFrame)->GetAlign();
|
|
|
|
switch(align) {
|
|
case NS_STYLE_TEXT_ALIGN_RIGHT:
|
|
mLegendRect.x = contentRect.width - mLegendRect.width + borderPadding.left;
|
|
break;
|
|
case NS_STYLE_TEXT_ALIGN_CENTER:
|
|
mLegendRect.x = contentRect.width/2 - mLegendRect.width/2 + borderPadding.left;
|
|
}
|
|
|
|
} else {
|
|
contentRect.width = mLegendRect.width + borderPadding.left + borderPadding.right;
|
|
aDesiredSize.width = contentRect.width;
|
|
}
|
|
// place the legend
|
|
nsRect actualLegendRect(mLegendRect);
|
|
actualLegendRect.Deflate(legendMargin);
|
|
|
|
nsPoint curOrigin;
|
|
mLegendFrame->GetOrigin(curOrigin);
|
|
|
|
// only if the origin changed
|
|
if ((curOrigin.x != mLegendRect.x) || (curOrigin.y != mLegendRect.y)) {
|
|
|
|
mLegendFrame->MoveTo(aPresContext, actualLegendRect.x , actualLegendRect.y);
|
|
|
|
nsIView* view;
|
|
mLegendFrame->GetView(aPresContext, &view);
|
|
if (view)
|
|
nsContainerFrame::PositionFrameView(aPresContext, mLegendFrame, view);
|
|
else
|
|
nsContainerFrame::PositionChildViews(aPresContext, mLegendFrame);
|
|
}
|
|
}
|
|
|
|
// Return our size and our result
|
|
if (aReflowState.mComputedHeight == NS_INTRINSICSIZE) {
|
|
aDesiredSize.height = mLegendSpace +
|
|
borderPadding.top +
|
|
contentRect.height +
|
|
borderPadding.bottom;
|
|
} else {
|
|
nscoord min = borderPadding.top + borderPadding.bottom + mLegendRect.height;
|
|
aDesiredSize.height = aReflowState.mComputedHeight + borderPadding.top + borderPadding.bottom;
|
|
if (aDesiredSize.height < min)
|
|
aDesiredSize.height = min;
|
|
}
|
|
|
|
if (aReflowState.mComputedWidth == NS_INTRINSICSIZE) {
|
|
aDesiredSize.width = borderPadding.left +
|
|
contentRect.width +
|
|
borderPadding.right;
|
|
} else {
|
|
nscoord min = borderPadding.left + borderPadding.right + mLegendRect.width;
|
|
aDesiredSize.width = aReflowState.mComputedWidth + borderPadding.left + borderPadding.right;
|
|
if (aDesiredSize.width < min)
|
|
aDesiredSize.width = min;
|
|
}
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
aDesiredSize.descent = 0;
|
|
aDesiredSize.mMaximumWidth = aDesiredSize.width;
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
|
// if the legend is wider use it
|
|
if (aDesiredSize.maxElementSize->width < mLegendRect.width)
|
|
aDesiredSize.maxElementSize->width = mLegendRect.width;
|
|
|
|
// add in padding.
|
|
aDesiredSize.maxElementSize->width += borderPadding.left + borderPadding.right;
|
|
|
|
// height is border + legend
|
|
aDesiredSize.maxElementSize->height += borderPadding.top + borderPadding.bottom + mLegendRect.height;
|
|
}
|
|
#ifdef NOISY_REFLOW
|
|
printf("FIELDSET: w=%d, maxWidth=%d, MES=%d\n",
|
|
aDesiredSize.width, aDesiredSize.mMaximumWidth,
|
|
aDesiredSize.maxElementSize ? aDesiredSize.maxElementSize->width : -1);
|
|
if (aDesiredSize.mFlags & NS_REFLOW_CALC_MAX_WIDTH)
|
|
printf(" and preferred size = %d\n", aDesiredSize.mMaximumWidth);
|
|
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
PRIntn
|
|
nsFieldSetFrame::GetSkipSides() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::AppendFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
return mContentFrame->AppendFrames(aPresContext,
|
|
aPresShell,
|
|
aListName,
|
|
aFrameList);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::InsertFrames(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
return mContentFrame->InsertFrames(aPresContext,
|
|
aPresShell,
|
|
aListName,
|
|
aPrevFrame,
|
|
aFrameList);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::RemoveFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
return mContentFrame->RemoveFrame (aPresContext,
|
|
aPresShell,
|
|
aListName,
|
|
aOldFrame);
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsFieldSetFrame::ReplaceFrame(nsIPresContext* aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame,
|
|
nsIFrame* aNewFrame)
|
|
{
|
|
return mContentFrame->ReplaceFrame (aPresContext,
|
|
aPresShell,
|
|
aListName,
|
|
aOldFrame,
|
|
aNewFrame);
|
|
}
|
|
|
|
|