gecko-dev/layout/generic/nsHTMLFrame.cpp

365 строки
12 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.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "nsHTMLParts.h"
#include "nsContainerFrame.h"
#include "nsCSSRendering.h"
#include "nsIDocument.h"
#include "nsIReflowCommand.h"
#include "nsIPresContext.h"
#include "nsIStyleContext.h"
#include "nsViewsCID.h"
#include "nsIView.h"
#include "nsIViewManager.h"
#include "nsIWidget.h"
#include "nsHTMLIIDs.h"
#include "nsPageFrame.h"
#include "nsIRenderingContext.h"
#include "nsGUIEvent.h"
#include "nsDOMEvent.h"
#include "nsStyleConsts.h"
#include "nsIViewManager.h"
#include "nsHTMLAtoms.h"
#include "nsIEventStateManager.h"
#include "nsIDeviceContext.h"
#include "nsIScrollableView.h"
#include "nsIAreaFrame.h"
#include "nsLayoutAtoms.h"
// Interface IDs
static NS_DEFINE_IID(kAreaFrameIID, NS_IAREAFRAME_IID);
static NS_DEFINE_IID(kScrollViewIID, NS_ISCROLLABLEVIEW_IID);
static NS_DEFINE_IID(kIFrameIID, NS_IFRAME_IID);
/**
* Root frame class.
*
* The root frame is the parent frame for the document element's frame.
* It only supports having a single child frame which must be an area
* frame
*/
class RootFrame : public nsHTMLContainerFrame {
public:
NS_IMETHOD Reflow(nsIPresContext& aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
NS_IMETHOD IsPercentageBase(PRBool& aBase) const {
aBase = PR_TRUE;
return NS_OK;
}
/**
* Get the "type" of the frame
*
* @see nsLayoutAtoms::rootFrame
*/
NS_IMETHOD GetFrameType(nsIAtom** aType) const;
NS_IMETHOD GetFrameName(nsString& aResult) const;
// XXX Temporary hack...
NS_IMETHOD SetRect(const nsRect& aRect);
protected:
virtual PRIntn GetSkipSides() const;
private:
nscoord mNaturalHeight;
};
//----------------------------------------------------------------------
nsresult
NS_NewRootFrame(nsIFrame** aNewFrame)
{
NS_PRECONDITION(aNewFrame, "null OUT ptr");
if (nsnull == aNewFrame) {
return NS_ERROR_NULL_POINTER;
}
RootFrame* it = new RootFrame;
if (nsnull == it) {
return NS_ERROR_OUT_OF_MEMORY;
}
*aNewFrame = it;
return NS_OK;
}
// XXX Temporary hack until we support the CSS2 'min-width', 'max-width',
// 'min-height', and 'max-height' properties. Then we can do this in a top-down
// fashion
NS_IMETHODIMP
RootFrame::SetRect(const nsRect& aRect)
{
nsresult rv = nsHTMLContainerFrame::SetRect(aRect);
// If our height is larger than our natural height (the height we returned
// as our desired height), then make sure the document element's frame is
// increased as well. This happens because the scroll frame will make sure
// that our height fills the entire scroll area.
// Note: only do this if the document element's 'height' is 'auto'
nsIFrame* kidFrame = mFrames.FirstChild();
if (nsnull != kidFrame) {
nsStylePosition* kidPosition;
kidFrame->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)kidPosition);
if (eStyleUnit_Auto == kidPosition->mHeight.GetUnit()) {
nscoord yDelta = aRect.height - mNaturalHeight;
nsSize kidSize;
kidFrame->GetSize(kidSize);
kidFrame->SizeTo(kidSize.width, kidSize.height + yDelta);
}
}
return rv;
}
NS_IMETHODIMP
RootFrame::Reflow(nsIPresContext& aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
NS_FRAME_TRACE_REFLOW_IN("RootFrame::Reflow");
NS_PRECONDITION(nsnull == aDesiredSize.maxElementSize, "unexpected request");
// Initialize OUT parameter
aStatus = NS_FRAME_COMPLETE;
PRBool isChildInitialReflow = PR_FALSE;
PRBool isStyleChange = PR_FALSE;
// Check for an incremental reflow
// XXX This needs to use the new reflow command handling instead...
if (eReflowReason_Incremental == aReflowState.reason) {
// See if we're the target frame
nsIFrame* targetFrame;
aReflowState.reflowCommand->GetTarget(targetFrame);
if (this == targetFrame) {
nsIReflowCommand::ReflowType reflowType;
nsIFrame* childFrame;
nsIFrame* deletedFrame;
// Get the reflow type
aReflowState.reflowCommand->GetType(reflowType);
switch (reflowType) {
case nsIReflowCommand::FrameAppended:
case nsIReflowCommand::FrameInserted:
NS_ASSERTION(mFrames.IsEmpty(), "only one child frame allowed");
// Insert the frame into the child list
aReflowState.reflowCommand->GetChildFrame(childFrame);
mFrames.SetFrames(childFrame);
// It's the child frame's initial reflow
isChildInitialReflow = PR_TRUE;
break;
case nsIReflowCommand::FrameRemoved:
// Get the child frame we should delete
aReflowState.reflowCommand->GetChildFrame(deletedFrame);
NS_ASSERTION(deletedFrame == mFrames.FirstChild(), "not a child frame");
// Remove it from the child list
if (deletedFrame == mFrames.FirstChild()) {
// Damage the area occupied by the deleted frame
nsRect damageRect;
deletedFrame->GetRect(damageRect);
Invalidate(damageRect, PR_FALSE);
mFrames.DeleteFrame(aPresContext, deletedFrame);
}
break;
case nsIReflowCommand::StyleChanged:
// Remember it's a style change so we can set the reflow reason below
isStyleChange = PR_TRUE;
break;
default:
NS_ASSERTION(PR_FALSE, "unexpected reflow command type");
}
} else {
nsIFrame* nextFrame;
// Get the next frame in the reflow chain
aReflowState.reflowCommand->GetNext(nextFrame);
NS_ASSERTION(nextFrame == mFrames.FirstChild(), "unexpected next reflow command frame");
}
}
// Reflow our one and only child frame
nsHTMLReflowMetrics kidDesiredSize(nsnull);
if (mFrames.IsEmpty()) {
// Return our desired size
aDesiredSize.width = aDesiredSize.height = 0;
aDesiredSize.ascent = aDesiredSize.descent = 0;
} else {
nsIFrame* kidFrame = mFrames.FirstChild();
// We must specify an unconstrained available height, because constrained
// is only for when we're paginated...
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, kidFrame,
nsSize(aReflowState.availableWidth,
NS_UNCONSTRAINEDSIZE));
if (isChildInitialReflow) {
kidReflowState.reason = eReflowReason_Initial;
kidReflowState.reflowCommand = nsnull;
} else if (isStyleChange) {
kidReflowState.reason = eReflowReason_StyleChange;
kidReflowState.reflowCommand = nsnull;
}
// Reflow the frame
nsIHTMLReflow* htmlReflow;
if (NS_OK == kidFrame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {
ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState,
aStatus);
// The document element's background should cover the entire canvas, so
// take into account the combined area and any space taken up by
// absolutely positioned elements
nsMargin border;
nsFrameState kidState;
kidReflowState.mStyleSpacing->GetBorder(border);
kidFrame->GetFrameState(&kidState);
// First check the combined area
if (NS_FRAME_OUTSIDE_CHILDREN & kidState) {
// The background covers the content area and padding area, so check
// for children sticking outside the child frame's padding edge
nscoord paddingEdgeX = kidDesiredSize.width - border.right;
nscoord paddingEdgeY = kidDesiredSize.height - border.bottom;
if (kidDesiredSize.mCombinedArea.XMost() > paddingEdgeX) {
kidDesiredSize.width = kidDesiredSize.mCombinedArea.XMost() +
border.right;
}
if (kidDesiredSize.mCombinedArea.YMost() > paddingEdgeY) {
kidDesiredSize.height = kidDesiredSize.mCombinedArea.YMost() +
border.bottom;
}
}
// XXX It would be nice if this were also part of the reflow metrics...
nsIAreaFrame* areaFrame;
if (NS_SUCCEEDED(kidFrame->QueryInterface(kAreaFrameIID, (void**)&areaFrame))) {
// Get the x-most and y-most of the absolutely positioned children
nscoord positionedXMost, positionedYMost;
areaFrame->GetPositionedInfo(positionedXMost, positionedYMost);
// The background covers the content area and padding area, so check
// for children sticking outside the padding edge
nscoord paddingEdgeX = kidDesiredSize.width - border.right;
nscoord paddingEdgeY = kidDesiredSize.height - border.bottom;
if (positionedXMost > paddingEdgeX) {
kidDesiredSize.width = positionedXMost + border.right;
}
if (positionedYMost > paddingEdgeY) {
kidDesiredSize.height = positionedYMost + border.bottom;
}
}
// If our height is fixed, then make sure the child frame plus its top and
// bottom margin is at least that high as well...
if (NS_AUTOHEIGHT != aReflowState.computedHeight) {
nscoord totalHeight = kidDesiredSize.height + kidReflowState.computedMargin.top +
kidReflowState.computedMargin.bottom;
if (totalHeight < aReflowState.computedHeight) {
kidDesiredSize.height += aReflowState.computedHeight - totalHeight;
}
}
// Position and size the child frame
nsRect rect(kidReflowState.computedMargin.left, kidReflowState.computedMargin.top,
kidDesiredSize.width, kidDesiredSize.height);
kidFrame->SetRect(rect);
}
// If this is a resize reflow, then do a repaint
if (eReflowReason_Resize == aReflowState.reason) {
nsRect damageRect(0, 0, aReflowState.availableWidth, aReflowState.availableHeight);
Invalidate(damageRect, PR_FALSE);
}
// Return our desired size
aDesiredSize.width = kidDesiredSize.width + kidReflowState.computedMargin.left +
kidReflowState.computedMargin.right;
aDesiredSize.height = kidDesiredSize.height + kidReflowState.computedMargin.top +
kidReflowState.computedMargin.bottom;
aDesiredSize.ascent = aDesiredSize.height;
aDesiredSize.descent = 0;
// XXX Don't completely ignore NS_FRAME_OUTSIDE_CHILDREN for child frames
// that stick out on the left or top edges...
// XXX Temporary hack. Remember this for later when our parent resizes us.
// See SetRect()
mNaturalHeight = aDesiredSize.height;
}
NS_FRAME_TRACE_REFLOW_OUT("RootFrame::Reflow", aStatus);
return NS_OK;
}
PRIntn
RootFrame::GetSkipSides() const
{
return 0;
}
NS_IMETHODIMP
RootFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
if (nsEventStatus_eConsumeNoDefault == aEventStatus) {
return NS_OK;
}
if (aEvent->message == NS_MOUSE_LEFT_BUTTON_UP ||
aEvent->message == NS_MOUSE_MIDDLE_BUTTON_UP ||
aEvent->message == NS_MOUSE_RIGHT_BUTTON_UP) {
nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
}
return NS_OK;
}
NS_IMETHODIMP
RootFrame::GetFrameType(nsIAtom** aType) const
{
NS_PRECONDITION(nsnull != aType, "null OUT parameter pointer");
*aType = nsLayoutAtoms::rootFrame;
NS_ADDREF(*aType);
return NS_OK;
}
NS_IMETHODIMP
RootFrame::GetFrameName(nsString& aResult) const
{
return MakeFrameName("Root", aResult);
}