xul/grid/nsGridRowLeafLayout.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//
// Eric Vaughan
// Netscape Communications
//
// See documentation in associated header file
//

#include "nsGridRowLeafLayout.h"
#include "nsGridRowGroupLayout.h"
#include "nsGridRow.h"
#include "nsBoxLayoutState.h"
#include "nsBox.h"
#include "nsIScrollableFrame.h"
#include "nsBoxFrame.h"
#include "nsGridLayout2.h"
#include <algorithm>

already_AddRefed<nsBoxLayout> NS_NewGridRowLeafLayout() {
  RefPtr<nsBoxLayout> layout = new nsGridRowLeafLayout();
  return layout.forget();
}

nsGridRowLeafLayout::nsGridRowLeafLayout() : nsGridRowLayout() {}

nsGridRowLeafLayout::~nsGridRowLeafLayout() {}

nsSize nsGridRowLeafLayout::GetXULPrefSize(nsIFrame* aBox,
                                           nsBoxLayoutState& aState) {
  int32_t index = 0;
  nsGrid* grid = GetGrid(aBox, &index);
  bool isHorizontal = IsXULHorizontal(aBox);

  // If we are not in a grid. Then we just work like a box. But if we are in a
  // grid ask the grid for our size.
  if (!grid) {
    return nsGridRowLayout::GetXULPrefSize(aBox, aState);
  } else {
    return grid->GetPrefRowSize(aState, index, isHorizontal);
    // AddBorderAndPadding(aBox, pref);
  }
}

nsSize nsGridRowLeafLayout::GetXULMinSize(nsIFrame* aBox,
                                          nsBoxLayoutState& aState) {
  int32_t index = 0;
  nsGrid* grid = GetGrid(aBox, &index);
  bool isHorizontal = IsXULHorizontal(aBox);

  if (!grid)
    return nsGridRowLayout::GetXULMinSize(aBox, aState);
  else {
    nsSize minSize = grid->GetMinRowSize(aState, index, isHorizontal);
    AddBorderAndPadding(aBox, minSize);
    return minSize;
  }
}

nsSize nsGridRowLeafLayout::GetXULMaxSize(nsIFrame* aBox,
                                          nsBoxLayoutState& aState) {
  int32_t index = 0;
  nsGrid* grid = GetGrid(aBox, &index);
  bool isHorizontal = IsXULHorizontal(aBox);

  if (!grid)
    return nsGridRowLayout::GetXULMaxSize(aBox, aState);
  else {
    nsSize maxSize;
    maxSize = grid->GetMaxRowSize(aState, index, isHorizontal);
    AddBorderAndPadding(aBox, maxSize);
    return maxSize;
  }
}

/** If a child is added or removed or changes size
 */
void nsGridRowLeafLayout::ChildAddedOrRemoved(nsIFrame* aBox,
                                              nsBoxLayoutState& aState) {
  int32_t index = 0;
  nsGrid* grid = GetGrid(aBox, &index);
  bool isHorizontal = IsXULHorizontal(aBox);

  if (grid) grid->CellAddedOrRemoved(aState, index, isHorizontal);
}

void nsGridRowLeafLayout::PopulateBoxSizes(nsIFrame* aBox,
                                           nsBoxLayoutState& aState,
                                           nsBoxSize*& aBoxSizes,
                                           nscoord& aMinSize, nscoord& aMaxSize,
                                           int32_t& aFlexes) {
  int32_t index = 0;
  nsGrid* grid = GetGrid(aBox, &index);
  bool isHorizontal = IsXULHorizontal(aBox);

  // Our base class SprocketLayout is giving us a chance to change the box sizes
  // before layout If we are a row lets change the sizes to match our columns.
  // If we are a column then do the opposite and make them match or rows.
  if (grid) {
    nsGridRow* column;
    int32_t count = grid->GetColumnCount(isHorizontal);
    nsBoxSize* start = nullptr;
    nsBoxSize* last = nullptr;
    nsBoxSize* current = nullptr;
    nsIFrame* child = nsBox::GetChildXULBox(aBox);
    for (int i = 0; i < count; i++) {
      column = grid->GetColumnAt(i, isHorizontal);

      // make sure the value was computed before we use it.
      // !isHorizontal is passed in to invert the behavior of these methods.
      nscoord pref = grid->GetPrefRowHeight(
          aState, i, !isHorizontal);  // GetPrefColumnWidth
      nscoord min =
          grid->GetMinRowHeight(aState, i, !isHorizontal);  // GetMinColumnWidth
      nscoord max =
          grid->GetMaxRowHeight(aState, i, !isHorizontal);  // GetMaxColumnWidth
      nscoord flex = grid->GetRowFlex(i, !isHorizontal);    // GetColumnFlex
      nscoord left = 0;
      nscoord right = 0;
      grid->GetRowOffsets(i, left, right, !isHorizontal);  // GetColumnOffsets
      nsIFrame* box = column->GetBox();
      bool collapsed = false;
      nscoord topMargin = column->mTopMargin;
      nscoord bottomMargin = column->mBottomMargin;

      if (box) collapsed = box->IsXULCollapsed();

      pref = pref - (left + right);
      if (pref < 0) pref = 0;

      // if this is the first or last column. Take into account that
      // our row could have a border that could affect our left or right
      // padding from our columns. If the row has padding subtract it.
      // would should always be able to garentee that our margin is smaller
      // or equal to our left or right
      int32_t firstIndex = 0;
      int32_t lastIndex = 0;
      nsGridRow* firstRow = nullptr;
      nsGridRow* lastRow = nullptr;
      grid->GetFirstAndLastRow(firstIndex, lastIndex, firstRow, lastRow,
                               !isHorizontal);

      if (i == firstIndex || i == lastIndex) {
        nsMargin offset = GetTotalMargin(aBox, isHorizontal);

        nsMargin border(0, 0, 0, 0);
        // can't call GetBorderPadding we will get into recursion
        aBox->GetXULBorder(border);
        offset += border;
        aBox->GetXULPadding(border);
        offset += border;

        // subtract from out left and right
        if (i == firstIndex) {
          if (isHorizontal)
            left -= offset.left;
          else
            left -= offset.top;
        }

        if (i == lastIndex) {
          if (isHorizontal)
            right -= offset.right;
          else
            right -= offset.bottom;
        }
      }

      // initialize the box size here
      max = std::max(min, max);
      pref = nsBox::BoundsCheck(min, pref, max);

      current = new (aState) nsBoxSize();
      current->pref = pref;
      current->min = min;
      current->max = max;
      current->flex = flex;
      current->bogus = column->mIsBogus;
      current->left = left + topMargin;
      current->right = right + bottomMargin;
      current->collapsed = collapsed;

      if (!start) {
        start = current;
        last = start;
      } else {
        last->next = current;
        last = current;
      }

      if (child && !column->mIsBogus) child = nsBox::GetNextXULBox(child);
    }
    aBoxSizes = start;
  }

  nsSprocketLayout::PopulateBoxSizes(aBox, aState, aBoxSizes, aMinSize,
                                     aMaxSize, aFlexes);
}

