mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
344 lines
11 KiB
C++
344 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
#ifndef nsTableColFrame_h__
|
|
#define nsTableColFrame_h__
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "celldata.h"
|
|
#include "nscore.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsTArray.h"
|
|
#include "nsTableColGroupFrame.h"
|
|
#include "mozilla/WritingModes.h"
|
|
|
|
class nsTableColFrame : public nsSplittableFrame {
|
|
public:
|
|
NS_DECL_FRAMEARENA_HELPERS
|
|
|
|
enum {eWIDTH_SOURCE_NONE =0, // no cell has contributed to the width style
|
|
eWIDTH_SOURCE_CELL =1, // a cell specified a width
|
|
eWIDTH_SOURCE_CELL_WITH_SPAN=2 // a cell implicitly specified a width via colspan
|
|
};
|
|
|
|
nsTableColType GetColType() const;
|
|
void SetColType(nsTableColType aType);
|
|
|
|
/** instantiate a new instance of nsTableRowFrame.
|
|
* @param aPresShell the pres shell for this frame
|
|
*
|
|
* @return the frame that was created
|
|
*/
|
|
friend nsTableColFrame* NS_NewTableColFrame(nsIPresShell* aPresShell,
|
|
nsStyleContext* aContext);
|
|
|
|
nsTableColGroupFrame* GetTableColGroupFrame() const
|
|
{
|
|
nsIFrame* parent = GetParent();
|
|
MOZ_ASSERT(parent && parent->GetType() == nsGkAtoms::tableColGroupFrame);
|
|
return static_cast<nsTableColGroupFrame*>(parent);
|
|
}
|
|
|
|
nsTableFrame* GetTableFrame() const
|
|
{
|
|
return GetTableColGroupFrame()->GetTableFrame();
|
|
}
|
|
|
|
/** @see nsIFrame::DidSetStyleContext */
|
|
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
|
|
|
|
int32_t GetColIndex() const;
|
|
|
|
void SetColIndex (int32_t aColIndex);
|
|
|
|
nsTableColFrame* GetNextCol() const;
|
|
|
|
virtual void Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus) override;
|
|
|
|
/**
|
|
* Table columns never paint anything, nor receive events.
|
|
*/
|
|
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists) override {}
|
|
|
|
/**
|
|
* Get the "type" of the frame
|
|
*
|
|
* @see nsGkAtoms::tableColFrame
|
|
*/
|
|
virtual nsIAtom* GetType() const override;
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
virtual nsresult GetFrameName(nsAString& aResult) const override;
|
|
#endif
|
|
|
|
virtual nsSplittableType GetSplittableType() const override;
|
|
|
|
virtual mozilla::WritingMode GetWritingMode() const override
|
|
{ return GetTableFrame()->GetWritingMode(); }
|
|
|
|
/** return the number of the columns the col represents. always >= 1 */
|
|
int32_t GetSpan();
|
|
|
|
/** convenience method, calls into cellmap */
|
|
int32_t Count() const;
|
|
|
|
nscoord GetIStartBorderWidth() const { return mIStartBorderWidth; }
|
|
nscoord GetIEndBorderWidth() const { return mIEndBorderWidth; }
|
|
void SetIStartBorderWidth(BCPixelSize aWidth) { mIStartBorderWidth = aWidth; }
|
|
void SetIEndBorderWidth(BCPixelSize aWidth) { mIEndBorderWidth = aWidth; }
|
|
|
|
/**
|
|
* Gets inner border widths before collapsing with cell borders
|
|
* Caller must get istart border from previous column or from table
|
|
* GetContinuousBCBorderWidth will not overwrite aBorder.IStart
|
|
* see nsTablePainter about continuous borders
|
|
*
|
|
* @return outer iend border width (istart inner for next column)
|
|
*/
|
|
nscoord GetContinuousBCBorderWidth(mozilla::WritingMode aWM,
|
|
mozilla::LogicalMargin& aBorder);
|
|
/**
|
|
* Set full border widths before collapsing with cell borders
|
|
* @param aForSide - side to set; only valid for bstart, iend, and bend
|
|
*/
|
|
void SetContinuousBCBorderWidth(mozilla::LogicalSide aForSide,
|
|
BCPixelSize aPixelValue);
|
|
#ifdef DEBUG
|
|
void Dump(int32_t aIndent);
|
|
#endif
|
|
|
|
/**
|
|
* Restore the default values of the intrinsic widths, so that we can
|
|
* re-accumulate intrinsic widths from the cells in the column.
|
|
*/
|
|
void ResetIntrinsics() {
|
|
mMinCoord = 0;
|
|
mPrefCoord = 0;
|
|
mPrefPercent = 0.0f;
|
|
mHasSpecifiedCoord = false;
|
|
}
|
|
|
|
/**
|
|
* Restore the default value of the preferred percentage width (the
|
|
* only intrinsic width used by FixedTableLayoutStrategy.
|
|
*/
|
|
void ResetPrefPercent() {
|
|
mPrefPercent = 0.0f;
|
|
}
|
|
|
|
/**
|
|
* Restore the default values of the temporary buffer for
|
|
* spanning-cell intrinsic widths (as we process spanning cells).
|
|
*/
|
|
void ResetSpanIntrinsics() {
|
|
mSpanMinCoord = 0;
|
|
mSpanPrefCoord = 0;
|
|
mSpanPrefPercent = 0.0f;
|
|
}
|
|
|
|
/**
|
|
* Add the widths for a cell or column element, or the contribution of
|
|
* the widths from a column-spanning cell:
|
|
* @param aMinCoord The minimum intrinsic width
|
|
* @param aPrefCoord The preferred intrinsic width or, if there is a
|
|
* specified non-percentage width, max(specified width, minimum intrinsic
|
|
* width).
|
|
* @param aHasSpecifiedCoord Whether there is a specified
|
|
* non-percentage width.
|
|
*
|
|
* Note that the implementation of this functions is a bit tricky
|
|
* since mPrefCoord means different things depending on
|
|
* whether mHasSpecifiedCoord is true (and likewise for aPrefCoord and
|
|
* aHasSpecifiedCoord). If mHasSpecifiedCoord is false, then
|
|
* all widths added had aHasSpecifiedCoord false and mPrefCoord is the
|
|
* largest of the pref widths. But if mHasSpecifiedCoord is true,
|
|
* then mPrefCoord is the largest of (1) the pref widths for cells
|
|
* with aHasSpecifiedCoord true and (2) the min widths for cells with
|
|
* aHasSpecifiedCoord false.
|
|
*/
|
|
void AddCoords(nscoord aMinCoord, nscoord aPrefCoord,
|
|
bool aHasSpecifiedCoord) {
|
|
NS_ASSERTION(aMinCoord <= aPrefCoord, "intrinsic widths out of order");
|
|
|
|
if (aHasSpecifiedCoord && !mHasSpecifiedCoord) {
|
|
mPrefCoord = mMinCoord;
|
|
mHasSpecifiedCoord = true;
|
|
}
|
|
if (!aHasSpecifiedCoord && mHasSpecifiedCoord) {
|
|
aPrefCoord = aMinCoord; // NOTE: modifying argument
|
|
}
|
|
|
|
if (aMinCoord > mMinCoord)
|
|
mMinCoord = aMinCoord;
|
|
if (aPrefCoord > mPrefCoord)
|
|
mPrefCoord = aPrefCoord;
|
|
|
|
NS_ASSERTION(mMinCoord <= mPrefCoord, "min larger than pref");
|
|
}
|
|
|
|
/**
|
|
* Add a percentage width specified on a cell or column element or the
|
|
* contribution to this column of a percentage width specified on a
|
|
* column-spanning cell.
|
|
*/
|
|
void AddPrefPercent(float aPrefPercent) {
|
|
if (aPrefPercent > mPrefPercent)
|
|
mPrefPercent = aPrefPercent;
|
|
}
|
|
|
|
/**
|
|
* Get the largest minimum intrinsic width for this column.
|
|
*/
|
|
nscoord GetMinCoord() const { return mMinCoord; }
|
|
/**
|
|
* Get the largest preferred width for this column, or, if there were
|
|
* any specified non-percentage widths (see GetHasSpecifiedCoord), the
|
|
* largest minimum intrinsic width or specified width.
|
|
*/
|
|
nscoord GetPrefCoord() const { return mPrefCoord; }
|
|
/**
|
|
* Get whether there were any specified widths contributing to this
|
|
* column.
|
|
*/
|
|
bool GetHasSpecifiedCoord() const { return mHasSpecifiedCoord; }
|
|
|
|
/**
|
|
* Get the largest specified percentage width contributing to this
|
|
* column (returns 0 if there were none).
|
|
*/
|
|
float GetPrefPercent() const { return mPrefPercent; }
|
|
|
|
/**
|
|
* Like AddCoords, but into a temporary buffer used for groups of
|
|
* column-spanning cells.
|
|
*/
|
|
void AddSpanCoords(nscoord aSpanMinCoord, nscoord aSpanPrefCoord,
|
|
bool aSpanHasSpecifiedCoord) {
|
|
NS_ASSERTION(aSpanMinCoord <= aSpanPrefCoord,
|
|
"intrinsic widths out of order");
|
|
|
|
if (!aSpanHasSpecifiedCoord && mHasSpecifiedCoord) {
|
|
aSpanPrefCoord = aSpanMinCoord; // NOTE: modifying argument
|
|
}
|
|
|
|
if (aSpanMinCoord > mSpanMinCoord)
|
|
mSpanMinCoord = aSpanMinCoord;
|
|
if (aSpanPrefCoord > mSpanPrefCoord)
|
|
mSpanPrefCoord = aSpanPrefCoord;
|
|
|
|
NS_ASSERTION(mSpanMinCoord <= mSpanPrefCoord, "min larger than pref");
|
|
}
|
|
|
|
/*
|
|
* Accumulate percentage widths on column spanning cells into
|
|
* temporary variables.
|
|
*/
|
|
void AddSpanPrefPercent(float aSpanPrefPercent) {
|
|
if (aSpanPrefPercent > mSpanPrefPercent)
|
|
mSpanPrefPercent = aSpanPrefPercent;
|
|
}
|
|
|
|
/*
|
|
* Accumulate the temporary variables for column spanning cells into
|
|
* the primary variables.
|
|
*/
|
|
void AccumulateSpanIntrinsics() {
|
|
AddCoords(mSpanMinCoord, mSpanPrefCoord, mHasSpecifiedCoord);
|
|
AddPrefPercent(mSpanPrefPercent);
|
|
}
|
|
|
|
// Used to adjust a column's pref percent so that the table's total
|
|
// never exceeeds 100% (by only allowing percentages to be used,
|
|
// starting at the first column, until they reach 100%).
|
|
void AdjustPrefPercent(float *aTableTotalPercent) {
|
|
float allowed = 1.0f - *aTableTotalPercent;
|
|
if (mPrefPercent > allowed)
|
|
mPrefPercent = allowed;
|
|
*aTableTotalPercent += mPrefPercent;
|
|
}
|
|
|
|
// The final width of the column.
|
|
void ResetFinalISize() {
|
|
mFinalISize = nscoord_MIN; // so we detect that it changed
|
|
}
|
|
void SetFinalISize(nscoord aFinalISize) {
|
|
mFinalISize = aFinalISize;
|
|
}
|
|
nscoord GetFinalISize() {
|
|
return mFinalISize;
|
|
}
|
|
|
|
virtual bool IsFrameOfType(uint32_t aFlags) const override
|
|
{
|
|
return nsSplittableFrame::IsFrameOfType(aFlags & ~(nsIFrame::eTablePart));
|
|
}
|
|
|
|
virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0) override;
|
|
virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override;
|
|
virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
|
|
|
|
protected:
|
|
|
|
explicit nsTableColFrame(nsStyleContext* aContext);
|
|
~nsTableColFrame();
|
|
|
|
nscoord mMinCoord;
|
|
nscoord mPrefCoord;
|
|
nscoord mSpanMinCoord; // XXX...
|
|
nscoord mSpanPrefCoord; // XXX...
|
|
float mPrefPercent;
|
|
float mSpanPrefPercent; // XXX...
|
|
// ...XXX the four members marked above could be allocated as part of
|
|
// a separate array allocated only during
|
|
// BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes (and only
|
|
// when colspans were present).
|
|
nscoord mFinalISize;
|
|
|
|
// the index of the column with respect to the whole table (starting at 0)
|
|
// it should never be smaller then the start column index of the parent
|
|
// colgroup
|
|
uint32_t mColIndex;
|
|
|
|
// border width in pixels of the inner half of the border only
|
|
BCPixelSize mIStartBorderWidth;
|
|
BCPixelSize mIEndBorderWidth;
|
|
BCPixelSize mBStartContBorderWidth;
|
|
BCPixelSize mIEndContBorderWidth;
|
|
BCPixelSize mBEndContBorderWidth;
|
|
|
|
bool mHasSpecifiedCoord;
|
|
};
|
|
|
|
inline int32_t nsTableColFrame::GetColIndex() const
|
|
{
|
|
return mColIndex;
|
|
}
|
|
|
|
inline void nsTableColFrame::SetColIndex (int32_t aColIndex)
|
|
{
|
|
mColIndex = aColIndex;
|
|
}
|
|
|
|
inline nscoord
|
|
nsTableColFrame::GetContinuousBCBorderWidth(mozilla::WritingMode aWM,
|
|
mozilla::LogicalMargin& aBorder)
|
|
{
|
|
int32_t aPixelsToTwips = nsPresContext::AppUnitsPerCSSPixel();
|
|
aBorder.BStart(aWM) = BC_BORDER_END_HALF_COORD(aPixelsToTwips,
|
|
mBStartContBorderWidth);
|
|
aBorder.IEnd(aWM) = BC_BORDER_START_HALF_COORD(aPixelsToTwips,
|
|
mIEndContBorderWidth);
|
|
aBorder.BEnd(aWM) = BC_BORDER_START_HALF_COORD(aPixelsToTwips,
|
|
mBEndContBorderWidth);
|
|
return BC_BORDER_END_HALF_COORD(aPixelsToTwips, mIEndContBorderWidth);
|
|
}
|
|
|
|
#endif
|
|
|