void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect)
{
// FIXME: This method does not work correctly with transforms.
if (layer->isComposited())
layer->setBackingNeedsRepaintInRect(rect);
if (layer->hasCompositingDescendant()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = negZOrderList->at(i);
int x = 0;
int y = 0;
curLayer->convertToLayerCoords(layer, x, y);
IntRect childRect(rect);
childRect.move(-x, -y);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = posZOrderList->at(i);
int x = 0;
int y = 0;
curLayer->convertToLayerCoords(layer, x, y);
IntRect childRect(rect);
childRect.move(-x, -y);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
}
if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
size_t listSize = normalFlowList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = normalFlowList->at(i);
int x = 0;
int y = 0;
curLayer->convertToLayerCoords(layer, x, y);
IntRect childRect(rect);
childRect.move(-x, -y);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
}
void tst_QGraphicsEffect::boundingRect2()
{
CustomEffect *effect = new CustomEffect;
QGraphicsRectItem *root = new QGraphicsRectItem;
root->setGraphicsEffect(effect);
QGraphicsRectItem *child = new QGraphicsRectItem;
QRectF childRect(0, 0, 100, 100);
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
child->setRect(childRect);
child->setParentItem(root);
QGraphicsRectItem *grandChild = new QGraphicsRectItem;
QRectF grandChildRect(0, 0, 200, 200);
grandChild->setRect(grandChildRect);
grandChild->setParentItem(child);
// Make sure the effect's bounding rect is clipped to the child's bounding rect.
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect));
// Disable ItemClipsChildrenToShape; effect's bounding rect is no longer clipped.
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect | grandChildRect));
// Add root item to a scene, do the same tests as above. Results should be the same.
QGraphicsScene scene;
scene.addItem(root);
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect));
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect | grandChildRect));
// Now add the scene to a view, results should be the same.
QGraphicsView view(&scene);
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect));
child->setFlag(QGraphicsItem::ItemClipsChildrenToShape, false);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect | grandChildRect));
CustomEffect *childEffect = new CustomEffect;
child->setGraphicsEffect(childEffect);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childEffect->boundingRectFor(childRect | grandChildRect)));
child->setGraphicsEffect(0);
QCOMPARE(effect->boundingRect(), effect->boundingRectFor(childRect | grandChildRect));
}
NS_IMETHODIMP
nsStackLayout::Layout(nsIBox* aBox, nsBoxLayoutState& aState)
{
nsRect clientRect;
aBox->GetClientRect(clientRect);
PRBool grow;
do {
nsIBox* child = aBox->GetChildBox();
grow = PR_FALSE;
while (child)
{
nsMargin margin;
child->GetMargin(margin);
nsRect childRect(clientRect);
childRect.Deflate(margin);
if (childRect.width < 0)
childRect.width = 0;
if (childRect.height < 0)
childRect.height = 0;
nsRect oldRect(child->GetRect());
PRBool sizeChanged = (oldRect != childRect);
// only lay out dirty children or children whose sizes have changed
if (sizeChanged || NS_SUBTREE_DIRTY(child)) {
// add in the child's margin
nsMargin margin;
child->GetMargin(margin);
// obtain our offset from the top left border of the stack's content box.
nsSize offset(0,0);
PRBool offsetSpecified = AddOffset(aState, child, offset);
// Correct the child's x/y position by adding in both the margins
// and the left/top offset.
childRect.x = clientRect.x + offset.width + margin.left;
childRect.y = clientRect.y + offset.height + margin.top;
// If we have an offset, we don't stretch the child. Just use
// its preferred size.
if (offsetSpecified) {
nsSize pref = child->GetPrefSize(aState);
childRect.width = pref.width;
childRect.height = pref.height;
}
// Now place the child.
child->SetBounds(aState, childRect);
// Flow the child.
child->Layout(aState);
// Get the child's new rect.
nsRect childRectNoMargin;
childRectNoMargin = childRect = child->GetRect();
childRect.Inflate(margin);
// Did the child push back on us and get bigger?
if (offset.width + childRect.width > clientRect.width) {
clientRect.width = childRect.width + offset.width;
grow = PR_TRUE;
}
if (offset.height + childRect.height > clientRect.height) {
clientRect.height = childRect.height + offset.height;
grow = PR_TRUE;
}
if (childRectNoMargin != oldRect)
{
// redraw the new and old positions if the
// child moved or resized.
// if the new and old rect intersect meaning we just moved a little
// then just redraw the union. If they don't intersect (meaning
// we moved a good distance) redraw both separately.
if (childRectNoMargin.Intersects(oldRect)) {
nsRect u;
u.UnionRect(oldRect, childRectNoMargin);
aBox->Redraw(aState, &u);
} else {
aBox->Redraw(aState, &oldRect);
aBox->Redraw(aState, &childRectNoMargin);
}
}
}
child = child->GetNextBox();
}
} while (grow);
// if some HTML inside us got bigger we need to force ourselves to
// get bigger
nsRect bounds(aBox->GetRect());
nsMargin bp;
aBox->GetBorderAndPadding(bp);
clientRect.Inflate(bp);
if (clientRect.width > bounds.width || clientRect.height > bounds.height)
{
if (clientRect.width > bounds.width)
bounds.width = clientRect.width;
if (clientRect.height > bounds.height)
bounds.height = clientRect.height;
aBox->SetBounds(aState, bounds);
}
return NS_OK;
}
/**
* Called to layout our our children. Does no frame construction
*/
NS_IMETHODIMP
nsListBoxLayout::LayoutInternal(nsIFrame* aBox, nsBoxLayoutState& aState)
{
int32_t redrawStart = -1;
// Get the start y position.
nsListBoxBodyFrame* body = static_cast<nsListBoxBodyFrame*>(aBox);
if (!body) {
NS_ERROR("Frame encountered that isn't a listboxbody!");
return NS_ERROR_FAILURE;
}
nsMargin margin;
// Get our client rect.
nsRect clientRect;
aBox->GetClientRect(clientRect);
// Get the starting y position and the remaining available
// height.
nscoord availableHeight = body->GetAvailableHeight();
nscoord yOffset = body->GetYPosition();
if (availableHeight <= 0) {
bool fixed = (body->GetFixedRowSize() != -1);
if (fixed)
availableHeight = 10;
else
return NS_OK;
}
// run through all our currently created children
nsIFrame* box = body->GetChildBox();
// if the reason is resize or initial we must relayout.
nscoord rowHeight = body->GetRowHeightAppUnits();
while (box) {
// If this box is dirty or if it has dirty children, we
// call layout on it.
nsRect childRect(box->GetRect());
box->GetMargin(margin);
// relayout if we must or we are dirty or some of our children are dirty
// or the client area is wider than us
// XXXldb There should probably be a resize check here too!
if (NS_SUBTREE_DIRTY(box) || childRect.width < clientRect.width) {
childRect.x = 0;
childRect.y = yOffset;
childRect.width = clientRect.width;
nsSize size = box->GetPrefSize(aState);
body->SetRowHeight(size.height);
childRect.height = rowHeight;
childRect.Deflate(margin);
box->SetBounds(aState, childRect);
box->Layout(aState);
} else {
// if the child did not need to be relayed out. Then its easy.
// Place the child by just grabbing its rect and adjusting the y.
int32_t newPos = yOffset+margin.top;
// are we pushing down or pulling up any rows?
// Then we may have to redraw everything below the moved
// rows.
if (redrawStart == -1 && childRect.y != newPos)
redrawStart = newPos;
childRect.y = newPos;
box->SetBounds(aState, childRect);
}
// Ok now the available size gets smaller and we move the
// starting position of the next child down some.
nscoord size = childRect.height + margin.top + margin.bottom;
yOffset += size;
availableHeight -= size;
box = box->GetNextBox();
}
// We have enough available height left to add some more rows
// Since we can't do this during layout, we post a callback
// that will be processed after the reflow completes.
body->PostReflowCallback();
// if rows were pushed down or pulled up because some rows were added
// before them then redraw everything under the inserted rows. The inserted
// rows will automatically be redrawn because the were marked dirty on insertion.
if (redrawStart > -1) {
aBox->Redraw(aState);
}
return NS_OK;
}
/**
@SYMTestCaseID GRAPHICS-WSERV-0462
@SYMDEF PDEF114190
@SYMTestCaseDesc Test sprite list cleanup when a window is deleted in low memory conditions
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Have a loop which increases the number of allocations in the server thread before failure;
Within the loop:
1) Create a parent window and a child window of the parent;
2) Create a sprite on the child window;
3) Delete the parent window only, but not the child window;
4) Create a testWindow and do redraw on this window;
5) Do redraw on the testWindow. This testWindow's redraw will force checking the sprite list.
This would panic the client thread due to this defect because the sprite on the orphaned
window (which is the previous child window) is still in the sprite list;
6) Delete all the windows involved.
@SYMTestExpectedResults The sprite should be disabled when a window is deleted;
The client thread should not be panic'd.
The test should pass.
*/
void CTTSprite::SpriteOnWindowOrphanedTestsL()
{
TInt handles = 344;
TInt loop = 0;
TInt allocFailRate = 0;
TInt err = KErrNone;
CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
User::LeaveIfError(bitmap->Create(TSize(500, 500), EColor16MU));
TSpriteMember spritemember;
spritemember.iBitmap = bitmap;
spritemember.iMaskBitmap = NULL;
RWindowGroup group(TheClient->iWs);
RWindow parent1(TheClient->iWs);
RWindow child1(TheClient->iWs);
RWindow testWindow(TheClient->iWs);
RWsSprite sprite(TheClient->iWs);
while (loop < 5)
{
TRect mainRect(TPoint(0,0), TSize(500,500));
err = group.Construct(++handles, EFalse);
if (err == KErrNone)
{
TheClient->iWs.HeapSetFail(RHeap::EDeterministic, allocFailRate);
//Create parent 1
err = parent1.Construct(group,++handles);
if (err == KErrNone)
{
parent1.SetExtent(mainRect.iTl, mainRect.Size());
parent1.EnableRedrawStore(ETrue);
parent1.Activate();
}
}
//Create child 1
if (err == KErrNone)
{
TRect childRect(TPoint (10, 10), TSize (200, 150));
err = child1.Construct(parent1,++handles);
if (err == KErrNone)
{
child1.SetExtent(childRect.iTl, childRect.Size());
child1.SetBackgroundColor(TRgb(128,100,255,20));
child1.Activate();
}
}
//Add sprite to child 1
if (err == KErrNone)
{
err = sprite.Construct(child1,TPoint(10,10), 0);
if (err == KErrNone)
{
err = sprite.AppendMember(spritemember);
if (err == KErrNone)
err = sprite.Activate();
}
}
//Only delete parent 1, but not child 1
parent1.Close();
if (err == KErrNone)
{
TRect testRect(TPoint(10, 30), TSize(200, 150));
//Create testWindow
err = testWindow.Construct(group,++handles);
if (err == KErrNone)
{
testWindow.SetExtent(testRect.iTl, testRect.Size());
testWindow.SetBackgroundColor(TRgb(128,100,255,20));
testWindow.EnableRedrawStore(ETrue);
testWindow.Activate();
testWindow.BeginRedraw();
testWindow.EndRedraw();
TheClient->Flush();
}
}
TheClient->iWs.HeapSetFail(RAllocator::ENone, 0);
sprite.Close();
child1.Close();
testWindow.Close();
group.Close();
++allocFailRate;
loop = (err == KErrNone) ? loop + 1 : 0;
}
CleanupStack::PopAndDestroy(bitmap);
}
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);
childRect.x = originalClientRect.x;
}
// 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 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;
}