зеркало из https://github.com/mozilla/gecko-dev.git
235 строки
10 KiB
C++
235 строки
10 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* 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.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* 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.
|
|
*
|
|
* Contributor(s):
|
|
* buster@netscape.com
|
|
*
|
|
* 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 ***** */
|
|
|
|
#ifndef BasicTableLayoutStrategy_h__
|
|
#define BasicTableLayoutStrategy_h__
|
|
|
|
#include "nscore.h"
|
|
#include "nsITableLayoutStrategy.h"
|
|
#include "nsCoord.h"
|
|
|
|
class nsVoidArray;
|
|
class nsTableFrame;
|
|
struct nsStylePosition;
|
|
struct nsStyleTable;
|
|
|
|
static const PRInt32 kUninitialized=-1;
|
|
|
|
/* ---------- BasicTableLayoutStrategy ---------- */
|
|
|
|
/** Implementation of Nav4 compatible HTML browser table layout.
|
|
* The input to this class is the results from pass1 table layout.
|
|
* The output from this class is to set the column widths in
|
|
* mTableFrame.
|
|
*/
|
|
class BasicTableLayoutStrategy : public nsITableLayoutStrategy
|
|
{
|
|
public:
|
|
|
|
/** Public constructor.
|
|
* @paran aFrame - the table frame for which this delegate will do layout
|
|
* @param aIsNavQuirksMode - honor NN4x table quirks
|
|
*/
|
|
BasicTableLayoutStrategy(nsTableFrame *aFrame,
|
|
PRBool aIsNavQuirksMode = PR_TRUE);
|
|
|
|
/** destructor */
|
|
virtual ~BasicTableLayoutStrategy();
|
|
|
|
/** call every time any table thing changes that might effect the width of any column
|
|
* in the table (content, structure, or style)
|
|
* @param aReflowState - the reflow state for mTableFrame
|
|
*/
|
|
virtual PRBool Initialize(const nsHTMLReflowState& aReflowState);
|
|
|
|
/** Called during resize reflow to determine the new column widths
|
|
* @param aReflowState - the reflow state for mTableFrame
|
|
*/
|
|
virtual PRBool BalanceColumnWidths(const nsHTMLReflowState& aReflowState);
|
|
|
|
/**
|
|
* Calculate the basis for percent width calculations of the table elements
|
|
* @param aReflowState - the reflow state of the table
|
|
* @param aAvailWidth - the available width for the table
|
|
* @return - the basis for percent calculations
|
|
*/
|
|
virtual nscoord CalcPctAdjTableWidth(const nsHTMLReflowState& aReflowState,
|
|
nscoord aAvailWidth);
|
|
|
|
void Dump(PRInt32 aIndent);
|
|
|
|
protected:
|
|
|
|
/** assign widths for each column.
|
|
* if the column has a fixed coord width, use it.
|
|
* if the column includes col spanning cells,
|
|
* then distribute the fixed space between cells proportionately.
|
|
* Computes the minimum and maximum table widths.
|
|
* Set column width information in each column frame and in the table frame.
|
|
*
|
|
* @return PR_TRUE has a pct cell or col, PR_FALSE otherwise
|
|
*/
|
|
virtual PRBool AssignNonPctColumnWidths(nscoord aComputedWidth,
|
|
const nsHTMLReflowState& aReflowState);
|
|
|
|
/**
|
|
* Calculate the adjusted widths (min, desired, fixed, or pct) for a cell
|
|
* spanning multiple columns.
|
|
* @param aReflowState - the reflow state of the table
|
|
* @param aConsiderPct - if true, consider columns that have pct widths and are spanned by the cell
|
|
* @param aPixelToTwips- the number of twips in a pixel.
|
|
* @param aHasPctCol - if not null, then set *aHasPctCol to true if there is a pct cell or col
|
|
*/
|
|
void ComputeNonPctColspanWidths(const nsHTMLReflowState& aReflowState,
|
|
PRBool aConsiderPct,
|
|
float aPixelToTwips,
|
|
PRBool* aHasPctCol);
|
|
|
|
/**
|
|
* main helper for above. For min width calculations, it can get called up to
|
|
* 3 times, 1st to let constrained pct cols reach their limit, 2nd
|
|
* to let fix cols reach their limit and 3rd to spread any remainder among
|
|
* auto cols. If there are no auto cols then only constrained cols are considered.
|
|
* @param aWidthIndex - the width to calculate (see nsTableColFrame.h for enums)
|
|
* @param aCellFrame - the frame of the cell with a colspan
|
|
* @param aCellWidth - the width of the cell with a colspan
|
|
* @param aColIndex - the column index of the cell in the table
|
|
* @param aColSpan - the colspan of the cell
|
|
* @param aLimitType - the type of limit (ie. pct, fix, none).
|
|
* @param aPixelToTwips- the number of twips in a pixel.
|
|
* @return - true if all of aCellWidth was allocated, false otherwise
|
|
*/
|
|
PRBool ComputeNonPctColspanWidths(PRInt32 aWidthIndex,
|
|
const nsTableCellFrame* aCellFrame,
|
|
PRInt32 aCellWidth,
|
|
PRInt32 aColIndex,
|
|
PRInt32 aColSpan,
|
|
PRInt32& aLimitType,
|
|
float aPixelToTwips);
|
|
|
|
/**
|
|
* Determine percentage col widths for each col frame
|
|
* @param aReflowState - the reflow state of the table
|
|
* @param aBasis - the basis for percent width as computed by CalcPctAdjTableWidth
|
|
* @param aTableIsAutoWidth - true if no width specification for the table is available
|
|
* @param aPixelToTwips - the number of twips in a pixel.
|
|
* @return - the adjusted basis including table border, padding and cell spacing
|
|
*/
|
|
nscoord AssignPctColumnWidths(const nsHTMLReflowState& aReflowState,
|
|
nscoord aBasis,
|
|
PRBool aTableIsAutoWidth,
|
|
float aPixelToTwips);
|
|
|
|
/**
|
|
* Reduce the percent columns by the amount specified in aExcess as the percent width's
|
|
* can accumulate to be over 100%
|
|
* @param aExcess - reduction amount
|
|
*/
|
|
void ReduceOverSpecifiedPctCols(nscoord aExcess);
|
|
|
|
/**
|
|
* calculate totals by width type. The logic here is kept in synch with
|
|
* that in CanAllocate
|
|
* @param aTotalCounts - array with counts for each width type that has determined the aTotalWidths sum
|
|
* @param aTotalWidths - array with accumulated widths for each width type
|
|
* @param aDupedWidths - (duplicatd) are widths that will be allocated in BalanceColumnWidths before aTotalsWidths
|
|
* @param a0ProportionalCount - number of columns with col="0*" constraint
|
|
*/
|
|
void CalculateTotals(PRInt32* aTotalCounts,
|
|
PRInt32* aTotalWidths,
|
|
PRInt32* aDupedWidths,
|
|
PRInt32& a0ProportionalCount);
|
|
|
|
/**
|
|
* Allocate aWidthType values to the corresponding columns
|
|
* @param aTotalAllocated - width that has been allocated in this routine
|
|
* @param aAllocTypes - width type that has determined col width
|
|
* @param aWidthType - width type selecting the columns for full width allocation
|
|
*/
|
|
void AllocateFully(nscoord& aTotalAllocated,
|
|
PRInt32* aAllocTypes,
|
|
PRInt32 aWidthType);
|
|
|
|
/**
|
|
* Allocate aWidthType values to the corresponding columns up to the aAvailWidth
|
|
* @param aAvailWidth - width that can distributed to the selected columns
|
|
* @param aWidthType - width type selecting the columns for width allocation
|
|
* @param aStartAtMin - allocation should start at min. content width
|
|
* @param aAllocTypes - width type that has determined col width
|
|
* @param aPixelToTwips - the number of twips in a pixel.
|
|
*/
|
|
void AllocateConstrained(PRInt32 aAvailWidth,
|
|
PRInt32 aWidthType,
|
|
PRBool aStartAtMin,
|
|
PRInt32* aAllocTypes,
|
|
float aPixelToTwips);
|
|
|
|
/**
|
|
* Give the remaining space and exclude the selected columns
|
|
* @param aAllocAmount - space that can be distributed
|
|
* @param aAllocTypes - width type that has determined col width
|
|
* @param aExcludePct - dont give space to percent columns
|
|
* @param aExcludeFix - dont give space to fixed width columns
|
|
* @param aExcludePro - dont give space to proportional columns
|
|
* @param aExclude0Pro - dont give space to proportional columns with 0*
|
|
* @param aPixelToTwips - the number of twips in a pixel.
|
|
*/
|
|
void AllocateUnconstrained(PRInt32 aAllocAmount,
|
|
PRInt32* aAllocTypes,
|
|
PRBool aExcludePct,
|
|
PRBool aExcludeFix,
|
|
PRBool aExcludePro,
|
|
PRBool aExclude0Pro,
|
|
float aPixelToTwips);
|
|
|
|
/**
|
|
* Check in debug mode whether the routine is called on a continuing frame
|
|
*/
|
|
void ContinuingFrameCheck();
|
|
|
|
protected:
|
|
nsTableFrame * mTableFrame;
|
|
PRInt32 mCols;
|
|
// cached data
|
|
nscoord mCellSpacingTotal; // all of the cellspacing for all of the cols
|
|
float mMinToDesProportionRatio;
|
|
PRPackedBool mIsNavQuirksMode;
|
|
};
|
|
#endif
|
|
|