2001-09-29 00:14:13 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 18:30:37 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* 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.
|
1998-04-14 00:24:54 +04:00
|
|
|
*
|
1999-11-06 06:40:37 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-29 00:14:13 +04:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:40:37 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 18:30:37 +04:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-29 00:14:13 +04:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 18:30:37 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-29 00:14:13 +04:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 18:30:37 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsPageFrame.h"
|
1998-12-18 08:44:26 +03:00
|
|
|
#include "nsHTMLParts.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsIContent.h"
|
2004-08-01 03:15:21 +04:00
|
|
|
#include "nsPresContext.h"
|
2003-02-22 03:32:13 +03:00
|
|
|
#include "nsStyleContext.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsIRenderingContext.h"
|
1998-06-25 18:53:45 +04:00
|
|
|
#include "nsHTMLAtoms.h"
|
1999-02-14 06:47:33 +03:00
|
|
|
#include "nsLayoutAtoms.h"
|
1999-02-24 07:03:50 +03:00
|
|
|
#include "nsIPresShell.h"
|
2004-01-22 02:05:10 +03:00
|
|
|
#include "nsCSSFrameConstructor.h"
|
2001-01-27 17:09:34 +03:00
|
|
|
#include "nsIDeviceContext.h"
|
2001-09-29 12:28:41 +04:00
|
|
|
#include "nsReadableUtils.h"
|
2002-01-25 17:30:14 +03:00
|
|
|
#include "nsPageContentFrame.h"
|
2006-01-26 05:29:17 +03:00
|
|
|
#include "nsDisplayList.h"
|
2005-12-06 03:32:52 +03:00
|
|
|
#include "nsLayoutUtils.h" // for function BinarySearchForPosition
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#include "nsIView.h" // view flags for clipping
|
2001-12-05 01:46:41 +03:00
|
|
|
#include "nsCSSRendering.h"
|
2001-11-03 17:59:39 +03:00
|
|
|
|
|
|
|
#include "nsHTMLContainerFrame.h" // view creation
|
|
|
|
|
|
|
|
#include "nsSimplePageSequence.h" // for nsSharedPageData
|
2002-08-30 07:32:05 +04:00
|
|
|
#include "nsRegion.h"
|
2002-01-25 17:30:14 +03:00
|
|
|
#include "nsIViewManager.h"
|
2001-01-27 17:09:34 +03:00
|
|
|
|
|
|
|
// for page number localization formatting
|
|
|
|
#include "nsTextFormatter.h"
|
|
|
|
|
2002-04-30 04:37:12 +04:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
#include "nsBidiUtils.h"
|
|
|
|
#include "nsBidiPresUtils.h"
|
|
|
|
#endif
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
// Temporary
|
|
|
|
#include "nsIFontMetrics.h"
|
|
|
|
|
2001-09-26 18:01:26 +04:00
|
|
|
// Print Options
|
2002-01-01 15:58:53 +03:00
|
|
|
#include "nsIPrintSettings.h"
|
2001-09-26 18:01:26 +04:00
|
|
|
#include "nsGfxCIID.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
|
2002-01-25 17:30:14 +03:00
|
|
|
// Widget Creation
|
|
|
|
#include "nsIWidget.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
|
|
|
static NS_DEFINE_CID(kCChildCID, NS_CHILD_CID);
|
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#if defined(DEBUG_rods) || defined(DEBUG_dcone)
|
2001-11-03 17:59:39 +03:00
|
|
|
//#define DEBUG_PRINTING
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
|
|
|
|
2002-06-20 01:51:13 +04:00
|
|
|
#include "prlog.h"
|
|
|
|
#ifdef PR_LOGGING
|
2002-08-27 01:20:31 +04:00
|
|
|
extern PRLogModuleInfo * kLayoutPrintingLogMod;
|
|
|
|
#define PR_PL(_p1) PR_LOG(kLayoutPrintingLogMod, PR_LOG_DEBUG, _p1)
|
2002-06-20 01:51:13 +04:00
|
|
|
#else
|
|
|
|
#define PR_PL(_p1)
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
|
|
|
|
2005-11-04 05:38:33 +03:00
|
|
|
nsIFrame*
|
2006-03-27 01:30:36 +04:00
|
|
|
NS_NewPageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
1999-05-12 02:03:29 +04:00
|
|
|
{
|
2006-03-27 01:30:36 +04:00
|
|
|
return new (aPresShell) nsPageFrame(aContext);
|
1999-05-12 02:03:29 +04:00
|
|
|
}
|
|
|
|
|
2006-03-27 01:30:36 +04:00
|
|
|
nsPageFrame::nsPageFrame(nsStyleContext* aContext)
|
2006-03-30 04:27:42 +04:00
|
|
|
: nsContainerFrame(aContext)
|
1999-02-19 01:23:36 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
nsPageFrame::~nsPageFrame()
|
|
|
|
{
|
2001-11-03 17:59:39 +03:00
|
|
|
}
|
2001-09-26 18:01:26 +04:00
|
|
|
|
2004-08-01 03:15:21 +04:00
|
|
|
NS_IMETHODIMP nsPageFrame::Reflow(nsPresContext* aPresContext,
|
2001-11-03 17:59:39 +03:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
2000-04-21 18:59:47 +04:00
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsPageFrame", aReflowState.reason);
|
2001-11-14 16:40:03 +03:00
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
1998-05-12 08:17:56 +04:00
|
|
|
aStatus = NS_FRAME_COMPLETE; // initialize out parameter
|
1998-04-14 00:24:54 +04:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// Do we have any children?
|
|
|
|
// XXX We should use the overflow list instead...
|
|
|
|
nsIFrame* firstFrame = mFrames.FirstChild();
|
|
|
|
nsPageContentFrame* contentPage = NS_STATIC_CAST(nsPageContentFrame*, firstFrame);
|
|
|
|
NS_ASSERTION(contentPage, "There should always be a content page");
|
|
|
|
NS_ASSERTION(nsLayoutAtoms::pageContentFrame == firstFrame->GetType(),
|
|
|
|
"This frame isn't a pageContentFrame");
|
|
|
|
|
|
|
|
if (contentPage && GetPrevInFlow() &&
|
|
|
|
eReflowReason_Incremental != aReflowState.reason &&
|
|
|
|
eReflowReason_Dirty != aReflowState.reason) {
|
|
|
|
|
|
|
|
nsPageFrame* prevPage = NS_STATIC_CAST(nsPageFrame*, GetPrevInFlow());
|
|
|
|
nsPageContentFrame* prevContentPage = NS_STATIC_CAST(nsPageContentFrame*, prevPage->mFrames.FirstChild());
|
|
|
|
nsIFrame* prevLastChild = prevContentPage->mFrames.LastChild();
|
|
|
|
|
|
|
|
// Create a continuing child of the previous page's last child
|
|
|
|
nsIFrame* newFrame;
|
|
|
|
|
|
|
|
aPresContext->PresShell()->FrameConstructor()->
|
|
|
|
CreateContinuingFrame(aPresContext, prevLastChild,
|
|
|
|
contentPage, &newFrame);
|
|
|
|
|
|
|
|
// Make the new area frame the 1st child of the page content frame. There may already be
|
|
|
|
// children placeholders which don't get reflowed but must not be destroyed until the
|
|
|
|
// page content frame is destroyed.
|
|
|
|
contentPage->mFrames.InsertFrame(contentPage, nsnull, newFrame);
|
|
|
|
}
|
1998-05-30 00:36:05 +04:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// Resize our frame allowing it only to be as big as we are
|
|
|
|
// XXX Pay attention to the page's border and padding...
|
|
|
|
if (mFrames.NotEmpty()) {
|
|
|
|
nsIFrame* frame = mFrames.FirstChild();
|
|
|
|
// When the reflow size is NS_UNCONSTRAINEDSIZE it means we are reflowing
|
|
|
|
// a single page to print selection. So this means we want to use
|
|
|
|
// NS_UNCONSTRAINEDSIZE without altering it
|
|
|
|
nscoord avHeight;
|
|
|
|
if (mPD->mReflowSize.height == NS_UNCONSTRAINEDSIZE) {
|
|
|
|
avHeight = NS_UNCONSTRAINEDSIZE;
|
|
|
|
} else {
|
|
|
|
avHeight = mPD->mReflowSize.height - mPD->mReflowMargin.TopBottom();
|
|
|
|
}
|
|
|
|
nsSize maxSize(mPD->mReflowSize.width - mPD->mReflowMargin.LeftRight(),
|
|
|
|
avHeight);
|
|
|
|
// Get the number of Twips per pixel from the PresContext
|
|
|
|
nscoord onePixelInTwips = aPresContext->IntScaledPixelsToTwips(1);
|
|
|
|
// insurance against infinite reflow, when reflowing less than a pixel
|
|
|
|
// XXX Shouldn't we do something more friendly when invalid margins
|
|
|
|
// are set?
|
|
|
|
if (maxSize.width < onePixelInTwips || maxSize.height < onePixelInTwips) {
|
|
|
|
aDesiredSize.width = 0;
|
|
|
|
aDesiredSize.height = 0;
|
|
|
|
NS_WARNING("Reflow aborted; no space for content");
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-11-28 18:19:47 +03:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, frame, maxSize);
|
|
|
|
kidReflowState.mFlags.mIsTopOfPage = PR_TRUE;
|
2001-11-28 18:19:47 +03:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// calc location of frame
|
2006-04-11 05:48:48 +04:00
|
|
|
nscoord xc = mPD->mReflowMargin.left + mPD->mExtraMargin.left;
|
|
|
|
nscoord yc = mPD->mReflowMargin.top + mPD->mExtraMargin.top;
|
2001-11-06 17:34:00 +03:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// Get the child's desired size
|
|
|
|
ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, xc, yc, 0, aStatus);
|
1999-10-30 06:52:11 +04:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// Place and size the child
|
|
|
|
FinishReflowChild(frame, aPresContext, &kidReflowState, aDesiredSize, xc, yc, 0);
|
1999-10-30 06:52:11 +04:00
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
// Make sure the child is at least as tall as our max size (the containing window)
|
|
|
|
if (aDesiredSize.height < aReflowState.availableHeight &&
|
|
|
|
aReflowState.availableHeight != NS_UNCONSTRAINEDSIZE) {
|
|
|
|
aDesiredSize.height = aReflowState.availableHeight;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
2006-04-01 05:19:28 +04:00
|
|
|
NS_ASSERTION(!NS_FRAME_IS_COMPLETE(aStatus) ||
|
|
|
|
!frame->GetNextInFlow(), "bad child flow list");
|
|
|
|
}
|
|
|
|
PR_PL(("PageFrame::Reflow %p ", this));
|
|
|
|
PR_PL(("[%d,%d][%d,%d]\n", aDesiredSize.width, aDesiredSize.height, aReflowState.availableWidth, aReflowState.availableHeight));
|
|
|
|
|
|
|
|
// Return our desired size
|
|
|
|
aDesiredSize.width = aReflowState.availableWidth;
|
|
|
|
if (aReflowState.availableHeight != NS_UNCONSTRAINEDSIZE) {
|
|
|
|
aDesiredSize.height = aReflowState.availableHeight;
|
1998-05-25 21:31:49 +04:00
|
|
|
}
|
2006-04-11 05:48:48 +04:00
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
|
|
|
aDesiredSize.descent = 0;
|
2002-06-20 01:51:13 +04:00
|
|
|
PR_PL(("PageFrame::Reflow %p ", this));
|
|
|
|
PR_PL(("[%d,%d]\n", aReflowState.availableWidth, aReflowState.availableHeight));
|
1998-04-14 00:24:54 +04:00
|
|
|
|
2002-05-29 02:50:43 +04:00
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
1998-04-17 05:41:24 +04:00
|
|
|
return NS_OK;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
2003-10-31 23:19:18 +03:00
|
|
|
nsIAtom*
|
|
|
|
nsPageFrame::GetType() const
|
1999-02-14 06:47:33 +03:00
|
|
|
{
|
2003-10-31 23:19:18 +03:00
|
|
|
return nsLayoutAtoms::pageFrame;
|
1999-02-14 06:47:33 +03:00
|
|
|
}
|
|
|
|
|
1999-11-02 01:12:45 +03:00
|
|
|
#ifdef DEBUG
|
1998-11-19 20:22:29 +03:00
|
|
|
NS_IMETHODIMP
|
2001-11-14 04:33:42 +03:00
|
|
|
nsPageFrame::GetFrameName(nsAString& aResult) const
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
2001-11-14 04:33:42 +03:00
|
|
|
return MakeFrameName(NS_LITERAL_STRING("Page"), aResult);
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
1999-11-02 01:12:45 +03:00
|
|
|
#endif
|
1998-04-14 00:24:54 +04:00
|
|
|
|
2004-03-12 07:40:17 +03:00
|
|
|
/* virtual */ PRBool
|
|
|
|
nsPageFrame::IsContainingBlock() const
|
1999-03-05 07:28:07 +03:00
|
|
|
{
|
2004-03-12 07:40:17 +03:00
|
|
|
return PR_TRUE;
|
1999-03-05 07:28:07 +03:00
|
|
|
}
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2001-09-26 18:01:26 +04:00
|
|
|
// done with static helper functions
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPageFrame::ProcessSpecialCodes(const nsString& aStr, nsString& aNewStr)
|
|
|
|
{
|
|
|
|
|
|
|
|
aNewStr = aStr;
|
|
|
|
|
|
|
|
// Search to see if the &D code is in the string
|
|
|
|
// then subst in the current date/time
|
2002-03-19 09:46:56 +03:00
|
|
|
NS_NAMED_LITERAL_STRING(kDate, "&D");
|
|
|
|
if (aStr.Find(kDate) != kNotFound) {
|
|
|
|
if (mPD->mDateTimeStr != nsnull) {
|
|
|
|
aNewStr.ReplaceSubstring(kDate.get(), mPD->mDateTimeStr);
|
|
|
|
} else {
|
2004-01-30 01:04:45 +03:00
|
|
|
aNewStr.ReplaceSubstring(kDate.get(), EmptyString().get());
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// NOTE: Must search for &PT before searching for &P
|
|
|
|
//
|
|
|
|
// Search to see if the "page number and page" total code are in the string
|
2002-03-19 09:46:56 +03:00
|
|
|
// and replace the page number and page total code with the actual
|
|
|
|
// values
|
|
|
|
NS_NAMED_LITERAL_STRING(kPageAndTotal, "&PT");
|
|
|
|
if (aStr.Find(kPageAndTotal) != kNotFound) {
|
|
|
|
PRUnichar * uStr = nsTextFormatter::smprintf(mPD->mPageNumAndTotalsFormat, mPageNum, mTotNumPages);
|
|
|
|
aNewStr.ReplaceSubstring(kPageAndTotal.get(), uStr);
|
|
|
|
nsMemory::Free(uStr);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Search to see if the page number code is in the string
|
2002-03-19 09:46:56 +03:00
|
|
|
// and replace the page number code with the actual value
|
|
|
|
NS_NAMED_LITERAL_STRING(kPage, "&P");
|
|
|
|
if (aStr.Find(kPage) != kNotFound) {
|
|
|
|
PRUnichar * uStr = nsTextFormatter::smprintf(mPD->mPageNumFormat, mPageNum);
|
|
|
|
aNewStr.ReplaceSubstring(kPage.get(), uStr);
|
|
|
|
nsMemory::Free(uStr);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
|
2002-03-19 09:46:56 +03:00
|
|
|
NS_NAMED_LITERAL_STRING(kTitle, "&T");
|
|
|
|
if (aStr.Find(kTitle) != kNotFound) {
|
2005-04-29 08:57:51 +04:00
|
|
|
if (mPD->mDocTitle != nsnull) {
|
|
|
|
aNewStr.ReplaceSubstring(kTitle.get(), mPD->mDocTitle);
|
|
|
|
} else {
|
|
|
|
aNewStr.ReplaceSubstring(kTitle.get(), EmptyString().get());
|
|
|
|
}
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
|
2002-03-19 09:46:56 +03:00
|
|
|
NS_NAMED_LITERAL_STRING(kDocURL, "&U");
|
|
|
|
if (aStr.Find(kDocURL) != kNotFound) {
|
2005-04-29 08:57:51 +04:00
|
|
|
if (mPD->mDocURL != nsnull) {
|
|
|
|
aNewStr.ReplaceSubstring(kDocURL.get(), mPD->mDocURL);
|
|
|
|
} else {
|
|
|
|
aNewStr.ReplaceSubstring(kDocURL.get(), EmptyString().get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_NAMED_LITERAL_STRING(kPageTotal, "&L");
|
|
|
|
if (aStr.Find(kPageTotal) != kNotFound) {
|
|
|
|
PRUnichar * uStr = nsTextFormatter::smprintf(mPD->mPageNumFormat, mTotNumPages);
|
|
|
|
aNewStr.ReplaceSubstring(kPageTotal.get(), uStr);
|
|
|
|
nsMemory::Free(uStr);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
nscoord nsPageFrame::GetXPosition(nsIRenderingContext& aRenderingContext,
|
|
|
|
const nsRect& aRect,
|
|
|
|
PRInt32 aJust,
|
|
|
|
const nsString& aStr)
|
|
|
|
{
|
|
|
|
PRInt32 width;
|
|
|
|
aRenderingContext.GetWidth(aStr, width);
|
|
|
|
|
|
|
|
nscoord x = aRect.x;
|
|
|
|
switch (aJust) {
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kJustLeft:
|
2002-02-01 18:31:15 +03:00
|
|
|
x += mPD->mExtraMargin.left + mPD->mEdgePaperMargin.left;
|
2001-01-27 17:09:34 +03:00
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kJustCenter:
|
2001-01-27 17:09:34 +03:00
|
|
|
x += (aRect.width - width) / 2;
|
|
|
|
break;
|
|
|
|
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kJustRight:
|
2002-02-01 18:31:15 +03:00
|
|
|
x += aRect.width - width - mPD->mExtraMargin.right - mPD->mEdgePaperMargin.right;
|
2001-01-27 17:09:34 +03:00
|
|
|
break;
|
|
|
|
} // switch
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Draw a Header or footer text lrft,right or center justified
|
|
|
|
// @parm aRenderingContext - rendering content ot draw into
|
|
|
|
// @parm aHeaderFooter - indicates whether it is a header or footer
|
|
|
|
// @parm aJust - indicates the justification of the text
|
|
|
|
// @parm aStr - The string to be drawn
|
|
|
|
// @parm aRect - the rect of the page
|
|
|
|
// @parm aHeight - the height of the text
|
|
|
|
// @parm aUseHalfThePage - indicates whether the text should limited to the width
|
|
|
|
// of the entire page or just half the page
|
|
|
|
void
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPageFrame::DrawHeaderFooter(nsPresContext* aPresContext,
|
2002-04-30 04:37:12 +04:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
2001-09-26 18:01:26 +04:00
|
|
|
nsIFrame * aFrame,
|
|
|
|
nsHeaderFooterEnum aHeaderFooter,
|
|
|
|
PRInt32 aJust,
|
|
|
|
const nsString& aStr1,
|
|
|
|
const nsString& aStr2,
|
|
|
|
const nsString& aStr3,
|
|
|
|
const nsRect& aRect,
|
2001-10-31 01:58:00 +03:00
|
|
|
nscoord aAscent,
|
2001-09-26 18:01:26 +04:00
|
|
|
nscoord aHeight)
|
|
|
|
{
|
|
|
|
PRInt32 numStrs = 0;
|
|
|
|
if (!aStr1.IsEmpty()) numStrs++;
|
|
|
|
if (!aStr2.IsEmpty()) numStrs++;
|
|
|
|
if (!aStr3.IsEmpty()) numStrs++;
|
|
|
|
|
|
|
|
if (numStrs == 0) return;
|
2001-10-02 03:57:57 +04:00
|
|
|
nscoord strSpace = aRect.width / numStrs;
|
2001-09-26 18:01:26 +04:00
|
|
|
|
|
|
|
if (!aStr1.IsEmpty()) {
|
2002-04-30 04:37:12 +04:00
|
|
|
DrawHeaderFooter(aPresContext, aRenderingContext, aFrame, aHeaderFooter, nsIPrintSettings::kJustLeft, aStr1, aRect, aAscent, aHeight, strSpace);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
if (!aStr2.IsEmpty()) {
|
2002-04-30 04:37:12 +04:00
|
|
|
DrawHeaderFooter(aPresContext, aRenderingContext, aFrame, aHeaderFooter, nsIPrintSettings::kJustCenter, aStr2, aRect, aAscent, aHeight, strSpace);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
if (!aStr3.IsEmpty()) {
|
2002-04-30 04:37:12 +04:00
|
|
|
DrawHeaderFooter(aPresContext, aRenderingContext, aFrame, aHeaderFooter, nsIPrintSettings::kJustRight, aStr3, aRect, aAscent, aHeight, strSpace);
|
2001-09-26 18:01:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Draw a Header or footer text lrft,right or center justified
|
|
|
|
// @parm aRenderingContext - rendering content ot draw into
|
|
|
|
// @parm aHeaderFooter - indicates whether it is a header or footer
|
|
|
|
// @parm aJust - indicates the justification of the text
|
|
|
|
// @parm aStr - The string to be drawn
|
|
|
|
// @parm aRect - the rect of the page
|
|
|
|
// @parm aHeight - the height of the text
|
|
|
|
// @parm aWidth - available width for any one of the strings
|
|
|
|
void
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPageFrame::DrawHeaderFooter(nsPresContext* aPresContext,
|
2002-04-30 04:37:12 +04:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
2001-01-27 17:09:34 +03:00
|
|
|
nsIFrame * aFrame,
|
|
|
|
nsHeaderFooterEnum aHeaderFooter,
|
|
|
|
PRInt32 aJust,
|
|
|
|
const nsString& aStr,
|
|
|
|
const nsRect& aRect,
|
2001-10-31 01:58:00 +03:00
|
|
|
nscoord aAscent,
|
2001-01-27 17:09:34 +03:00
|
|
|
nscoord aHeight,
|
2001-09-26 18:01:26 +04:00
|
|
|
nscoord aWidth)
|
2001-01-27 17:09:34 +03:00
|
|
|
{
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2002-02-01 18:31:15 +03:00
|
|
|
nscoord contentWidth = aWidth - (mPD->mEdgePaperMargin.left + mPD->mEdgePaperMargin.right);
|
2001-11-28 18:19:47 +03:00
|
|
|
|
2001-01-27 17:09:34 +03:00
|
|
|
// first make sure we have a vaild string and that the height of the
|
|
|
|
// text will fit in the margin
|
2003-05-24 01:34:47 +04:00
|
|
|
if (!aStr.IsEmpty() &&
|
2001-01-27 17:09:34 +03:00
|
|
|
((aHeaderFooter == eHeader && aHeight < mMargin.top) ||
|
|
|
|
(aHeaderFooter == eFooter && aHeight < mMargin.bottom))) {
|
2001-09-26 18:01:26 +04:00
|
|
|
nsAutoString str;
|
|
|
|
ProcessSpecialCodes(aStr, str);
|
|
|
|
|
2002-04-26 15:30:33 +04:00
|
|
|
PRInt32 indx;
|
|
|
|
PRInt32 textWidth = 0;
|
|
|
|
const PRUnichar* text = str.get();
|
2001-09-26 18:01:26 +04:00
|
|
|
|
2002-04-26 15:30:33 +04:00
|
|
|
PRInt32 len = (PRInt32)str.Length();
|
|
|
|
if (len == 0) {
|
|
|
|
return; // bail is empty string
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
2003-03-19 07:35:08 +03:00
|
|
|
// find how much text fits, the "position" is the size of the available area
|
2005-12-06 03:32:52 +03:00
|
|
|
if (nsLayoutUtils::BinarySearchForPosition(&aRenderingContext, text, 0, 0, 0, len,
|
2002-04-26 15:30:33 +04:00
|
|
|
PRInt32(contentWidth), indx, textWidth)) {
|
2004-10-20 01:46:45 +04:00
|
|
|
if (indx < len-1 ) {
|
|
|
|
// we can't fit in all the text
|
|
|
|
if (indx > 3) {
|
|
|
|
// But we can fit in at least 4 chars. Show all but 3 of them, then
|
|
|
|
// an ellipsis.
|
|
|
|
// XXXbz for non-plane0 text, this may be cutting things in the
|
|
|
|
// middle of a codepoint! Also, we have no guarantees that the three
|
|
|
|
// dots will fit in the space the three chars we removed took up with
|
|
|
|
// these font metrics!
|
|
|
|
str.Truncate(indx-3);
|
|
|
|
str.AppendLiteral("...");
|
|
|
|
} else {
|
|
|
|
// We can only fit 3 or fewer chars. Just show nothing
|
|
|
|
str.Truncate();
|
|
|
|
}
|
2002-04-26 15:30:33 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return; // bail if couldn't find the correct length
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// cacl the x and y positions of the text
|
|
|
|
nsRect rect(aRect);
|
|
|
|
nscoord x = GetXPosition(aRenderingContext, rect, aJust, str);
|
|
|
|
nscoord y;
|
|
|
|
if (aHeaderFooter == eHeader) {
|
2002-02-01 18:31:15 +03:00
|
|
|
y = rect.y + mPD->mExtraMargin.top + mPD->mEdgePaperMargin.top;
|
2001-01-27 17:09:34 +03:00
|
|
|
} else {
|
2002-02-01 18:31:15 +03:00
|
|
|
y = rect.y + rect.height - aHeight - mPD->mExtraMargin.bottom - mPD->mEdgePaperMargin.bottom;
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// set up new clip and draw the text
|
|
|
|
aRenderingContext.PushState();
|
2001-11-03 17:59:39 +03:00
|
|
|
aRenderingContext.SetColor(NS_RGB(0,0,0));
|
2004-04-23 19:21:24 +04:00
|
|
|
aRenderingContext.SetClipRect(rect, nsClipCombine_kReplace);
|
2002-04-30 04:37:12 +04:00
|
|
|
#ifdef IBMBIDI
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
2004-04-13 04:28:44 +04:00
|
|
|
if (aPresContext->BidiEnabled()) {
|
2004-07-29 23:41:39 +04:00
|
|
|
nsBidiPresUtils* bidiUtils = aPresContext->GetBidiUtils();
|
2002-04-30 04:37:12 +04:00
|
|
|
|
|
|
|
if (bidiUtils) {
|
|
|
|
// Base direction is always LTR for now. If bug 139337 is fixed,
|
|
|
|
// that should change.
|
2004-10-29 16:28:19 +04:00
|
|
|
rv = bidiUtils->RenderText(str.get(), str.Length(), NSBIDI_LTR,
|
2002-04-30 04:37:12 +04:00
|
|
|
aPresContext, aRenderingContext,
|
|
|
|
x, y + aAscent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
#endif // IBMBIDI
|
2001-10-31 01:58:00 +03:00
|
|
|
aRenderingContext.DrawString(str, x, y + aAscent);
|
2004-04-18 17:13:35 +04:00
|
|
|
aRenderingContext.PopState();
|
2002-06-20 01:51:13 +04:00
|
|
|
|
2001-04-12 17:04:29 +04:00
|
|
|
#ifdef DEBUG_PRINTING
|
2002-06-20 01:51:13 +04:00
|
|
|
PR_PL(("Page: %p", this));
|
2006-02-03 17:18:39 +03:00
|
|
|
PR_PL((" [%s]", NS_ConvertUTF16toUTF8(str).get()));
|
2001-04-12 17:04:29 +04:00
|
|
|
char justStr[64];
|
|
|
|
switch (aJust) {
|
2002-01-01 15:58:53 +03:00
|
|
|
case nsIPrintSettings::kJustLeft:strcpy(justStr, "Left");break;
|
|
|
|
case nsIPrintSettings::kJustCenter:strcpy(justStr, "Center");break;
|
|
|
|
case nsIPrintSettings::kJustRight:strcpy(justStr, "Right");break;
|
2001-04-12 17:04:29 +04:00
|
|
|
} // switch
|
2002-06-20 01:51:13 +04:00
|
|
|
PR_PL((" HF: %s ", aHeaderFooter==eHeader?"Header":"Footer"));
|
|
|
|
PR_PL((" JST: %s ", justStr));
|
|
|
|
PR_PL((" x,y: %d,%d", x, y));
|
|
|
|
PR_PL((" Hgt: %d \n", aHeight));
|
2001-04-12 17:04:29 +04:00
|
|
|
#endif
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
static void PaintPrintPreviewBackground(nsIFrame* aFrame, nsIRenderingContext* aCtx,
|
|
|
|
const nsRect& aDirtyRect, nsPoint aPt)
|
2001-01-27 17:09:34 +03:00
|
|
|
{
|
2006-01-26 05:29:17 +03:00
|
|
|
NS_STATIC_CAST(nsPageFrame*, aFrame)->PaintPrintPreviewBackground(*aCtx, aPt);
|
|
|
|
}
|
2001-11-03 17:59:39 +03:00
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
static void PaintPageBackground(nsIFrame* aFrame, nsIRenderingContext* aCtx,
|
|
|
|
const nsRect& aDirtyRect, nsPoint aPt)
|
|
|
|
{
|
|
|
|
NS_STATIC_CAST(nsPageFrame*, aFrame)->DrawBackground(*aCtx, aDirtyRect, aPt);
|
|
|
|
}
|
2001-09-26 18:01:26 +04:00
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
static void PaintHeaderFooter(nsIFrame* aFrame, nsIRenderingContext* aCtx,
|
|
|
|
const nsRect& aDirtyRect, nsPoint aPt)
|
|
|
|
{
|
|
|
|
NS_STATIC_CAST(nsPageFrame*, aFrame)->PaintHeaderFooter(*aCtx, aPt);
|
|
|
|
}
|
2001-04-12 17:04:29 +04:00
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPageFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
const nsDisplayListSet& aLists)
|
|
|
|
{
|
|
|
|
nsDisplayListCollection set;
|
|
|
|
|
2006-04-01 05:19:28 +04:00
|
|
|
if (GetPresContext()->IsScreen()) {
|
2006-01-26 05:29:17 +03:00
|
|
|
nsresult rv = set.BorderBackground()->AppendNewToTop(new (aBuilder)
|
|
|
|
nsDisplayGeneric(this, ::PaintPrintPreviewBackground, "PrintPreviewBackground"));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2002-02-22 04:45:05 +03:00
|
|
|
}
|
2006-01-26 05:29:17 +03:00
|
|
|
|
|
|
|
nsresult rv = set.BorderBackground()->AppendNewToTop(new (aBuilder)
|
|
|
|
nsDisplayGeneric(this, ::PaintPageBackground, "PageBackground"));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// REVIEW: There was a "aRenderingContext.SetColor(NS_RGB(255,255,255));"
|
|
|
|
// here which was overridden on every code path, so I removed it.
|
|
|
|
rv = nsContainerFrame::BuildDisplayList(aBuilder, aDirtyRect, set);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2001-01-27 17:09:34 +03:00
|
|
|
|
2006-03-30 04:27:42 +04:00
|
|
|
if (GetPresContext()->IsRootPaginatedDocument()) {
|
2006-01-26 05:29:17 +03:00
|
|
|
rv = set.Content()->AppendNewToTop(new (aBuilder)
|
|
|
|
nsDisplayGeneric(this, ::PaintHeaderFooter, "HeaderFooter"));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
set.MoveTo(aLists);
|
|
|
|
return NS_OK;
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
nsPageFrame::SetPageNumInfo(PRInt32 aPageNumber, PRInt32 aTotalPages)
|
|
|
|
{
|
|
|
|
mPageNum = aPageNumber;
|
2001-04-12 17:04:29 +04:00
|
|
|
mTotNumPages = aTotalPages;
|
2001-01-27 17:09:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
void
|
|
|
|
nsPageFrame::PaintPrintPreviewBackground(nsIRenderingContext& aRenderingContext,
|
|
|
|
nsPoint aPt)
|
|
|
|
{
|
|
|
|
// fill page with White
|
|
|
|
aRenderingContext.SetColor(NS_RGB(255,255,255));
|
|
|
|
// REVIEW: this used to have rect's width and height be the
|
|
|
|
// mClipRect if specialClipIsSet ... but that seems completely bogus
|
|
|
|
// and inconsistent with the painting of the shadow below
|
|
|
|
nsRect rect(aPt, GetSize());
|
|
|
|
rect.width -= mPD->mShadowSize.width;
|
|
|
|
rect.height -= mPD->mShadowSize.height;
|
|
|
|
aRenderingContext.FillRect(rect);
|
|
|
|
// draw line around outside of page
|
|
|
|
aRenderingContext.SetColor(NS_RGB(0,0,0));
|
|
|
|
aRenderingContext.DrawRect(rect);
|
|
|
|
|
|
|
|
if (mPD->mShadowSize.width > 0 && mPD->mShadowSize.height > 0) {
|
|
|
|
aRenderingContext.SetColor(NS_RGB(51,51,51));
|
|
|
|
nsRect r(aPt.x,aPt.y, mRect.width, mRect.height);
|
|
|
|
nsRect shadowRect;
|
|
|
|
shadowRect.x = r.x + r.width - mPD->mShadowSize.width;
|
|
|
|
shadowRect.y = r.y + mPD->mShadowSize.height;
|
|
|
|
shadowRect.width = mPD->mShadowSize.width;
|
|
|
|
shadowRect.height = r.height - mPD->mShadowSize.height;
|
|
|
|
aRenderingContext.FillRect(shadowRect);
|
|
|
|
|
|
|
|
shadowRect.x = r.x + mPD->mShadowSize.width;
|
|
|
|
shadowRect.y = r.y + r.height - mPD->mShadowSize.height;
|
|
|
|
shadowRect.width = r.width - mPD->mShadowSize.width;
|
|
|
|
shadowRect.height = mPD->mShadowSize.height;
|
|
|
|
aRenderingContext.FillRect(shadowRect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsPageFrame::PaintHeaderFooter(nsIRenderingContext& aRenderingContext,
|
|
|
|
nsPoint aPt)
|
|
|
|
{
|
|
|
|
nsPresContext* pc = GetPresContext();
|
|
|
|
|
|
|
|
if (!mPD->mPrintSettings) {
|
2006-04-01 05:19:28 +04:00
|
|
|
if (pc->Type() == nsPresContext::eContext_PrintPreview || pc->IsDynamic())
|
2006-01-26 05:29:17 +03:00
|
|
|
mPD->mPrintSettings = pc->GetPrintSettings();
|
2006-04-01 05:19:28 +04:00
|
|
|
if (!mPD->mPrintSettings)
|
|
|
|
return;
|
2006-01-26 05:29:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// get the current margin
|
|
|
|
mPD->mPrintSettings->GetMarginInTwips(mMargin);
|
|
|
|
|
|
|
|
nsRect rect(aPt.x, aPt.y, mRect.width - mPD->mShadowSize.width,
|
|
|
|
mRect.height - mPD->mShadowSize.height);
|
|
|
|
|
|
|
|
aRenderingContext.SetFont(*mPD->mHeadFootFont, nsnull);
|
|
|
|
aRenderingContext.SetColor(NS_RGB(0,0,0));
|
|
|
|
|
|
|
|
// Get the FontMetrics to determine width.height of strings
|
|
|
|
nsCOMPtr<nsIFontMetrics> fontMet;
|
|
|
|
pc->DeviceContext()->GetMetricsFor(*mPD->mHeadFootFont, nsnull,
|
|
|
|
*getter_AddRefs(fontMet));
|
|
|
|
nscoord ascent = 0;
|
|
|
|
nscoord visibleHeight = 0;
|
|
|
|
if (fontMet) {
|
|
|
|
fontMet->GetHeight(visibleHeight);
|
|
|
|
fontMet->GetMaxAscent(ascent);
|
|
|
|
}
|
|
|
|
|
|
|
|
// print document headers and footers
|
|
|
|
PRUnichar * headers[3];
|
|
|
|
mPD->mPrintSettings->GetHeaderStrLeft(&headers[0]); // creates memory
|
|
|
|
mPD->mPrintSettings->GetHeaderStrCenter(&headers[1]); // creates memory
|
|
|
|
mPD->mPrintSettings->GetHeaderStrRight(&headers[2]); // creates memory
|
|
|
|
DrawHeaderFooter(pc, aRenderingContext, this, eHeader, nsIPrintSettings::kJustLeft,
|
|
|
|
nsAutoString(headers[0]), nsAutoString(headers[1]), nsAutoString(headers[2]),
|
|
|
|
rect, ascent, visibleHeight);
|
|
|
|
PRInt32 i;
|
|
|
|
for (i=0;i<3;i++) nsMemory::Free(headers[i]);
|
|
|
|
|
|
|
|
PRUnichar * footers[3];
|
|
|
|
mPD->mPrintSettings->GetFooterStrLeft(&footers[0]); // creates memory
|
|
|
|
mPD->mPrintSettings->GetFooterStrCenter(&footers[1]); // creates memory
|
|
|
|
mPD->mPrintSettings->GetFooterStrRight(&footers[2]); // creates memory
|
|
|
|
DrawHeaderFooter(pc, aRenderingContext, this, eFooter, nsIPrintSettings::kJustRight,
|
|
|
|
nsAutoString(footers[0]), nsAutoString(footers[1]), nsAutoString(footers[2]),
|
|
|
|
rect, ascent, visibleHeight);
|
|
|
|
for (i=0;i<3;i++) nsMemory::Free(footers[i]);
|
|
|
|
}
|
|
|
|
|
2001-12-05 01:46:41 +03:00
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void
|
2006-01-26 05:29:17 +03:00
|
|
|
nsPageFrame::DrawBackground(nsIRenderingContext& aRenderingContext,
|
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsPoint aPt)
|
2001-12-05 01:46:41 +03:00
|
|
|
{
|
|
|
|
nsSimplePageSequenceFrame* seqFrame = NS_STATIC_CAST(nsSimplePageSequenceFrame*, mParent);
|
|
|
|
if (seqFrame != nsnull) {
|
2002-02-22 04:45:05 +03:00
|
|
|
nsIFrame* pageContentFrame = mFrames.FirstChild();
|
|
|
|
NS_ASSERTION(pageContentFrame, "Must always be there.");
|
2001-12-05 01:46:41 +03:00
|
|
|
|
2003-05-15 07:42:21 +04:00
|
|
|
const nsStyleBorder* border = GetStyleBorder();
|
|
|
|
const nsStylePadding* padding = GetStylePadding();
|
2001-12-05 01:46:41 +03:00
|
|
|
|
2006-01-26 05:29:17 +03:00
|
|
|
nsCSSRendering::PaintBackground(GetPresContext(), aRenderingContext, this,
|
|
|
|
aDirtyRect, pageContentFrame->GetRect() + aPt, *border, *padding,
|
2003-02-23 05:49:22 +03:00
|
|
|
PR_TRUE);
|
2001-12-05 01:46:41 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-20 01:45:07 +04:00
|
|
|
void
|
|
|
|
nsPageFrame::SetSharedPageData(nsSharedPageData* aPD)
|
|
|
|
{
|
|
|
|
mPD = aPD;
|
|
|
|
// Set the shared data into the page frame before reflow
|
|
|
|
nsPageContentFrame * pcf = NS_STATIC_CAST(nsPageContentFrame*, mFrames.FirstChild());
|
|
|
|
if (pcf) {
|
|
|
|
pcf->SetSharedPageData(mPD);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-11-04 05:38:33 +03:00
|
|
|
nsIFrame*
|
2006-03-27 01:30:36 +04:00
|
|
|
NS_NewPageBreakFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
|
2002-03-18 00:35:08 +03:00
|
|
|
{
|
2005-11-04 05:38:33 +03:00
|
|
|
NS_PRECONDITION(aPresShell, "null PresShell");
|
2002-03-18 00:35:08 +03:00
|
|
|
#ifdef DEBUG
|
|
|
|
//check that we are only creating page break frames when printing
|
2004-08-21 00:34:37 +04:00
|
|
|
NS_ASSERTION(aPresShell->GetPresContext()->IsPaginated(), "created a page break frame while not printing");
|
2002-03-18 00:35:08 +03:00
|
|
|
#endif
|
|
|
|
|
2006-03-27 01:30:36 +04:00
|
|
|
return new (aPresShell) nsPageBreakFrame(aContext);
|
2002-03-18 00:35:08 +03:00
|
|
|
}
|
|
|
|
|
2006-03-27 01:30:36 +04:00
|
|
|
nsPageBreakFrame::nsPageBreakFrame(nsStyleContext* aContext) :
|
|
|
|
nsLeafFrame(aContext), mHaveReflowed(PR_FALSE)
|
2002-03-18 00:35:08 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPageBreakFrame::~nsPageBreakFrame()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPageBreakFrame::GetDesiredSize(nsPresContext* aPresContext,
|
2002-03-18 00:35:08 +03:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aPresContext, "null pres context");
|
2004-07-29 23:41:39 +04:00
|
|
|
nscoord onePixel = aPresContext->IntScaledPixelsToTwips(1);
|
2002-03-18 00:35:08 +03:00
|
|
|
|
|
|
|
aDesiredSize.width = onePixel;
|
|
|
|
if (mHaveReflowed) {
|
|
|
|
// If blocks reflow us a 2nd time trying to put us on a new page, then return
|
|
|
|
// a desired height of 0 to avoid an extra page break.
|
|
|
|
aDesiredSize.height = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aDesiredSize.height = aReflowState.availableHeight;
|
|
|
|
// round the height down to the nearest pixel
|
|
|
|
aDesiredSize.height -= aDesiredSize.height % onePixel;
|
|
|
|
}
|
|
|
|
|
2003-01-09 17:26:32 +03:00
|
|
|
if (aDesiredSize.mComputeMEW) {
|
|
|
|
aDesiredSize.mMaxElementWidth = onePixel;
|
2002-03-18 00:35:08 +03:00
|
|
|
}
|
|
|
|
aDesiredSize.ascent = 0;
|
|
|
|
aDesiredSize.descent = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPageBreakFrame::Reflow(nsPresContext* aPresContext,
|
2002-03-18 00:35:08 +03:00
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
const nsHTMLReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(aPresContext, "null pres context");
|
|
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableFrame", aReflowState.reason);
|
|
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
|
|
|
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
GetDesiredSize(aPresContext, aReflowState, aDesiredSize);
|
|
|
|
mHaveReflowed = PR_TRUE;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-10-31 23:19:18 +03:00
|
|
|
nsIAtom*
|
|
|
|
nsPageBreakFrame::GetType() const
|
2002-03-18 00:35:08 +03:00
|
|
|
{
|
2003-10-31 23:19:18 +03:00
|
|
|
return nsLayoutAtoms::pageBreakFrame;
|
2002-03-18 00:35:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|