1998-09-15 04:19:49 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
2001-10-25 05:08:40 +04:00
|
|
|
* vim:cindent:ts=2:et:sw=2:
|
1998-09-15 04:19:49 +04:00
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-09-15 04:19:49 +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/
|
|
|
|
*
|
|
|
|
* 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-09-15 04:19:49 +04:00
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code.
|
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* 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
|
|
|
*
|
2004-04-18 18:30:37 +04:00
|
|
|
* Contributor(s):
|
2000-04-17 18:40:46 +04:00
|
|
|
* Steve Clark <buster@netscape.com>
|
2004-04-18 18:30:37 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* 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"),
|
|
|
|
* 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
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* 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
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK *****
|
2000-05-03 03:07:11 +04:00
|
|
|
* This Original Code has been modified by IBM Corporation. Modifications made by IBM
|
|
|
|
* described herein are Copyright (c) International Business Machines Corporation, 2000.
|
|
|
|
* Modifications to Mozilla code or documentation identified per MPL Section 3.3
|
|
|
|
*
|
|
|
|
* Date Modified by Description of modification
|
|
|
|
* 04/20/2000 IBM Corp. OS/2 VisualAge build.
|
1998-09-15 04:19:49 +04:00
|
|
|
*/
|
2006-03-29 22:29:03 +04:00
|
|
|
|
|
|
|
/* state and methods used while laying out a single line of a block frame */
|
|
|
|
|
1998-09-15 04:19:49 +04:00
|
|
|
#ifndef nsLineLayout_h___
|
|
|
|
#define nsLineLayout_h___
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
#include "nsFrame.h"
|
2002-03-20 00:57:45 +03:00
|
|
|
#include "nsDeque.h"
|
2000-02-15 07:26:44 +03:00
|
|
|
#include "nsLineBox.h"
|
2001-05-01 08:22:57 +04:00
|
|
|
#include "nsBlockReflowState.h"
|
2004-07-15 21:50:34 +04:00
|
|
|
#include "plarena.h"
|
2008-07-24 11:16:18 +04:00
|
|
|
#include "gfxTypes.h"
|
1998-09-15 04:19:49 +04:00
|
|
|
|
2006-10-19 05:47:47 +04:00
|
|
|
class nsBlockFrame;
|
|
|
|
|
2009-01-05 03:39:54 +03:00
|
|
|
class nsFloatManager;
|
1998-09-15 04:19:49 +04:00
|
|
|
class nsPlaceholderFrame;
|
1999-03-19 00:03:25 +03:00
|
|
|
struct nsStyleText;
|
1998-09-15 04:19:49 +04:00
|
|
|
|
|
|
|
class nsLineLayout {
|
|
|
|
public:
|
2004-08-01 03:15:21 +04:00
|
|
|
nsLineLayout(nsPresContext* aPresContext,
|
2009-01-05 03:39:54 +03:00
|
|
|
nsFloatManager* aFloatManager,
|
2007-01-18 04:20:09 +03:00
|
|
|
const nsHTMLReflowState* aOuterReflowState,
|
|
|
|
const nsLineList::iterator* aLine);
|
1998-09-15 04:19:49 +04:00
|
|
|
~nsLineLayout();
|
|
|
|
|
1999-08-28 01:49:12 +04:00
|
|
|
void Init(nsBlockReflowState* aState, nscoord aMinLineHeight,
|
|
|
|
PRInt32 aLineNumber) {
|
1999-03-19 00:03:25 +03:00
|
|
|
mBlockRS = aState;
|
1999-08-28 01:49:12 +04:00
|
|
|
mMinLineHeight = aMinLineHeight;
|
|
|
|
mLineNumber = aLineNumber;
|
1998-09-15 04:19:49 +04:00
|
|
|
}
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
PRInt32 GetLineNumber() const {
|
|
|
|
return mLineNumber;
|
1998-09-23 06:31:00 +04:00
|
|
|
}
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
void BeginLineReflow(nscoord aX, nscoord aY,
|
|
|
|
nscoord aWidth, nscoord aHeight,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aImpactedByFloats,
|
2011-10-18 16:51:58 +04:00
|
|
|
bool aIsTopOfPage,
|
|
|
|
PRUint8 aDirection);
|
1998-10-27 19:52:10 +03:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
void EndLineReflow();
|
1998-09-30 02:32:04 +04:00
|
|
|
|
2008-06-11 03:53:22 +04:00
|
|
|
/**
|
|
|
|
* Called when a float has been placed. This method updates the
|
|
|
|
* inline frame and span data to account for any change in positions
|
|
|
|
* due to available space for the line boxes changing.
|
|
|
|
* @param aX/aY/aWidth/aHeight are the new available
|
|
|
|
* space rectangle, relative to the containing block.
|
|
|
|
* @param aFloatFrame the float frame that was placed.
|
|
|
|
*/
|
|
|
|
void UpdateBand(const nsRect& aNewAvailableSpace,
|
2003-10-14 01:51:02 +04:00
|
|
|
nsIFrame* aFloatFrame);
|
1998-09-30 02:32:04 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
nsresult BeginSpan(nsIFrame* aFrame,
|
|
|
|
const nsHTMLReflowState* aSpanReflowState,
|
|
|
|
nscoord aLeftEdge,
|
2011-08-03 22:30:58 +04:00
|
|
|
nscoord aRightEdge,
|
|
|
|
nscoord* aBaseline);
|
1998-10-10 02:58:25 +04:00
|
|
|
|
2007-12-13 00:51:18 +03:00
|
|
|
// Returns the width of the span
|
|
|
|
nscoord EndSpan(nsIFrame* aFrame);
|
1999-09-03 07:47:49 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
PRInt32 GetCurrentSpanCount() const;
|
1998-10-10 02:58:25 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
void SplitLineTo(PRInt32 aNewCount);
|
1998-09-15 04:19:49 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool IsZeroHeight();
|
1998-09-15 04:19:49 +04:00
|
|
|
|
2011-10-17 18:59:28 +04:00
|
|
|
// Reflows the frame and returns the reflow status. aPushedFrame is true
|
2000-01-03 07:32:13 +03:00
|
|
|
// if the frame is pushed to the next line because it doesn't fit
|
1999-03-19 00:03:25 +03:00
|
|
|
nsresult ReflowFrame(nsIFrame* aFrame,
|
1999-10-29 18:33:26 +04:00
|
|
|
nsReflowStatus& aReflowStatus,
|
2000-01-03 07:32:13 +03:00
|
|
|
nsHTMLReflowMetrics* aMetrics,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool& aPushedFrame);
|
1998-09-15 04:19:49 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
nsresult AddBulletFrame(nsIFrame* aFrame,
|
|
|
|
const nsHTMLReflowMetrics& aMetrics);
|
1998-10-20 04:22:48 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
void RemoveBulletFrame(nsIFrame* aFrame) {
|
|
|
|
PushFrame(aFrame);
|
1998-10-10 08:35:01 +04:00
|
|
|
}
|
|
|
|
|
2007-01-18 04:20:09 +03:00
|
|
|
void VerticalAlignLine();
|
1998-10-10 08:35:01 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool TrimTrailingWhiteSpace();
|
1998-10-10 08:35:01 +04:00
|
|
|
|
2012-01-12 21:52:21 +04:00
|
|
|
void HorizontalAlignFrames(nsRect& aLineBounds, bool aIsLastLine);
|
1998-10-10 08:35:01 +04:00
|
|
|
|
2003-07-23 04:14:16 +04:00
|
|
|
/**
|
|
|
|
* Handle all the relative positioning in the line, compute the
|
|
|
|
* combined area (== overflow area) for the line, and handle view
|
2009-04-06 04:31:50 +04:00
|
|
|
* sizing/positioning and the setting of the overflow rect.
|
2003-07-23 04:14:16 +04:00
|
|
|
*/
|
2010-10-07 08:25:45 +04:00
|
|
|
void RelativePositionFrames(nsOverflowAreas& aOverflowAreas);
|
1998-10-10 08:35:01 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
//----------------------------------------
|
1998-10-10 08:35:01 +04:00
|
|
|
|
2000-04-17 18:40:46 +04:00
|
|
|
// Supporting methods and data for flags
|
|
|
|
protected:
|
|
|
|
#define LL_FIRSTLETTERSTYLEOK 0x00000008
|
|
|
|
#define LL_ISTOPOFPAGE 0x00000010
|
2003-10-14 01:51:02 +04:00
|
|
|
#define LL_IMPACTEDBYFLOATS 0x00000040
|
|
|
|
#define LL_LASTFLOATWASLETTERFRAME 0x00000080
|
2008-06-14 12:28:07 +04:00
|
|
|
#define LL_LINEISEMPTY 0x00000100
|
2002-06-26 01:16:17 +04:00
|
|
|
#define LL_LINEENDSINBR 0x00000200
|
2007-10-20 11:30:26 +04:00
|
|
|
#define LL_NEEDBACKUP 0x00000400
|
|
|
|
#define LL_INFIRSTLINE 0x00000800
|
|
|
|
#define LL_GOTLINEBOX 0x00001000
|
2009-01-05 03:36:56 +03:00
|
|
|
#define LL_INFIRSTLETTER 0x00002000
|
2009-08-11 06:48:42 +04:00
|
|
|
#define LL_HASBULLET 0x00004000
|
2009-10-27 04:43:56 +03:00
|
|
|
#define LL_DIRTYNEXTLINE 0x00008000
|
2010-03-10 03:14:14 +03:00
|
|
|
#define LL_LINEATSTART 0x00010000
|
|
|
|
#define LL_LASTFLAG LL_LINEATSTART
|
2000-04-17 18:40:46 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetFlag(PRUint32 aFlag, bool aValue)
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aFlag<=LL_LASTFLAG, "bad flag");
|
2011-10-17 18:59:28 +04:00
|
|
|
NS_ASSERTION(aValue==false || aValue==true, "bad value");
|
2000-04-17 18:40:46 +04:00
|
|
|
if (aValue) { // set flag
|
|
|
|
mFlags |= aFlag;
|
|
|
|
}
|
|
|
|
else { // unset flag
|
|
|
|
mFlags &= ~aFlag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetFlag(PRUint32 aFlag) const
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aFlag<=LL_LASTFLAG, "bad flag");
|
2007-10-10 04:00:05 +04:00
|
|
|
return !!(mFlags & aFlag);
|
2000-04-17 18:40:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
2007-10-02 06:36:26 +04:00
|
|
|
// Support methods for word-wrapping during line reflow
|
2000-04-17 18:40:46 +04:00
|
|
|
|
|
|
|
void SetTextJustificationWeights(PRInt32 aNumSpaces, PRInt32 aNumLetters) {
|
|
|
|
mTextJustificationNumSpaces = aNumSpaces;
|
|
|
|
mTextJustificationNumLetters = aNumLetters;
|
1998-09-15 04:19:49 +04:00
|
|
|
}
|
1999-03-19 00:03:25 +03:00
|
|
|
|
2008-06-14 12:28:07 +04:00
|
|
|
/**
|
|
|
|
* @return true if so far during reflow no non-empty content has been
|
2010-03-10 03:14:14 +03:00
|
|
|
* placed in the line (according to nsIFrame::IsEmpty())
|
2008-06-14 12:28:07 +04:00
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
bool LineIsEmpty() const
|
2008-06-14 12:28:07 +04:00
|
|
|
{
|
|
|
|
return GetFlag(LL_LINEISEMPTY);
|
|
|
|
}
|
1998-10-10 08:35:01 +04:00
|
|
|
|
2010-03-10 03:14:14 +03:00
|
|
|
/**
|
|
|
|
* @return true if so far during reflow no non-empty leaf content
|
|
|
|
* (non-collapsed whitespace, replaced element, inline-block, etc) has been
|
|
|
|
* placed in the line
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
bool LineAtStart() const
|
2010-03-10 03:14:14 +03:00
|
|
|
{
|
|
|
|
return GetFlag(LL_LINEATSTART);
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool LineIsBreakable() const;
|
1999-03-21 04:14:05 +03:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetLineEndsInBR() const
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
return GetFlag(LL_LINEENDSINBR);
|
|
|
|
}
|
1999-10-29 18:33:26 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetLineEndsInBR(bool aOn)
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
SetFlag(LL_LINEENDSINBR, aOn);
|
|
|
|
}
|
1999-10-29 18:33:26 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
//----------------------------------------
|
|
|
|
// Inform the line-layout about the presence of a floating frame
|
|
|
|
// XXX get rid of this: use get-frame-type?
|
2011-09-29 10:19:26 +04:00
|
|
|
bool AddFloat(nsIFrame* aFloat, nscoord aAvailableWidth)
|
2009-08-31 22:25:35 +04:00
|
|
|
{
|
2010-08-06 08:59:20 +04:00
|
|
|
return mBlockRS->AddFloat(this, aFloat, aAvailableWidth);
|
2001-05-01 08:22:57 +04:00
|
|
|
}
|
1998-09-15 04:19:49 +04:00
|
|
|
|
2007-10-20 11:30:26 +04:00
|
|
|
void SetTrimmableWidth(nscoord aTrimmableWidth) {
|
|
|
|
mTrimmableWidth = aTrimmableWidth;
|
2006-10-19 05:47:47 +04:00
|
|
|
}
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
//----------------------------------------
|
1998-09-15 04:19:49 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetFirstLetterStyleOK() const {
|
2000-04-17 18:40:46 +04:00
|
|
|
return GetFlag(LL_FIRSTLETTERSTYLEOK);
|
1998-11-05 22:30:31 +03:00
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetFirstLetterStyleOK(bool aSetting) {
|
2000-04-17 18:40:46 +04:00
|
|
|
SetFlag(LL_FIRSTLETTERSTYLEOK, aSetting);
|
1998-11-05 22:30:31 +03:00
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetInFirstLetter() const {
|
2009-01-05 03:36:56 +03:00
|
|
|
return GetFlag(LL_INFIRSTLETTER);
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetInFirstLetter(bool aSetting) {
|
2009-01-05 03:36:56 +03:00
|
|
|
SetFlag(LL_INFIRSTLETTER, aSetting);
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetInFirstLine() const {
|
2007-01-18 04:20:09 +03:00
|
|
|
return GetFlag(LL_INFIRSTLINE);
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetInFirstLine(bool aSetting) {
|
2007-01-18 04:20:09 +03:00
|
|
|
SetFlag(LL_INFIRSTLINE, aSetting);
|
|
|
|
}
|
|
|
|
|
2009-10-27 04:43:56 +03:00
|
|
|
// Calling this during block reflow ensures that the next line of inlines
|
|
|
|
// will be marked dirty, if there is one.
|
|
|
|
void SetDirtyNextLine() {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetFlag(LL_DIRTYNEXTLINE, true);
|
2009-10-27 04:43:56 +03:00
|
|
|
}
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetDirtyNextLine() {
|
2009-10-27 04:43:56 +03:00
|
|
|
return GetFlag(LL_DIRTYNEXTLINE);
|
|
|
|
}
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
//----------------------------------------
|
|
|
|
|
2004-08-01 03:15:21 +04:00
|
|
|
nsPresContext* mPresContext;
|
1999-03-19 00:03:25 +03:00
|
|
|
|
2006-10-19 05:47:47 +04:00
|
|
|
/**
|
|
|
|
* Record where an optional break could have been placed. During line reflow,
|
|
|
|
* frames containing optional break points (e.g., whitespace in text frames)
|
|
|
|
* can call SetLastOptionalBreakPosition to record where a break could
|
2007-02-21 04:52:03 +03:00
|
|
|
* have been made, but wasn't because we decided to place more content on
|
|
|
|
* the line. For non-text frames, offset 0 means
|
2006-10-19 05:47:47 +04:00
|
|
|
* before the content, offset PR_INT32_MAX means after the content.
|
|
|
|
*
|
|
|
|
* Currently this is used to handle cases where a single word comprises
|
|
|
|
* multiple frames, and the first frame fits on the line but the whole word
|
|
|
|
* doesn't. We look back to the last optional break position and
|
|
|
|
* reflow the whole line again, forcing a break at that position. The last
|
|
|
|
* optional break position could be in a text frame or else after a frame
|
|
|
|
* that cannot be part of a text run, so those are the positions we record.
|
|
|
|
*
|
2007-02-21 04:52:03 +03:00
|
|
|
* @param aFits set to true if the break position is within the available width.
|
2006-10-19 05:47:47 +04:00
|
|
|
*
|
2008-07-24 11:16:18 +04:00
|
|
|
* @param aPriority the priority of the break opportunity. If we are
|
|
|
|
* prioritizing break opportunities, we will not set a break if we have
|
|
|
|
* already set a break with a higher priority. @see gfxBreakPriority.
|
|
|
|
*
|
2011-10-17 18:59:28 +04:00
|
|
|
* @return true if we are actually reflowing with forced break position and we
|
2006-10-19 05:47:47 +04:00
|
|
|
* should break here
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
bool NotifyOptionalBreakPosition(nsIContent* aContent, PRInt32 aOffset,
|
|
|
|
bool aFits, gfxBreakPriority aPriority) {
|
2007-12-07 12:17:19 +03:00
|
|
|
NS_ASSERTION(!aFits || !GetFlag(LL_NEEDBACKUP),
|
|
|
|
"Shouldn't be updating the break position with a break that fits after we've already flagged an overrun");
|
2007-02-21 04:52:03 +03:00
|
|
|
// Remember the last break position that fits; if there was no break that fit,
|
|
|
|
// just remember the first break
|
2008-07-24 11:16:18 +04:00
|
|
|
if ((aFits && aPriority >= mLastOptionalBreakPriority) ||
|
|
|
|
!mLastOptionalBreakContent) {
|
2007-02-21 04:52:03 +03:00
|
|
|
mLastOptionalBreakContent = aContent;
|
|
|
|
mLastOptionalBreakContentOffset = aOffset;
|
2008-07-24 11:16:18 +04:00
|
|
|
mLastOptionalBreakPriority = aPriority;
|
2007-02-21 04:52:03 +03:00
|
|
|
}
|
2006-10-19 05:47:47 +04:00
|
|
|
return aContent && mForceBreakContent == aContent &&
|
|
|
|
mForceBreakContentOffset == aOffset;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Like NotifyOptionalBreakPosition, but here it's OK for LL_NEEDBACKUP
|
|
|
|
* to be set, because the caller is merely pruning some saved break position(s)
|
|
|
|
* that are actually not feasible.
|
|
|
|
*/
|
2008-07-24 11:16:18 +04:00
|
|
|
void RestoreSavedBreakPosition(nsIContent* aContent, PRInt32 aOffset,
|
|
|
|
gfxBreakPriority aPriority) {
|
2006-10-19 05:47:47 +04:00
|
|
|
mLastOptionalBreakContent = aContent;
|
|
|
|
mLastOptionalBreakContentOffset = aOffset;
|
2008-07-24 11:16:18 +04:00
|
|
|
mLastOptionalBreakPriority = aPriority;
|
2006-10-19 05:47:47 +04:00
|
|
|
}
|
2007-02-21 04:52:03 +03:00
|
|
|
/**
|
|
|
|
* Signal that no backing up will be required after all.
|
|
|
|
*/
|
2006-10-19 05:47:47 +04:00
|
|
|
void ClearOptionalBreakPosition() {
|
2011-10-17 18:59:28 +04:00
|
|
|
SetFlag(LL_NEEDBACKUP, false);
|
2006-10-19 05:47:47 +04:00
|
|
|
mLastOptionalBreakContent = nsnull;
|
|
|
|
mLastOptionalBreakContentOffset = -1;
|
2008-07-24 11:16:18 +04:00
|
|
|
mLastOptionalBreakPriority = eNoBreak;
|
2006-10-19 05:47:47 +04:00
|
|
|
}
|
|
|
|
// Retrieve last set optional break position. When this returns null, no
|
|
|
|
// optional break has been recorded (which means that the line can't break yet).
|
2008-07-24 11:16:18 +04:00
|
|
|
nsIContent* GetLastOptionalBreakPosition(PRInt32* aOffset,
|
|
|
|
gfxBreakPriority* aPriority) {
|
2006-10-19 05:47:47 +04:00
|
|
|
*aOffset = mLastOptionalBreakContentOffset;
|
2008-07-24 11:16:18 +04:00
|
|
|
*aPriority = mLastOptionalBreakPriority;
|
2006-10-19 05:47:47 +04:00
|
|
|
return mLastOptionalBreakContent;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check whether frames overflowed the available width and CanPlaceFrame
|
|
|
|
* requested backing up to a saved break position.
|
|
|
|
*/
|
2011-09-29 10:19:26 +04:00
|
|
|
bool NeedsBackup() { return GetFlag(LL_NEEDBACKUP); }
|
2006-10-19 05:47:47 +04:00
|
|
|
|
|
|
|
// Line layout may place too much content on a line, overflowing its available
|
|
|
|
// width. When that happens, if SetLastOptionalBreakPosition has been
|
|
|
|
// used to record an optional break that wasn't taken, we can reflow the line
|
|
|
|
// again and force the break to happen at that point (i.e., backtracking
|
|
|
|
// to the last choice point).
|
|
|
|
|
|
|
|
// Record that we want to break at the given content+offset (which
|
|
|
|
// should have been previously returned by GetLastOptionalBreakPosition
|
|
|
|
// from another nsLineLayout).
|
|
|
|
void ForceBreakAtPosition(nsIContent* aContent, PRInt32 aOffset) {
|
|
|
|
mForceBreakContent = aContent;
|
|
|
|
mForceBreakContentOffset = aOffset;
|
|
|
|
}
|
2011-09-29 10:19:26 +04:00
|
|
|
bool HaveForcedBreakPosition() { return mForceBreakContent != nsnull; }
|
2006-10-19 05:47:47 +04:00
|
|
|
PRInt32 GetForcedBreakPosition(nsIContent* aContent) {
|
|
|
|
return mForceBreakContent == aContent ? mForceBreakContentOffset : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This can't be null. It usually returns a block frame but may return
|
|
|
|
* some other kind of frame when inline frames are reflowed in a non-block
|
2008-07-30 09:11:26 +04:00
|
|
|
* context (e.g. MathML or floating first-letter).
|
2006-10-19 05:47:47 +04:00
|
|
|
*/
|
2007-01-18 04:20:09 +03:00
|
|
|
nsIFrame* GetLineContainerFrame() const { return mBlockReflowState->frame; }
|
2011-11-24 06:48:23 +04:00
|
|
|
const nsHTMLReflowState* GetLineContainerRS() const {
|
|
|
|
return mBlockReflowState;
|
|
|
|
}
|
2007-01-18 04:20:09 +03:00
|
|
|
const nsLineList::iterator* GetLine() const {
|
|
|
|
return GetFlag(LL_GOTLINEBOX) ? &mLineBox : nsnull;
|
|
|
|
}
|
2010-08-06 08:59:20 +04:00
|
|
|
nsLineList::iterator* GetLine() {
|
|
|
|
return GetFlag(LL_GOTLINEBOX) ? &mLineBox : nsnull;
|
|
|
|
}
|
2007-05-21 07:44:26 +04:00
|
|
|
|
|
|
|
/**
|
2008-06-20 08:39:56 +04:00
|
|
|
* Returns the accumulated advance width of frames before the current frame
|
|
|
|
* on the line, plus the line container's left border+padding.
|
|
|
|
* This is always positive, the advance width is measured from
|
2007-05-21 07:44:26 +04:00
|
|
|
* the right edge for RTL blocks and from the left edge for LTR blocks.
|
2008-06-20 08:39:56 +04:00
|
|
|
* In other words, the current frame's distance from the line container's
|
|
|
|
* start content edge is:
|
|
|
|
* <code>GetCurrentFrameXDistanceFromBlock() - lineContainer->GetUsedBorderAndPadding().left</code>
|
|
|
|
* Note the use of <code>.left</code> for both LTR and RTL line containers.
|
2007-05-21 07:44:26 +04:00
|
|
|
*/
|
|
|
|
nscoord GetCurrentFrameXDistanceFromBlock();
|
2007-01-18 04:20:09 +03:00
|
|
|
|
1998-09-15 04:19:49 +04:00
|
|
|
protected:
|
1999-03-19 00:03:25 +03:00
|
|
|
// This state is constant for a given block frame doing line layout
|
2009-01-05 03:39:54 +03:00
|
|
|
nsFloatManager* mFloatManager;
|
2001-10-25 05:08:40 +04:00
|
|
|
const nsStyleText* mStyleText; // for the block
|
1999-03-19 00:03:25 +03:00
|
|
|
const nsHTMLReflowState* mBlockReflowState;
|
2002-09-25 02:13:20 +04:00
|
|
|
|
2006-10-19 05:47:47 +04:00
|
|
|
nsIContent* mLastOptionalBreakContent;
|
|
|
|
nsIContent* mForceBreakContent;
|
|
|
|
|
2002-09-25 02:13:20 +04:00
|
|
|
// XXX remove this when landing bug 154892 (splitting absolute positioned frames)
|
|
|
|
friend class nsInlineFrame;
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
nsBlockReflowState* mBlockRS;/* XXX hack! */
|
2000-04-17 18:40:46 +04:00
|
|
|
|
2007-01-18 04:20:09 +03:00
|
|
|
nsLineList::iterator mLineBox;
|
2000-04-17 18:40:46 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
// Per-frame data recorded by the line-layout reflow logic. This
|
|
|
|
// state is the state needed to post-process the line after reflow
|
|
|
|
// has completed (vertical alignment, horizontal alignment,
|
|
|
|
// justification and relative positioning).
|
1999-03-31 08:21:53 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
struct PerSpanData;
|
1999-04-13 00:12:15 +04:00
|
|
|
struct PerFrameData;
|
|
|
|
friend struct PerSpanData;
|
|
|
|
friend struct PerFrameData;
|
1999-03-19 00:03:25 +03:00
|
|
|
struct PerFrameData {
|
|
|
|
// link to next/prev frame in same span
|
|
|
|
PerFrameData* mNext;
|
|
|
|
PerFrameData* mPrev;
|
|
|
|
|
|
|
|
// pointer to child span data if this is an inline container frame
|
|
|
|
PerSpanData* mSpan;
|
|
|
|
|
2009-02-20 00:55:48 +03:00
|
|
|
// The frame
|
1999-03-19 00:03:25 +03:00
|
|
|
nsIFrame* mFrame;
|
|
|
|
|
|
|
|
// From metrics
|
2007-01-23 07:06:56 +03:00
|
|
|
nscoord mAscent;
|
1999-03-19 00:03:25 +03:00
|
|
|
nsRect mBounds;
|
2010-10-07 08:25:45 +04:00
|
|
|
nsOverflowAreas mOverflowAreas;
|
1999-03-19 00:03:25 +03:00
|
|
|
|
|
|
|
// From reflow-state
|
|
|
|
nsMargin mMargin;
|
|
|
|
nsMargin mBorderPadding;
|
|
|
|
nsMargin mOffsets;
|
|
|
|
|
2000-04-17 18:40:46 +04:00
|
|
|
// state for text justification
|
|
|
|
PRInt32 mJustificationNumSpaces;
|
|
|
|
PRInt32 mJustificationNumLetters;
|
2002-11-06 05:03:43 +03:00
|
|
|
|
|
|
|
// Other state we use
|
|
|
|
PRUint8 mVerticalAlign;
|
2000-04-17 18:40:46 +04:00
|
|
|
|
|
|
|
// PerFrameData flags
|
|
|
|
#define PFD_RELATIVEPOS 0x00000001
|
|
|
|
#define PFD_ISTEXTFRAME 0x00000002
|
|
|
|
#define PFD_ISNONEMPTYTEXTFRAME 0x00000004
|
|
|
|
#define PFD_ISNONWHITESPACETEXTFRAME 0x00000008
|
|
|
|
#define PFD_ISLETTERFRAME 0x00000010
|
2007-09-24 06:19:14 +04:00
|
|
|
#define PFD_RECOMPUTEOVERFLOW 0x00000020
|
2000-04-17 18:40:46 +04:00
|
|
|
#define PFD_ISBULLET 0x00000040
|
2006-04-21 05:31:35 +04:00
|
|
|
#define PFD_SKIPWHENTRIMMINGWHITESPACE 0x00000080
|
|
|
|
#define PFD_LASTFLAG PFD_SKIPWHENTRIMMINGWHITESPACE
|
2000-04-17 18:40:46 +04:00
|
|
|
|
2006-04-21 05:31:35 +04:00
|
|
|
PRUint8 mFlags;
|
2000-04-17 18:40:46 +04:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
void SetFlag(PRUint32 aFlag, bool aValue)
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aFlag<=PFD_LASTFLAG, "bad flag");
|
2006-04-21 05:31:35 +04:00
|
|
|
NS_ASSERTION(aFlag<=PR_UINT8_MAX, "bad flag");
|
2011-10-17 18:59:28 +04:00
|
|
|
NS_ASSERTION(aValue==false || aValue==true, "bad value");
|
2000-04-17 18:40:46 +04:00
|
|
|
if (aValue) { // set flag
|
|
|
|
mFlags |= aFlag;
|
|
|
|
}
|
|
|
|
else { // unset flag
|
|
|
|
mFlags &= ~aFlag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool GetFlag(PRUint32 aFlag) const
|
2000-04-17 18:40:46 +04:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aFlag<=PFD_LASTFLAG, "bad flag");
|
2007-10-10 04:00:05 +04:00
|
|
|
return !!(mFlags & aFlag);
|
2000-04-17 18:40:46 +04:00
|
|
|
}
|
|
|
|
|
1999-09-21 04:14:22 +04:00
|
|
|
|
|
|
|
PerFrameData* Last() {
|
|
|
|
PerFrameData* pfd = this;
|
|
|
|
while (pfd->mNext) {
|
|
|
|
pfd = pfd->mNext;
|
|
|
|
}
|
|
|
|
return pfd;
|
|
|
|
}
|
1999-03-19 00:03:25 +03:00
|
|
|
};
|
2002-08-14 17:00:16 +04:00
|
|
|
PerFrameData* mFrameFreeList;
|
1999-03-19 00:03:25 +03:00
|
|
|
|
|
|
|
struct PerSpanData {
|
2002-08-14 17:00:16 +04:00
|
|
|
union {
|
|
|
|
PerSpanData* mParent;
|
|
|
|
PerSpanData* mNextFreeSpan;
|
|
|
|
};
|
1999-03-19 00:03:25 +03:00
|
|
|
PerFrameData* mFrame;
|
|
|
|
PerFrameData* mFirstFrame;
|
|
|
|
PerFrameData* mLastFrame;
|
|
|
|
|
|
|
|
const nsHTMLReflowState* mReflowState;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mNoWrap;
|
1999-03-22 23:45:09 +03:00
|
|
|
PRUint8 mDirection;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mChangedFrameDirection;
|
|
|
|
bool mZeroEffectiveSpanBox;
|
|
|
|
bool mContainsFloat;
|
|
|
|
bool mHasNonemptyContent;
|
1999-03-22 23:45:09 +03:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
nscoord mLeftEdge;
|
|
|
|
nscoord mX;
|
|
|
|
nscoord mRightEdge;
|
|
|
|
|
|
|
|
nscoord mTopLeading, mBottomLeading;
|
|
|
|
nscoord mLogicalHeight;
|
|
|
|
nscoord mMinY, mMaxY;
|
2011-08-03 22:30:58 +04:00
|
|
|
nscoord* mBaseline;
|
1999-03-19 00:03:25 +03:00
|
|
|
|
|
|
|
void AppendFrame(PerFrameData* pfd) {
|
|
|
|
if (nsnull == mLastFrame) {
|
|
|
|
mFirstFrame = pfd;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
mLastFrame->mNext = pfd;
|
|
|
|
pfd->mPrev = mLastFrame;
|
|
|
|
}
|
|
|
|
mLastFrame = pfd;
|
|
|
|
}
|
|
|
|
};
|
2002-08-14 17:00:16 +04:00
|
|
|
PerSpanData* mSpanFreeList;
|
1999-03-19 00:03:25 +03:00
|
|
|
PerSpanData* mRootSpan;
|
|
|
|
PerSpanData* mCurrentSpan;
|
2009-05-12 12:53:06 +04:00
|
|
|
|
|
|
|
gfxBreakPriority mLastOptionalBreakPriority;
|
|
|
|
PRInt32 mLastOptionalBreakContentOffset;
|
|
|
|
PRInt32 mForceBreakContentOffset;
|
|
|
|
|
|
|
|
nscoord mMinLineHeight;
|
|
|
|
|
|
|
|
// The amount of text indent that we applied to this line, needed for
|
|
|
|
// max-element-size calculation.
|
|
|
|
nscoord mTextIndent;
|
|
|
|
|
|
|
|
// This state varies during the reflow of a line but is line
|
|
|
|
// "global" state not span "local" state.
|
|
|
|
PRInt32 mLineNumber;
|
|
|
|
PRInt32 mTextJustificationNumSpaces;
|
|
|
|
PRInt32 mTextJustificationNumLetters;
|
|
|
|
|
|
|
|
PRInt32 mTotalPlacedFrames;
|
|
|
|
|
|
|
|
nscoord mTopEdge;
|
|
|
|
nscoord mMaxTopBoxHeight;
|
|
|
|
nscoord mMaxBottomBoxHeight;
|
|
|
|
|
2011-11-24 06:48:23 +04:00
|
|
|
nscoord mInflationMinFontSize;
|
|
|
|
|
2009-05-12 12:53:06 +04:00
|
|
|
// Final computed line-height value after VerticalAlignFrames for
|
|
|
|
// the block has been called.
|
|
|
|
nscoord mFinalLineHeight;
|
|
|
|
|
|
|
|
// Amount of trimmable whitespace width for the trailing text frame, if any
|
|
|
|
nscoord mTrimmableWidth;
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
PRInt32 mSpanDepth;
|
2002-08-14 17:00:16 +04:00
|
|
|
#ifdef DEBUG
|
|
|
|
PRInt32 mSpansAllocated, mSpansFreed;
|
|
|
|
PRInt32 mFramesAllocated, mFramesFreed;
|
|
|
|
#endif
|
2009-05-12 12:53:06 +04:00
|
|
|
PLArenaPool mArena; // Per span and per frame data, 4 byte aligned
|
|
|
|
|
2010-03-10 03:14:14 +03:00
|
|
|
PRUint32 mFlags;
|
2009-05-12 12:53:06 +04:00
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
nsresult NewPerFrameData(PerFrameData** aResult);
|
|
|
|
|
|
|
|
nsresult NewPerSpanData(PerSpanData** aResult);
|
|
|
|
|
2002-08-14 17:00:16 +04:00
|
|
|
void FreeSpan(PerSpanData* psd);
|
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool InBlockContext() const {
|
1999-03-19 00:03:25 +03:00
|
|
|
return mSpanDepth == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PushFrame(nsIFrame* aFrame);
|
|
|
|
|
2002-01-31 02:28:56 +03:00
|
|
|
void ApplyStartMargin(PerFrameData* pfd,
|
|
|
|
nsHTMLReflowState& aReflowState);
|
1999-03-19 00:03:25 +03:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool CanPlaceFrame(PerFrameData* pfd,
|
2010-08-25 22:54:47 +04:00
|
|
|
PRUint8 aFrameDirection,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aNotSafeToBreak,
|
|
|
|
bool aFrameCanContinueTextRun,
|
|
|
|
bool aCanRollBackBeforeFrame,
|
1999-03-19 00:03:25 +03:00
|
|
|
nsHTMLReflowMetrics& aMetrics,
|
2007-12-07 12:17:19 +03:00
|
|
|
nsReflowStatus& aStatus,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool* aOptionalBreakAfterFits);
|
1999-03-19 00:03:25 +03:00
|
|
|
|
|
|
|
void PlaceFrame(PerFrameData* pfd,
|
|
|
|
nsHTMLReflowMetrics& aMetrics);
|
|
|
|
|
|
|
|
void VerticalAlignFrames(PerSpanData* psd);
|
|
|
|
|
|
|
|
void PlaceTopBottomFrames(PerSpanData* psd,
|
|
|
|
nscoord aDistanceFromTop,
|
|
|
|
nscoord aLineHeight);
|
|
|
|
|
2010-10-07 08:25:45 +04:00
|
|
|
void RelativePositionFrames(PerSpanData* psd, nsOverflowAreas& aOverflowAreas);
|
1999-03-19 00:03:25 +03:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool TrimTrailingWhiteSpaceIn(PerSpanData* psd, nscoord* aDeltaWidth);
|
1999-09-21 04:14:22 +04:00
|
|
|
|
2000-04-17 18:40:46 +04:00
|
|
|
void ComputeJustificationWeights(PerSpanData* psd, PRInt32* numSpaces, PRInt32* numLetters);
|
|
|
|
|
|
|
|
struct FrameJustificationState {
|
|
|
|
PRInt32 mTotalNumSpaces;
|
|
|
|
PRInt32 mTotalNumLetters;
|
|
|
|
nscoord mTotalWidthForSpaces;
|
|
|
|
nscoord mTotalWidthForLetters;
|
|
|
|
PRInt32 mNumSpacesProcessed;
|
|
|
|
PRInt32 mNumLettersProcessed;
|
|
|
|
nscoord mWidthForSpacesProcessed;
|
|
|
|
nscoord mWidthForLettersProcessed;
|
|
|
|
};
|
2006-04-12 05:07:01 +04:00
|
|
|
|
|
|
|
// Apply justification. The return value is the amount by which the width of
|
|
|
|
// the span corresponding to aPSD got increased due to justification.
|
|
|
|
nscoord ApplyFrameJustification(PerSpanData* aPSD,
|
|
|
|
FrameJustificationState* aState);
|
2000-04-17 18:40:46 +04:00
|
|
|
|
|
|
|
|
1999-03-19 00:03:25 +03:00
|
|
|
#ifdef DEBUG
|
|
|
|
void DumpPerSpanData(PerSpanData* psd, PRInt32 aIndent);
|
|
|
|
#endif
|
1998-09-15 04:19:49 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* nsLineLayout_h___ */
|