void nsGridRowLeafLayout::ComputeChildSizes(
    nsIFrame* aBox, nsBoxLayoutState& aState, nscoord& aGivenSize,
    nsBoxSize* aBoxSizes, nsComputedBoxSize*& aComputedBoxSizes) {
  // see if we are in a scrollable frame. If we are then there could be
  // scrollbars present if so we need to subtract them out to make sure our
  // columns line up.
  if (aBox) {
    bool isHorizontal = aBox->IsXULHorizontal();

    // go up the parent chain looking for scrollframes
    nscoord diff = 0;
    nsIFrame* parentBox;
    (void)GetParentGridPart(aBox, &parentBox);
    while (parentBox) {
      nsIFrame* scrollbox = nsGrid::GetScrollBox(parentBox);
      nsIScrollableFrame* scrollable = do_QueryFrame(scrollbox);
      if (scrollable) {
        // Don't call GetActualScrollbarSizes here because it's not safe
        // to call that while we're reflowing the contents of the scrollframe,
        // which we are here.
        nsMargin scrollbarSizes = scrollable->GetDesiredScrollbarSizes(&aState);
        uint32_t visible = scrollable->GetScrollbarVisibility();

        if (isHorizontal && (visible & nsIScrollableFrame::VERTICAL)) {
          diff += scrollbarSizes.left + scrollbarSizes.right;
        } else if (!isHorizontal &&
                   (visible & nsIScrollableFrame::HORIZONTAL)) {
          diff += scrollbarSizes.top + scrollbarSizes.bottom;
        }
      }

      (void)GetParentGridPart(parentBox, &parentBox);
    }

    if (diff > 0) {
      aGivenSize += diff;

      nsSprocketLayout::ComputeChildSizes(aBox, aState, aGivenSize, aBoxSizes,
                                          aComputedBoxSizes);

      aGivenSize -= diff;

      nsComputedBoxSize* s = aComputedBoxSizes;
      nsComputedBoxSize* last = aComputedBoxSizes;
      while (s) {
        last = s;
        s = s->next;
      }

      if (last) last->size -= diff;

      return;
    }
  }

  nsSprocketLayout::ComputeChildSizes(aBox, aState, aGivenSize, aBoxSizes,
                                      aComputedBoxSizes);
}

NS_IMETHODIMP
nsGridRowLeafLayout::XULLayout(nsIFrame* aBox,
                               nsBoxLayoutState& aBoxLayoutState) {
  return nsGridRowLayout::XULLayout(aBox, aBoxLayoutState);
}

void nsGridRowLeafLayout::DirtyRows(nsIFrame* aBox, nsBoxLayoutState& aState) {
  if (aBox) {
    // mark us dirty
    // XXXldb We probably don't want to walk up the ancestor chain
    // calling MarkIntrinsicISizesDirty for every row.
    aState.PresShell()->FrameNeedsReflow(aBox, nsIPresShell::eTreeChange,
                                         NS_FRAME_IS_DIRTY);
  }
}

void nsGridRowLeafLayout::CountRowsColumns(nsIFrame* aBox, int32_t& aRowCount,
                                           int32_t& aComputedColumnCount) {
  if (aBox) {
    nsIFrame* child = nsBox::GetChildXULBox(aBox);

    // count the children
    int32_t columnCount = 0;
    while (child) {
      child = nsBox::GetNextXULBox(child);
      columnCount++;
    }

    // if our count is greater than the current column count
    if (columnCount > aComputedColumnCount) aComputedColumnCount = columnCount;

    aRowCount++;
  }
}

int32_t nsGridRowLeafLayout::BuildRows(nsIFrame* aBox, nsGridRow* aRows) {
  if (aBox) {
    aRows[0].Init(aBox, false);
    return 1;
  }

  return 0;
}