forked from mirrors/gecko-dev
d20e8e7674
Backed out changeset 0a8334bbcf45 (bug 1483121) Backed out changeset cb2dcb859071 (bug 1482782) Backed out changeset c834d4ca2eef (bug 1482782) Backed out changeset 887de0efbb67 (bug 1482782) Backed out changeset 018fdb50a6be (bug 1482782) Backed out changeset 33a8aa8096c9 (bug 1482782) Backed out changeset e3632354f16e (bug 1482782) Backed out changeset 46f8319bee82 (bug 1482782)
1635 lines
55 KiB
C++
1635 lines
55 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
|
|
/* rendering object for HTML <frameset> elements */
|
|
|
|
#include "nsFrameSetFrame.h"
|
|
|
|
#include "gfxContext.h"
|
|
#include "gfxUtils.h"
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/DebugOnly.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/gfx/Helpers.h"
|
|
#include "mozilla/Likely.h"
|
|
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsAttrValueInlines.h"
|
|
#include "nsLeafFrame.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsIContentInlines.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsCSSAnonBoxes.h"
|
|
#include "mozilla/ServoStyleSet.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsNodeUtils.h"
|
|
#include "mozAutoDocUpdate.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/dom/HTMLFrameSetElement.h"
|
|
#include "mozilla/LookAndFeel.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "nsSubDocumentFrame.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::gfx;
|
|
|
|
// masks for mEdgeVisibility
|
|
#define LEFT_VIS 0x0001
|
|
#define RIGHT_VIS 0x0002
|
|
#define TOP_VIS 0x0004
|
|
#define BOTTOM_VIS 0x0008
|
|
#define ALL_VIS 0x000F
|
|
#define NONE_VIS 0x0000
|
|
|
|
/*******************************************************************************
|
|
* nsFramesetDrag
|
|
******************************************************************************/
|
|
nsFramesetDrag::nsFramesetDrag()
|
|
{
|
|
UnSet();
|
|
}
|
|
|
|
void nsFramesetDrag::Reset(bool aVertical,
|
|
int32_t aIndex,
|
|
int32_t aChange,
|
|
nsHTMLFramesetFrame* aSource)
|
|
{
|
|
mVertical = aVertical;
|
|
mIndex = aIndex;
|
|
mChange = aChange;
|
|
mSource = aSource;
|
|
}
|
|
|
|
void nsFramesetDrag::UnSet()
|
|
{
|
|
mVertical = true;
|
|
mIndex = -1;
|
|
mChange = 0;
|
|
mSource = nullptr;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* nsHTMLFramesetBorderFrame
|
|
******************************************************************************/
|
|
class nsHTMLFramesetBorderFrame final : public nsLeafFrame
|
|
{
|
|
public:
|
|
NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBorderFrame)
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
virtual nsresult GetFrameName(nsAString& aResult) const override;
|
|
#endif
|
|
|
|
virtual nsresult HandleEvent(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus) override;
|
|
|
|
virtual nsresult GetCursor(const nsPoint& aPoint,
|
|
nsIFrame::Cursor& aCursor) override;
|
|
|
|
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) override;
|
|
|
|
virtual void Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus) override;
|
|
|
|
bool GetVisibility() { return mVisibility; }
|
|
void SetVisibility(bool aVisibility);
|
|
void SetColor(nscolor aColor);
|
|
|
|
void PaintBorder(DrawTarget* aDrawTarget, nsPoint aPt);
|
|
|
|
protected:
|
|
nsHTMLFramesetBorderFrame(ComputedStyle* aStyle, int32_t aWidth, bool aVertical, bool aVisible);
|
|
virtual ~nsHTMLFramesetBorderFrame();
|
|
virtual nscoord GetIntrinsicISize() override;
|
|
virtual nscoord GetIntrinsicBSize() override;
|
|
|
|
// the prev and next neighbors are indexes into the row (for a horizontal border) or col (for
|
|
// a vertical border) of nsHTMLFramesetFrames or nsHTMLFrames
|
|
int32_t mPrevNeighbor;
|
|
int32_t mNextNeighbor;
|
|
nscolor mColor;
|
|
int32_t mWidth;
|
|
bool mVertical;
|
|
bool mVisibility;
|
|
bool mCanResize;
|
|
friend class nsHTMLFramesetFrame;
|
|
};
|
|
/*******************************************************************************
|
|
* nsHTMLFramesetBlankFrame
|
|
******************************************************************************/
|
|
class nsHTMLFramesetBlankFrame final : public nsLeafFrame
|
|
{
|
|
public:
|
|
NS_DECL_QUERYFRAME
|
|
NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBlankFrame)
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
virtual nsresult GetFrameName(nsAString& aResult) const override
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("FramesetBlank"), aResult);
|
|
}
|
|
#endif
|
|
|
|
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) override;
|
|
|
|
virtual void Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus) override;
|
|
|
|
protected:
|
|
explicit nsHTMLFramesetBlankFrame(ComputedStyle* aStyle)
|
|
: nsLeafFrame(aStyle, kClassID)
|
|
{}
|
|
|
|
virtual ~nsHTMLFramesetBlankFrame();
|
|
virtual nscoord GetIntrinsicISize() override;
|
|
virtual nscoord GetIntrinsicBSize() override;
|
|
|
|
friend class nsHTMLFramesetFrame;
|
|
friend class nsHTMLFrameset;
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* nsHTMLFramesetFrame
|
|
******************************************************************************/
|
|
bool nsHTMLFramesetFrame::gDragInProgress = false;
|
|
#define DEFAULT_BORDER_WIDTH_PX 6
|
|
|
|
nsHTMLFramesetFrame::nsHTMLFramesetFrame(ComputedStyle* aStyle)
|
|
: nsContainerFrame(aStyle, kClassID)
|
|
{
|
|
mNumRows = 0;
|
|
mNumCols = 0;
|
|
mEdgeVisibility = 0;
|
|
mParentFrameborder = eFrameborder_Yes; // default
|
|
mParentBorderWidth = -1; // default not set
|
|
mParentBorderColor = NO_COLOR; // default not set
|
|
mFirstDragPoint.x = mFirstDragPoint.y = 0;
|
|
mMinDrag = nsPresContext::CSSPixelsToAppUnits(2);
|
|
mNonBorderChildCount = 0;
|
|
mNonBlankChildCount = 0;
|
|
mDragger = nullptr;
|
|
mChildCount = 0;
|
|
mTopLevelFrameset = nullptr;
|
|
mEdgeColors.Set(NO_COLOR);
|
|
}
|
|
|
|
nsHTMLFramesetFrame::~nsHTMLFramesetFrame()
|
|
{
|
|
}
|
|
|
|
NS_QUERYFRAME_HEAD(nsHTMLFramesetFrame)
|
|
NS_QUERYFRAME_ENTRY(nsHTMLFramesetFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
|
|
|
|
void
|
|
nsHTMLFramesetFrame::Init(nsIContent* aContent,
|
|
nsContainerFrame* aParent,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
|
|
// find the highest ancestor that is a frameset
|
|
nsIFrame* parentFrame = GetParent();
|
|
mTopLevelFrameset = this;
|
|
while (parentFrame) {
|
|
nsHTMLFramesetFrame* frameset = do_QueryFrame(parentFrame);
|
|
if (frameset) {
|
|
mTopLevelFrameset = frameset;
|
|
parentFrame = parentFrame->GetParent();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
nsPresContext* presContext = PresContext();
|
|
nsIPresShell* shell = presContext->PresShell();
|
|
|
|
nsFrameborder frameborder = GetFrameBorder();
|
|
int32_t borderWidth = GetBorderWidth(presContext, false);
|
|
nscolor borderColor = GetBorderColor();
|
|
|
|
// Get the rows= cols= data
|
|
HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
|
|
NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
|
|
const nsFramesetSpec* rowSpecs = nullptr;
|
|
const nsFramesetSpec* colSpecs = nullptr;
|
|
// GetRowSpec and GetColSpec can fail, but when they do they set
|
|
// mNumRows and mNumCols respectively to 0, so we deal with it fine.
|
|
ourContent->GetRowSpec(&mNumRows, &rowSpecs);
|
|
ourContent->GetColSpec(&mNumCols, &colSpecs);
|
|
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscoord),
|
|
"Maximum value of mNumRows and mNumCols is NS_MAX_FRAMESET_SPEC_COUNT");
|
|
mRowSizes = MakeUnique<nscoord[]>(mNumRows);
|
|
mColSizes = MakeUnique<nscoord[]>(mNumCols);
|
|
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Should not overflow numCells");
|
|
int32_t numCells = mNumRows*mNumCols;
|
|
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nsHTMLFramesetBorderFrame*),
|
|
"Should not overflow nsHTMLFramesetBorderFrame");
|
|
mVerBorders = MakeUnique<nsHTMLFramesetBorderFrame*[]>(mNumCols); // 1 more than number of ver borders
|
|
|
|
for (int verX = 0; verX < mNumCols; verX++)
|
|
mVerBorders[verX] = nullptr;
|
|
|
|
mHorBorders = MakeUnique<nsHTMLFramesetBorderFrame*[]>(mNumRows); // 1 more than number of hor borders
|
|
|
|
for (int horX = 0; horX < mNumRows; horX++)
|
|
mHorBorders[horX] = nullptr;
|
|
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT
|
|
< UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Should not overflow numCells");
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT
|
|
< UINT_MAX / sizeof(nsFrameborder) / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Should not overflow numCells");
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT
|
|
< UINT_MAX / sizeof(nsBorderColor) / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Should not overflow numCells");
|
|
mChildFrameborder = MakeUnique<nsFrameborder[]>(numCells);
|
|
mChildBorderColors = MakeUnique<nsBorderColor[]>(numCells);
|
|
|
|
// create the children frames; skip content which isn't <frameset> or <frame>
|
|
mChildCount = 0; // number of <frame> or <frameset> children
|
|
|
|
for (nsIContent* child = mContent->GetFirstChild();
|
|
child;
|
|
child = child->GetNextSibling()) {
|
|
if (mChildCount == numCells) { // we have more <frame> or <frameset> than cells
|
|
// Clear the lazy bits in the remaining children. Also clear
|
|
// the restyle flags, like nsCSSFrameConstructor::ProcessChildren does.
|
|
for (; child; child = child->GetNextSibling()) {
|
|
child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
|
|
}
|
|
break;
|
|
}
|
|
child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
|
|
|
|
// IMPORTANT: This must match the conditions in
|
|
// nsCSSFrameConstructor::ContentAppended/Inserted/Removed
|
|
if (!child->IsHTMLElement()) {
|
|
continue;
|
|
}
|
|
|
|
if (!child->IsAnyOfHTMLElements(nsGkAtoms::frameset, nsGkAtoms::frame)) {
|
|
continue;
|
|
}
|
|
|
|
RefPtr<ComputedStyle> kidSC =
|
|
shell->StyleSet()->ResolveStyleFor(child->AsElement(),
|
|
mComputedStyle,
|
|
LazyComputeBehavior::Allow);
|
|
|
|
nsIFrame* frame;
|
|
if (child->IsHTMLElement(nsGkAtoms::frameset)) {
|
|
frame = NS_NewHTMLFramesetFrame(shell, kidSC);
|
|
|
|
nsHTMLFramesetFrame* childFrame = (nsHTMLFramesetFrame*)frame;
|
|
childFrame->SetParentFrameborder(frameborder);
|
|
childFrame->SetParentBorderWidth(borderWidth);
|
|
childFrame->SetParentBorderColor(borderColor);
|
|
frame->Init(child, this, nullptr);
|
|
|
|
mChildBorderColors[mChildCount].Set(childFrame->GetBorderColor());
|
|
} else { // frame
|
|
frame = NS_NewSubDocumentFrame(shell, kidSC);
|
|
|
|
frame->Init(child, this, nullptr);
|
|
|
|
mChildFrameborder[mChildCount] = GetFrameBorder(child);
|
|
mChildBorderColors[mChildCount].Set(GetBorderColor(child));
|
|
}
|
|
child->SetPrimaryFrame(frame);
|
|
|
|
mFrames.AppendFrame(nullptr, frame);
|
|
|
|
mChildCount++;
|
|
}
|
|
|
|
mNonBlankChildCount = mChildCount;
|
|
// add blank frames for frameset cells that had no content provided
|
|
for (int blankX = mChildCount; blankX < numCells; blankX++) {
|
|
RefPtr<ComputedStyle> pseudoComputedStyle;
|
|
pseudoComputedStyle = shell->StyleSet()->
|
|
ResolveNonInheritingAnonymousBoxStyle(nsCSSAnonBoxes::framesetBlank);
|
|
|
|
// XXX the blank frame is using the content of its parent - at some point it
|
|
// should just have null content, if we support that
|
|
nsHTMLFramesetBlankFrame* blankFrame = new (shell) nsHTMLFramesetBlankFrame(pseudoComputedStyle);
|
|
|
|
blankFrame->Init(mContent, this, nullptr);
|
|
|
|
mFrames.AppendFrame(nullptr, blankFrame);
|
|
|
|
mChildBorderColors[mChildCount].Set(NO_COLOR);
|
|
mChildCount++;
|
|
}
|
|
|
|
mNonBorderChildCount = mChildCount;
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList)
|
|
{
|
|
// We do this weirdness where we create our child frames in Init(). On the
|
|
// other hand, we're going to get a SetInitialChildList() with an empty list
|
|
// and null list name after the frame constructor is done creating us. So
|
|
// just ignore that call.
|
|
if (aListID == kPrincipalList && aChildList.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
nsContainerFrame::SetInitialChildList(aListID, aChildList);
|
|
}
|
|
|
|
// XXX should this try to allocate twips based on an even pixel boundary?
|
|
void nsHTMLFramesetFrame::Scale(nscoord aDesired,
|
|
int32_t aNumIndicies,
|
|
int32_t* aIndicies,
|
|
int32_t aNumItems,
|
|
int32_t* aItems)
|
|
{
|
|
int32_t actual = 0;
|
|
int32_t i, j;
|
|
// get the actual total
|
|
for (i = 0; i < aNumIndicies; i++) {
|
|
j = aIndicies[i];
|
|
actual += aItems[j];
|
|
}
|
|
|
|
if (actual > 0) {
|
|
float factor = (float)aDesired / (float)actual;
|
|
actual = 0;
|
|
// scale the items up or down
|
|
for (i = 0; i < aNumIndicies; i++) {
|
|
j = aIndicies[i];
|
|
aItems[j] = NSToCoordRound((float)aItems[j] * factor);
|
|
actual += aItems[j];
|
|
}
|
|
} else if (aNumIndicies != 0) {
|
|
// All the specs say zero width, but we have to fill up space
|
|
// somehow. Distribute it equally.
|
|
nscoord width = NSToCoordRound((float)aDesired / (float)aNumIndicies);
|
|
actual = width * aNumIndicies;
|
|
for (i = 0; i < aNumIndicies; i++) {
|
|
aItems[aIndicies[i]] = width;
|
|
}
|
|
}
|
|
|
|
if (aNumIndicies > 0 && aDesired != actual) {
|
|
int32_t unit = (aDesired > actual) ? 1 : -1;
|
|
for (i=0; (i < aNumIndicies) && (aDesired != actual); i++) {
|
|
j = aIndicies[i];
|
|
if (j < aNumItems) {
|
|
aItems[j] += unit;
|
|
actual += unit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Translate the rows/cols specs into an array of integer sizes for
|
|
* each cell in the frameset. Sizes are allocated based on the priorities of the
|
|
* specifier - fixed sizes have the highest priority, percentage sizes have the next
|
|
* highest priority and relative sizes have the lowest.
|
|
*/
|
|
void nsHTMLFramesetFrame::CalculateRowCol(nsPresContext* aPresContext,
|
|
nscoord aSize,
|
|
int32_t aNumSpecs,
|
|
const nsFramesetSpec* aSpecs,
|
|
nscoord* aValues)
|
|
{
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(int32_t),
|
|
"aNumSpecs maximum value is NS_MAX_FRAMESET_SPEC_COUNT");
|
|
|
|
int32_t fixedTotal = 0;
|
|
int32_t numFixed = 0;
|
|
auto fixed = MakeUnique<int32_t[]>(aNumSpecs);
|
|
int32_t numPercent = 0;
|
|
auto percent = MakeUnique<int32_t[]>(aNumSpecs);
|
|
int32_t relativeSums = 0;
|
|
int32_t numRelative = 0;
|
|
auto relative = MakeUnique<int32_t[]>(aNumSpecs);
|
|
|
|
if (MOZ_UNLIKELY(!fixed || !percent || !relative)) {
|
|
return; // NS_ERROR_OUT_OF_MEMORY
|
|
}
|
|
|
|
int32_t i, j;
|
|
|
|
// initialize the fixed, percent, relative indices, allocate the fixed sizes and zero the others
|
|
for (i = 0; i < aNumSpecs; i++) {
|
|
aValues[i] = 0;
|
|
switch (aSpecs[i].mUnit) {
|
|
case eFramesetUnit_Fixed:
|
|
aValues[i] = nsPresContext::CSSPixelsToAppUnits(aSpecs[i].mValue);
|
|
fixedTotal += aValues[i];
|
|
fixed[numFixed] = i;
|
|
numFixed++;
|
|
break;
|
|
case eFramesetUnit_Percent:
|
|
percent[numPercent] = i;
|
|
numPercent++;
|
|
break;
|
|
case eFramesetUnit_Relative:
|
|
relative[numRelative] = i;
|
|
numRelative++;
|
|
relativeSums += aSpecs[i].mValue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// scale the fixed sizes if they total too much (or too little and there aren't any percent or relative)
|
|
if ((fixedTotal > aSize) || ((fixedTotal < aSize) && (0 == numPercent) && (0 == numRelative))) {
|
|
Scale(aSize, numFixed, fixed.get(), aNumSpecs, aValues);
|
|
return;
|
|
}
|
|
|
|
int32_t percentMax = aSize - fixedTotal;
|
|
int32_t percentTotal = 0;
|
|
// allocate the percentage sizes from what is left over from the fixed allocation
|
|
for (i = 0; i < numPercent; i++) {
|
|
j = percent[i];
|
|
aValues[j] = NSToCoordRound((float)aSpecs[j].mValue * (float)aSize / 100.0f);
|
|
percentTotal += aValues[j];
|
|
}
|
|
|
|
// scale the percent sizes if they total too much (or too little and there aren't any relative)
|
|
if ((percentTotal > percentMax) || ((percentTotal < percentMax) && (0 == numRelative))) {
|
|
Scale(percentMax, numPercent, percent.get(), aNumSpecs, aValues);
|
|
return;
|
|
}
|
|
|
|
int32_t relativeMax = percentMax - percentTotal;
|
|
int32_t relativeTotal = 0;
|
|
// allocate the relative sizes from what is left over from the percent allocation
|
|
for (i = 0; i < numRelative; i++) {
|
|
j = relative[i];
|
|
aValues[j] = NSToCoordRound((float)aSpecs[j].mValue * (float)relativeMax / (float)relativeSums);
|
|
relativeTotal += aValues[j];
|
|
}
|
|
|
|
// scale the relative sizes if they take up too much or too little
|
|
if (relativeTotal != relativeMax) {
|
|
Scale(relativeMax, numRelative, relative.get(), aNumSpecs, aValues);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Translate the rows/cols integer sizes into an array of specs for
|
|
* each cell in the frameset. Reverse of CalculateRowCol() behaviour.
|
|
* This allows us to maintain the user size info through reflows.
|
|
*/
|
|
void nsHTMLFramesetFrame::GenerateRowCol(nsPresContext* aPresContext,
|
|
nscoord aSize,
|
|
int32_t aNumSpecs,
|
|
const nsFramesetSpec* aSpecs,
|
|
nscoord* aValues,
|
|
nsString& aNewAttr)
|
|
{
|
|
int32_t i;
|
|
|
|
for (i = 0; i < aNumSpecs; i++) {
|
|
if (!aNewAttr.IsEmpty())
|
|
aNewAttr.Append(char16_t(','));
|
|
|
|
switch (aSpecs[i].mUnit) {
|
|
case eFramesetUnit_Fixed:
|
|
aNewAttr.AppendInt(nsPresContext::AppUnitsToIntCSSPixels(aValues[i]));
|
|
break;
|
|
case eFramesetUnit_Percent: // XXX Only accurate to 1%, need 1 pixel
|
|
case eFramesetUnit_Relative:
|
|
// Add 0.5 to the percentage to make rounding work right.
|
|
aNewAttr.AppendInt(uint32_t((100.0*aValues[i])/aSize + 0.5));
|
|
aNewAttr.Append(char16_t('%'));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t nsHTMLFramesetFrame::GetBorderWidth(nsPresContext* aPresContext,
|
|
bool aTakeForcingIntoAccount)
|
|
{
|
|
nsFrameborder frameborder = GetFrameBorder();
|
|
if (frameborder == eFrameborder_No) {
|
|
return 0;
|
|
}
|
|
nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);
|
|
|
|
if (content) {
|
|
const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::border);
|
|
if (attr) {
|
|
int32_t intVal = 0;
|
|
if (attr->Type() == nsAttrValue::eInteger) {
|
|
intVal = attr->GetIntegerValue();
|
|
if (intVal < 0) {
|
|
intVal = 0;
|
|
}
|
|
}
|
|
|
|
return nsPresContext::CSSPixelsToAppUnits(intVal);
|
|
}
|
|
}
|
|
|
|
if (mParentBorderWidth >= 0) {
|
|
return mParentBorderWidth;
|
|
}
|
|
|
|
return nsPresContext::CSSPixelsToAppUnits(DEFAULT_BORDER_WIDTH_PX);
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::GetDesiredSize(nsPresContext* aPresContext,
|
|
const ReflowInput& aReflowInput,
|
|
ReflowOutput& aDesiredSize)
|
|
{
|
|
WritingMode wm = aReflowInput.GetWritingMode();
|
|
LogicalSize desiredSize(wm);
|
|
nsHTMLFramesetFrame* framesetParent = do_QueryFrame(GetParent());
|
|
if (nullptr == framesetParent) {
|
|
if (aPresContext->IsPaginated()) {
|
|
// XXX This needs to be changed when framesets paginate properly
|
|
desiredSize.ISize(wm) = aReflowInput.AvailableISize();
|
|
desiredSize.BSize(wm) = aReflowInput.AvailableBSize();
|
|
} else {
|
|
LogicalSize area(wm, aPresContext->GetVisibleArea().Size());
|
|
|
|
desiredSize.ISize(wm) = area.ISize(wm);
|
|
desiredSize.BSize(wm) = area.BSize(wm);
|
|
}
|
|
} else {
|
|
LogicalSize size(wm);
|
|
framesetParent->GetSizeOfChild(this, wm, size);
|
|
desiredSize.ISize(wm) = size.ISize(wm);
|
|
desiredSize.BSize(wm) = size.BSize(wm);
|
|
}
|
|
aDesiredSize.SetSize(wm, desiredSize);
|
|
}
|
|
|
|
// only valid for non border children
|
|
void nsHTMLFramesetFrame::GetSizeOfChildAt(int32_t aIndexInParent,
|
|
WritingMode aWM,
|
|
LogicalSize& aSize,
|
|
nsIntPoint& aCellIndex)
|
|
{
|
|
int32_t row = aIndexInParent / mNumCols;
|
|
int32_t col = aIndexInParent - (row * mNumCols); // remainder from dividing index by mNumCols
|
|
if ((row < mNumRows) && (col < mNumCols)) {
|
|
aSize.ISize(aWM) = mColSizes[col];
|
|
aSize.BSize(aWM) = mRowSizes[row];
|
|
aCellIndex.x = col;
|
|
aCellIndex.y = row;
|
|
} else {
|
|
aSize.SizeTo(aWM, 0, 0);
|
|
aCellIndex.x = aCellIndex.y = 0;
|
|
}
|
|
}
|
|
|
|
// only valid for non border children
|
|
void nsHTMLFramesetFrame::GetSizeOfChild(nsIFrame* aChild,
|
|
WritingMode aWM,
|
|
LogicalSize& aSize)
|
|
{
|
|
// Reflow only creates children frames for <frameset> and <frame> content.
|
|
// this assumption is used here
|
|
int i = 0;
|
|
for (nsIFrame* child : mFrames) {
|
|
if (aChild == child) {
|
|
nsIntPoint ignore;
|
|
GetSizeOfChildAt(i, aWM, aSize, ignore);
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
aSize.SizeTo(aWM, 0, 0);
|
|
}
|
|
|
|
|
|
nsresult nsHTMLFramesetFrame::HandleEvent(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aEventStatus);
|
|
if (mDragger) {
|
|
// the nsFramesetBorderFrame has captured NS_MOUSE_DOWN
|
|
switch (aEvent->mMessage) {
|
|
case eMouseMove:
|
|
MouseDrag(aPresContext, aEvent);
|
|
break;
|
|
case eMouseUp:
|
|
if (aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
|
|
EndMouseDrag(aPresContext);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
*aEventStatus = nsEventStatus_eConsumeNoDefault;
|
|
} else {
|
|
*aEventStatus = nsEventStatus_eIgnore;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsHTMLFramesetFrame::GetCursor(const nsPoint& aPoint,
|
|
nsIFrame::Cursor& aCursor)
|
|
{
|
|
aCursor.mLoading = false;
|
|
if (mDragger) {
|
|
aCursor.mCursor = (mDragger->mVertical) ? NS_STYLE_CURSOR_EW_RESIZE : NS_STYLE_CURSOR_NS_RESIZE;
|
|
} else {
|
|
aCursor.mCursor = NS_STYLE_CURSOR_DEFAULT;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
BuildDisplayListForInline(aBuilder, aLists);
|
|
|
|
if (mDragger && aBuilder->IsForEventDelivery()) {
|
|
aLists.Content()->AppendToTop(
|
|
MakeDisplayItem<nsDisplayEventReceiver>(aBuilder, this));
|
|
}
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::ReflowPlaceChild(nsIFrame* aChild,
|
|
nsPresContext* aPresContext,
|
|
const ReflowInput& aReflowInput,
|
|
nsPoint& aOffset,
|
|
nsSize& aSize,
|
|
nsIntPoint* aCellIndex)
|
|
{
|
|
// reflow the child
|
|
ReflowInput reflowInput(aPresContext, aReflowInput, aChild,
|
|
LogicalSize(aChild->GetWritingMode(), aSize));
|
|
reflowInput.SetComputedWidth(std::max(0, aSize.width - reflowInput.ComputedPhysicalBorderPadding().LeftRight()));
|
|
reflowInput.SetComputedHeight(std::max(0, aSize.height - reflowInput.ComputedPhysicalBorderPadding().TopBottom()));
|
|
ReflowOutput reflowOutput(aReflowInput);
|
|
reflowOutput.Width() = aSize.width;
|
|
reflowOutput.Height() = aSize.height;
|
|
nsReflowStatus status;
|
|
|
|
ReflowChild(aChild, aPresContext, reflowOutput, reflowInput, aOffset.x,
|
|
aOffset.y, 0, status);
|
|
NS_ASSERTION(status.IsComplete(), "bad status");
|
|
|
|
// Place and size the child
|
|
reflowOutput.Width() = aSize.width;
|
|
reflowOutput.Height() = aSize.height;
|
|
FinishReflowChild(aChild, aPresContext, reflowOutput, nullptr, aOffset.x, aOffset.y, 0);
|
|
}
|
|
|
|
static
|
|
nsFrameborder GetFrameBorderHelper(nsGenericHTMLElement* aContent)
|
|
{
|
|
if (nullptr != aContent) {
|
|
const nsAttrValue* attr = aContent->GetParsedAttr(nsGkAtoms::frameborder);
|
|
if (attr && attr->Type() == nsAttrValue::eEnum) {
|
|
switch (attr->GetEnumValue())
|
|
{
|
|
case NS_STYLE_FRAME_YES:
|
|
case NS_STYLE_FRAME_1:
|
|
return eFrameborder_Yes;
|
|
|
|
case NS_STYLE_FRAME_NO:
|
|
case NS_STYLE_FRAME_0:
|
|
return eFrameborder_No;
|
|
}
|
|
}
|
|
}
|
|
return eFrameborder_Notset;
|
|
}
|
|
|
|
nsFrameborder nsHTMLFramesetFrame::GetFrameBorder()
|
|
{
|
|
nsFrameborder result = eFrameborder_Notset;
|
|
nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);
|
|
|
|
if (content) {
|
|
result = GetFrameBorderHelper(content);
|
|
}
|
|
if (eFrameborder_Notset == result) {
|
|
return mParentFrameborder;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
nsFrameborder nsHTMLFramesetFrame::GetFrameBorder(nsIContent* aContent)
|
|
{
|
|
nsFrameborder result = eFrameborder_Notset;
|
|
|
|
nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(aContent);
|
|
|
|
if (content) {
|
|
result = GetFrameBorderHelper(content);
|
|
}
|
|
if (eFrameborder_Notset == result) {
|
|
return GetFrameBorder();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
nscolor nsHTMLFramesetFrame::GetBorderColor()
|
|
{
|
|
nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);
|
|
|
|
if (content) {
|
|
const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);
|
|
if (attr) {
|
|
nscolor color;
|
|
if (attr->GetColorValue(color)) {
|
|
return color;
|
|
}
|
|
}
|
|
}
|
|
|
|
return mParentBorderColor;
|
|
}
|
|
|
|
nscolor nsHTMLFramesetFrame::GetBorderColor(nsIContent* aContent)
|
|
{
|
|
nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(aContent);
|
|
|
|
if (content) {
|
|
const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);
|
|
if (attr) {
|
|
nscolor color;
|
|
if (attr->GetColorValue(color)) {
|
|
return color;
|
|
}
|
|
}
|
|
}
|
|
return GetBorderColor();
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
nsIPresShell *shell = aPresContext->PresShell();
|
|
ServoStyleSet* styleSet = shell->StyleSet();
|
|
|
|
GetParent()->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
|
|
|
|
//printf("FramesetFrame2::Reflow %X (%d,%d) \n", this, aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight());
|
|
// Always get the size so that the caller knows how big we are
|
|
GetDesiredSize(aPresContext, aReflowInput, aDesiredSize);
|
|
|
|
nscoord width = (aDesiredSize.Width() <= aReflowInput.AvailableWidth())
|
|
? aDesiredSize.Width() : aReflowInput.AvailableWidth();
|
|
nscoord height = (aDesiredSize.Height() <= aReflowInput.AvailableHeight())
|
|
? aDesiredSize.Height() : aReflowInput.AvailableHeight();
|
|
|
|
// We might be reflowed more than once with NS_FRAME_FIRST_REFLOW;
|
|
// that's allowed. (Though it will only happen for misuse of frameset
|
|
// that includes it within other content.) So measure firstTime by
|
|
// what we care about, which is whether we've processed the data we
|
|
// process below if firstTime is true.
|
|
MOZ_ASSERT(!mChildFrameborder == !mChildBorderColors);
|
|
bool firstTime = !!mChildFrameborder;
|
|
|
|
// subtract out the width of all of the potential borders. There are
|
|
// only borders between <frame>s. There are none on the edges (e.g the
|
|
// leftmost <frame> has no left border).
|
|
int32_t borderWidth = GetBorderWidth(aPresContext, true);
|
|
|
|
width -= (mNumCols - 1) * borderWidth;
|
|
if (width < 0) width = 0;
|
|
|
|
height -= (mNumRows - 1) * borderWidth;
|
|
if (height < 0) height = 0;
|
|
|
|
HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
|
|
NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
|
|
const nsFramesetSpec* rowSpecs = nullptr;
|
|
const nsFramesetSpec* colSpecs = nullptr;
|
|
int32_t rows = 0;
|
|
int32_t cols = 0;
|
|
ourContent->GetRowSpec(&rows, &rowSpecs);
|
|
ourContent->GetColSpec(&cols, &colSpecs);
|
|
// If the number of cols or rows has changed, the frame for the frameset
|
|
// will be re-created.
|
|
if (mNumRows != rows || mNumCols != cols) {
|
|
mDrag.UnSet();
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
|
|
return;
|
|
}
|
|
|
|
CalculateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get());
|
|
CalculateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get());
|
|
|
|
UniquePtr<bool[]> verBordersVis; // vertical borders visibility
|
|
UniquePtr<nscolor[]> verBorderColors;
|
|
UniquePtr<bool[]> horBordersVis; // horizontal borders visibility
|
|
UniquePtr<nscolor[]> horBorderColors;
|
|
nscolor borderColor = GetBorderColor();
|
|
nsFrameborder frameborder = GetFrameBorder();
|
|
|
|
if (firstTime) {
|
|
// Check for overflow in memory allocations using mNumCols and mNumRows
|
|
// which have a maxium value of NS_MAX_FRAMESET_SPEC_COUNT.
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(bool),
|
|
"Check for overflow");
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscolor),
|
|
"Check for overflow");
|
|
|
|
verBordersVis = MakeUnique<bool[]>(mNumCols);
|
|
verBorderColors = MakeUnique<nscolor[]>(mNumCols);
|
|
for (int verX = 0; verX < mNumCols; verX++) {
|
|
verBordersVis[verX] = false;
|
|
verBorderColors[verX] = NO_COLOR;
|
|
}
|
|
|
|
horBordersVis = MakeUnique<bool[]>(mNumRows);
|
|
horBorderColors = MakeUnique<nscolor[]>(mNumRows);
|
|
for (int horX = 0; horX < mNumRows; horX++) {
|
|
horBordersVis[horX] = false;
|
|
horBorderColors[horX] = NO_COLOR;
|
|
}
|
|
}
|
|
|
|
// reflow the children
|
|
int32_t lastRow = 0;
|
|
int32_t lastCol = 0;
|
|
int32_t borderChildX = mNonBorderChildCount; // index of border children
|
|
nsHTMLFramesetBorderFrame* borderFrame = nullptr;
|
|
nsPoint offset(0,0);
|
|
nsSize size, lastSize;
|
|
WritingMode wm = GetWritingMode();
|
|
LogicalSize logicalSize(wm);
|
|
nsIFrame* child = mFrames.FirstChild();
|
|
|
|
for (int32_t childX = 0; childX < mNonBorderChildCount; childX++) {
|
|
nsIntPoint cellIndex;
|
|
GetSizeOfChildAt(childX, wm, logicalSize, cellIndex);
|
|
size = logicalSize.GetPhysicalSize(wm);
|
|
|
|
if (lastRow != cellIndex.y) { // changed to next row
|
|
offset.x = 0;
|
|
offset.y += lastSize.height;
|
|
if (firstTime) { // create horizontal border
|
|
|
|
RefPtr<ComputedStyle> pseudoComputedStyle;
|
|
pseudoComputedStyle = styleSet->
|
|
ResolveNonInheritingAnonymousBoxStyle(nsCSSAnonBoxes::horizontalFramesetBorder);
|
|
|
|
borderFrame = new (shell) nsHTMLFramesetBorderFrame(pseudoComputedStyle,
|
|
borderWidth,
|
|
false,
|
|
false);
|
|
borderFrame->Init(mContent, this, nullptr);
|
|
mChildCount++;
|
|
mFrames.AppendFrame(nullptr, borderFrame);
|
|
mHorBorders[cellIndex.y-1] = borderFrame;
|
|
// set the neighbors for determining drag boundaries
|
|
borderFrame->mPrevNeighbor = lastRow;
|
|
borderFrame->mNextNeighbor = cellIndex.y;
|
|
} else {
|
|
borderFrame = (nsHTMLFramesetBorderFrame*)mFrames.FrameAt(borderChildX);
|
|
borderFrame->mWidth = borderWidth;
|
|
borderChildX++;
|
|
}
|
|
nsSize borderSize(aDesiredSize.Width(), borderWidth);
|
|
ReflowPlaceChild(borderFrame, aPresContext, aReflowInput, offset, borderSize);
|
|
borderFrame = nullptr;
|
|
offset.y += borderWidth;
|
|
} else {
|
|
if (cellIndex.x > 0) { // moved to next col in same row
|
|
if (0 == cellIndex.y) { // in 1st row
|
|
if (firstTime) { // create vertical border
|
|
|
|
RefPtr<ComputedStyle> pseudoComputedStyle;
|
|
pseudoComputedStyle = styleSet->
|
|
ResolveNonInheritingAnonymousBoxStyle(nsCSSAnonBoxes::verticalFramesetBorder);
|
|
|
|
borderFrame = new (shell) nsHTMLFramesetBorderFrame(pseudoComputedStyle,
|
|
borderWidth,
|
|
true,
|
|
false);
|
|
borderFrame->Init(mContent, this, nullptr);
|
|
mChildCount++;
|
|
mFrames.AppendFrame(nullptr, borderFrame);
|
|
mVerBorders[cellIndex.x-1] = borderFrame;
|
|
// set the neighbors for determining drag boundaries
|
|
borderFrame->mPrevNeighbor = lastCol;
|
|
borderFrame->mNextNeighbor = cellIndex.x;
|
|
} else {
|
|
borderFrame = (nsHTMLFramesetBorderFrame*)mFrames.FrameAt(borderChildX);
|
|
borderFrame->mWidth = borderWidth;
|
|
borderChildX++;
|
|
}
|
|
nsSize borderSize(borderWidth, aDesiredSize.Height());
|
|
ReflowPlaceChild(borderFrame, aPresContext, aReflowInput, offset, borderSize);
|
|
borderFrame = nullptr;
|
|
}
|
|
offset.x += borderWidth;
|
|
}
|
|
}
|
|
|
|
ReflowPlaceChild(child, aPresContext, aReflowInput, offset, size, &cellIndex);
|
|
|
|
if (firstTime) {
|
|
int32_t childVis;
|
|
nsHTMLFramesetFrame* framesetFrame = do_QueryFrame(child);
|
|
nsSubDocumentFrame* subdocFrame;
|
|
if (framesetFrame) {
|
|
childVis = framesetFrame->mEdgeVisibility;
|
|
mChildBorderColors[childX] = framesetFrame->mEdgeColors;
|
|
} else if ((subdocFrame = do_QueryFrame(child))) {
|
|
if (eFrameborder_Yes == mChildFrameborder[childX]) {
|
|
childVis = ALL_VIS;
|
|
} else if (eFrameborder_No == mChildFrameborder[childX]) {
|
|
childVis = NONE_VIS;
|
|
} else { // notset
|
|
childVis = (eFrameborder_No == frameborder) ? NONE_VIS : ALL_VIS;
|
|
}
|
|
} else { // blank
|
|
#ifdef DEBUG
|
|
nsHTMLFramesetBlankFrame* blank = do_QueryFrame(child);
|
|
MOZ_ASSERT(blank, "unexpected child frame type");
|
|
#endif
|
|
childVis = NONE_VIS;
|
|
}
|
|
nsBorderColor childColors = mChildBorderColors[childX];
|
|
// set the visibility, color of our edge borders based on children
|
|
if (0 == cellIndex.x) {
|
|
if (!(mEdgeVisibility & LEFT_VIS)) {
|
|
mEdgeVisibility |= (LEFT_VIS & childVis);
|
|
}
|
|
if (NO_COLOR == mEdgeColors.mLeft) {
|
|
mEdgeColors.mLeft = childColors.mLeft;
|
|
}
|
|
}
|
|
if (0 == cellIndex.y) {
|
|
if (!(mEdgeVisibility & TOP_VIS)) {
|
|
mEdgeVisibility |= (TOP_VIS & childVis);
|
|
}
|
|
if (NO_COLOR == mEdgeColors.mTop) {
|
|
mEdgeColors.mTop = childColors.mTop;
|
|
}
|
|
}
|
|
if (mNumCols-1 == cellIndex.x) {
|
|
if (!(mEdgeVisibility & RIGHT_VIS)) {
|
|
mEdgeVisibility |= (RIGHT_VIS & childVis);
|
|
}
|
|
if (NO_COLOR == mEdgeColors.mRight) {
|
|
mEdgeColors.mRight = childColors.mRight;
|
|
}
|
|
}
|
|
if (mNumRows-1 == cellIndex.y) {
|
|
if (!(mEdgeVisibility & BOTTOM_VIS)) {
|
|
mEdgeVisibility |= (BOTTOM_VIS & childVis);
|
|
}
|
|
if (NO_COLOR == mEdgeColors.mBottom) {
|
|
mEdgeColors.mBottom = childColors.mBottom;
|
|
}
|
|
}
|
|
// set the visibility of borders that the child may affect
|
|
if (childVis & RIGHT_VIS) {
|
|
verBordersVis[cellIndex.x] = true;
|
|
}
|
|
if (childVis & BOTTOM_VIS) {
|
|
horBordersVis[cellIndex.y] = true;
|
|
}
|
|
if ((cellIndex.x > 0) && (childVis & LEFT_VIS)) {
|
|
verBordersVis[cellIndex.x-1] = true;
|
|
}
|
|
if ((cellIndex.y > 0) && (childVis & TOP_VIS)) {
|
|
horBordersVis[cellIndex.y-1] = true;
|
|
}
|
|
// set the colors of borders that the child may affect
|
|
if (NO_COLOR == verBorderColors[cellIndex.x]) {
|
|
verBorderColors[cellIndex.x] = mChildBorderColors[childX].mRight;
|
|
}
|
|
if (NO_COLOR == horBorderColors[cellIndex.y]) {
|
|
horBorderColors[cellIndex.y] = mChildBorderColors[childX].mBottom;
|
|
}
|
|
if ((cellIndex.x > 0) && (NO_COLOR == verBorderColors[cellIndex.x-1])) {
|
|
verBorderColors[cellIndex.x-1] = mChildBorderColors[childX].mLeft;
|
|
}
|
|
if ((cellIndex.y > 0) && (NO_COLOR == horBorderColors[cellIndex.y-1])) {
|
|
horBorderColors[cellIndex.y-1] = mChildBorderColors[childX].mTop;
|
|
}
|
|
}
|
|
lastRow = cellIndex.y;
|
|
lastCol = cellIndex.x;
|
|
lastSize = size;
|
|
offset.x += size.width;
|
|
child = child->GetNextSibling();
|
|
}
|
|
|
|
if (firstTime) {
|
|
nscolor childColor;
|
|
// set the visibility, color, mouse sensitivity of borders
|
|
for (int verX = 0; verX < mNumCols-1; verX++) {
|
|
if (mVerBorders[verX]) {
|
|
mVerBorders[verX]->SetVisibility(verBordersVis[verX]);
|
|
SetBorderResize(mVerBorders[verX]);
|
|
childColor = (NO_COLOR == verBorderColors[verX]) ? borderColor : verBorderColors[verX];
|
|
mVerBorders[verX]->SetColor(childColor);
|
|
}
|
|
}
|
|
for (int horX = 0; horX < mNumRows-1; horX++) {
|
|
if (mHorBorders[horX]) {
|
|
mHorBorders[horX]->SetVisibility(horBordersVis[horX]);
|
|
SetBorderResize(mHorBorders[horX]);
|
|
childColor = (NO_COLOR == horBorderColors[horX]) ? borderColor : horBorderColors[horX];
|
|
mHorBorders[horX]->SetColor(childColor);
|
|
}
|
|
}
|
|
|
|
mChildFrameborder.reset();
|
|
mChildBorderColors.reset();
|
|
}
|
|
|
|
mDrag.UnSet();
|
|
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
FinishAndStoreOverflow(&aDesiredSize);
|
|
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult
|
|
nsHTMLFramesetFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("Frameset"), aResult);
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
nsHTMLFramesetFrame::CanResize(bool aVertical,
|
|
bool aLeft)
|
|
{
|
|
int32_t childX;
|
|
int32_t startX;
|
|
if (aVertical) {
|
|
startX = (aLeft) ? 0 : mNumCols-1;
|
|
for (childX = startX; childX < mNonBorderChildCount; childX += mNumCols) {
|
|
if (!CanChildResize(aVertical, aLeft, childX)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
startX = (aLeft) ? 0 : (mNumRows - 1) * mNumCols;
|
|
int32_t endX = startX + mNumCols;
|
|
for (childX = startX; childX < endX; childX++) {
|
|
if (!CanChildResize(aVertical, aLeft, childX)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsHTMLFramesetFrame::GetNoResize(nsIFrame* aChildFrame)
|
|
{
|
|
nsIContent* content = aChildFrame->GetContent();
|
|
|
|
return content &&
|
|
content->IsElement() &&
|
|
content->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::noresize);
|
|
}
|
|
|
|
bool
|
|
nsHTMLFramesetFrame::CanChildResize(bool aVertical, bool aLeft, int32_t aChildX)
|
|
{
|
|
nsIFrame* child = mFrames.FrameAt(aChildX);
|
|
nsHTMLFramesetFrame* frameset = do_QueryFrame(child);
|
|
return frameset ? frameset->CanResize(aVertical, aLeft) : !GetNoResize(child);
|
|
}
|
|
|
|
// This calculates and sets the resizability of all border frames
|
|
|
|
void
|
|
nsHTMLFramesetFrame::RecalculateBorderResize()
|
|
{
|
|
if (!mContent) {
|
|
return;
|
|
}
|
|
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Check for overflow");
|
|
static_assert(NS_MAX_FRAMESET_SPEC_COUNT
|
|
< UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT,
|
|
"Check for overflow");
|
|
// set the visibility and mouse sensitivity of borders
|
|
int32_t verX;
|
|
for (verX = 0; verX < mNumCols-1; verX++) {
|
|
if (mVerBorders[verX]) {
|
|
mVerBorders[verX]->mCanResize = true;
|
|
SetBorderResize(mVerBorders[verX]);
|
|
}
|
|
}
|
|
int32_t horX;
|
|
for (horX = 0; horX < mNumRows-1; horX++) {
|
|
if (mHorBorders[horX]) {
|
|
mHorBorders[horX]->mCanResize = true;
|
|
SetBorderResize(mHorBorders[horX]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::SetBorderResize(nsHTMLFramesetBorderFrame* aBorderFrame)
|
|
{
|
|
if (aBorderFrame->mVertical) {
|
|
for (int rowX = 0; rowX < mNumRows; rowX++) {
|
|
int32_t childX = aBorderFrame->mPrevNeighbor + (rowX * mNumCols);
|
|
if (!CanChildResize(true, false, childX) ||
|
|
!CanChildResize(true, true, childX+1)) {
|
|
aBorderFrame->mCanResize = false;
|
|
}
|
|
}
|
|
} else {
|
|
int32_t childX = aBorderFrame->mPrevNeighbor * mNumCols;
|
|
int32_t endX = childX + mNumCols;
|
|
for (; childX < endX; childX++) {
|
|
if (!CanChildResize(false, false, childX)) {
|
|
aBorderFrame->mCanResize = false;
|
|
}
|
|
}
|
|
endX = endX + mNumCols;
|
|
for (; childX < endX; childX++) {
|
|
if (!CanChildResize(false, true, childX)) {
|
|
aBorderFrame->mCanResize = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::StartMouseDrag(nsPresContext* aPresContext,
|
|
nsHTMLFramesetBorderFrame* aBorder,
|
|
WidgetGUIEvent* aEvent)
|
|
{
|
|
#if 0
|
|
int32_t index;
|
|
IndexOf(aBorder, index);
|
|
NS_ASSERTION((nullptr != aBorder) && (index >= 0), "invalid dragger");
|
|
#endif
|
|
|
|
nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);
|
|
|
|
mDragger = aBorder;
|
|
|
|
mFirstDragPoint = aEvent->mRefPoint;
|
|
|
|
// Store the original frame sizes
|
|
if (mDragger->mVertical) {
|
|
mPrevNeighborOrigSize = mColSizes[mDragger->mPrevNeighbor];
|
|
mNextNeighborOrigSize = mColSizes[mDragger->mNextNeighbor];
|
|
} else {
|
|
mPrevNeighborOrigSize = mRowSizes[mDragger->mPrevNeighbor];
|
|
mNextNeighborOrigSize = mRowSizes[mDragger->mNextNeighbor];
|
|
}
|
|
|
|
gDragInProgress = true;
|
|
}
|
|
|
|
|
|
void
|
|
nsHTMLFramesetFrame::MouseDrag(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent)
|
|
{
|
|
// if the capture ended, reset the drag state
|
|
if (nsIPresShell::GetCapturingContent() != GetContent()) {
|
|
mDragger = nullptr;
|
|
gDragInProgress = false;
|
|
return;
|
|
}
|
|
|
|
int32_t change; // measured positive from left-to-right or top-to-bottom
|
|
AutoWeakFrame weakFrame(this);
|
|
if (mDragger->mVertical) {
|
|
change = aPresContext->DevPixelsToAppUnits(
|
|
aEvent->mRefPoint.x - mFirstDragPoint.x);
|
|
if (change > mNextNeighborOrigSize - mMinDrag) {
|
|
change = mNextNeighborOrigSize - mMinDrag;
|
|
} else if (change <= mMinDrag - mPrevNeighborOrigSize) {
|
|
change = mMinDrag - mPrevNeighborOrigSize;
|
|
}
|
|
mColSizes[mDragger->mPrevNeighbor] = mPrevNeighborOrigSize + change;
|
|
mColSizes[mDragger->mNextNeighbor] = mNextNeighborOrigSize - change;
|
|
|
|
if (change != 0) {
|
|
// Recompute the specs from the new sizes.
|
|
nscoord width = mRect.width - (mNumCols - 1) * GetBorderWidth(aPresContext, true);
|
|
HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
|
|
NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
|
|
const nsFramesetSpec* colSpecs = nullptr;
|
|
ourContent->GetColSpec(&mNumCols, &colSpecs);
|
|
nsAutoString newColAttr;
|
|
GenerateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get(),
|
|
newColAttr);
|
|
// Setting the attr will trigger a reflow
|
|
mContent->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::cols,
|
|
newColAttr, true);
|
|
}
|
|
} else {
|
|
change = aPresContext->DevPixelsToAppUnits(
|
|
aEvent->mRefPoint.y - mFirstDragPoint.y);
|
|
if (change > mNextNeighborOrigSize - mMinDrag) {
|
|
change = mNextNeighborOrigSize - mMinDrag;
|
|
} else if (change <= mMinDrag - mPrevNeighborOrigSize) {
|
|
change = mMinDrag - mPrevNeighborOrigSize;
|
|
}
|
|
mRowSizes[mDragger->mPrevNeighbor] = mPrevNeighborOrigSize + change;
|
|
mRowSizes[mDragger->mNextNeighbor] = mNextNeighborOrigSize - change;
|
|
|
|
if (change != 0) {
|
|
// Recompute the specs from the new sizes.
|
|
nscoord height = mRect.height - (mNumRows - 1) * GetBorderWidth(aPresContext, true);
|
|
HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);
|
|
NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
|
|
const nsFramesetSpec* rowSpecs = nullptr;
|
|
ourContent->GetRowSpec(&mNumRows, &rowSpecs);
|
|
nsAutoString newRowAttr;
|
|
GenerateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get(),
|
|
newRowAttr);
|
|
// Setting the attr will trigger a reflow
|
|
mContent->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::rows,
|
|
newRowAttr, true);
|
|
}
|
|
}
|
|
|
|
NS_ENSURE_TRUE_VOID(weakFrame.IsAlive());
|
|
if (change != 0) {
|
|
mDrag.Reset(mDragger->mVertical, mDragger->mPrevNeighbor, change, this);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetFrame::EndMouseDrag(nsPresContext* aPresContext)
|
|
{
|
|
nsIPresShell::SetCapturingContent(nullptr, 0);
|
|
mDragger = nullptr;
|
|
gDragInProgress = false;
|
|
}
|
|
|
|
nsIFrame*
|
|
NS_NewHTMLFramesetFrame(nsIPresShell* aPresShell, ComputedStyle* aStyle)
|
|
{
|
|
#ifdef DEBUG
|
|
const nsStyleDisplay* disp = aStyle->StyleDisplay();
|
|
NS_ASSERTION(!disp->IsAbsolutelyPositionedStyle() && !disp->IsFloatingStyle(),
|
|
"Framesets should not be positioned and should not float");
|
|
#endif
|
|
|
|
return new (aPresShell) nsHTMLFramesetFrame(aStyle);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetFrame)
|
|
|
|
/*******************************************************************************
|
|
* nsHTMLFramesetBorderFrame
|
|
******************************************************************************/
|
|
nsHTMLFramesetBorderFrame::nsHTMLFramesetBorderFrame(ComputedStyle* aStyle,
|
|
int32_t aWidth,
|
|
bool aVertical,
|
|
bool aVisibility)
|
|
: nsLeafFrame(aStyle, kClassID)
|
|
, mWidth(aWidth)
|
|
, mVertical(aVertical)
|
|
, mVisibility(aVisibility)
|
|
{
|
|
mCanResize = true;
|
|
mColor = NO_COLOR;
|
|
mPrevNeighbor = 0;
|
|
mNextNeighbor = 0;
|
|
}
|
|
|
|
nsHTMLFramesetBorderFrame::~nsHTMLFramesetBorderFrame()
|
|
{
|
|
//printf("nsHTMLFramesetBorderFrame destructor %p \n", this);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetBorderFrame)
|
|
|
|
nscoord nsHTMLFramesetBorderFrame::GetIntrinsicISize()
|
|
{
|
|
// No intrinsic width
|
|
return 0;
|
|
}
|
|
|
|
nscoord nsHTMLFramesetBorderFrame::GetIntrinsicBSize()
|
|
{
|
|
// No intrinsic height
|
|
return 0;
|
|
}
|
|
|
|
void nsHTMLFramesetBorderFrame::SetVisibility(bool aVisibility)
|
|
{
|
|
mVisibility = aVisibility;
|
|
}
|
|
|
|
void nsHTMLFramesetBorderFrame::SetColor(nscolor aColor)
|
|
{
|
|
mColor = aColor;
|
|
}
|
|
|
|
|
|
void
|
|
nsHTMLFramesetBorderFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBorderFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
// Override Reflow(), since we don't want to deal with what our
|
|
// computed values are.
|
|
SizeToAvailSize(aReflowInput, aDesiredSize);
|
|
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
}
|
|
|
|
class nsDisplayFramesetBorder : public nsDisplayItem {
|
|
public:
|
|
nsDisplayFramesetBorder(nsDisplayListBuilder* aBuilder,
|
|
nsHTMLFramesetBorderFrame* aFrame)
|
|
: nsDisplayItem(aBuilder, aFrame) {
|
|
MOZ_COUNT_CTOR(nsDisplayFramesetBorder);
|
|
}
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
virtual ~nsDisplayFramesetBorder() {
|
|
MOZ_COUNT_DTOR(nsDisplayFramesetBorder);
|
|
}
|
|
#endif
|
|
|
|
// REVIEW: see old GetFrameForPoint
|
|
// Receives events in its bounds
|
|
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
|
|
HitTestState* aState,
|
|
nsTArray<nsIFrame*> *aOutFrames) override {
|
|
aOutFrames->AppendElement(mFrame);
|
|
}
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
gfxContext* aCtx) override;
|
|
NS_DISPLAY_DECL_NAME("FramesetBorder", TYPE_FRAMESET_BORDER)
|
|
};
|
|
|
|
void nsDisplayFramesetBorder::Paint(nsDisplayListBuilder* aBuilder,
|
|
gfxContext* aCtx)
|
|
{
|
|
static_cast<nsHTMLFramesetBorderFrame*>(mFrame)->
|
|
PaintBorder(aCtx->GetDrawTarget(), ToReferenceFrame());
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetBorderFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
aLists.Content()->AppendToTop(
|
|
MakeDisplayItem<nsDisplayFramesetBorder>(aBuilder, this));
|
|
}
|
|
|
|
void nsHTMLFramesetBorderFrame::PaintBorder(DrawTarget* aDrawTarget,
|
|
nsPoint aPt)
|
|
{
|
|
nscoord widthInPixels = nsPresContext::AppUnitsToIntCSSPixels(mWidth);
|
|
nscoord pixelWidth = nsPresContext::CSSPixelsToAppUnits(1);
|
|
|
|
if (widthInPixels <= 0)
|
|
return;
|
|
|
|
ColorPattern bgColor(ToDeviceColor(
|
|
LookAndFeel::GetColor(LookAndFeel::eColorID_WidgetBackground,
|
|
NS_RGB(200, 200, 200))));
|
|
|
|
ColorPattern fgColor(ToDeviceColor(
|
|
LookAndFeel::GetColor(LookAndFeel::eColorID_WidgetForeground,
|
|
NS_RGB(0, 0, 0))));
|
|
|
|
ColorPattern hltColor(ToDeviceColor(
|
|
LookAndFeel::GetColor(LookAndFeel::eColorID_Widget3DHighlight,
|
|
NS_RGB(255, 255, 255))));
|
|
|
|
ColorPattern sdwColor(ToDeviceColor(
|
|
LookAndFeel::GetColor(LookAndFeel::eColorID_Widget3DShadow,
|
|
NS_RGB(128, 128, 128))));
|
|
|
|
ColorPattern color(ToDeviceColor(NS_RGB(255, 255, 255))); // default to white
|
|
if (mVisibility) {
|
|
color = (NO_COLOR == mColor) ? bgColor :
|
|
ColorPattern(ToDeviceColor(mColor));
|
|
}
|
|
|
|
int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
|
|
|
|
Point toRefFrame = NSPointToPoint(aPt, appUnitsPerDevPixel);
|
|
|
|
AutoRestoreTransform autoRestoreTransform(aDrawTarget);
|
|
aDrawTarget->SetTransform(
|
|
aDrawTarget->GetTransform().PreTranslate(toRefFrame));
|
|
|
|
nsPoint start(0, 0);
|
|
nsPoint end = mVertical ? nsPoint(0, mRect.height) : nsPoint(mRect.width, 0);
|
|
|
|
// draw grey or white first
|
|
for (int i = 0; i < widthInPixels; i++) {
|
|
StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
|
|
color);
|
|
if (mVertical) {
|
|
start.x += pixelWidth;
|
|
end.x = start.x;
|
|
} else {
|
|
start.y += pixelWidth;
|
|
end.y = start.y;
|
|
}
|
|
}
|
|
|
|
if (!mVisibility)
|
|
return;
|
|
|
|
if (widthInPixels >= 5) {
|
|
start.x = (mVertical) ? pixelWidth : 0;
|
|
start.y = (mVertical) ? 0 : pixelWidth;
|
|
end.x = (mVertical) ? start.x : mRect.width;
|
|
end.y = (mVertical) ? mRect.height : start.y;
|
|
StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
|
|
hltColor);
|
|
}
|
|
|
|
if (widthInPixels >= 2) {
|
|
start.x = (mVertical) ? mRect.width - (2 * pixelWidth) : 0;
|
|
start.y = (mVertical) ? 0 : mRect.height - (2 * pixelWidth);
|
|
end.x = (mVertical) ? start.x : mRect.width;
|
|
end.y = (mVertical) ? mRect.height : start.y;
|
|
StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
|
|
sdwColor);
|
|
}
|
|
|
|
if (widthInPixels >= 1) {
|
|
start.x = (mVertical) ? mRect.width - pixelWidth : 0;
|
|
start.y = (mVertical) ? 0 : mRect.height - pixelWidth;
|
|
end.x = (mVertical) ? start.x : mRect.width;
|
|
end.y = (mVertical) ? mRect.height : start.y;
|
|
StrokeLineWithSnapping(start, end, appUnitsPerDevPixel, *aDrawTarget,
|
|
fgColor);
|
|
}
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsHTMLFramesetBorderFrame::HandleEvent(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aEventStatus);
|
|
*aEventStatus = nsEventStatus_eIgnore;
|
|
|
|
//XXX Mouse setting logic removed. The remaining logic should also move.
|
|
if (!mCanResize) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aEvent->mMessage == eMouseDown &&
|
|
aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
|
|
nsHTMLFramesetFrame* parentFrame = do_QueryFrame(GetParent());
|
|
if (parentFrame) {
|
|
parentFrame->StartMouseDrag(aPresContext, this, aEvent);
|
|
*aEventStatus = nsEventStatus_eConsumeNoDefault;
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsHTMLFramesetBorderFrame::GetCursor(const nsPoint& aPoint,
|
|
nsIFrame::Cursor& aCursor)
|
|
{
|
|
aCursor.mLoading = false;
|
|
if (!mCanResize) {
|
|
aCursor.mCursor = NS_STYLE_CURSOR_DEFAULT;
|
|
} else {
|
|
aCursor.mCursor = (mVertical) ? NS_STYLE_CURSOR_EW_RESIZE : NS_STYLE_CURSOR_NS_RESIZE;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult nsHTMLFramesetBorderFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("FramesetBorder"), aResult);
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* nsHTMLFramesetBlankFrame
|
|
******************************************************************************/
|
|
|
|
NS_QUERYFRAME_HEAD(nsHTMLFramesetBlankFrame)
|
|
NS_QUERYFRAME_ENTRY(nsHTMLFramesetBlankFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsLeafFrame)
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsHTMLFramesetBlankFrame)
|
|
|
|
nsHTMLFramesetBlankFrame::~nsHTMLFramesetBlankFrame()
|
|
{
|
|
//printf("nsHTMLFramesetBlankFrame destructor %p \n", this);
|
|
}
|
|
|
|
nscoord nsHTMLFramesetBlankFrame::GetIntrinsicISize()
|
|
{
|
|
// No intrinsic width
|
|
return 0;
|
|
}
|
|
|
|
nscoord nsHTMLFramesetBlankFrame::GetIntrinsicBSize()
|
|
{
|
|
// No intrinsic height
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetBlankFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBlankFrame");
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
// Override Reflow(), since we don't want to deal with what our
|
|
// computed values are.
|
|
SizeToAvailSize(aReflowInput, aDesiredSize);
|
|
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
}
|
|
|
|
class nsDisplayFramesetBlank : public nsDisplayItem {
|
|
public:
|
|
nsDisplayFramesetBlank(nsDisplayListBuilder* aBuilder,
|
|
nsIFrame* aFrame) :
|
|
nsDisplayItem(aBuilder, aFrame) {
|
|
MOZ_COUNT_CTOR(nsDisplayFramesetBlank);
|
|
}
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
virtual ~nsDisplayFramesetBlank() {
|
|
MOZ_COUNT_DTOR(nsDisplayFramesetBlank);
|
|
}
|
|
#endif
|
|
|
|
virtual void Paint(nsDisplayListBuilder* aBuilder,
|
|
gfxContext* aCtx) override;
|
|
NS_DISPLAY_DECL_NAME("FramesetBlank", TYPE_FRAMESET_BLANK)
|
|
};
|
|
|
|
void nsDisplayFramesetBlank::Paint(nsDisplayListBuilder* aBuilder,
|
|
gfxContext* aCtx)
|
|
{
|
|
DrawTarget* drawTarget = aCtx->GetDrawTarget();
|
|
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
|
|
Rect rect =
|
|
NSRectToSnappedRect(GetPaintRect(), appUnitsPerDevPixel, *drawTarget);
|
|
ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f)));
|
|
drawTarget->FillRect(rect, white);
|
|
}
|
|
|
|
void
|
|
nsHTMLFramesetBlankFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
aLists.Content()->AppendToTop(
|
|
MakeDisplayItem<nsDisplayFramesetBlank>(aBuilder, this));
|
|
}
|