LCOV - app.info - layout/xul/base/src/nsSprocketLayout.cpp

LCOV - code coverage report
| Current view: | directory - layout/xul/base/src - nsSprocketLayout.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 745 | 3 | 0.4 %
| Date: | 2012-04-21 | Functions: | 30 | 1 | 3.3 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is Mozilla Communicator client code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   David Hyatt <hyatt@netscape.com>
          24                 :  *   Pierre Phaneuf <pp@ludusdesign.com>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : //
          41                 : // Eric Vaughan
          42                 : // Netscape Communications
          43                 : //
          44                 : // See documentation in associated header file
          45                 : //
          46                 :
          47                 : #include "nsBoxLayoutState.h"
          48                 : #include "nsSprocketLayout.h"
          49                 : #include "nsPresContext.h"
          50                 : #include "nsCOMPtr.h"
          51                 : #include "nsIContent.h"
          52                 : #include "nsIPresShell.h"
          53                 : #include "nsContainerFrame.h"
          54                 : #include "nsBoxFrame.h"
          55                 :
          56                 : nsBoxLayout* nsSprocketLayout::gInstance = nsnull;
          57                 :
          58                 : //#define DEBUG_GROW
          59                 :
          60                 : #define DEBUG_SPRING_SIZE 8
          61                 : #define DEBUG_BORDER_SIZE 2
          62                 : #define COIL_SIZE 8
          63                 :
          64                 :
          65                 : nsresult
          66               0 : NS_NewSprocketLayout( nsIPresShell* aPresShell, nsCOMPtr<nsBoxLayout>& aNewLayout)
          67                 : {
          68               0 :   if (!nsSprocketLayout::gInstance) {
          69               0 :     nsSprocketLayout::gInstance = new nsSprocketLayout();
          70               0 :     NS_IF_ADDREF(nsSprocketLayout::gInstance);
          71                 :   }
          72                 :   // we have not instance variables so just return our static one.
          73               0 :   aNewLayout = nsSprocketLayout::gInstance;
          74               0 :   return NS_OK;
          75                 : }
          76                 :
          77                 : /*static*/ void
          78            1364 : nsSprocketLayout::Shutdown()
          79                 : {
          80            1364 :   NS_IF_RELEASE(gInstance);
          81            1364 : }
          82                 :
          83               0 : nsSprocketLayout::nsSprocketLayout()
          84                 : {
          85               0 : }
          86                 :
          87                 : bool
          88               0 : nsSprocketLayout::IsHorizontal(nsIBox* aBox)
          89                 : {
          90               0 :    return (aBox->GetStateBits() & NS_STATE_IS_HORIZONTAL) != 0;
          91                 : }
          92                 :
          93                 : void
          94               0 : nsSprocketLayout::GetFrameState(nsIBox* aBox, nsFrameState& aState)
          95                 : {
          96               0 :    aState = aBox->GetStateBits();
          97               0 : }
          98                 :
          99                 : static PRUint8
         100               0 : GetFrameDirection(nsIBox* aBox)
         101                 : {
         102               0 :    return aBox->GetStyleVisibility()->mDirection;
         103                 : }
         104                 :
         105                 : static void
         106               0 : HandleBoxPack(nsIBox* aBox, const nsFrameState& aFrameState, nscoord& aX, nscoord& aY,
         107                 :               const nsRect& aOriginalRect, const nsRect& aClientRect)
         108                 : {
         109                 :   // In the normal direction we lay out our kids in the positive direction (e.g., |x| will get
         110                 :   // bigger for a horizontal box, and |y| will get bigger for a vertical box).  In the reverse
         111                 :   // direction, the opposite is true.  We'll be laying out each child at a smaller |x| or
         112                 :   // |y|.
         113               0 :   PRUint8 frameDirection = GetFrameDirection(aBox);
         114                 :
         115               0 :   if (aFrameState & NS_STATE_IS_HORIZONTAL) {
         116               0 :     if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
         117                 :       // The normal direction. |x| increases as we move through our children.
         118               0 :       aX = aClientRect.x;
         119                 :     }
         120                 :     else {
         121                 :       // The reverse direction. |x| decreases as we move through our children.
         122               0 :       aX = aClientRect.x + aOriginalRect.width;
         123                 :     }
         124                 :     // |y| is always in the normal direction in horizontal boxes
         125               0 :     aY = aClientRect.y;
         126                 :   }
         127                 :   else {
         128                 :     // take direction property into account for |x| in vertical boxes
         129               0 :     if (frameDirection == NS_STYLE_DIRECTION_LTR) {
         130                 :       // The normal direction. |x| increases as we move through our children.
         131               0 :       aX = aClientRect.x;
         132                 :     }
         133                 :     else {
         134                 :       // The reverse direction. |x| decreases as we move through our children.
         135               0 :       aX = aClientRect.x + aOriginalRect.width;
         136                 :     }
         137               0 :     if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
         138                 :       // The normal direction. |y| increases as we move through our children.
         139               0 :       aY = aClientRect.y;
         140                 :     }
         141                 :     else {
         142                 :       // The reverse direction. |y| decreases as we move through our children.
         143               0 :       aY = aClientRect.y + aOriginalRect.height;
         144                 :     }
         145                 :   }
         146                 :
         147                 :   // Get our pack/alignment information.
         148               0 :   nsIBox::Halignment halign = aBox->GetHAlign();
         149               0 :   nsIBox::Valignment valign = aBox->GetVAlign();
         150                 :
         151                 :   // The following code handles box PACKING.  Packing comes into play in the case where the computed size for
         152                 :   // all of our children (now stored in our client rect) is smaller than the size available for
         153                 :   // the box (stored in |aOriginalRect|).
         154                 :   //
         155                 :   // Here we adjust our |x| and |y| variables accordingly so that we start at the beginning,
         156                 :   // middle, or end of the box.
         157                 :   //
         158                 :   // XXXdwh JUSTIFY needs to be implemented!
         159               0 :   if (aFrameState & NS_STATE_IS_HORIZONTAL) {
         160               0 :     switch(halign) {
         161                 :       case nsBoxFrame::hAlign_Left:
         162               0 :         break; // Nothing to do.  The default initialized us properly.
         163                 :
         164                 :       case nsBoxFrame::hAlign_Center:
         165               0 :         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
         166               0 :           aX += (aOriginalRect.width - aClientRect.width)/2;
         167                 :         else
         168               0 :           aX -= (aOriginalRect.width - aClientRect.width)/2;
         169               0 :         break;
         170                 :
         171                 :       case nsBoxFrame::hAlign_Right:
         172               0 :         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
         173               0 :           aX += (aOriginalRect.width - aClientRect.width);
         174                 :         else
         175               0 :           aX -= (aOriginalRect.width - aClientRect.width);
         176               0 :         break; // Nothing to do for the reverse dir.  The default initialized us properly.
         177                 :     }
         178                 :   } else {
         179               0 :     switch(valign) {
         180                 :       case nsBoxFrame::vAlign_Top:
         181                 :       case nsBoxFrame::vAlign_BaseLine: // This value is technically impossible to specify for pack.
         182               0 :         break;  // Don't do anything.  We were initialized correctly.
         183                 :
         184                 :       case nsBoxFrame::vAlign_Middle:
         185               0 :         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
         186               0 :           aY += (aOriginalRect.height - aClientRect.height)/2;
         187                 :         else
         188               0 :           aY -= (aOriginalRect.height - aClientRect.height)/2;
         189               0 :         break;
         190                 :
         191                 :       case nsBoxFrame::vAlign_Bottom:
         192               0 :         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
         193               0 :           aY += (aOriginalRect.height - aClientRect.height);
         194                 :         else
         195               0 :           aY -= (aOriginalRect.height - aClientRect.height);
         196               0 :         break;
         197                 :     }
         198                 :   }
         199               0 : }
         200                 :
         201                 : NS_IMETHODIMP
         202               0 : nsSprocketLayout::Layout(nsIBox* aBox, nsBoxLayoutState& aState)
         203                 : {
         204                 :   // See if we are collapsed. If we are, then simply iterate over all our
         205                 :   // children and give them a rect of 0 width and height.
         206               0 :   if (aBox->IsCollapsed()) {
         207               0 :     nsIBox* child = aBox->GetChildBox();
         208               0 :     while(child)
         209                 :     {
         210               0 :       nsBoxFrame::LayoutChildAt(aState, child, nsRect(0,0,0,0));
         211               0 :       child = child->GetNextBox();
         212                 :     }
         213               0 :     return NS_OK;
         214                 :   }
         215                 :
         216               0 :   aState.PushStackMemory();
         217                 :
         218                 :   // ----- figure out our size ----------
         219               0 :   const nsSize originalSize = aBox->GetSize();
         220                 :
         221                 :   // -- make sure we remove our border and padding  ----
         222               0 :   nsRect clientRect;
         223               0 :   aBox->GetClientRect(clientRect);
         224                 :
         225                 :   // |originalClientRect| represents the rect of the entire box (excluding borders
         226                 :   // and padding).  We store it here because we're going to use |clientRect| to hold
         227                 :   // the required size for all our kids.  As an example, consider an hbox with a
         228                 :   // specified width of 300.  If the kids total only 150 pixels of width, then
         229                 :   // we have 150 pixels left over.  |clientRect| is going to hold a width of 150 and
         230                 :   // is going to be adjusted based off the value of the PACK property.  If flexible
         231                 :   // objects are in the box, then the two rects will match.
         232               0 :   nsRect originalClientRect(clientRect);
         233                 :
         234                 :   // The frame state contains cached knowledge about our box, such as our orientation
         235                 :   // and direction.
         236               0 :   nsFrameState frameState = 0;
         237               0 :   GetFrameState(aBox, frameState);
         238                 :
         239                 :   // Build a list of our children's desired sizes and computed sizes
         240               0 :   nsBoxSize*         boxSizes = nsnull;
         241               0 :   nsComputedBoxSize* computedBoxSizes = nsnull;
         242                 :
         243               0 :   nscoord min = 0;
         244               0 :   nscoord max = 0;
         245               0 :   PRInt32 flexes = 0;
         246               0 :   PopulateBoxSizes(aBox, aState, boxSizes, min, max, flexes);
         247                 :
         248                 :   // The |size| variable will hold the total size of children along the axis of
         249                 :   // the box.  Continuing with the example begun in the comment above, size would
         250                 :   // be 150 pixels.
         251               0 :   nscoord size = clientRect.width;
         252               0 :   if (!IsHorizontal(aBox))
         253               0 :     size = clientRect.height;
         254               0 :   ComputeChildSizes(aBox, aState, size, boxSizes, computedBoxSizes);
         255                 :
         256                 :   // After the call to ComputeChildSizes, the |size| variable contains the
         257                 :   // total required size of all the children.  We adjust our clientRect in the
         258                 :   // appropriate dimension to match this size.  In our example, we now assign
         259                 :   // 150 pixels into the clientRect.width.
         260                 :   //
         261                 :   // The variables |min| and |max| hold the minimum required size box must be
         262                 :   // in the OPPOSITE orientation, e.g., for a horizontal box, |min| is the minimum
         263                 :   // height we require to enclose our children, and |max| is the maximum height
         264                 :   // required to enclose our children.
         265               0 :   if (IsHorizontal(aBox)) {
         266               0 :     clientRect.width = size;
         267               0 :     if (clientRect.height < min)
         268               0 :       clientRect.height = min;
         269                 :
         270               0 :     if (frameState & NS_STATE_AUTO_STRETCH) {
         271               0 :       if (clientRect.height > max)
         272               0 :         clientRect.height = max;
         273                 :     }
         274                 :   } else {
         275               0 :     clientRect.height = size;
         276               0 :     if (clientRect.width < min)
         277               0 :       clientRect.width = min;
         278                 :
         279               0 :     if (frameState & NS_STATE_AUTO_STRETCH) {
         280               0 :       if (clientRect.width > max)
         281               0 :         clientRect.width = max;
         282                 :     }
         283                 :   }
         284                 :
         285                 :   // With the sizes computed, now it's time to lay out our children.
         286               0 :   bool needsRedraw = false;
         287                 :   bool finished;
         288               0 :   nscoord passes = 0;
         289                 :
         290                 :   // We flow children at their preferred locations (along with the appropriate computed flex).
         291                 :   // After we flow a child, it is possible that the child will change its size.  If/when this happens,
         292                 :   // we have to do another pass.  Typically only 2 passes are required, but the code is prepared to
         293                 :   // do as many passes as are necessary to achieve equilibrium.
         294               0 :   nscoord x = 0;
         295               0 :   nscoord y = 0;
         296               0 :   nscoord origX = 0;
         297               0 :   nscoord origY = 0;
         298                 :
         299                 :   // |childResized| lets us know if a child changed its size after we attempted to lay it out at
         300                 :   // the specified size.  If this happens, we usually have to do another pass.
         301               0 :   bool childResized = false;
         302                 :
         303                 :   // |passes| stores our number of passes.  If for any reason we end up doing more than, say, 10
         304                 :   // passes, we assert to indicate that something is seriously screwed up.
         305               0 :   passes = 0;
         306               0 :   do
         307                 :   {
         308                 : #ifdef DEBUG_REFLOW
         309                 :     if (passes > 0) {
         310                 :       AddIndents();
         311                 :       printf("ChildResized doing pass: %d\n", passes);
         312                 :     }
         313                 : #endif
         314                 :
         315                 :     // Always assume that we're done.  This will change if, for example, children don't stay
         316                 :     // the same size after being flowed.
         317               0 :     finished = true;
         318                 :
         319                 :     // Handle box packing.
         320               0 :     HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
         321                 :
         322                 :     // Now that packing is taken care of we set up a few additional
         323                 :     // tracking variables.
         324               0 :     origX = x;
         325               0 :     origY = y;
         326                 :
         327               0 :     nscoord nextX = x;
         328               0 :     nscoord nextY = y;
         329                 :
         330                 :     // Now we iterate over our box children and our box size lists in
         331                 :     // parallel.  For each child, we look at its sizes and figure out
         332                 :     // where to place it.
         333               0 :     nsComputedBoxSize* childComputedBoxSize = computedBoxSizes;
         334               0 :     nsBoxSize* childBoxSize                 = boxSizes;
         335                 :
         336               0 :     nsIBox* child = aBox->GetChildBox();
         337                 :
         338               0 :     PRInt32 count = 0;
         339               0 :     while (child || (childBoxSize && childBoxSize->bogus))
         340                 :     {
         341                 :       // If for some reason, our lists are not the same length, we guard
         342                 :       // by bailing out of the loop.
         343               0 :       if (childBoxSize == nsnull) {
         344               0 :         NS_NOTREACHED("Lists not the same length.");
         345               0 :         break;
         346                 :       }
         347                 :
         348               0 :       nscoord width = clientRect.width;
         349               0 :       nscoord height = clientRect.height;
         350                 :
         351               0 :       if (!childBoxSize->bogus) {
         352                 :         // We have a valid box size entry.  This entry already contains information about our
         353                 :         // sizes along the axis of the box (e.g., widths in a horizontal box).  If our default
         354                 :         // ALIGN is not stretch, however, then we also need to know the child's size along the
         355                 :         // opposite axis.
         356               0 :         if (!(frameState & NS_STATE_AUTO_STRETCH)) {
         357               0 :            nsSize prefSize = child->GetPrefSize(aState);
         358               0 :            nsSize minSize = child->GetMinSize(aState);
         359               0 :            nsSize maxSize = child->GetMaxSize(aState);
         360               0 :            prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
         361                 :
         362               0 :            AddMargin(child, prefSize);
         363               0 :            width = NS_MIN(prefSize.width, originalClientRect.width);
         364               0 :            height = NS_MIN(prefSize.height, originalClientRect.height);
         365                 :         }
         366                 :       }
         367                 :
         368                 :       // Obtain the computed size along the axis of the box for this child from the computedBoxSize entry.
         369                 :       // We store the result in |width| for horizontal boxes and |height| for vertical boxes.
         370               0 :       if (frameState & NS_STATE_IS_HORIZONTAL)
         371               0 :         width = childComputedBoxSize->size;
         372                 :       else
         373               0 :         height = childComputedBoxSize->size;
         374                 :
         375                 :       // Adjust our x/y for the left/right spacing.
         376               0 :       if (frameState & NS_STATE_IS_HORIZONTAL) {
         377               0 :         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         378               0 :           x += (childBoxSize->left);
         379                 :         else
         380               0 :           x -= (childBoxSize->right);
         381                 :       } else {
         382               0 :         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         383               0 :           y += (childBoxSize->left);
         384                 :         else
         385               0 :           y -= (childBoxSize->right);
         386                 :       }
         387                 :
         388               0 :       nextX = x;
         389               0 :       nextY = y;
         390                 :
         391                 :       // Now we build a child rect.
         392               0 :       nscoord rectX = x;
         393               0 :       nscoord rectY = y;
         394               0 :       if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
         395               0 :         if (frameState & NS_STATE_IS_HORIZONTAL)
         396               0 :           rectX -= width;
         397                 :         else
         398               0 :           rectY -= height;
         399                 :       }
         400                 :
         401                 :       // We now create an accurate child rect based off our computed size information.
         402               0 :       nsRect childRect(rectX, rectY, width, height);
         403                 :
         404                 :       // Sanity check against our clientRect.  It is possible that a child specified
         405                 :       // a size that is too large to fit.  If that happens, then we have to grow
         406                 :       // our client rect.  Remember, clientRect is not the total rect of the enclosing
         407                 :       // box.  It currently holds our perception of how big the children needed to
         408                 :       // be.
         409               0 :       if (childRect.width > clientRect.width)
         410               0 :         clientRect.width = childRect.width;
         411                 :
         412               0 :       if (childRect.height > clientRect.height)
         413               0 :         clientRect.height = childRect.height;
         414                 :
         415                 :       // Either |nextX| or |nextY| is updated by this function call, according
         416                 :       // to our axis.
         417               0 :       ComputeChildsNextPosition(aBox, x, y, nextX, nextY, childRect);
         418                 :
         419                 :       // Now we further update our nextX/Y along our axis.
         420                 :       // We also set childRect.y/x along the opposite axis appropriately for a
         421                 :       // stretch alignment.  (Non-stretch alignment is handled below.)
         422               0 :       if (frameState & NS_STATE_IS_HORIZONTAL) {
         423               0 :         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         424               0 :           nextX += (childBoxSize->right);
         425                 :         else
         426               0 :           nextX -= (childBoxSize->left);
         427               0 :         childRect.y = originalClientRect.y;
         428                 :       }
         429                 :       else {
         430               0 :         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         431               0 :           nextY += (childBoxSize->right);
         432                 :         else
         433               0 :           nextY -= (childBoxSize->left);
         434               0 :         childRect.x = originalClientRect.x;
         435                 :       }
         436                 :
         437                 :       // If we encounter a completely bogus box size, we just leave this child completely
         438                 :       // alone and continue through the loop to the next child.
         439               0 :       if (childBoxSize->bogus)
         440                 :       {
         441               0 :         childComputedBoxSize = childComputedBoxSize->next;
         442               0 :         childBoxSize = childBoxSize->next;
         443               0 :         count++;
         444               0 :         x = nextX;
         445               0 :         y = nextY;
         446               0 :         continue;
         447                 :       }
         448                 :
         449               0 :       nsMargin margin(0,0,0,0);
         450                 :
         451               0 :       bool layout = true;
         452                 :
         453                 :       // Deflate the rect of our child by its margin.
         454               0 :       child->GetMargin(margin);
         455               0 :       childRect.Deflate(margin);
         456               0 :       if (childRect.width < 0)
         457               0 :         childRect.width = 0;
         458               0 :       if (childRect.height < 0)
         459               0 :         childRect.height = 0;
         460                 :
         461                 :       // Now we're trying to figure out if we have to lay out this child, i.e., to call
         462                 :       // the child's Layout method.
         463               0 :       if (passes > 0) {
         464               0 :         layout = false;
         465                 :       } else {
         466                 :         // Always perform layout if we are dirty or have dirty children
         467               0 :         if (!NS_SUBTREE_DIRTY(child))
         468               0 :           layout = false;
         469                 :       }
         470                 :
         471               0 :       nsRect oldRect(child->GetRect());
         472                 :
         473                 :       // Non-stretch alignment will be handled in AlignChildren(), so don't
         474                 :       // change child out-of-axis positions yet.
         475               0 :       if (!(frameState & NS_STATE_AUTO_STRETCH)) {
         476               0 :         if (frameState & NS_STATE_IS_HORIZONTAL) {
         477               0 :           childRect.y = oldRect.y;
         478                 :         } else {
         479               0 :           childRect.x = oldRect.x;
         480                 :         }
         481                 :       }
         482                 :
         483                 :       // We computed a childRect.  Now we want to set the bounds of the child to be that rect.
         484                 :       // If our old rect is different, then we know our size changed and we cache that fact
         485                 :       // in the |sizeChanged| variable.
         486                 :
         487               0 :       child->SetBounds(aState, childRect);
         488                 :       bool sizeChanged = (childRect.width != oldRect.width ||
         489               0 :                             childRect.height != oldRect.height);
         490                 :
         491               0 :       if (sizeChanged) {
         492                 :         // Our size is different.  Sanity check against our maximum allowed size to ensure
         493                 :         // we didn't exceed it.
         494               0 :         nsSize minSize = child->GetMinSize(aState);
         495               0 :         nsSize maxSize = child->GetMaxSize(aState);
         496               0 :         maxSize = nsBox::BoundsCheckMinMax(minSize, maxSize);
         497                 :
         498                 :         // make sure the size is in our max size.
         499               0 :         if (childRect.width > maxSize.width)
         500               0 :           childRect.width = maxSize.width;
         501                 :
         502               0 :         if (childRect.height > maxSize.height)
         503               0 :           childRect.height = maxSize.height;
         504                 :
         505                 :         // set it again
         506               0 :         child->SetBounds(aState, childRect);
         507                 :
         508                 :         // Since the child changed size, we know a redraw is probably going to be required.
         509               0 :         needsRedraw = true;
         510                 :       }
         511                 :
         512                 :       // if something moved then we might need to redraw
         513               0 :       if (oldRect.x != childRect.x || oldRect.y != childRect.y)
         514               0 :           needsRedraw = true;
         515                 :
         516                 :       // If we already determined that layout was required or if our size has changed, then
         517                 :       // we make sure to call layout on the child, since its children may need to be shifted
         518                 :       // around as a result of the size change.
         519               0 :       if (layout || sizeChanged)
         520               0 :         child->Layout(aState);
         521                 :
         522                 :       // If the child was a block or inline (e.g., HTML) it may have changed its rect *during* layout.
         523                 :       // We have to check for this.
         524               0 :       nsRect newChildRect(child->GetRect());
         525                 :
         526               0 :       if (!newChildRect.IsEqualInterior(childRect)) {
         527                 : #ifdef DEBUG_GROW
         528                 :         child->DumpBox(stdout);
         529                 :         printf(" GREW from (%d,%d) -> (%d,%d)\n", childRect.width, childRect.height, newChildRect.width, newChildRect.height);
         530                 : #endif
         531               0 :         newChildRect.Inflate(margin);
         532               0 :         childRect.Inflate(margin);
         533                 :
         534                 :         // The child changed size during layout.  The ChildResized method handles this
         535                 :         // scenario.
         536                 :         ChildResized(aBox,
         537                 :                      aState,
         538                 :                      child,
         539                 :                      childBoxSize,
         540                 :                      childComputedBoxSize,
         541                 :                      boxSizes,
         542                 :                      computedBoxSizes,
         543                 :                      childRect,
         544                 :                      newChildRect,
         545                 :                      clientRect,
         546                 :                      flexes,
         547               0 :                      finished);
         548                 :
         549                 :         // We note that a child changed size, which means that another pass will be required.
         550               0 :         childResized = true;
         551                 :
         552                 :         // Now that a child resized, it's entirely possible that OUR rect is too small.  Now we
         553                 :         // ensure that |originalClientRect| is grown to accommodate the size of |clientRect|.
         554               0 :         if (clientRect.width > originalClientRect.width)
         555               0 :           originalClientRect.width = clientRect.width;
         556                 :
         557               0 :         if (clientRect.height > originalClientRect.height)
         558               0 :           originalClientRect.height = clientRect.height;
         559                 :
         560               0 :         if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
         561                 :           // Our childRect had its XMost() or YMost() (depending on our layout
         562                 :           // direction), positioned at a certain point.  Ensure that the
         563                 :           // newChildRect satisfies the same constraint.  Note that this is
         564                 :           // just equivalent to adjusting the x/y by the difference in
         565                 :           // width/height between childRect and newChildRect.  So we don't need
         566                 :           // to reaccount for the left and right of the box layout state again.
         567               0 :           if (frameState & NS_STATE_IS_HORIZONTAL)
         568               0 :             newChildRect.x = childRect.XMost() - newChildRect.width;
         569                 :           else
         570               0 :             newChildRect.y = childRect.YMost() - newChildRect.height;
         571                 :         }
         572                 :
         573                 :         // If the child resized then recompute its position.
         574               0 :         ComputeChildsNextPosition(aBox, x, y, nextX, nextY, newChildRect);
         575                 :
         576               0 :         if (newChildRect.width >= margin.left + margin.right && newChildRect.height >= margin.top + margin.bottom)
         577               0 :           newChildRect.Deflate(margin);
         578                 :
         579               0 :         if (childRect.width >= margin.left + margin.right && childRect.height >= margin.top + margin.bottom)
         580               0 :           childRect.Deflate(margin);
         581                 :
         582               0 :         child->SetBounds(aState, newChildRect);
         583                 :
         584                 :         // If we are the first box that changed size, then we don't need to do a second pass
         585               0 :         if (count == 0)
         586               0 :           finished = true;
         587                 :       }
         588                 :
         589                 :       // Now update our x/y finally.
         590               0 :       x = nextX;
         591               0 :       y = nextY;
         592                 :
         593                 :       // Move to the next child.
         594               0 :       childComputedBoxSize = childComputedBoxSize->next;
         595               0 :       childBoxSize = childBoxSize->next;
         596                 :
         597               0 :       child = child->GetNextBox();
         598               0 :       count++;
         599                 :     }
         600                 :
         601                 :     // Sanity-checking code to ensure we don't do an infinite # of passes.
         602               0 :     passes++;
         603               0 :     NS_ASSERTION(passes < 10, "A Box's child is constantly growing!!!!!");
         604               0 :     if (passes > 10)
         605               0 :       break;
         606                 :   } while (false == finished);
         607                 :
         608                 :   // Get rid of our size lists.
         609               0 :   while(boxSizes)
         610                 :   {
         611               0 :     nsBoxSize* toDelete = boxSizes;
         612               0 :     boxSizes = boxSizes->next;
         613               0 :     delete toDelete;
         614                 :   }
         615                 :
         616               0 :   while(computedBoxSizes)
         617                 :   {
         618               0 :     nsComputedBoxSize* toDelete = computedBoxSizes;
         619               0 :     computedBoxSizes = computedBoxSizes->next;
         620               0 :     delete toDelete;
         621                 :   }
         622                 :
         623               0 :   if (childResized) {
         624                 :     // See if one of our children forced us to get bigger
         625               0 :     nsRect tmpClientRect(originalClientRect);
         626               0 :     nsMargin bp(0,0,0,0);
         627               0 :     aBox->GetBorderAndPadding(bp);
         628               0 :     tmpClientRect.Inflate(bp);
         629                 :
         630               0 :     if (tmpClientRect.width > originalSize.width || tmpClientRect.height > originalSize.height)
         631                 :     {
         632                 :       // if it did reset our bounds.
         633               0 :       nsRect bounds(aBox->GetRect());
         634               0 :       if (tmpClientRect.width > originalSize.width)
         635               0 :         bounds.width = tmpClientRect.width;
         636                 :
         637               0 :       if (tmpClientRect.height > originalSize.height)
         638               0 :         bounds.height = tmpClientRect.height;
         639                 :
         640               0 :       aBox->SetBounds(aState, bounds);
         641                 :     }
         642                 :   }
         643                 :
         644                 :   // Because our size grew, we now have to readjust because of box packing.  Repack
         645                 :   // in order to update our x and y to the correct values.
         646               0 :   HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
         647                 :
         648                 :   // Compare against our original x and y and only worry about adjusting the children if
         649                 :   // we really did have to change the positions because of packing (typically for 'center'
         650                 :   // or 'end' pack values).
         651               0 :   if (x != origX || y != origY) {
         652               0 :     nsIBox* child = aBox->GetChildBox();
         653                 :
         654                 :     // reposition all our children
         655               0 :     while (child)
         656                 :     {
         657               0 :       nsRect childRect(child->GetRect());
         658               0 :       childRect.x += (x - origX);
         659               0 :       childRect.y += (y - origY);
         660               0 :       child->SetBounds(aState, childRect);
         661               0 :       child = child->GetNextBox();
         662                 :     }
         663                 :   }
         664                 :
         665                 :   // Perform out-of-axis alignment for non-stretch alignments
         666               0 :   if (!(frameState & NS_STATE_AUTO_STRETCH)) {
         667               0 :     AlignChildren(aBox, aState, &needsRedraw);
         668                 :   }
         669                 :
         670                 :   // Now do our redraw.
         671               0 :   if (needsRedraw)
         672               0 :     aBox->Redraw(aState);
         673                 :
         674               0 :   aState.PopStackMemory();
         675                 :
         676                 :   // That's it!  If you made it this far without having a nervous breakdown,
         677                 :   // congratulations!  Go get yourself a beer.
         678               0 :   return NS_OK;
         679                 : }
         680                 :
         681                 : void
         682               0 : nsSprocketLayout::PopulateBoxSizes(nsIBox* aBox, nsBoxLayoutState& aState, nsBoxSize*& aBoxSizes, nscoord& aMinSize, nscoord& aMaxSize, PRInt32& aFlexes)
         683                 : {
         684                 :   // used for the equal size flag
         685               0 :   nscoord biggestPrefWidth = 0;
         686               0 :   nscoord biggestMinWidth = 0;
         687               0 :   nscoord smallestMaxWidth = NS_INTRINSICSIZE;
         688                 :
         689               0 :   nsFrameState frameState = 0;
         690               0 :   GetFrameState(aBox, frameState);
         691                 :
         692                 :   //if (frameState & NS_STATE_CURRENTLY_IN_DEBUG)
         693                 :   //   printf("In debug\n");
         694                 :
         695               0 :   aMinSize = 0;
         696               0 :   aMaxSize = NS_INTRINSICSIZE;
         697                 :
         698                 :   bool isHorizontal;
         699                 :
         700               0 :   if (IsHorizontal(aBox))
         701               0 :      isHorizontal = true;
         702                 :   else
         703               0 :      isHorizontal = false;
         704                 :
         705                 :   // this is a nice little optimization
         706                 :   // it turns out that if we only have 1 flexable child
         707                 :   // then it does not matter what its preferred size is
         708                 :   // there is nothing to flex it relative. This is great
         709                 :   // because we can avoid asking for a preferred size in this
         710                 :   // case. Why is this good? Well you might have html inside it
         711                 :   // and asking html for its preferred size is rather expensive.
         712                 :   // so we can just optimize it out this way.
         713                 :
         714                 :   // set flexes
         715               0 :   nsIBox* child = aBox->GetChildBox();
         716                 :
         717               0 :   aFlexes = 0;
         718               0 :   nsBoxSize* currentBox = nsnull;
         719                 :
         720                 : #if 0
         721                 :   nsBoxSize* start = aBoxSizes;
         722                 :
         723                 :   while(child)
         724                 :   {
         725                 :     // ok if we started with a list move down the list
         726                 :     // until we reach the end. Then start looking at childen.
         727                 :     // This feature is used extensively for Grid.
         728                 :     nscoord flex = 0;
         729                 :
         730                 :     if (!start) {
         731                 :       if (!currentBox) {
         732                 :         aBoxSizes      = new (aState) nsBoxSize();
         733                 :         currentBox      = aBoxSizes;
         734                 :       } else {
         735                 :         currentBox->next      = new (aState) nsBoxSize();
         736                 :         currentBox      = currentBox->next;
         737                 :       }
         738                 :
         739                 :
         740                 :       flex = child->GetFlex(aState);
         741                 :
         742                 :       currentBox->flex = flex;
         743                 :       currentBox->collapsed = child->IsCollapsed();
         744                 :     } else {
         745                 :       flex = start->flex;
         746                 :       start = start->next;
         747                 :     }
         748                 :
         749                 :     if (flex > 0)
         750                 :        aFlexes++;
         751                 :
         752                 :     child = child->GetNextBox();
         753                 :   }
         754                 : #endif
         755                 :
         756                 :   // get pref, min, max
         757               0 :   child = aBox->GetChildBox();
         758               0 :   currentBox = aBoxSizes;
         759               0 :   nsBoxSize* last = nsnull;
         760                 :
         761               0 :   nscoord maxFlex = 0;
         762               0 :   PRInt32 childCount = 0;
         763                 :
         764               0 :   while(child)
         765                 :   {
         766               0 :     while (currentBox && currentBox->bogus) {
         767               0 :       last = currentBox;
         768               0 :       currentBox = currentBox->next;
         769                 :     }
         770               0 :     ++childCount;
         771               0 :     nsSize pref(0,0);
         772               0 :     nsSize minSize(0,0);
         773               0 :     nsSize maxSize(NS_INTRINSICSIZE,NS_INTRINSICSIZE);
         774               0 :     nscoord ascent = 0;
         775               0 :     bool collapsed = child->IsCollapsed();
         776                 :
         777               0 :     if (!collapsed) {
         778                 :     // only one flexible child? Cool we will just make its preferred size
         779                 :     // 0 then and not even have to ask for it.
         780                 :     //if (flexes != 1)  {
         781                 :
         782               0 :       pref = child->GetPrefSize(aState);
         783               0 :       minSize = child->GetMinSize(aState);
         784               0 :       maxSize = nsBox::BoundsCheckMinMax(minSize, child->GetMaxSize(aState));
         785               0 :       ascent = child->GetBoxAscent(aState);
         786               0 :       nsMargin margin;
         787               0 :       child->GetMargin(margin);
         788               0 :       ascent += margin.top;
         789                 :     //}
         790                 :
         791               0 :       pref = nsBox::BoundsCheck(minSize, pref, maxSize);
         792                 :
         793               0 :       AddMargin(child, pref);
         794               0 :       AddMargin(child, minSize);
         795               0 :       AddMargin(child, maxSize);
         796                 :     }
         797                 :
         798               0 :     if (!currentBox) {
         799                 :       // create one.
         800               0 :       currentBox = new (aState) nsBoxSize();
         801               0 :       if (!aBoxSizes) {
         802               0 :         aBoxSizes = currentBox;
         803               0 :         last = aBoxSizes;
         804                 :       } else {
         805               0 :         last->next = currentBox;
         806               0 :         last = currentBox;
         807                 :       }
         808                 :
         809                 :       nscoord minWidth;
         810                 :       nscoord maxWidth;
         811                 :       nscoord prefWidth;
         812                 :
         813                 :       // get sizes from child
         814               0 :       if (isHorizontal) {
         815               0 :           minWidth  = minSize.width;
         816               0 :           maxWidth  = maxSize.width;
         817               0 :           prefWidth = pref.width;
         818                 :       } else {
         819               0 :           minWidth = minSize.height;
         820               0 :           maxWidth = maxSize.height;
         821               0 :           prefWidth = pref.height;
         822                 :       }
         823                 :
         824               0 :       nscoord flex = child->GetFlex(aState);
         825                 :
         826                 :       // set them if you collapsed you are not flexible.
         827               0 :       if (collapsed) {
         828               0 :         currentBox->flex = 0;
         829                 :       }
         830                 :       else {
         831               0 :         if (flex > maxFlex) {
         832               0 :           maxFlex = flex;
         833                 :         }
         834               0 :         currentBox->flex = flex;
         835                 :       }
         836                 :
         837                 :       // we specified all our children are equal size;
         838               0 :       if (frameState & NS_STATE_EQUAL_SIZE) {
         839                 :
         840               0 :         if (prefWidth > biggestPrefWidth)
         841               0 :           biggestPrefWidth = prefWidth;
         842                 :
         843               0 :         if (minWidth > biggestMinWidth)
         844               0 :           biggestMinWidth = minWidth;
         845                 :
         846               0 :         if (maxWidth < smallestMaxWidth)
         847               0 :           smallestMaxWidth = maxWidth;
         848                 :       } else { // not we can set our children right now.
         849               0 :         currentBox->pref    = prefWidth;
         850               0 :         currentBox->min     = minWidth;
         851               0 :         currentBox->max     = maxWidth;
         852                 :       }
         853                 :
         854               0 :       NS_ASSERTION(minWidth <= prefWidth && prefWidth <= maxWidth,"Bad min, pref, max widths!");
         855                 :
         856                 :     }
         857                 :
         858               0 :     if (!isHorizontal) {
         859               0 :       if (minSize.width > aMinSize)
         860               0 :         aMinSize = minSize.width;
         861                 :
         862               0 :       if (maxSize.width < aMaxSize)
         863               0 :         aMaxSize = maxSize.width;
         864                 :
         865                 :     } else {
         866               0 :       if (minSize.height > aMinSize)
         867               0 :         aMinSize = minSize.height;
         868                 :
         869               0 :       if (maxSize.height < aMaxSize)
         870               0 :         aMaxSize = maxSize.height;
         871                 :     }
         872                 :
         873               0 :     currentBox->collapsed = collapsed;
         874               0 :     aFlexes += currentBox->flex;
         875                 :
         876               0 :     child = child->GetNextBox();
         877                 :
         878               0 :     last = currentBox;
         879               0 :     currentBox = currentBox->next;
         880                 :
         881                 :   }
         882                 :
         883               0 :   if (childCount > 0) {
         884               0 :     nscoord maxAllowedFlex = nscoord_MAX / childCount;
         885                 :
         886               0 :     if (NS_UNLIKELY(maxFlex > maxAllowedFlex)) {
         887                 :       // clamp all the flexes
         888               0 :       currentBox = aBoxSizes;
         889               0 :       while (currentBox) {
         890               0 :         currentBox->flex = NS_MIN(currentBox->flex, maxAllowedFlex);
         891               0 :         currentBox = currentBox->next;
         892                 :       }
         893                 :     }
         894                 :   }
         895                 : #ifdef DEBUG
         896                 :   else {
         897               0 :     NS_ASSERTION(maxFlex == 0, "How did that happen?");
         898                 :   }
         899                 : #endif
         900                 :
         901                 :   // we specified all our children are equal size;
         902               0 :   if (frameState & NS_STATE_EQUAL_SIZE) {
         903               0 :     smallestMaxWidth = NS_MAX(smallestMaxWidth, biggestMinWidth);
         904               0 :     biggestPrefWidth = nsBox::BoundsCheck(biggestMinWidth, biggestPrefWidth, smallestMaxWidth);
         905                 :
         906               0 :     currentBox = aBoxSizes;
         907                 :
         908               0 :     while(currentBox)
         909                 :     {
         910               0 :       if (!currentBox->collapsed) {
         911               0 :         currentBox->pref = biggestPrefWidth;
         912               0 :         currentBox->min = biggestMinWidth;
         913               0 :         currentBox->max = smallestMaxWidth;
         914                 :       } else {
         915               0 :         currentBox->pref = 0;
         916               0 :         currentBox->min = 0;
         917               0 :         currentBox->max = 0;
         918                 :       }
         919               0 :       currentBox = currentBox->next;
         920                 :     }
         921                 :   }
         922                 :
         923               0 : }
         924                 :
         925                 : void
         926               0 : nsSprocketLayout::ComputeChildsNextPosition(nsIBox* aBox,
         927                 :                                       const nscoord& aCurX,
         928                 :                                       const nscoord& aCurY,
         929                 :                                       nscoord& aNextX,
         930                 :                                       nscoord& aNextY,
         931                 :                                       const nsRect& aCurrentChildSize)
         932                 : {
         933                 :   // Get the position along the box axis for the child.
         934                 :   // The out-of-axis position is not set.
         935               0 :   nsFrameState frameState = 0;
         936               0 :   GetFrameState(aBox, frameState);
         937                 :
         938               0 :   if (IsHorizontal(aBox)) {
         939                 :     // horizontal box's children.
         940               0 :     if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         941               0 :       aNextX = aCurX + aCurrentChildSize.width;
         942                 :     else
         943               0 :       aNextX = aCurX - aCurrentChildSize.width;
         944                 :
         945                 :   } else {
         946                 :     // vertical box's children.
         947               0 :     if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
         948               0 :       aNextY = aCurY + aCurrentChildSize.height;
         949                 :     else
         950               0 :       aNextY = aCurY - aCurrentChildSize.height;
         951                 :   }
         952               0 : }
         953                 :
         954                 : void
         955               0 : nsSprocketLayout::AlignChildren(nsIBox* aBox,
         956                 :                                 nsBoxLayoutState& aState,
         957                 :                                 bool* aNeedsRedraw)
         958                 : {
         959               0 :   nsFrameState frameState = 0;
         960               0 :   GetFrameState(aBox, frameState);
         961               0 :   bool isHorizontal = (frameState & NS_STATE_IS_HORIZONTAL) != 0;
         962               0 :   nsRect clientRect;
         963               0 :   aBox->GetClientRect(clientRect);
         964                 :
         965               0 :   NS_PRECONDITION(!(frameState & NS_STATE_AUTO_STRETCH),
         966                 :                   "Only AlignChildren() with non-stretch alignment");
         967                 :
         968                 :   // These are only calculated if needed
         969                 :   nsIBox::Halignment halign;
         970                 :   nsIBox::Valignment valign;
         971                 :   nscoord maxAscent;
         972                 :   bool isLTR;
         973                 :
         974               0 :   if (isHorizontal) {
         975               0 :     valign = aBox->GetVAlign();
         976               0 :     if (valign == nsBoxFrame::vAlign_BaseLine) {
         977               0 :       maxAscent = aBox->GetBoxAscent(aState);
         978                 :     }
         979                 :   } else {
         980               0 :     isLTR = GetFrameDirection(aBox) == NS_STYLE_DIRECTION_LTR;
         981               0 :     halign = aBox->GetHAlign();
         982                 :   }
         983                 :
         984               0 :   nsIBox* child = aBox->GetChildBox();
         985               0 :   while (child) {
         986                 :
         987               0 :     nsMargin margin;
         988               0 :     child->GetMargin(margin);
         989               0 :     nsRect childRect = child->GetRect();
         990                 :
         991               0 :     if (isHorizontal) {
         992               0 :       const nscoord startAlign = clientRect.y + margin.top;
         993                 :       const nscoord endAlign =
         994               0 :         clientRect.YMost() - margin.bottom - childRect.height;
         995                 :
         996                 :       nscoord y;
         997               0 :       switch (valign) {
         998                 :         case nsBoxFrame::vAlign_Top:
         999               0 :           y = startAlign;
        1000               0 :           break;
        1001                 :         case nsBoxFrame::vAlign_Middle:
        1002                 :           // Should this center the border box?
        1003                 :           // This centers the margin box, the historical behavior.
        1004               0 :           y = (startAlign + endAlign) / 2;
        1005               0 :           break;
        1006                 :         case nsBoxFrame::vAlign_Bottom:
        1007               0 :           y = endAlign;
        1008               0 :           break;
        1009                 :         case nsBoxFrame::vAlign_BaseLine:
        1010                 :           // Alignments don't force the box to grow (only sizes do),
        1011                 :           // so keep the children within the box.
        1012               0 :           y = maxAscent - child->GetBoxAscent(aState);
        1013               0 :           y = NS_MAX(startAlign, y);
        1014               0 :           y = NS_MIN(y, endAlign);
        1015               0 :           break;
        1016                 :       }
        1017                 :
        1018               0 :       childRect.y = y;
        1019                 :
        1020                 :     } else { // vertical box
        1021               0 :       const nscoord leftAlign = clientRect.x + margin.left;
        1022                 :       const nscoord rightAlign =
        1023               0 :         clientRect.XMost() - margin.right - childRect.width;
        1024                 :
        1025                 :       nscoord x;
        1026               0 :       switch (halign) {
        1027                 :         case nsBoxFrame::hAlign_Left: // start
        1028               0 :           x = isLTR ? leftAlign : rightAlign;
        1029               0 :           break;
        1030                 :         case nsBoxFrame::hAlign_Center:
        1031               0 :           x = (leftAlign + rightAlign) / 2;
        1032               0 :           break;
        1033                 :         case nsBoxFrame::hAlign_Right: // end
        1034               0 :           x = isLTR ? rightAlign : leftAlign;
        1035               0 :           break;
        1036                 :       }
        1037                 :
        1038               0 :       childRect.x = x;
        1039                 :     }
        1040                 :
        1041               0 :     if (childRect.TopLeft() != child->GetPosition()) {
        1042               0 :       *aNeedsRedraw = true;
        1043               0 :       child->SetBounds(aState, childRect);
        1044                 :     }
        1045                 :
        1046               0 :     child = child->GetNextBox();
        1047                 :   }
        1048               0 : }
        1049                 :
        1050                 : void
        1051               0 : nsSprocketLayout::ChildResized(nsIBox* aBox,
        1052                 :                          nsBoxLayoutState& aState,
        1053                 :                          nsIBox* aChild,
        1054                 :                          nsBoxSize* aChildBoxSize,
        1055                 :                          nsComputedBoxSize* aChildComputedSize,
        1056                 :                          nsBoxSize* aBoxSizes,
        1057                 :                          nsComputedBoxSize* aComputedBoxSizes,
        1058                 :                          const nsRect& aChildLayoutRect,
        1059                 :                          nsRect& aChildActualRect,
        1060                 :                          nsRect& aContainingRect,
        1061                 :                          PRInt32 aFlexes,
        1062                 :                          bool& aFinished)
        1063                 :
        1064                 : {
        1065               0 :       nsRect childCurrentRect(aChildLayoutRect);
        1066                 :
        1067               0 :       bool isHorizontal = IsHorizontal(aBox);
        1068               0 :       nscoord childLayoutWidth  = GET_WIDTH(aChildLayoutRect,isHorizontal);
        1069               0 :       nscoord& childActualWidth  = GET_WIDTH(aChildActualRect,isHorizontal);
        1070               0 :       nscoord& containingWidth   = GET_WIDTH(aContainingRect,isHorizontal);
        1071                 :
        1072                 :       //nscoord childLayoutHeight = GET_HEIGHT(aChildLayoutRect,isHorizontal);
        1073               0 :       nscoord& childActualHeight = GET_HEIGHT(aChildActualRect,isHorizontal);
        1074               0 :       nscoord& containingHeight  = GET_HEIGHT(aContainingRect,isHorizontal);
        1075                 :
        1076               0 :       bool recompute = false;
        1077                 :
        1078                 :       // if we are a horizontal box see if the child will fit inside us.
        1079               0 :       if ( childActualHeight > containingHeight) {
        1080                 :             // if we are a horizontal box and the child is bigger than our height
        1081                 :
        1082                 :             // ok if the height changed then we need to reflow everyone but us at the new height
        1083                 :             // so we will set the changed index to be us. And signal that we need a new pass.
        1084                 :
        1085               0 :             nsSize min = aChild->GetMinSize(aState);
        1086               0 :             nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
        1087               0 :             AddMargin(aChild, max);
        1088                 :
        1089               0 :             if (isHorizontal)
        1090               0 :               childActualHeight = max.height < childActualHeight ? max.height : childActualHeight;
        1091                 :             else
        1092               0 :               childActualHeight = max.width < childActualHeight ? max.width : childActualHeight;
        1093                 :
        1094                 :             // only set if it changes
        1095               0 :             if (childActualHeight > containingHeight) {
        1096               0 :                  containingHeight = childActualHeight;
        1097                 :
        1098                 :               // remember we do not need to clear the resized list because changing the height of a horizontal box
        1099                 :               // will not affect the width of any of its children because block flow left to right, top to bottom. Just trust me
        1100                 :               // on this one.
        1101               0 :               aFinished = false;
        1102                 :
        1103                 :               // only recompute if there are flexes.
        1104               0 :               if (aFlexes > 0) {
        1105                 :                 // relayout everything
        1106               0 :                 recompute = true;
        1107               0 :                 InvalidateComputedSizes(aComputedBoxSizes);
        1108               0 :                 nsComputedBoxSize* node = aComputedBoxSizes;
        1109                 :
        1110               0 :                 while(node) {
        1111               0 :                   node->resized = false;
        1112               0 :                   node = node->next;
        1113                 :                 }
        1114                 :
        1115                 :               }
        1116                 :             }
        1117                 :       }
        1118                 :
        1119               0 :       if (childActualWidth > childLayoutWidth) {
        1120               0 :             nsSize min = aChild->GetMinSize(aState);
        1121               0 :             nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
        1122                 :
        1123               0 :             AddMargin(aChild, max);
        1124                 :
        1125                 :             // our width now becomes the new size
        1126                 :
        1127               0 :             if (isHorizontal)
        1128               0 :               childActualWidth = max.width < childActualWidth ? max.width : childActualWidth;
        1129                 :             else
        1130               0 :               childActualWidth = max.height < childActualWidth ? max.height : childActualWidth;
        1131                 :
        1132               0 :             if (childActualWidth > childLayoutWidth) {
        1133               0 :                aChildComputedSize->size = childActualWidth;
        1134               0 :                aChildBoxSize->min = childActualWidth;
        1135               0 :                if (aChildBoxSize->pref < childActualWidth)
        1136               0 :                   aChildBoxSize->pref = childActualWidth;
        1137               0 :                if (aChildBoxSize->max < childActualWidth)
        1138               0 :                   aChildBoxSize->max = childActualWidth;
        1139                 :
        1140                 :               // if we have flexible elements with us then reflex things. Otherwise we can skip doing it.
        1141               0 :               if (aFlexes > 0) {
        1142               0 :                 InvalidateComputedSizes(aComputedBoxSizes);
        1143                 :
        1144               0 :                 nsComputedBoxSize* node = aComputedBoxSizes;
        1145               0 :                 aChildComputedSize->resized = true;
        1146                 :
        1147               0 :                 while(node) {
        1148               0 :                   if (node->resized)
        1149               0 :                       node->valid = true;
        1150                 :
        1151               0 :                   node = node->next;
        1152                 :                 }
        1153                 :
        1154               0 :                 recompute = true;
        1155               0 :                 aFinished = false;
        1156                 :               } else {
        1157               0 :                 containingWidth += aChildComputedSize->size - childLayoutWidth;
        1158                 :               }
        1159                 :             }
        1160                 :       }
        1161                 :
        1162               0 :       if (recompute)
        1163               0 :             ComputeChildSizes(aBox, aState, containingWidth, aBoxSizes, aComputedBoxSizes);
        1164                 :
        1165               0 :       if (!childCurrentRect.IsEqualInterior(aChildActualRect)) {
        1166                 :         // the childRect includes the margin
        1167                 :         // make sure we remove it before setting
        1168                 :         // the bounds.
        1169               0 :         nsMargin margin(0,0,0,0);
        1170               0 :         aChild->GetMargin(margin);
        1171               0 :         nsRect rect(aChildActualRect);
        1172               0 :         if (rect.width >= margin.left + margin.right && rect.height >= margin.top + margin.bottom)
        1173               0 :           rect.Deflate(margin);
        1174                 :
        1175               0 :         aChild->SetBounds(aState, rect);
        1176               0 :         aChild->Layout(aState);
        1177                 :       }
        1178                 :
        1179               0 : }
        1180                 :
        1181                 : void
        1182               0 : nsSprocketLayout::InvalidateComputedSizes(nsComputedBoxSize* aComputedBoxSizes)
        1183                 : {
        1184               0 :   while(aComputedBoxSizes) {
        1185               0 :       aComputedBoxSizes->valid = false;
        1186               0 :       aComputedBoxSizes = aComputedBoxSizes->next;
        1187                 :   }
        1188               0 : }
        1189                 :
        1190                 : void
        1191               0 : nsSprocketLayout::ComputeChildSizes(nsIBox* aBox,
        1192                 :                            nsBoxLayoutState& aState,
        1193                 :                            nscoord& aGivenSize,
        1194                 :                            nsBoxSize* aBoxSizes,
        1195                 :                            nsComputedBoxSize*& aComputedBoxSizes)
        1196                 : {
        1197                 :
        1198                 :   //nscoord onePixel = aState.PresContext()->IntScaledPixelsToTwips(1);
        1199                 :
        1200               0 :   PRInt32 sizeRemaining            = aGivenSize;
        1201               0 :   PRInt32 spacerConstantsRemaining = 0;
        1202                 :
        1203                 :    // ----- calculate the spacers constants and the size remaining -----
        1204                 :
        1205               0 :   if (!aComputedBoxSizes)
        1206               0 :       aComputedBoxSizes = new (aState) nsComputedBoxSize();
        1207                 :
        1208               0 :   nsBoxSize*         boxSizes = aBoxSizes;
        1209               0 :   nsComputedBoxSize* computedBoxSizes = aComputedBoxSizes;
        1210               0 :   PRInt32 count = 0;
        1211               0 :   PRInt32 validCount = 0;
        1212                 :
        1213               0 :   while (boxSizes)
        1214                 :   {
        1215                 :
        1216               0 :     NS_ASSERTION((boxSizes->min <= boxSizes->pref && boxSizes->pref <= boxSizes->max),"bad pref, min, max size");
        1217                 :
        1218                 :
        1219                 :      // ignore collapsed children
        1220                 :   //  if (boxSizes->collapsed)
        1221                 :   //  {
        1222                 :     //  computedBoxSizes->valid = true;
        1223                 :     //  computedBoxSizes->size = boxSizes->pref;
        1224                 :      // validCount++;
        1225                 :   //      boxSizes->flex = 0;
        1226                 :    // }// else {
        1227                 :
        1228               0 :       if (computedBoxSizes->valid) {
        1229               0 :         sizeRemaining -= computedBoxSizes->size;
        1230               0 :         validCount++;
        1231                 :       } else {
        1232               0 :           if (boxSizes->flex == 0)
        1233                 :           {
        1234               0 :             computedBoxSizes->valid = true;
        1235               0 :             computedBoxSizes->size = boxSizes->pref;
        1236               0 :             validCount++;
        1237                 :           }
        1238                 :
        1239               0 :           spacerConstantsRemaining += boxSizes->flex;
        1240               0 :           sizeRemaining -= boxSizes->pref;
        1241                 :       }
        1242                 :
        1243               0 :       sizeRemaining -= (boxSizes->left + boxSizes->right);
        1244                 :
        1245                 :     //}
        1246                 :
        1247               0 :     boxSizes = boxSizes->next;
        1248                 :
        1249               0 :     if (boxSizes && !computedBoxSizes->next)
        1250               0 :       computedBoxSizes->next = new (aState) nsComputedBoxSize();
        1251                 :
        1252               0 :     computedBoxSizes = computedBoxSizes->next;
        1253               0 :     count++;
        1254                 :   }
        1255                 :
        1256                 :   // everything accounted for?
        1257               0 :   if (validCount < count)
        1258                 :   {
        1259                 :     // ----- Ok we are give a size to fit into so stretch or squeeze to fit
        1260                 :     // ----- Make sure we look at our min and max size
        1261               0 :     bool limit = true;
        1262               0 :     for (int pass=1; true == limit; pass++)
        1263                 :     {
        1264               0 :       limit = false;
        1265               0 :       boxSizes = aBoxSizes;
        1266               0 :       computedBoxSizes = aComputedBoxSizes;
        1267                 :
        1268               0 :       while (boxSizes) {
        1269                 :
        1270                 :         // ignore collapsed spacers
        1271                 :
        1272                 :    //    if (!boxSizes->collapsed) {
        1273                 :
        1274               0 :           nscoord pref = 0;
        1275               0 :           nscoord max  = NS_INTRINSICSIZE;
        1276               0 :           nscoord min  = 0;
        1277               0 :           nscoord flex = 0;
        1278                 :
        1279               0 :           pref = boxSizes->pref;
        1280               0 :           min  = boxSizes->min;
        1281               0 :           max  = boxSizes->max;
        1282               0 :           flex = boxSizes->flex;
        1283                 :
        1284                 :           // ----- look at our min and max limits make sure we aren't too small or too big -----
        1285               0 :           if (!computedBoxSizes->valid) {
        1286               0 :             PRInt32 newSize = pref + PRInt32(PRInt64(sizeRemaining) * flex / spacerConstantsRemaining);
        1287                 :
        1288               0 :             if (newSize<=min) {
        1289               0 :               computedBoxSizes->size = min;
        1290               0 :               computedBoxSizes->valid = true;
        1291               0 :               spacerConstantsRemaining -= flex;
        1292               0 :               sizeRemaining += pref;
        1293               0 :               sizeRemaining -= min;
        1294               0 :               limit = true;
        1295               0 :             } else if (newSize>=max) {
        1296               0 :               computedBoxSizes->size = max;
        1297               0 :               computedBoxSizes->valid = true;
        1298               0 :               spacerConstantsRemaining -= flex;
        1299               0 :               sizeRemaining += pref;
        1300               0 :               sizeRemaining -= max;
        1301               0 :               limit = true;
        1302                 :             }
        1303                 :           }
        1304                 :        // }
        1305               0 :         boxSizes         = boxSizes->next;
        1306               0 :         computedBoxSizes = computedBoxSizes->next;
        1307                 :       }
        1308                 :     }
        1309                 :   }
        1310                 :
        1311                 :   // ---- once we have removed and min and max issues just stretch us out in the remaining space
        1312                 :   // ---- or shrink us. Depends on the size remaining and the spacer constants
        1313               0 :   aGivenSize = 0;
        1314               0 :   boxSizes = aBoxSizes;
        1315               0 :   computedBoxSizes = aComputedBoxSizes;
        1316                 :
        1317               0 :   while (boxSizes) {
        1318                 :
        1319                 :     // ignore collapsed spacers
        1320                 :   //  if (!(boxSizes && boxSizes->collapsed)) {
        1321                 :
        1322               0 :       nscoord pref = 0;
        1323               0 :       nscoord flex = 0;
        1324               0 :       pref = boxSizes->pref;
        1325               0 :       flex = boxSizes->flex;
        1326                 :
        1327               0 :       if (!computedBoxSizes->valid) {
        1328               0 :         computedBoxSizes->size = pref + PRInt32(PRInt64(sizeRemaining) * flex / spacerConstantsRemaining);
        1329               0 :         computedBoxSizes->valid = true;
        1330                 :       }
        1331                 :
        1332               0 :       aGivenSize += (boxSizes->left + boxSizes->right);
        1333               0 :       aGivenSize += computedBoxSizes->size;
        1334                 :
        1335                 :    // }
        1336                 :
        1337               0 :     boxSizes         = boxSizes->next;
        1338               0 :     computedBoxSizes = computedBoxSizes->next;
        1339                 :   }
        1340               0 : }
        1341                 :
        1342                 :
        1343                 : nsSize
        1344               0 : nsSprocketLayout::GetPrefSize(nsIBox* aBox, nsBoxLayoutState& aState)
        1345                 : {
        1346               0 :    nsSize vpref (0, 0);
        1347               0 :    bool isHorizontal = IsHorizontal(aBox);
        1348                 :
        1349               0 :    nscoord biggestPref = 0;
        1350                 :
        1351                 :    // run through all the children and get their min, max, and preferred sizes
        1352                 :    // return us the size of the box
        1353                 :
        1354               0 :    nsIBox* child = aBox->GetChildBox();
        1355               0 :    nsFrameState frameState = 0;
        1356               0 :    GetFrameState(aBox, frameState);
        1357               0 :    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
        1358               0 :    PRInt32 count = 0;
        1359                 :
        1360               0 :    while (child)
        1361                 :    {
        1362                 :       // ignore collapsed children
        1363               0 :       if (!child->IsCollapsed())
        1364                 :       {
        1365               0 :         nsSize pref = child->GetPrefSize(aState);
        1366               0 :         AddMargin(child, pref);
        1367                 :
        1368               0 :         if (isEqual) {
        1369               0 :           if (isHorizontal)
        1370                 :           {
        1371               0 :             if (pref.width > biggestPref)
        1372               0 :               biggestPref = pref.width;
        1373                 :           } else {
        1374               0 :             if (pref.height > biggestPref)
        1375               0 :               biggestPref = pref.height;
        1376                 :           }
        1377                 :         }
        1378                 :
        1379               0 :         AddLargestSize(vpref, pref, isHorizontal);
        1380               0 :         count++;
        1381                 :       }
        1382                 :
        1383               0 :       child = child->GetNextBox();
        1384                 :    }
        1385                 :
        1386               0 :    if (isEqual) {
        1387               0 :       if (isHorizontal)
        1388               0 :          vpref.width = biggestPref*count;
        1389                 :       else
        1390               0 :          vpref.height = biggestPref*count;
        1391                 :    }
        1392                 :
        1393                 :    // now add our border and padding
        1394               0 :    AddBorderAndPadding(aBox, vpref);
        1395                 :
        1396                 :   return vpref;
        1397                 : }
        1398                 :
        1399                 : nsSize
        1400               0 : nsSprocketLayout::GetMinSize(nsIBox* aBox, nsBoxLayoutState& aState)
        1401                 : {
        1402               0 :    nsSize minSize (0, 0);
        1403               0 :    bool isHorizontal = IsHorizontal(aBox);
        1404                 :
        1405               0 :    nscoord biggestMin = 0;
        1406                 :
        1407                 :
        1408                 :    // run through all the children and get their min, max, and preferred sizes
        1409                 :    // return us the size of the box
        1410                 :
        1411               0 :    nsIBox* child = aBox->GetChildBox();
        1412               0 :    nsFrameState frameState = 0;
        1413               0 :    GetFrameState(aBox, frameState);
        1414               0 :    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
        1415               0 :    PRInt32 count = 0;
        1416                 :
        1417               0 :    while (child)
        1418                 :    {
        1419                 :        // ignore collapsed children
        1420               0 :       if (!child->IsCollapsed())
        1421                 :       {
        1422               0 :         nsSize min = child->GetMinSize(aState);
        1423               0 :         nsSize pref(0,0);
        1424                 :
        1425                 :         // if the child is not flexible then
        1426                 :         // its min size is its pref size.
        1427               0 :         if (child->GetFlex(aState) == 0) {
        1428               0 :             pref = child->GetPrefSize(aState);
        1429               0 :             if (isHorizontal)
        1430               0 :                min.width = pref.width;
        1431                 :             else
        1432               0 :                min.height = pref.height;
        1433                 :         }
        1434                 :
        1435               0 :         if (isEqual) {
        1436               0 :           if (isHorizontal)
        1437                 :           {
        1438               0 :             if (min.width > biggestMin)
        1439               0 :               biggestMin = min.width;
        1440                 :           } else {
        1441               0 :             if (min.height > biggestMin)
        1442               0 :               biggestMin = min.height;
        1443                 :           }
        1444                 :         }
        1445                 :
        1446               0 :         AddMargin(child, min);
        1447               0 :         AddLargestSize(minSize, min, isHorizontal);
        1448               0 :         count++;
        1449                 :       }
        1450                 :
        1451               0 :       child = child->GetNextBox();
        1452                 :    }
        1453                 :
        1454                 :
        1455               0 :    if (isEqual) {
        1456               0 :       if (isHorizontal)
        1457               0 :          minSize.width = biggestMin*count;
        1458                 :       else
        1459               0 :          minSize.height = biggestMin*count;
        1460                 :    }
        1461                 :
        1462                 :   // now add our border and padding
        1463               0 :   AddBorderAndPadding(aBox, minSize);
        1464                 :
        1465                 :   return minSize;
        1466                 : }
        1467                 :
        1468                 : nsSize
        1469               0 : nsSprocketLayout::GetMaxSize(nsIBox* aBox, nsBoxLayoutState& aState)
        1470                 : {
        1471                 :
        1472               0 :   bool isHorizontal = IsHorizontal(aBox);
        1473                 :
        1474               0 :    nscoord smallestMax = NS_INTRINSICSIZE;
        1475               0 :    nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
        1476                 :
        1477                 :    // run through all the children and get their min, max, and preferred sizes
        1478                 :    // return us the size of the box
        1479                 :
        1480               0 :    nsIBox* child = aBox->GetChildBox();
        1481               0 :    nsFrameState frameState = 0;
        1482               0 :    GetFrameState(aBox, frameState);
        1483               0 :    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
        1484               0 :    PRInt32 count = 0;
        1485                 :
        1486               0 :    while (child)
        1487                 :    {
        1488                 :       // ignore collapsed children
        1489               0 :       if (!child->IsCollapsed())
        1490                 :       {
        1491                 :         // if completely redefined don't even ask our child for its size.
        1492               0 :         nsSize min = child->GetMinSize(aState);
        1493               0 :         nsSize max = nsBox::BoundsCheckMinMax(min, child->GetMaxSize(aState));
        1494                 :
        1495               0 :         AddMargin(child, max);
        1496               0 :         AddSmallestSize(maxSize, max, isHorizontal);
        1497                 :
        1498               0 :         if (isEqual) {
        1499               0 :           if (isHorizontal)
        1500                 :           {
        1501               0 :             if (max.width < smallestMax)
        1502               0 :               smallestMax = max.width;
        1503                 :           } else {
        1504               0 :             if (max.height < smallestMax)
        1505               0 :               smallestMax = max.height;
        1506                 :           }
        1507                 :         }
        1508               0 :         count++;
        1509                 :       }
        1510                 :
        1511               0 :       child = child->GetNextBox();
        1512                 :    }
        1513                 :
        1514               0 :    if (isEqual) {
        1515               0 :      if (isHorizontal) {
        1516               0 :          if (smallestMax != NS_INTRINSICSIZE)
        1517               0 :             maxSize.width = smallestMax*count;
        1518                 :          else
        1519               0 :             maxSize.width = NS_INTRINSICSIZE;
        1520                 :      } else {
        1521               0 :          if (smallestMax != NS_INTRINSICSIZE)
        1522               0 :             maxSize.height = smallestMax*count;
        1523                 :          else
        1524               0 :             maxSize.height = NS_INTRINSICSIZE;
        1525                 :      }
        1526                 :    }
        1527                 :
        1528                 :   // now add our border and padding
        1529               0 :   AddBorderAndPadding(aBox, maxSize);
        1530                 :
        1531                 :   return maxSize;
        1532                 : }
        1533                 :
        1534                 :
        1535                 : nscoord
        1536               0 : nsSprocketLayout::GetAscent(nsIBox* aBox, nsBoxLayoutState& aState)
        1537                 : {
        1538               0 :    nscoord vAscent = 0;
        1539                 :
        1540               0 :    bool isHorizontal = IsHorizontal(aBox);
        1541                 :
        1542                 :    // run through all the children and get their min, max, and preferred sizes
        1543                 :    // return us the size of the box
        1544                 :
        1545               0 :    nsIBox* child = aBox->GetChildBox();
        1546                 :
        1547               0 :    while (child)
        1548                 :    {
        1549                 :       // ignore collapsed children
        1550                 :       //if (!child->IsCollapsed())
        1551                 :       //{
        1552                 :         // if completely redefined don't even ask our child for its size.
        1553               0 :         nscoord ascent = child->GetBoxAscent(aState);
        1554                 :
        1555               0 :         nsMargin margin;
        1556               0 :         child->GetMargin(margin);
        1557               0 :         ascent += margin.top;
        1558                 :
        1559               0 :         if (isHorizontal)
        1560                 :         {
        1561               0 :           if (ascent > vAscent)
        1562               0 :             vAscent = ascent;
        1563                 :         } else {
        1564               0 :           if (vAscent == 0)
        1565               0 :             vAscent = ascent;
        1566                 :         }
        1567                 :       //}
        1568                 :
        1569               0 :       child = child->GetNextBox();
        1570                 :    }
        1571                 :
        1572               0 :    nsMargin borderPadding;
        1573               0 :    aBox->GetBorderAndPadding(borderPadding);
        1574                 :
        1575               0 :    return vAscent + borderPadding.top;
        1576                 : }
        1577                 :
        1578                 : void
        1579               0 : nsSprocketLayout::SetLargestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
        1580                 : {
        1581               0 :   if (aIsHorizontal)
        1582                 :   {
        1583               0 :     if (aSize1.height < aSize2.height)
        1584               0 :        aSize1.height = aSize2.height;
        1585                 :   } else {
        1586               0 :     if (aSize1.width < aSize2.width)
        1587               0 :        aSize1.width = aSize2.width;
        1588                 :   }
        1589               0 : }
        1590                 :
        1591                 : void
        1592               0 : nsSprocketLayout::SetSmallestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
        1593                 : {
        1594               0 :   if (aIsHorizontal)
        1595                 :   {
        1596               0 :     if (aSize1.height > aSize2.height)
        1597               0 :        aSize1.height = aSize2.height;
        1598                 :   } else {
        1599               0 :     if (aSize1.width > aSize2.width)
        1600               0 :        aSize1.width = aSize2.width;
        1601                 :
        1602                 :   }
        1603               0 : }
        1604                 :
        1605                 : void
        1606               0 : nsSprocketLayout::AddLargestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
        1607                 : {
        1608               0 :   if (aIsHorizontal)
        1609               0 :     AddCoord(aSize.width, aSizeToAdd.width);
        1610                 :   else
        1611               0 :     AddCoord(aSize.height, aSizeToAdd.height);
        1612                 :
        1613               0 :   SetLargestSize(aSize, aSizeToAdd, aIsHorizontal);
        1614               0 : }
        1615                 :
        1616                 : void
        1617               0 : nsSprocketLayout::AddCoord(nscoord& aCoord, nscoord aCoordToAdd)
        1618                 : {
        1619               0 :   if (aCoord != NS_INTRINSICSIZE)
        1620                 :   {
        1621               0 :     if (aCoordToAdd == NS_INTRINSICSIZE)
        1622               0 :       aCoord = aCoordToAdd;
        1623                 :     else
        1624               0 :       aCoord += aCoordToAdd;
        1625                 :   }
        1626               0 : }
        1627                 : void
        1628               0 : nsSprocketLayout::AddSmallestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
        1629                 : {
        1630               0 :   if (aIsHorizontal)
        1631               0 :     AddCoord(aSize.width, aSizeToAdd.width);
        1632                 :   else
        1633               0 :     AddCoord(aSize.height, aSizeToAdd.height);
        1634                 :
        1635               0 :   SetSmallestSize(aSize, aSizeToAdd, aIsHorizontal);
        1636               0 : }
        1637                 :
        1638                 : bool
        1639               0 : nsSprocketLayout::GetDefaultFlex(PRInt32& aFlex)
        1640                 : {
        1641               0 :     aFlex = 0;
        1642               0 :     return true;
        1643                 : }
        1644                 :
        1645               0 : nsComputedBoxSize::nsComputedBoxSize()
        1646                 : {
        1647               0 :   resized = false;
        1648               0 :   valid = false;
        1649               0 :   size = 0;
        1650               0 :   next = nsnull;
        1651               0 : }
        1652                 :
        1653               0 : nsBoxSize::nsBoxSize()
        1654                 : {
        1655               0 :   pref = 0;
        1656               0 :   min = 0;
        1657               0 :   max = NS_INTRINSICSIZE;
        1658               0 :   collapsed = false;
        1659               0 :   left = 0;
        1660               0 :   right = 0;
        1661               0 :   flex = 0;
        1662               0 :   next = nsnull;
        1663               0 :   bogus = false;
        1664               0 : }
        1665                 :
        1666                 :
        1667                 : void*
        1668               0 : nsBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
        1669                 : {
        1670               0 :    return aState.AllocateStackMemory(sz);
        1671                 : }
        1672                 :
        1673                 :
        1674                 : void
        1675               0 : nsBoxSize::operator delete(void* aPtr, size_t sz)
        1676                 : {
        1677               0 : }
        1678                 :
        1679                 :
        1680                 : void*
        1681               0 : nsComputedBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
        1682                 : {
        1683               0 :    return aState.AllocateStackMemory(sz);
        1684                 : }
        1685                 :
        1686                 : void
        1687               0 : nsComputedBoxSize::operator delete(void* aPtr, size_t sz)
        1688                 : {
        1689               0 : }

Generated by: LCOV version 1.7