LCOV - app.info - layout/xul/base/src/grid/nsGridRowLeafLayout.cpp

LCOV - code coverage report
| Current view: | directory - layout/xul/base/src/grid - nsGridRowLeafLayout.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 162 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 14 | 0 | 0.0 %

           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                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : //
          39                 : // Eric Vaughan
          40                 : // Netscape Communications
          41                 : //
          42                 : // See documentation in associated header file
          43                 : //
          44                 :
          45                 : #include "nsGridRowLeafLayout.h"
          46                 : #include "nsGridRowGroupLayout.h"
          47                 : #include "nsGridRow.h"
          48                 : #include "nsBoxLayoutState.h"
          49                 : #include "nsBox.h"
          50                 : #include "nsIScrollableFrame.h"
          51                 : #include "nsBoxFrame.h"
          52                 : #include "nsGridLayout2.h"
          53                 :
          54               0 : already_AddRefed<nsBoxLayout> NS_NewGridRowLeafLayout()
          55                 : {
          56               0 :   nsBoxLayout* layout = new nsGridRowLeafLayout();
          57               0 :   NS_IF_ADDREF(layout);
          58               0 :   return layout;
          59                 : }
          60                 :
          61               0 : nsGridRowLeafLayout::nsGridRowLeafLayout():nsGridRowLayout()
          62                 : {
          63               0 : }
          64                 :
          65               0 : nsGridRowLeafLayout::~nsGridRowLeafLayout()
          66                 : {
          67               0 : }
          68                 :
          69                 : nsSize
          70               0 : nsGridRowLeafLayout::GetPrefSize(nsIBox* aBox, nsBoxLayoutState& aState)
          71                 : {
          72               0 :   PRInt32 index = 0;
          73               0 :   nsGrid* grid = GetGrid(aBox, &index);
          74               0 :   bool isHorizontal = IsHorizontal(aBox);
          75                 :
          76                 :   // If we are not in a grid. Then we just work like a box. But if we are in a grid
          77                 :   // ask the grid for our size.
          78               0 :   if (!grid) {
          79               0 :     return nsGridRowLayout::GetPrefSize(aBox, aState);
          80                 :   }
          81                 :   else {
          82               0 :     return grid->GetPrefRowSize(aState, index, isHorizontal);
          83                 :     //AddBorderAndPadding(aBox, pref);
          84                 :   }
          85                 : }
          86                 :
          87                 : nsSize
          88               0 : nsGridRowLeafLayout::GetMinSize(nsIBox* aBox, nsBoxLayoutState& aState)
          89                 : {
          90               0 :   PRInt32 index = 0;
          91               0 :   nsGrid* grid = GetGrid(aBox, &index);
          92               0 :   bool isHorizontal = IsHorizontal(aBox);
          93                 :
          94               0 :   if (!grid)
          95               0 :     return nsGridRowLayout::GetMinSize(aBox, aState);
          96                 :   else {
          97               0 :     nsSize minSize = grid->GetMinRowSize(aState, index, isHorizontal);
          98               0 :     AddBorderAndPadding(aBox, minSize);
          99               0 :     return minSize;
         100                 :   }
         101                 : }
         102                 :
         103                 : nsSize
         104               0 : nsGridRowLeafLayout::GetMaxSize(nsIBox* aBox, nsBoxLayoutState& aState)
         105                 : {
         106               0 :   PRInt32 index = 0;
         107               0 :   nsGrid* grid = GetGrid(aBox, &index);
         108               0 :   bool isHorizontal = IsHorizontal(aBox);
         109                 :
         110               0 :   if (!grid)
         111               0 :     return nsGridRowLayout::GetMaxSize(aBox, aState);
         112                 :   else {
         113               0 :     nsSize maxSize;
         114               0 :     maxSize = grid->GetMaxRowSize(aState, index, isHorizontal);
         115               0 :     AddBorderAndPadding(aBox, maxSize);
         116               0 :     return maxSize;
         117                 :   }
         118                 : }
         119                 :
         120                 : /** If a child is added or removed or changes size
         121                 :   */
         122                 : void
         123               0 : nsGridRowLeafLayout::ChildAddedOrRemoved(nsIBox* aBox, nsBoxLayoutState& aState)
         124                 : {
         125               0 :   PRInt32 index = 0;
         126               0 :   nsGrid* grid = GetGrid(aBox, &index);
         127               0 :   bool isHorizontal = IsHorizontal(aBox);
         128                 :
         129               0 :   if (grid)
         130               0 :     grid->CellAddedOrRemoved(aState, index, isHorizontal);
         131               0 : }
         132                 :
         133                 : void
         134               0 : nsGridRowLeafLayout::PopulateBoxSizes(nsIBox* aBox, nsBoxLayoutState& aState, nsBoxSize*& aBoxSizes, nscoord& aMinSize, nscoord& aMaxSize, PRInt32& aFlexes)
         135                 : {
         136               0 :   PRInt32 index = 0;
         137               0 :   nsGrid* grid = GetGrid(aBox, &index);
         138               0 :   bool isHorizontal = IsHorizontal(aBox);
         139                 :
         140                 :   // Our base class SprocketLayout is giving us a chance to change the box sizes before layout
         141                 :   // If we are a row lets change the sizes to match our columns. If we are a column then do the opposite
         142                 :   // and make them match or rows.
         143               0 :   if (grid) {
         144                 :     nsGridRow* column;
         145               0 :     PRInt32 count = grid->GetColumnCount(isHorizontal);
         146               0 :     nsBoxSize* start = nsnull;
         147               0 :     nsBoxSize* last = nsnull;
         148               0 :     nsBoxSize* current = nsnull;
         149               0 :     nsIBox* child = aBox->GetChildBox();
         150               0 :     for (int i=0; i < count; i++)
         151                 :     {
         152               0 :       column = grid->GetColumnAt(i,isHorizontal);
         153                 :
         154                 :       // make sure the value was computed before we use it.
         155                 :       // !isHorizontal is passed in to invert the behavior of these methods.
         156                 :       nscoord pref =
         157               0 :         grid->GetPrefRowHeight(aState, i, !isHorizontal); // GetPrefColumnWidth
         158                 :       nscoord min =
         159               0 :         grid->GetMinRowHeight(aState, i, !isHorizontal);  // GetMinColumnWidth
         160                 :       nscoord max =
         161               0 :         grid->GetMaxRowHeight(aState, i, !isHorizontal);  // GetMaxColumnWidth
         162                 :       nscoord flex =
         163               0 :         grid->GetRowFlex(aState, i, !isHorizontal);       // GetColumnFlex
         164               0 :       nscoord left  = 0;
         165               0 :       nscoord right  = 0;
         166               0 :       grid->GetRowOffsets(aState, i, left, right, !isHorizontal); // GetColumnOffsets
         167               0 :       nsIBox* box = column->GetBox();
         168               0 :       bool collapsed = false;
         169               0 :       nscoord topMargin = column->mTopMargin;
         170               0 :       nscoord bottomMargin = column->mBottomMargin;
         171                 :
         172               0 :       if (box)
         173               0 :         collapsed = box->IsCollapsed();
         174                 :
         175               0 :       pref = pref - (left + right);
         176               0 :       if (pref < 0)
         177               0 :         pref = 0;
         178                 :
         179                 :       // if this is the first or last column. Take into account that
         180                 :       // our row could have a border that could affect our left or right
         181                 :       // padding from our columns. If the row has padding subtract it.
         182                 :       // would should always be able to garentee that our margin is smaller
         183                 :       // or equal to our left or right
         184               0 :       PRInt32 firstIndex = 0;
         185               0 :       PRInt32 lastIndex = 0;
         186               0 :       nsGridRow* firstRow = nsnull;
         187               0 :       nsGridRow* lastRow = nsnull;
         188               0 :       grid->GetFirstAndLastRow(aState, firstIndex, lastIndex, firstRow, lastRow, !isHorizontal);
         189                 :
         190               0 :       if (i == firstIndex || i == lastIndex) {
         191               0 :         nsMargin offset = GetTotalMargin(aBox, isHorizontal);
         192                 :
         193               0 :         nsMargin border(0,0,0,0);
         194                 :         // can't call GetBorderPadding we will get into recursion
         195               0 :         aBox->GetBorder(border);
         196               0 :         offset += border;
         197               0 :         aBox->GetPadding(border);
         198               0 :         offset += border;
         199                 :
         200                 :         // subtract from out left and right
         201               0 :         if (i == firstIndex)
         202                 :         {
         203               0 :           if (isHorizontal)
         204               0 :            left -= offset.left;
         205                 :           else
         206               0 :            left -= offset.top;
         207                 :         }
         208                 :
         209               0 :         if (i == lastIndex)
         210                 :         {
         211               0 :           if (isHorizontal)
         212               0 :            right -= offset.right;
         213                 :           else
         214               0 :            right -= offset.bottom;
         215                 :         }
         216                 :       }
         217                 :
         218                 :       // initialize the box size here
         219               0 :       max = NS_MAX(min, max);
         220               0 :       pref = nsBox::BoundsCheck(min, pref, max);
         221                 :
         222               0 :       current = new (aState) nsBoxSize();
         223               0 :       current->pref = pref;
         224               0 :       current->min = min;
         225               0 :       current->max = max;
         226               0 :       current->flex = flex;
         227               0 :       current->bogus = column->mIsBogus;
         228               0 :       current->left = left + topMargin;
         229               0 :       current->right = right + bottomMargin;
         230               0 :       current->collapsed = collapsed;
         231                 :
         232               0 :       if (!start) {
         233               0 :         start = current;
         234               0 :         last = start;
         235                 :       } else {
         236               0 :         last->next = current;
         237               0 :         last = current;
         238                 :       }
         239                 :
         240               0 :       if (child && !column->mIsBogus)
         241               0 :         child = child->GetNextBox();
         242                 :
         243                 :     }
         244               0 :     aBoxSizes = start;
         245                 :   }
         246                 :
         247               0 :   nsSprocketLayout::PopulateBoxSizes(aBox, aState, aBoxSizes, aMinSize, aMaxSize, aFlexes);
         248               0 : }
         249                 :
         250                 : void
         251               0 : nsGridRowLeafLayout::ComputeChildSizes(nsIBox* aBox,
         252                 :                            nsBoxLayoutState& aState,
         253                 :                            nscoord& aGivenSize,
         254                 :                            nsBoxSize* aBoxSizes,
         255                 :                            nsComputedBoxSize*& aComputedBoxSizes)
         256                 : {
         257                 :   // see if we are in a scrollable frame. If we are then there could be scrollbars present
         258                 :   // if so we need to subtract them out to make sure our columns line up.
         259               0 :   if (aBox) {
         260               0 :     bool isHorizontal = aBox->IsHorizontal();
         261                 :
         262                 :     // go up the parent chain looking for scrollframes
         263               0 :     nscoord diff = 0;
         264                 :     nsIBox* parentBox;
         265               0 :     (void)GetParentGridPart(aBox, &parentBox);
         266               0 :     while (parentBox) {
         267               0 :       nsIBox* scrollbox = nsGrid::GetScrollBox(parentBox);
         268               0 :       nsIScrollableFrame *scrollable = do_QueryFrame(scrollbox);
         269               0 :       if (scrollable) {
         270                 :         // Don't call GetActualScrollbarSizes here because it's not safe
         271                 :         // to call that while we're reflowing the contents of the scrollframe,
         272                 :         // which we are here.
         273               0 :         nsMargin scrollbarSizes = scrollable->GetDesiredScrollbarSizes(&aState);
         274               0 :         PRUint32 visible = scrollable->GetScrollbarVisibility();
         275                 :
         276               0 :         if (isHorizontal && (visible & nsIScrollableFrame::VERTICAL)) {
         277               0 :           diff += scrollbarSizes.left + scrollbarSizes.right;
         278               0 :         } else if (!isHorizontal && (visible & nsIScrollableFrame::HORIZONTAL)) {
         279               0 :           diff += scrollbarSizes.top + scrollbarSizes.bottom;
         280                 :         }
         281                 :       }
         282                 :
         283               0 :       (void)GetParentGridPart(parentBox, &parentBox);
         284                 :     }
         285                 :
         286               0 :     if (diff > 0) {
         287               0 :       aGivenSize += diff;
         288                 :
         289               0 :       nsSprocketLayout::ComputeChildSizes(aBox, aState, aGivenSize, aBoxSizes, aComputedBoxSizes);
         290                 :
         291               0 :       aGivenSize -= diff;
         292                 :
         293               0 :       nsComputedBoxSize* s    = aComputedBoxSizes;
         294               0 :       nsComputedBoxSize* last = aComputedBoxSizes;
         295               0 :       while(s)
         296                 :       {
         297               0 :         last = s;
         298               0 :         s = s->next;
         299                 :       }
         300                 :
         301               0 :       if (last)
         302               0 :         last->size -= diff;
         303                 :
         304               0 :       return;
         305                 :     }
         306                 :   }
         307                 :
         308               0 :   nsSprocketLayout::ComputeChildSizes(aBox, aState, aGivenSize, aBoxSizes, aComputedBoxSizes);
         309                 :
         310                 : }
         311                 :
         312                 : NS_IMETHODIMP
         313               0 : nsGridRowLeafLayout::Layout(nsIBox* aBox, nsBoxLayoutState& aBoxLayoutState)
         314                 : {
         315               0 :   return nsGridRowLayout::Layout(aBox, aBoxLayoutState);
         316                 : }
         317                 :
         318                 : void
         319               0 : nsGridRowLeafLayout::DirtyRows(nsIBox* aBox, nsBoxLayoutState& aState)
         320                 : {
         321               0 :   if (aBox) {
         322                 :     // mark us dirty
         323                 :     // XXXldb We probably don't want to walk up the ancestor chain
         324                 :     // calling MarkIntrinsicWidthsDirty for every row.
         325               0 :     aState.PresShell()->FrameNeedsReflow(aBox, nsIPresShell::eTreeChange,
         326               0 :                                          NS_FRAME_IS_DIRTY);
         327                 :   }
         328               0 : }
         329                 :
         330                 : void
         331               0 : nsGridRowLeafLayout::CountRowsColumns(nsIBox* aBox, PRInt32& aRowCount, PRInt32& aComputedColumnCount)
         332                 : {
         333               0 :   if (aBox) {
         334               0 :     nsIBox* child = aBox->GetChildBox();
         335                 :
         336                 :     // count the children
         337               0 :     PRInt32 columnCount = 0;
         338               0 :     while(child) {
         339               0 :       child = child->GetNextBox();
         340               0 :       columnCount++;
         341                 :     }
         342                 :
         343                 :     // if our count is greater than the current column count
         344               0 :     if (columnCount > aComputedColumnCount)
         345               0 :       aComputedColumnCount = columnCount;
         346                 :
         347               0 :     aRowCount++;
         348                 :   }
         349               0 : }
         350                 :
         351                 : PRInt32
         352               0 : nsGridRowLeafLayout::BuildRows(nsIBox* aBox, nsGridRow* aRows)
         353                 : {
         354               0 :   if (aBox) {
         355               0 :       aRows[0].Init(aBox, false);
         356               0 :       return 1;
         357                 :   }
         358                 :
         359               0 :   return 0;
         360                 : }
         361                 :

Generated by: LCOV version 1.7