mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1653 lines
49 KiB
C++
1653 lines
49 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/. */
|
|
|
|
//
|
|
// Eric Vaughan
|
|
// Netscape Communications
|
|
//
|
|
// See documentation in associated header file
|
|
//
|
|
|
|
#include "nsBoxLayoutState.h"
|
|
#include "nsSprocketLayout.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsBoxFrame.h"
|
|
#include "StackArena.h"
|
|
#include "mozilla/Likely.h"
|
|
#include <algorithm>
|
|
|
|
nsBoxLayout* nsSprocketLayout::gInstance = nullptr;
|
|
|
|
//#define DEBUG_GROW
|
|
|
|
#define DEBUG_SPRING_SIZE 8
|
|
#define DEBUG_BORDER_SIZE 2
|
|
#define COIL_SIZE 8
|
|
|
|
|
|
nsresult
|
|
NS_NewSprocketLayout( nsIPresShell* aPresShell, nsCOMPtr<nsBoxLayout>& aNewLayout)
|
|
{
|
|
if (!nsSprocketLayout::gInstance) {
|
|
nsSprocketLayout::gInstance = new nsSprocketLayout();
|
|
NS_IF_ADDREF(nsSprocketLayout::gInstance);
|
|
}
|
|
// we have not instance variables so just return our static one.
|
|
aNewLayout = nsSprocketLayout::gInstance;
|
|
return NS_OK;
|
|
}
|
|
|
|
/*static*/ void
|
|
nsSprocketLayout::Shutdown()
|
|
{
|
|
NS_IF_RELEASE(gInstance);
|
|
}
|
|
|
|
nsSprocketLayout::nsSprocketLayout()
|
|
{
|
|
}
|
|
|
|
bool
|
|
nsSprocketLayout::IsHorizontal(nsIFrame* aBox)
|
|
{
|
|
return (aBox->GetStateBits() & NS_STATE_IS_HORIZONTAL) != 0;
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::GetFrameState(nsIFrame* aBox, nsFrameState& aState)
|
|
{
|
|
aState = aBox->GetStateBits();
|
|
}
|
|
|
|
static uint8_t
|
|
GetFrameDirection(nsIFrame* aBox)
|
|
{
|
|
return aBox->StyleVisibility()->mDirection;
|
|
}
|
|
|
|
static void
|
|
HandleBoxPack(nsIFrame* aBox, const nsFrameState& aFrameState, nscoord& aX, nscoord& aY,
|
|
const nsRect& aOriginalRect, const nsRect& aClientRect)
|
|
{
|
|
// In the normal direction we lay out our kids in the positive direction (e.g., |x| will get
|
|
// bigger for a horizontal box, and |y| will get bigger for a vertical box). In the reverse
|
|
// direction, the opposite is true. We'll be laying out each child at a smaller |x| or
|
|
// |y|.
|
|
uint8_t frameDirection = GetFrameDirection(aBox);
|
|
|
|
if (aFrameState & NS_STATE_IS_HORIZONTAL) {
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
|
|
// The normal direction. |x| increases as we move through our children.
|
|
aX = aClientRect.x;
|
|
}
|
|
else {
|
|
// The reverse direction. |x| decreases as we move through our children.
|
|
aX = aClientRect.x + aOriginalRect.width;
|
|
}
|
|
// |y| is always in the normal direction in horizontal boxes
|
|
aY = aClientRect.y;
|
|
}
|
|
else {
|
|
// take direction property into account for |x| in vertical boxes
|
|
if (frameDirection == NS_STYLE_DIRECTION_LTR) {
|
|
// The normal direction. |x| increases as we move through our children.
|
|
aX = aClientRect.x;
|
|
}
|
|
else {
|
|
// The reverse direction. |x| decreases as we move through our children.
|
|
aX = aClientRect.x + aOriginalRect.width;
|
|
}
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
|
|
// The normal direction. |y| increases as we move through our children.
|
|
aY = aClientRect.y;
|
|
}
|
|
else {
|
|
// The reverse direction. |y| decreases as we move through our children.
|
|
aY = aClientRect.y + aOriginalRect.height;
|
|
}
|
|
}
|
|
|
|
// Get our pack/alignment information.
|
|
nsIFrame::Halignment halign = aBox->GetHAlign();
|
|
nsIFrame::Valignment valign = aBox->GetVAlign();
|
|
|
|
// The following code handles box PACKING. Packing comes into play in the case where the computed size for
|
|
// all of our children (now stored in our client rect) is smaller than the size available for
|
|
// the box (stored in |aOriginalRect|).
|
|
//
|
|
// Here we adjust our |x| and |y| variables accordingly so that we start at the beginning,
|
|
// middle, or end of the box.
|
|
//
|
|
// XXXdwh JUSTIFY needs to be implemented!
|
|
if (aFrameState & NS_STATE_IS_HORIZONTAL) {
|
|
switch(halign) {
|
|
case nsBoxFrame::hAlign_Left:
|
|
break; // Nothing to do. The default initialized us properly.
|
|
|
|
case nsBoxFrame::hAlign_Center:
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aX += (aOriginalRect.width - aClientRect.width)/2;
|
|
else
|
|
aX -= (aOriginalRect.width - aClientRect.width)/2;
|
|
break;
|
|
|
|
case nsBoxFrame::hAlign_Right:
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aX += (aOriginalRect.width - aClientRect.width);
|
|
else
|
|
aX -= (aOriginalRect.width - aClientRect.width);
|
|
break; // Nothing to do for the reverse dir. The default initialized us properly.
|
|
}
|
|
} else {
|
|
switch(valign) {
|
|
case nsBoxFrame::vAlign_Top:
|
|
case nsBoxFrame::vAlign_BaseLine: // This value is technically impossible to specify for pack.
|
|
break; // Don't do anything. We were initialized correctly.
|
|
|
|
case nsBoxFrame::vAlign_Middle:
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aY += (aOriginalRect.height - aClientRect.height)/2;
|
|
else
|
|
aY -= (aOriginalRect.height - aClientRect.height)/2;
|
|
break;
|
|
|
|
case nsBoxFrame::vAlign_Bottom:
|
|
if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aY += (aOriginalRect.height - aClientRect.height);
|
|
else
|
|
aY -= (aOriginalRect.height - aClientRect.height);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSprocketLayout::Layout(nsIFrame* aBox, nsBoxLayoutState& aState)
|
|
{
|
|
// See if we are collapsed. If we are, then simply iterate over all our
|
|
// children and give them a rect of 0 width and height.
|
|
if (aBox->IsCollapsed()) {
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
while(child)
|
|
{
|
|
nsBoxFrame::LayoutChildAt(aState, child, nsRect(0,0,0,0));
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsBoxLayoutState::AutoReflowDepth depth(aState);
|
|
mozilla::AutoStackArena arena;
|
|
|
|
// ----- figure out our size ----------
|
|
const nsSize originalSize = aBox->GetSize();
|
|
|
|
// -- make sure we remove our border and padding ----
|
|
nsRect clientRect;
|
|
aBox->GetClientRect(clientRect);
|
|
|
|
// |originalClientRect| represents the rect of the entire box (excluding borders
|
|
// and padding). We store it here because we're going to use |clientRect| to hold
|
|
// the required size for all our kids. As an example, consider an hbox with a
|
|
// specified width of 300. If the kids total only 150 pixels of width, then
|
|
// we have 150 pixels left over. |clientRect| is going to hold a width of 150 and
|
|
// is going to be adjusted based off the value of the PACK property. If flexible
|
|
// objects are in the box, then the two rects will match.
|
|
nsRect originalClientRect(clientRect);
|
|
|
|
// The frame state contains cached knowledge about our box, such as our orientation
|
|
// and direction.
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
|
|
// Build a list of our children's desired sizes and computed sizes
|
|
nsBoxSize* boxSizes = nullptr;
|
|
nsComputedBoxSize* computedBoxSizes = nullptr;
|
|
|
|
nscoord min = 0;
|
|
nscoord max = 0;
|
|
int32_t flexes = 0;
|
|
PopulateBoxSizes(aBox, aState, boxSizes, min, max, flexes);
|
|
|
|
// The |size| variable will hold the total size of children along the axis of
|
|
// the box. Continuing with the example begun in the comment above, size would
|
|
// be 150 pixels.
|
|
nscoord size = clientRect.width;
|
|
if (!IsHorizontal(aBox))
|
|
size = clientRect.height;
|
|
ComputeChildSizes(aBox, aState, size, boxSizes, computedBoxSizes);
|
|
|
|
// After the call to ComputeChildSizes, the |size| variable contains the
|
|
// total required size of all the children. We adjust our clientRect in the
|
|
// appropriate dimension to match this size. In our example, we now assign
|
|
// 150 pixels into the clientRect.width.
|
|
//
|
|
// The variables |min| and |max| hold the minimum required size box must be
|
|
// in the OPPOSITE orientation, e.g., for a horizontal box, |min| is the minimum
|
|
// height we require to enclose our children, and |max| is the maximum height
|
|
// required to enclose our children.
|
|
if (IsHorizontal(aBox)) {
|
|
clientRect.width = size;
|
|
if (clientRect.height < min)
|
|
clientRect.height = min;
|
|
|
|
if (frameState & NS_STATE_AUTO_STRETCH) {
|
|
if (clientRect.height > max)
|
|
clientRect.height = max;
|
|
}
|
|
} else {
|
|
clientRect.height = size;
|
|
if (clientRect.width < min)
|
|
clientRect.width = min;
|
|
|
|
if (frameState & NS_STATE_AUTO_STRETCH) {
|
|
if (clientRect.width > max)
|
|
clientRect.width = max;
|
|
}
|
|
}
|
|
|
|
// With the sizes computed, now it's time to lay out our children.
|
|
bool finished;
|
|
nscoord passes = 0;
|
|
|
|
// We flow children at their preferred locations (along with the appropriate computed flex).
|
|
// After we flow a child, it is possible that the child will change its size. If/when this happens,
|
|
// we have to do another pass. Typically only 2 passes are required, but the code is prepared to
|
|
// do as many passes as are necessary to achieve equilibrium.
|
|
nscoord x = 0;
|
|
nscoord y = 0;
|
|
nscoord origX = 0;
|
|
nscoord origY = 0;
|
|
|
|
// |childResized| lets us know if a child changed its size after we attempted to lay it out at
|
|
// the specified size. If this happens, we usually have to do another pass.
|
|
bool childResized = false;
|
|
|
|
// |passes| stores our number of passes. If for any reason we end up doing more than, say, 10
|
|
// passes, we assert to indicate that something is seriously screwed up.
|
|
passes = 0;
|
|
do
|
|
{
|
|
#ifdef DEBUG_REFLOW
|
|
if (passes > 0) {
|
|
AddIndents();
|
|
printf("ChildResized doing pass: %d\n", passes);
|
|
}
|
|
#endif
|
|
|
|
// Always assume that we're done. This will change if, for example, children don't stay
|
|
// the same size after being flowed.
|
|
finished = true;
|
|
|
|
// Handle box packing.
|
|
HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
|
|
|
|
// Now that packing is taken care of we set up a few additional
|
|
// tracking variables.
|
|
origX = x;
|
|
origY = y;
|
|
|
|
// Now we iterate over our box children and our box size lists in
|
|
// parallel. For each child, we look at its sizes and figure out
|
|
// where to place it.
|
|
nsComputedBoxSize* childComputedBoxSize = computedBoxSizes;
|
|
nsBoxSize* childBoxSize = boxSizes;
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
|
|
int32_t count = 0;
|
|
while (child || (childBoxSize && childBoxSize->bogus))
|
|
{
|
|
// If for some reason, our lists are not the same length, we guard
|
|
// by bailing out of the loop.
|
|
if (childBoxSize == nullptr) {
|
|
NS_NOTREACHED("Lists not the same length.");
|
|
break;
|
|
}
|
|
|
|
nscoord width = clientRect.width;
|
|
nscoord height = clientRect.height;
|
|
|
|
if (!childBoxSize->bogus) {
|
|
// We have a valid box size entry. This entry already contains information about our
|
|
// sizes along the axis of the box (e.g., widths in a horizontal box). If our default
|
|
// ALIGN is not stretch, however, then we also need to know the child's size along the
|
|
// opposite axis.
|
|
if (!(frameState & NS_STATE_AUTO_STRETCH)) {
|
|
nsSize prefSize = child->GetPrefSize(aState);
|
|
nsSize minSize = child->GetMinSize(aState);
|
|
nsSize maxSize = child->GetMaxSize(aState);
|
|
prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
|
|
|
|
AddMargin(child, prefSize);
|
|
width = std::min(prefSize.width, originalClientRect.width);
|
|
height = std::min(prefSize.height, originalClientRect.height);
|
|
}
|
|
}
|
|
|
|
// Obtain the computed size along the axis of the box for this child from the computedBoxSize entry.
|
|
// We store the result in |width| for horizontal boxes and |height| for vertical boxes.
|
|
if (frameState & NS_STATE_IS_HORIZONTAL)
|
|
width = childComputedBoxSize->size;
|
|
else
|
|
height = childComputedBoxSize->size;
|
|
|
|
// Adjust our x/y for the left/right spacing.
|
|
if (frameState & NS_STATE_IS_HORIZONTAL) {
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
x += (childBoxSize->left);
|
|
else
|
|
x -= (childBoxSize->right);
|
|
} else {
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
y += (childBoxSize->left);
|
|
else
|
|
y -= (childBoxSize->right);
|
|
}
|
|
|
|
// Now we build a child rect.
|
|
nscoord rectX = x;
|
|
nscoord rectY = y;
|
|
if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
|
|
if (frameState & NS_STATE_IS_HORIZONTAL)
|
|
rectX -= width;
|
|
else
|
|
rectY -= height;
|
|
}
|
|
|
|
// We now create an accurate child rect based off our computed size information.
|
|
nsRect childRect(rectX, rectY, width, height);
|
|
|
|
// Sanity check against our clientRect. It is possible that a child specified
|
|
// a size that is too large to fit. If that happens, then we have to grow
|
|
// our client rect. Remember, clientRect is not the total rect of the enclosing
|
|
// box. It currently holds our perception of how big the children needed to
|
|
// be.
|
|
if (childRect.width > clientRect.width)
|
|
clientRect.width = childRect.width;
|
|
|
|
if (childRect.height > clientRect.height)
|
|
clientRect.height = childRect.height;
|
|
|
|
// Either |nextX| or |nextY| is updated by this function call, according
|
|
// to our axis.
|
|
nscoord nextX = x;
|
|
nscoord nextY = y;
|
|
|
|
ComputeChildsNextPosition(aBox, x, y, nextX, nextY, childRect);
|
|
|
|
// Now we further update our nextX/Y along our axis.
|
|
// We also set childRect.y/x along the opposite axis appropriately for a
|
|
// stretch alignment. (Non-stretch alignment is handled below.)
|
|
if (frameState & NS_STATE_IS_HORIZONTAL) {
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
nextX += (childBoxSize->right);
|
|
else
|
|
nextX -= (childBoxSize->left);
|
|
childRect.y = originalClientRect.y;
|
|
}
|
|
else {
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
nextY += (childBoxSize->right);
|
|
else
|
|
nextY -= (childBoxSize->left);
|
|
if (GetFrameDirection(aBox) == NS_STYLE_DIRECTION_LTR) {
|
|
childRect.x = originalClientRect.x;
|
|
} else {
|
|
// keep the right edge of the box the same
|
|
childRect.x = clientRect.x + originalClientRect.width - childRect.width;
|
|
}
|
|
}
|
|
|
|
// If we encounter a completely bogus box size, we just leave this child completely
|
|
// alone and continue through the loop to the next child.
|
|
if (childBoxSize->bogus)
|
|
{
|
|
childComputedBoxSize = childComputedBoxSize->next;
|
|
childBoxSize = childBoxSize->next;
|
|
count++;
|
|
x = nextX;
|
|
y = nextY;
|
|
continue;
|
|
}
|
|
|
|
nsMargin margin(0,0,0,0);
|
|
|
|
bool layout = true;
|
|
|
|
// Deflate the rect of our child by its margin.
|
|
child->GetMargin(margin);
|
|
childRect.Deflate(margin);
|
|
if (childRect.width < 0)
|
|
childRect.width = 0;
|
|
if (childRect.height < 0)
|
|
childRect.height = 0;
|
|
|
|
// Now we're trying to figure out if we have to lay out this child, i.e., to call
|
|
// the child's Layout method.
|
|
if (passes > 0) {
|
|
layout = false;
|
|
} else {
|
|
// Always perform layout if we are dirty or have dirty children
|
|
if (!NS_SUBTREE_DIRTY(child))
|
|
layout = false;
|
|
}
|
|
|
|
nsRect oldRect(child->GetRect());
|
|
|
|
// Non-stretch alignment will be handled in AlignChildren(), so don't
|
|
// change child out-of-axis positions yet.
|
|
if (!(frameState & NS_STATE_AUTO_STRETCH)) {
|
|
if (frameState & NS_STATE_IS_HORIZONTAL) {
|
|
childRect.y = oldRect.y;
|
|
} else {
|
|
childRect.x = oldRect.x;
|
|
}
|
|
}
|
|
|
|
// We computed a childRect. Now we want to set the bounds of the child to be that rect.
|
|
// If our old rect is different, then we know our size changed and we cache that fact
|
|
// in the |sizeChanged| variable.
|
|
|
|
child->SetBounds(aState, childRect);
|
|
bool sizeChanged = (childRect.width != oldRect.width ||
|
|
childRect.height != oldRect.height);
|
|
|
|
if (sizeChanged) {
|
|
// Our size is different. Sanity check against our maximum allowed size to ensure
|
|
// we didn't exceed it.
|
|
nsSize minSize = child->GetMinSize(aState);
|
|
nsSize maxSize = child->GetMaxSize(aState);
|
|
maxSize = nsBox::BoundsCheckMinMax(minSize, maxSize);
|
|
|
|
// make sure the size is in our max size.
|
|
if (childRect.width > maxSize.width)
|
|
childRect.width = maxSize.width;
|
|
|
|
if (childRect.height > maxSize.height)
|
|
childRect.height = maxSize.height;
|
|
|
|
// set it again
|
|
child->SetBounds(aState, childRect);
|
|
}
|
|
|
|
// If we already determined that layout was required or if our size has changed, then
|
|
// we make sure to call layout on the child, since its children may need to be shifted
|
|
// around as a result of the size change.
|
|
if (layout || sizeChanged)
|
|
child->Layout(aState);
|
|
|
|
// If the child was a block or inline (e.g., HTML) it may have changed its rect *during* layout.
|
|
// We have to check for this.
|
|
nsRect newChildRect(child->GetRect());
|
|
|
|
if (!newChildRect.IsEqualInterior(childRect)) {
|
|
#ifdef DEBUG_GROW
|
|
child->DumpBox(stdout);
|
|
printf(" GREW from (%d,%d) -> (%d,%d)\n", childRect.width, childRect.height, newChildRect.width, newChildRect.height);
|
|
#endif
|
|
newChildRect.Inflate(margin);
|
|
childRect.Inflate(margin);
|
|
|
|
// The child changed size during layout. The ChildResized method handles this
|
|
// scenario.
|
|
ChildResized(aBox,
|
|
aState,
|
|
child,
|
|
childBoxSize,
|
|
childComputedBoxSize,
|
|
boxSizes,
|
|
computedBoxSizes,
|
|
childRect,
|
|
newChildRect,
|
|
clientRect,
|
|
flexes,
|
|
finished);
|
|
|
|
// We note that a child changed size, which means that another pass will be required.
|
|
childResized = true;
|
|
|
|
// Now that a child resized, it's entirely possible that OUR rect is too small. Now we
|
|
// ensure that |originalClientRect| is grown to accommodate the size of |clientRect|.
|
|
if (clientRect.width > originalClientRect.width)
|
|
originalClientRect.width = clientRect.width;
|
|
|
|
if (clientRect.height > originalClientRect.height)
|
|
originalClientRect.height = clientRect.height;
|
|
|
|
if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
|
|
// Our childRect had its XMost() or YMost() (depending on our layout
|
|
// direction), positioned at a certain point. Ensure that the
|
|
// newChildRect satisfies the same constraint. Note that this is
|
|
// just equivalent to adjusting the x/y by the difference in
|
|
// width/height between childRect and newChildRect. So we don't need
|
|
// to reaccount for the left and right of the box layout state again.
|
|
if (frameState & NS_STATE_IS_HORIZONTAL)
|
|
newChildRect.x = childRect.XMost() - newChildRect.width;
|
|
else
|
|
newChildRect.y = childRect.YMost() - newChildRect.height;
|
|
}
|
|
|
|
if (!(frameState & NS_STATE_IS_HORIZONTAL)) {
|
|
if (GetFrameDirection(aBox) != NS_STYLE_DIRECTION_LTR) {
|
|
// keep the right edge the same
|
|
newChildRect.x = childRect.XMost() - newChildRect.width;
|
|
}
|
|
}
|
|
|
|
// If the child resized then recompute its position.
|
|
ComputeChildsNextPosition(aBox, x, y, nextX, nextY, newChildRect);
|
|
|
|
if (newChildRect.width >= margin.left + margin.right && newChildRect.height >= margin.top + margin.bottom)
|
|
newChildRect.Deflate(margin);
|
|
|
|
if (childRect.width >= margin.left + margin.right && childRect.height >= margin.top + margin.bottom)
|
|
childRect.Deflate(margin);
|
|
|
|
child->SetBounds(aState, newChildRect);
|
|
|
|
// If we are the first box that changed size, then we don't need to do a second pass
|
|
if (count == 0)
|
|
finished = true;
|
|
}
|
|
|
|
// Now update our x/y finally.
|
|
x = nextX;
|
|
y = nextY;
|
|
|
|
// Move to the next child.
|
|
childComputedBoxSize = childComputedBoxSize->next;
|
|
childBoxSize = childBoxSize->next;
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
count++;
|
|
}
|
|
|
|
// Sanity-checking code to ensure we don't do an infinite # of passes.
|
|
passes++;
|
|
NS_ASSERTION(passes < 10, "A Box's child is constantly growing!!!!!");
|
|
if (passes > 10)
|
|
break;
|
|
} while (false == finished);
|
|
|
|
// Get rid of our size lists.
|
|
while(boxSizes)
|
|
{
|
|
nsBoxSize* toDelete = boxSizes;
|
|
boxSizes = boxSizes->next;
|
|
delete toDelete;
|
|
}
|
|
|
|
while(computedBoxSizes)
|
|
{
|
|
nsComputedBoxSize* toDelete = computedBoxSizes;
|
|
computedBoxSizes = computedBoxSizes->next;
|
|
delete toDelete;
|
|
}
|
|
|
|
if (childResized) {
|
|
// See if one of our children forced us to get bigger
|
|
nsRect tmpClientRect(originalClientRect);
|
|
nsMargin bp(0,0,0,0);
|
|
aBox->GetBorderAndPadding(bp);
|
|
tmpClientRect.Inflate(bp);
|
|
|
|
if (tmpClientRect.width > originalSize.width || tmpClientRect.height > originalSize.height)
|
|
{
|
|
// if it did reset our bounds.
|
|
nsRect bounds(aBox->GetRect());
|
|
if (tmpClientRect.width > originalSize.width)
|
|
bounds.width = tmpClientRect.width;
|
|
|
|
if (tmpClientRect.height > originalSize.height)
|
|
bounds.height = tmpClientRect.height;
|
|
|
|
aBox->SetBounds(aState, bounds);
|
|
}
|
|
}
|
|
|
|
// Because our size grew, we now have to readjust because of box packing. Repack
|
|
// in order to update our x and y to the correct values.
|
|
HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
|
|
|
|
// Compare against our original x and y and only worry about adjusting the children if
|
|
// we really did have to change the positions because of packing (typically for 'center'
|
|
// or 'end' pack values).
|
|
if (x != origX || y != origY) {
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
|
|
// reposition all our children
|
|
while (child)
|
|
{
|
|
nsRect childRect(child->GetRect());
|
|
childRect.x += (x - origX);
|
|
childRect.y += (y - origY);
|
|
child->SetBounds(aState, childRect);
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
}
|
|
|
|
// Perform out-of-axis alignment for non-stretch alignments
|
|
if (!(frameState & NS_STATE_AUTO_STRETCH)) {
|
|
AlignChildren(aBox, aState);
|
|
}
|
|
|
|
// That's it! If you made it this far without having a nervous breakdown,
|
|
// congratulations! Go get yourself a beer.
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::PopulateBoxSizes(nsIFrame* aBox, nsBoxLayoutState& aState, nsBoxSize*& aBoxSizes, nscoord& aMinSize, nscoord& aMaxSize, int32_t& aFlexes)
|
|
{
|
|
// used for the equal size flag
|
|
nscoord biggestPrefWidth = 0;
|
|
nscoord biggestMinWidth = 0;
|
|
nscoord smallestMaxWidth = NS_INTRINSICSIZE;
|
|
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
|
|
//if (frameState & NS_STATE_CURRENTLY_IN_DEBUG)
|
|
// printf("In debug\n");
|
|
|
|
aMinSize = 0;
|
|
aMaxSize = NS_INTRINSICSIZE;
|
|
|
|
bool isHorizontal;
|
|
|
|
if (IsHorizontal(aBox))
|
|
isHorizontal = true;
|
|
else
|
|
isHorizontal = false;
|
|
|
|
// this is a nice little optimization
|
|
// it turns out that if we only have 1 flexable child
|
|
// then it does not matter what its preferred size is
|
|
// there is nothing to flex it relative. This is great
|
|
// because we can avoid asking for a preferred size in this
|
|
// case. Why is this good? Well you might have html inside it
|
|
// and asking html for its preferred size is rather expensive.
|
|
// so we can just optimize it out this way.
|
|
|
|
// set flexes
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
|
|
aFlexes = 0;
|
|
nsBoxSize* currentBox = nullptr;
|
|
|
|
#if 0
|
|
nsBoxSize* start = aBoxSizes;
|
|
|
|
while(child)
|
|
{
|
|
// ok if we started with a list move down the list
|
|
// until we reach the end. Then start looking at childen.
|
|
// This feature is used extensively for Grid.
|
|
nscoord flex = 0;
|
|
|
|
if (!start) {
|
|
if (!currentBox) {
|
|
aBoxSizes = new (aState) nsBoxSize();
|
|
currentBox = aBoxSizes;
|
|
} else {
|
|
currentBox->next = new (aState) nsBoxSize();
|
|
currentBox = currentBox->next;
|
|
}
|
|
|
|
|
|
flex = child->GetFlex(aState);
|
|
|
|
currentBox->flex = flex;
|
|
currentBox->collapsed = child->IsCollapsed();
|
|
} else {
|
|
flex = start->flex;
|
|
start = start->next;
|
|
}
|
|
|
|
if (flex > 0)
|
|
aFlexes++;
|
|
|
|
child = GetNextBox(child);
|
|
}
|
|
#endif
|
|
|
|
// get pref, min, max
|
|
child = nsBox::GetChildBox(aBox);
|
|
currentBox = aBoxSizes;
|
|
nsBoxSize* last = nullptr;
|
|
|
|
nscoord maxFlex = 0;
|
|
int32_t childCount = 0;
|
|
|
|
while(child)
|
|
{
|
|
while (currentBox && currentBox->bogus) {
|
|
last = currentBox;
|
|
currentBox = currentBox->next;
|
|
}
|
|
++childCount;
|
|
nsSize pref(0,0);
|
|
nsSize minSize(0,0);
|
|
nsSize maxSize(NS_INTRINSICSIZE,NS_INTRINSICSIZE);
|
|
nscoord ascent = 0;
|
|
bool collapsed = child->IsCollapsed();
|
|
|
|
if (!collapsed) {
|
|
// only one flexible child? Cool we will just make its preferred size
|
|
// 0 then and not even have to ask for it.
|
|
//if (flexes != 1) {
|
|
|
|
pref = child->GetPrefSize(aState);
|
|
minSize = child->GetMinSize(aState);
|
|
maxSize = nsBox::BoundsCheckMinMax(minSize, child->GetMaxSize(aState));
|
|
ascent = child->GetBoxAscent(aState);
|
|
nsMargin margin;
|
|
child->GetMargin(margin);
|
|
ascent += margin.top;
|
|
//}
|
|
|
|
pref = nsBox::BoundsCheck(minSize, pref, maxSize);
|
|
|
|
AddMargin(child, pref);
|
|
AddMargin(child, minSize);
|
|
AddMargin(child, maxSize);
|
|
}
|
|
|
|
if (!currentBox) {
|
|
// create one.
|
|
currentBox = new (aState) nsBoxSize();
|
|
if (!aBoxSizes) {
|
|
aBoxSizes = currentBox;
|
|
last = aBoxSizes;
|
|
} else {
|
|
last->next = currentBox;
|
|
last = currentBox;
|
|
}
|
|
|
|
nscoord minWidth;
|
|
nscoord maxWidth;
|
|
nscoord prefWidth;
|
|
|
|
// get sizes from child
|
|
if (isHorizontal) {
|
|
minWidth = minSize.width;
|
|
maxWidth = maxSize.width;
|
|
prefWidth = pref.width;
|
|
} else {
|
|
minWidth = minSize.height;
|
|
maxWidth = maxSize.height;
|
|
prefWidth = pref.height;
|
|
}
|
|
|
|
nscoord flex = child->GetFlex(aState);
|
|
|
|
// set them if you collapsed you are not flexible.
|
|
if (collapsed) {
|
|
currentBox->flex = 0;
|
|
}
|
|
else {
|
|
if (flex > maxFlex) {
|
|
maxFlex = flex;
|
|
}
|
|
currentBox->flex = flex;
|
|
}
|
|
|
|
// we specified all our children are equal size;
|
|
if (frameState & NS_STATE_EQUAL_SIZE) {
|
|
|
|
if (prefWidth > biggestPrefWidth)
|
|
biggestPrefWidth = prefWidth;
|
|
|
|
if (minWidth > biggestMinWidth)
|
|
biggestMinWidth = minWidth;
|
|
|
|
if (maxWidth < smallestMaxWidth)
|
|
smallestMaxWidth = maxWidth;
|
|
} else { // not we can set our children right now.
|
|
currentBox->pref = prefWidth;
|
|
currentBox->min = minWidth;
|
|
currentBox->max = maxWidth;
|
|
}
|
|
|
|
NS_ASSERTION(minWidth <= prefWidth && prefWidth <= maxWidth,"Bad min, pref, max widths!");
|
|
|
|
}
|
|
|
|
if (!isHorizontal) {
|
|
if (minSize.width > aMinSize)
|
|
aMinSize = minSize.width;
|
|
|
|
if (maxSize.width < aMaxSize)
|
|
aMaxSize = maxSize.width;
|
|
|
|
} else {
|
|
if (minSize.height > aMinSize)
|
|
aMinSize = minSize.height;
|
|
|
|
if (maxSize.height < aMaxSize)
|
|
aMaxSize = maxSize.height;
|
|
}
|
|
|
|
currentBox->collapsed = collapsed;
|
|
aFlexes += currentBox->flex;
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
|
|
last = currentBox;
|
|
currentBox = currentBox->next;
|
|
|
|
}
|
|
|
|
if (childCount > 0) {
|
|
nscoord maxAllowedFlex = nscoord_MAX / childCount;
|
|
|
|
if (MOZ_UNLIKELY(maxFlex > maxAllowedFlex)) {
|
|
// clamp all the flexes
|
|
currentBox = aBoxSizes;
|
|
while (currentBox) {
|
|
currentBox->flex = std::min(currentBox->flex, maxAllowedFlex);
|
|
currentBox = currentBox->next;
|
|
}
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
else {
|
|
NS_ASSERTION(maxFlex == 0, "How did that happen?");
|
|
}
|
|
#endif
|
|
|
|
// we specified all our children are equal size;
|
|
if (frameState & NS_STATE_EQUAL_SIZE) {
|
|
smallestMaxWidth = std::max(smallestMaxWidth, biggestMinWidth);
|
|
biggestPrefWidth = nsBox::BoundsCheck(biggestMinWidth, biggestPrefWidth, smallestMaxWidth);
|
|
|
|
currentBox = aBoxSizes;
|
|
|
|
while(currentBox)
|
|
{
|
|
if (!currentBox->collapsed) {
|
|
currentBox->pref = biggestPrefWidth;
|
|
currentBox->min = biggestMinWidth;
|
|
currentBox->max = smallestMaxWidth;
|
|
} else {
|
|
currentBox->pref = 0;
|
|
currentBox->min = 0;
|
|
currentBox->max = 0;
|
|
}
|
|
currentBox = currentBox->next;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::ComputeChildsNextPosition(nsIFrame* aBox,
|
|
const nscoord& aCurX,
|
|
const nscoord& aCurY,
|
|
nscoord& aNextX,
|
|
nscoord& aNextY,
|
|
const nsRect& aCurrentChildSize)
|
|
{
|
|
// Get the position along the box axis for the child.
|
|
// The out-of-axis position is not set.
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
|
|
if (IsHorizontal(aBox)) {
|
|
// horizontal box's children.
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aNextX = aCurX + aCurrentChildSize.width;
|
|
else
|
|
aNextX = aCurX - aCurrentChildSize.width;
|
|
|
|
} else {
|
|
// vertical box's children.
|
|
if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
|
|
aNextY = aCurY + aCurrentChildSize.height;
|
|
else
|
|
aNextY = aCurY - aCurrentChildSize.height;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::AlignChildren(nsIFrame* aBox,
|
|
nsBoxLayoutState& aState)
|
|
{
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
bool isHorizontal = (frameState & NS_STATE_IS_HORIZONTAL) != 0;
|
|
nsRect clientRect;
|
|
aBox->GetClientRect(clientRect);
|
|
|
|
NS_PRECONDITION(!(frameState & NS_STATE_AUTO_STRETCH),
|
|
"Only AlignChildren() with non-stretch alignment");
|
|
|
|
// These are only calculated if needed
|
|
nsIFrame::Halignment halign;
|
|
nsIFrame::Valignment valign;
|
|
nscoord maxAscent;
|
|
bool isLTR;
|
|
|
|
if (isHorizontal) {
|
|
valign = aBox->GetVAlign();
|
|
if (valign == nsBoxFrame::vAlign_BaseLine) {
|
|
maxAscent = aBox->GetBoxAscent(aState);
|
|
}
|
|
} else {
|
|
isLTR = GetFrameDirection(aBox) == NS_STYLE_DIRECTION_LTR;
|
|
halign = aBox->GetHAlign();
|
|
}
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
while (child) {
|
|
|
|
nsMargin margin;
|
|
child->GetMargin(margin);
|
|
nsRect childRect = child->GetRect();
|
|
|
|
if (isHorizontal) {
|
|
const nscoord startAlign = clientRect.y + margin.top;
|
|
const nscoord endAlign =
|
|
clientRect.YMost() - margin.bottom - childRect.height;
|
|
|
|
nscoord y;
|
|
switch (valign) {
|
|
case nsBoxFrame::vAlign_Top:
|
|
y = startAlign;
|
|
break;
|
|
case nsBoxFrame::vAlign_Middle:
|
|
// Should this center the border box?
|
|
// This centers the margin box, the historical behavior.
|
|
y = (startAlign + endAlign) / 2;
|
|
break;
|
|
case nsBoxFrame::vAlign_Bottom:
|
|
y = endAlign;
|
|
break;
|
|
case nsBoxFrame::vAlign_BaseLine:
|
|
// Alignments don't force the box to grow (only sizes do),
|
|
// so keep the children within the box.
|
|
y = maxAscent - child->GetBoxAscent(aState);
|
|
y = std::max(startAlign, y);
|
|
y = std::min(y, endAlign);
|
|
break;
|
|
}
|
|
|
|
childRect.y = y;
|
|
|
|
} else { // vertical box
|
|
const nscoord leftAlign = clientRect.x + margin.left;
|
|
const nscoord rightAlign =
|
|
clientRect.XMost() - margin.right - childRect.width;
|
|
|
|
nscoord x;
|
|
switch (halign) {
|
|
case nsBoxFrame::hAlign_Left: // start
|
|
x = isLTR ? leftAlign : rightAlign;
|
|
break;
|
|
case nsBoxFrame::hAlign_Center:
|
|
x = (leftAlign + rightAlign) / 2;
|
|
break;
|
|
case nsBoxFrame::hAlign_Right: // end
|
|
x = isLTR ? rightAlign : leftAlign;
|
|
break;
|
|
}
|
|
|
|
childRect.x = x;
|
|
}
|
|
|
|
if (childRect.TopLeft() != child->GetPosition()) {
|
|
child->SetBounds(aState, childRect);
|
|
}
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::ChildResized(nsIFrame* aBox,
|
|
nsBoxLayoutState& aState,
|
|
nsIFrame* aChild,
|
|
nsBoxSize* aChildBoxSize,
|
|
nsComputedBoxSize* aChildComputedSize,
|
|
nsBoxSize* aBoxSizes,
|
|
nsComputedBoxSize* aComputedBoxSizes,
|
|
const nsRect& aChildLayoutRect,
|
|
nsRect& aChildActualRect,
|
|
nsRect& aContainingRect,
|
|
int32_t aFlexes,
|
|
bool& aFinished)
|
|
|
|
{
|
|
nsRect childCurrentRect(aChildLayoutRect);
|
|
|
|
bool isHorizontal = IsHorizontal(aBox);
|
|
nscoord childLayoutWidth = GET_WIDTH(aChildLayoutRect,isHorizontal);
|
|
nscoord& childActualWidth = GET_WIDTH(aChildActualRect,isHorizontal);
|
|
nscoord& containingWidth = GET_WIDTH(aContainingRect,isHorizontal);
|
|
|
|
//nscoord childLayoutHeight = GET_HEIGHT(aChildLayoutRect,isHorizontal);
|
|
nscoord& childActualHeight = GET_HEIGHT(aChildActualRect,isHorizontal);
|
|
nscoord& containingHeight = GET_HEIGHT(aContainingRect,isHorizontal);
|
|
|
|
bool recompute = false;
|
|
|
|
// if we are a horizontal box see if the child will fit inside us.
|
|
if ( childActualHeight > containingHeight) {
|
|
// if we are a horizontal box and the child is bigger than our height
|
|
|
|
// ok if the height changed then we need to reflow everyone but us at the new height
|
|
// so we will set the changed index to be us. And signal that we need a new pass.
|
|
|
|
nsSize min = aChild->GetMinSize(aState);
|
|
nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
|
|
AddMargin(aChild, max);
|
|
|
|
if (isHorizontal)
|
|
childActualHeight = max.height < childActualHeight ? max.height : childActualHeight;
|
|
else
|
|
childActualHeight = max.width < childActualHeight ? max.width : childActualHeight;
|
|
|
|
// only set if it changes
|
|
if (childActualHeight > containingHeight) {
|
|
containingHeight = childActualHeight;
|
|
|
|
// remember we do not need to clear the resized list because changing the height of a horizontal box
|
|
// will not affect the width of any of its children because block flow left to right, top to bottom. Just trust me
|
|
// on this one.
|
|
aFinished = false;
|
|
|
|
// only recompute if there are flexes.
|
|
if (aFlexes > 0) {
|
|
// relayout everything
|
|
recompute = true;
|
|
InvalidateComputedSizes(aComputedBoxSizes);
|
|
nsComputedBoxSize* node = aComputedBoxSizes;
|
|
|
|
while(node) {
|
|
node->resized = false;
|
|
node = node->next;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (childActualWidth > childLayoutWidth) {
|
|
nsSize min = aChild->GetMinSize(aState);
|
|
nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
|
|
|
|
AddMargin(aChild, max);
|
|
|
|
// our width now becomes the new size
|
|
|
|
if (isHorizontal)
|
|
childActualWidth = max.width < childActualWidth ? max.width : childActualWidth;
|
|
else
|
|
childActualWidth = max.height < childActualWidth ? max.height : childActualWidth;
|
|
|
|
if (childActualWidth > childLayoutWidth) {
|
|
aChildComputedSize->size = childActualWidth;
|
|
aChildBoxSize->min = childActualWidth;
|
|
if (aChildBoxSize->pref < childActualWidth)
|
|
aChildBoxSize->pref = childActualWidth;
|
|
if (aChildBoxSize->max < childActualWidth)
|
|
aChildBoxSize->max = childActualWidth;
|
|
|
|
// if we have flexible elements with us then reflex things. Otherwise we can skip doing it.
|
|
if (aFlexes > 0) {
|
|
InvalidateComputedSizes(aComputedBoxSizes);
|
|
|
|
nsComputedBoxSize* node = aComputedBoxSizes;
|
|
aChildComputedSize->resized = true;
|
|
|
|
while(node) {
|
|
if (node->resized)
|
|
node->valid = true;
|
|
|
|
node = node->next;
|
|
}
|
|
|
|
recompute = true;
|
|
aFinished = false;
|
|
} else {
|
|
containingWidth += aChildComputedSize->size - childLayoutWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (recompute)
|
|
ComputeChildSizes(aBox, aState, containingWidth, aBoxSizes, aComputedBoxSizes);
|
|
|
|
if (!childCurrentRect.IsEqualInterior(aChildActualRect)) {
|
|
// the childRect includes the margin
|
|
// make sure we remove it before setting
|
|
// the bounds.
|
|
nsMargin margin(0,0,0,0);
|
|
aChild->GetMargin(margin);
|
|
nsRect rect(aChildActualRect);
|
|
if (rect.width >= margin.left + margin.right && rect.height >= margin.top + margin.bottom)
|
|
rect.Deflate(margin);
|
|
|
|
aChild->SetBounds(aState, rect);
|
|
aChild->Layout(aState);
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::InvalidateComputedSizes(nsComputedBoxSize* aComputedBoxSizes)
|
|
{
|
|
while(aComputedBoxSizes) {
|
|
aComputedBoxSizes->valid = false;
|
|
aComputedBoxSizes = aComputedBoxSizes->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::ComputeChildSizes(nsIFrame* aBox,
|
|
nsBoxLayoutState& aState,
|
|
nscoord& aGivenSize,
|
|
nsBoxSize* aBoxSizes,
|
|
nsComputedBoxSize*& aComputedBoxSizes)
|
|
{
|
|
|
|
//nscoord onePixel = aState.PresContext()->IntScaledPixelsToTwips(1);
|
|
|
|
int32_t sizeRemaining = aGivenSize;
|
|
int32_t spacerConstantsRemaining = 0;
|
|
|
|
// ----- calculate the spacers constants and the size remaining -----
|
|
|
|
if (!aComputedBoxSizes)
|
|
aComputedBoxSizes = new (aState) nsComputedBoxSize();
|
|
|
|
nsBoxSize* boxSizes = aBoxSizes;
|
|
nsComputedBoxSize* computedBoxSizes = aComputedBoxSizes;
|
|
int32_t count = 0;
|
|
int32_t validCount = 0;
|
|
|
|
while (boxSizes)
|
|
{
|
|
|
|
NS_ASSERTION((boxSizes->min <= boxSizes->pref && boxSizes->pref <= boxSizes->max),"bad pref, min, max size");
|
|
|
|
|
|
// ignore collapsed children
|
|
// if (boxSizes->collapsed)
|
|
// {
|
|
// computedBoxSizes->valid = true;
|
|
// computedBoxSizes->size = boxSizes->pref;
|
|
// validCount++;
|
|
// boxSizes->flex = 0;
|
|
// }// else {
|
|
|
|
if (computedBoxSizes->valid) {
|
|
sizeRemaining -= computedBoxSizes->size;
|
|
validCount++;
|
|
} else {
|
|
if (boxSizes->flex == 0)
|
|
{
|
|
computedBoxSizes->valid = true;
|
|
computedBoxSizes->size = boxSizes->pref;
|
|
validCount++;
|
|
}
|
|
|
|
spacerConstantsRemaining += boxSizes->flex;
|
|
sizeRemaining -= boxSizes->pref;
|
|
}
|
|
|
|
sizeRemaining -= (boxSizes->left + boxSizes->right);
|
|
|
|
//}
|
|
|
|
boxSizes = boxSizes->next;
|
|
|
|
if (boxSizes && !computedBoxSizes->next)
|
|
computedBoxSizes->next = new (aState) nsComputedBoxSize();
|
|
|
|
computedBoxSizes = computedBoxSizes->next;
|
|
count++;
|
|
}
|
|
|
|
// everything accounted for?
|
|
if (validCount < count)
|
|
{
|
|
// ----- Ok we are give a size to fit into so stretch or squeeze to fit
|
|
// ----- Make sure we look at our min and max size
|
|
bool limit = true;
|
|
for (int pass=1; true == limit; pass++)
|
|
{
|
|
limit = false;
|
|
boxSizes = aBoxSizes;
|
|
computedBoxSizes = aComputedBoxSizes;
|
|
|
|
while (boxSizes) {
|
|
|
|
// ignore collapsed spacers
|
|
|
|
// if (!boxSizes->collapsed) {
|
|
|
|
nscoord pref = 0;
|
|
nscoord max = NS_INTRINSICSIZE;
|
|
nscoord min = 0;
|
|
nscoord flex = 0;
|
|
|
|
pref = boxSizes->pref;
|
|
min = boxSizes->min;
|
|
max = boxSizes->max;
|
|
flex = boxSizes->flex;
|
|
|
|
// ----- look at our min and max limits make sure we aren't too small or too big -----
|
|
if (!computedBoxSizes->valid) {
|
|
int32_t newSize = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
|
|
|
|
if (newSize<=min) {
|
|
computedBoxSizes->size = min;
|
|
computedBoxSizes->valid = true;
|
|
spacerConstantsRemaining -= flex;
|
|
sizeRemaining += pref;
|
|
sizeRemaining -= min;
|
|
limit = true;
|
|
} else if (newSize>=max) {
|
|
computedBoxSizes->size = max;
|
|
computedBoxSizes->valid = true;
|
|
spacerConstantsRemaining -= flex;
|
|
sizeRemaining += pref;
|
|
sizeRemaining -= max;
|
|
limit = true;
|
|
}
|
|
}
|
|
// }
|
|
boxSizes = boxSizes->next;
|
|
computedBoxSizes = computedBoxSizes->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- once we have removed and min and max issues just stretch us out in the remaining space
|
|
// ---- or shrink us. Depends on the size remaining and the spacer constants
|
|
aGivenSize = 0;
|
|
boxSizes = aBoxSizes;
|
|
computedBoxSizes = aComputedBoxSizes;
|
|
|
|
while (boxSizes) {
|
|
|
|
// ignore collapsed spacers
|
|
// if (!(boxSizes && boxSizes->collapsed)) {
|
|
|
|
nscoord pref = 0;
|
|
nscoord flex = 0;
|
|
pref = boxSizes->pref;
|
|
flex = boxSizes->flex;
|
|
|
|
if (!computedBoxSizes->valid) {
|
|
computedBoxSizes->size = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
|
|
computedBoxSizes->valid = true;
|
|
}
|
|
|
|
aGivenSize += (boxSizes->left + boxSizes->right);
|
|
aGivenSize += computedBoxSizes->size;
|
|
|
|
// }
|
|
|
|
boxSizes = boxSizes->next;
|
|
computedBoxSizes = computedBoxSizes->next;
|
|
}
|
|
}
|
|
|
|
|
|
nsSize
|
|
nsSprocketLayout::GetPrefSize(nsIFrame* aBox, nsBoxLayoutState& aState)
|
|
{
|
|
nsSize vpref (0, 0);
|
|
bool isHorizontal = IsHorizontal(aBox);
|
|
|
|
nscoord biggestPref = 0;
|
|
|
|
// run through all the children and get their min, max, and preferred sizes
|
|
// return us the size of the box
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
|
|
int32_t count = 0;
|
|
|
|
while (child)
|
|
{
|
|
// ignore collapsed children
|
|
if (!child->IsCollapsed())
|
|
{
|
|
nsSize pref = child->GetPrefSize(aState);
|
|
AddMargin(child, pref);
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal)
|
|
{
|
|
if (pref.width > biggestPref)
|
|
biggestPref = pref.width;
|
|
} else {
|
|
if (pref.height > biggestPref)
|
|
biggestPref = pref.height;
|
|
}
|
|
}
|
|
|
|
AddLargestSize(vpref, pref, isHorizontal);
|
|
count++;
|
|
}
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal)
|
|
vpref.width = biggestPref*count;
|
|
else
|
|
vpref.height = biggestPref*count;
|
|
}
|
|
|
|
// now add our border and padding
|
|
AddBorderAndPadding(aBox, vpref);
|
|
|
|
return vpref;
|
|
}
|
|
|
|
nsSize
|
|
nsSprocketLayout::GetMinSize(nsIFrame* aBox, nsBoxLayoutState& aState)
|
|
{
|
|
nsSize minSize (0, 0);
|
|
bool isHorizontal = IsHorizontal(aBox);
|
|
|
|
nscoord biggestMin = 0;
|
|
|
|
|
|
// run through all the children and get their min, max, and preferred sizes
|
|
// return us the size of the box
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
|
|
int32_t count = 0;
|
|
|
|
while (child)
|
|
{
|
|
// ignore collapsed children
|
|
if (!child->IsCollapsed())
|
|
{
|
|
nsSize min = child->GetMinSize(aState);
|
|
nsSize pref(0,0);
|
|
|
|
// if the child is not flexible then
|
|
// its min size is its pref size.
|
|
if (child->GetFlex(aState) == 0) {
|
|
pref = child->GetPrefSize(aState);
|
|
if (isHorizontal)
|
|
min.width = pref.width;
|
|
else
|
|
min.height = pref.height;
|
|
}
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal)
|
|
{
|
|
if (min.width > biggestMin)
|
|
biggestMin = min.width;
|
|
} else {
|
|
if (min.height > biggestMin)
|
|
biggestMin = min.height;
|
|
}
|
|
}
|
|
|
|
AddMargin(child, min);
|
|
AddLargestSize(minSize, min, isHorizontal);
|
|
count++;
|
|
}
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal)
|
|
minSize.width = biggestMin*count;
|
|
else
|
|
minSize.height = biggestMin*count;
|
|
}
|
|
|
|
// now add our border and padding
|
|
AddBorderAndPadding(aBox, minSize);
|
|
|
|
return minSize;
|
|
}
|
|
|
|
nsSize
|
|
nsSprocketLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
|
|
{
|
|
|
|
bool isHorizontal = IsHorizontal(aBox);
|
|
|
|
nscoord smallestMax = NS_INTRINSICSIZE;
|
|
nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
|
|
|
|
// run through all the children and get their min, max, and preferred sizes
|
|
// return us the size of the box
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
nsFrameState frameState = nsFrameState(0);
|
|
GetFrameState(aBox, frameState);
|
|
bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
|
|
int32_t count = 0;
|
|
|
|
while (child)
|
|
{
|
|
// ignore collapsed children
|
|
if (!child->IsCollapsed())
|
|
{
|
|
// if completely redefined don't even ask our child for its size.
|
|
nsSize min = child->GetMinSize(aState);
|
|
nsSize max = nsBox::BoundsCheckMinMax(min, child->GetMaxSize(aState));
|
|
|
|
AddMargin(child, max);
|
|
AddSmallestSize(maxSize, max, isHorizontal);
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal)
|
|
{
|
|
if (max.width < smallestMax)
|
|
smallestMax = max.width;
|
|
} else {
|
|
if (max.height < smallestMax)
|
|
smallestMax = max.height;
|
|
}
|
|
}
|
|
count++;
|
|
}
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
|
|
if (isEqual) {
|
|
if (isHorizontal) {
|
|
if (smallestMax != NS_INTRINSICSIZE)
|
|
maxSize.width = smallestMax*count;
|
|
else
|
|
maxSize.width = NS_INTRINSICSIZE;
|
|
} else {
|
|
if (smallestMax != NS_INTRINSICSIZE)
|
|
maxSize.height = smallestMax*count;
|
|
else
|
|
maxSize.height = NS_INTRINSICSIZE;
|
|
}
|
|
}
|
|
|
|
// now add our border and padding
|
|
AddBorderAndPadding(aBox, maxSize);
|
|
|
|
return maxSize;
|
|
}
|
|
|
|
|
|
nscoord
|
|
nsSprocketLayout::GetAscent(nsIFrame* aBox, nsBoxLayoutState& aState)
|
|
{
|
|
nscoord vAscent = 0;
|
|
|
|
bool isHorizontal = IsHorizontal(aBox);
|
|
|
|
// run through all the children and get their min, max, and preferred sizes
|
|
// return us the size of the box
|
|
|
|
nsIFrame* child = nsBox::GetChildBox(aBox);
|
|
|
|
while (child)
|
|
{
|
|
// ignore collapsed children
|
|
//if (!child->IsCollapsed())
|
|
//{
|
|
// if completely redefined don't even ask our child for its size.
|
|
nscoord ascent = child->GetBoxAscent(aState);
|
|
|
|
nsMargin margin;
|
|
child->GetMargin(margin);
|
|
ascent += margin.top;
|
|
|
|
if (isHorizontal)
|
|
{
|
|
if (ascent > vAscent)
|
|
vAscent = ascent;
|
|
} else {
|
|
if (vAscent == 0)
|
|
vAscent = ascent;
|
|
}
|
|
//}
|
|
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
|
|
nsMargin borderPadding;
|
|
aBox->GetBorderAndPadding(borderPadding);
|
|
|
|
return vAscent + borderPadding.top;
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::SetLargestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
|
|
{
|
|
if (aIsHorizontal)
|
|
{
|
|
if (aSize1.height < aSize2.height)
|
|
aSize1.height = aSize2.height;
|
|
} else {
|
|
if (aSize1.width < aSize2.width)
|
|
aSize1.width = aSize2.width;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::SetSmallestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
|
|
{
|
|
if (aIsHorizontal)
|
|
{
|
|
if (aSize1.height > aSize2.height)
|
|
aSize1.height = aSize2.height;
|
|
} else {
|
|
if (aSize1.width > aSize2.width)
|
|
aSize1.width = aSize2.width;
|
|
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::AddLargestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
|
|
{
|
|
if (aIsHorizontal)
|
|
AddCoord(aSize.width, aSizeToAdd.width);
|
|
else
|
|
AddCoord(aSize.height, aSizeToAdd.height);
|
|
|
|
SetLargestSize(aSize, aSizeToAdd, aIsHorizontal);
|
|
}
|
|
|
|
void
|
|
nsSprocketLayout::AddCoord(nscoord& aCoord, nscoord aCoordToAdd)
|
|
{
|
|
if (aCoord != NS_INTRINSICSIZE)
|
|
{
|
|
if (aCoordToAdd == NS_INTRINSICSIZE)
|
|
aCoord = aCoordToAdd;
|
|
else
|
|
aCoord += aCoordToAdd;
|
|
}
|
|
}
|
|
void
|
|
nsSprocketLayout::AddSmallestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
|
|
{
|
|
if (aIsHorizontal)
|
|
AddCoord(aSize.width, aSizeToAdd.width);
|
|
else
|
|
AddCoord(aSize.height, aSizeToAdd.height);
|
|
|
|
SetSmallestSize(aSize, aSizeToAdd, aIsHorizontal);
|
|
}
|
|
|
|
bool
|
|
nsSprocketLayout::GetDefaultFlex(int32_t& aFlex)
|
|
{
|
|
aFlex = 0;
|
|
return true;
|
|
}
|
|
|
|
nsComputedBoxSize::nsComputedBoxSize()
|
|
{
|
|
resized = false;
|
|
valid = false;
|
|
size = 0;
|
|
next = nullptr;
|
|
}
|
|
|
|
nsBoxSize::nsBoxSize()
|
|
{
|
|
pref = 0;
|
|
min = 0;
|
|
max = NS_INTRINSICSIZE;
|
|
collapsed = false;
|
|
left = 0;
|
|
right = 0;
|
|
flex = 0;
|
|
next = nullptr;
|
|
bogus = false;
|
|
}
|
|
|
|
|
|
void*
|
|
nsBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
|
|
{
|
|
return mozilla::AutoStackArena::Allocate(sz);
|
|
}
|
|
|
|
|
|
void
|
|
nsBoxSize::operator delete(void* aPtr, size_t sz)
|
|
{
|
|
}
|
|
|
|
|
|
void*
|
|
nsComputedBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
|
|
{
|
|
return mozilla::AutoStackArena::Allocate(sz);
|
|
}
|
|
|
|
void
|
|
nsComputedBoxSize::operator delete(void* aPtr, size_t sz)
|
|
{
|
|
}
|