pjs/layout/generic/nsPageFrame.cpp

196 строки
6.5 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 "nsPageFrame.h"
#include "nsIContent.h"
#include "nsIContentDelegate.h"
#include "nsIPresContext.h"
#include "nsIStyleContext.h"
#include "nsReflowCommand.h"
#include "nsIRenderingContext.h"
PageFrame::PageFrame(nsIContent* aContent, nsIFrame* aParent)
: nsContainerFrame(aContent, aParent)
{
}
void PageFrame::CreateFirstChild(nsIPresContext* aPresContext)
{
// Create a frame for our one and only content child
if (mContent->ChildCount() > 0) {
nsIContent* child = mContent->ChildAt(0);
if (nsnull != child) {
// Create a frame
nsIContentDelegate* cd = child->GetDelegate(aPresContext);
if (nsnull != cd) {
nsIStyleContext* kidStyleContext =
aPresContext->ResolveStyleContextFor(child, this);
nsresult rv = cd->CreateFrame(aPresContext, child, this,
kidStyleContext, mFirstChild);
NS_RELEASE(kidStyleContext);
if (NS_OK == mFirstChild) {
mChildCount = 1;
mLastContentOffset = mFirstContentOffset;
}
NS_RELEASE(cd);
}
NS_RELEASE(child);
}
}
}
NS_METHOD PageFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
nsReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
#endif
aStatus = NS_FRAME_COMPLETE; // initialize out parameter
// Do we have any children?
if (nsnull == mFirstChild) {
if (nsnull == mPrevInFlow) {
// Create the first child frame
CreateFirstChild(aPresContext);
} else {
PageFrame* prevPage = (PageFrame*)mPrevInFlow;
NS_ASSERTION(!prevPage->mLastContentIsComplete, "bad continuing page");
nsIFrame* prevLastChild;
prevPage->LastChild(prevLastChild);
// Create a continuing child of the previous page's last child
nsIStyleContext* kidSC;
prevLastChild->GetStyleContext(aPresContext, kidSC);
nsresult rv = prevLastChild->CreateContinuingFrame(aPresContext, this,
kidSC, mFirstChild);
NS_RELEASE(kidSC);
mChildCount = 1;
mLastContentOffset = mFirstContentOffset;
}
}
// Resize our frame allowing it only to be as big as we are
// XXX Pay attention to the page's border and padding...
if (nsnull != mFirstChild) {
// Get the child's desired size
mFirstChild->WillReflow(*aPresContext);
aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
aMaxElementSize);
mLastContentIsComplete = NS_FRAME_IS_COMPLETE(aStatus);
// Make sure the child is at least as tall as our max size (the containing window)
if (aDesiredSize.height < aMaxSize.height) {
aDesiredSize.height = aMaxSize.height;
}
// Place and size the child
nsRect rect(0, 0, aDesiredSize.width, aDesiredSize.height);
mFirstChild->SetRect(rect);
mFirstChild->DidReflow(*aPresContext, NS_FRAME_REFLOW_FINISHED);
// Is the frame complete?
if (NS_FRAME_IS_COMPLETE(aStatus)) {
nsIFrame* childNextInFlow;
mFirstChild->GetNextInFlow(childNextInFlow);
NS_ASSERTION(nsnull == childNextInFlow, "bad child flow list");
}
}
// Return our desired size
aDesiredSize.width = aMaxSize.width;
aDesiredSize.height = aMaxSize.height;
#ifdef NS_DEBUG
PostReflowCheck(aStatus);
#endif
return NS_OK;
}
// XXX Do something sensible in page mode...
NS_METHOD PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
nsReflowStatus& aStatus)
{
// We don't expect the target of the reflow command to be page frame
NS_ASSERTION(aReflowCommand.GetTarget() != this, "page frame is reflow command target");
nsSize maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
nsIFrame* child;
// Dispatch the reflow command to our pseudo frame. Allow it to be as high
// as it wants
aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
// Place and size the child. Make sure the child is at least as
// tall as our max size (the containing window)
if (nsnull != child) {
NS_ASSERTION(child == mFirstChild, "unexpected reflow command frame");
if (aDesiredSize.height < aMaxSize.height) {
aDesiredSize.height = aMaxSize.height;
}
nsRect rect(0, 0, aDesiredSize.width, aDesiredSize.height);
child->SetRect(rect);
}
return NS_OK;
}
NS_METHOD
PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIStyleContext* aStyleContext,
nsIFrame*& aContinuingFrame)
{
PageFrame* cf = new PageFrame(mContent, aParent);
if (nsnull == cf) {
return NS_ERROR_OUT_OF_MEMORY;
}
PrepareContinuingFrame(aPresContext, aParent, aStyleContext, cf);
aContinuingFrame = cf;
return NS_OK;
}
NS_METHOD PageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
// For the time being paint a border around the page so we know
// where each page begins and ends
aRenderingContext.SetColor(NS_RGB(0, 0, 0));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
return NS_OK;
}
NS_METHOD PageFrame::ListTag(FILE* out) const
{
fprintf(out, "*PAGE@%p", this);
return NS_OK;
}