gecko-dev/layout/xul/nsStackLayout.cpp

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

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

#include "nsStackLayout.h"
#include "nsCOMPtr.h"
#include "nsBoxLayoutState.h"
#include "nsBox.h"
#include "nsBoxFrame.h"
#include "nsGkAtoms.h"
#include "nsIContent.h"
#include "nsNameSpaceManager.h"

using namespace mozilla;

nsBoxLayout* nsStackLayout::gInstance = nullptr;

#define SPECIFIED_LEFT (1 << eSideLeft)
#define SPECIFIED_RIGHT (1 << eSideRight)
#define SPECIFIED_TOP (1 << eSideTop)
#define SPECIFIED_BOTTOM (1 << eSideBottom)

nsresult
NS_NewStackLayout(nsCOMPtr<nsBoxLayout>& aNewLayout)
{
  if (!nsStackLayout::gInstance) {
    nsStackLayout::gInstance = new nsStackLayout();
    NS_IF_ADDREF(nsStackLayout::gInstance);
  }
  // we have not instance variables so just return our static one.
  aNewLayout = nsStackLayout::gInstance;
  return NS_OK;
}

/*static*/ void
nsStackLayout::Shutdown()
{
  NS_IF_RELEASE(gInstance);
}

nsStackLayout::nsStackLayout()
{
}

/*
 * Sizing: we are as wide as the widest child plus its left offset
 * we are tall as the tallest child plus its top offset.
 *
 * Only children which have -moz-stack-sizing set to stretch-to-fit
 * (the default) will be included in the size computations.
 */

nsSize
nsStackLayout::GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
  nsSize prefSize (0, 0);

  nsIFrame* child = nsBox::GetChildXULBox(aBox);
  while (child) {
    auto stackSizing = child->StyleXUL()->mStackSizing;
    if (stackSizing != StyleStackSizing::Ignore) {
      nsSize pref = child->GetXULPrefSize(aState);

      AddMargin(child, pref);
      nsMargin offset;
      GetOffset(child, offset);
      pref.width += offset.LeftRight();
      pref.height += offset.TopBottom();

      if (pref.width > prefSize.width &&
          stackSizing != StyleStackSizing::IgnoreHorizontal) {
        prefSize.width = pref.width;
      }
      if (pref.height > prefSize.height &&
          stackSizing != StyleStackSizing::IgnoreVertical) {
        prefSize.height = pref.height;
      }
    }

    child = nsBox::GetNextXULBox(child);
  }

  AddBorderAndPadding(aBox, prefSize);

  return prefSize;
}

nsSize
nsStackLayout::GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
  nsSize minSize (0, 0);

  nsIFrame* child = nsBox::GetChildXULBox(aBox);
  while (child) {
    auto stackSizing = child->StyleXUL()->mStackSizing;
    if (stackSizing != StyleStackSizing::Ignore) {
      nsSize min = child->GetXULMinSize(aState);

      AddMargin(child, min);
      nsMargin offset;
      GetOffset(child, offset);
      min.width += offset.LeftRight();
      min.height += offset.TopBottom();

      if (min.width > minSize.width &&
          stackSizing != StyleStackSizing::IgnoreHorizontal) {
        minSize.width = min.width;
      }
      if (min.height > minSize.height &&
          stackSizing != StyleStackSizing::IgnoreVertical) {
        minSize.height = min.height;
      }
    }

    child = nsBox::GetNextXULBox(child);
  }

  AddBorderAndPadding(aBox, minSize);

  return minSize;
}

nsSize
nsStackLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
  nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);

  nsIFrame* child = nsBox::GetChildXULBox(aBox);
  while (child) {
    auto stackSizing = child->StyleXUL()->mStackSizing;
    if (stackSizing != StyleStackSizing::Ignore) {
      nsSize min = child->GetXULMinSize(aState);
      nsSize max = child->GetXULMaxSize(aState);

      max = nsBox::BoundsCheckMinMax(min, max);

      AddMargin(child, max);
      nsMargin offset;
      GetOffset(child, offset);
      max.width += offset.LeftRight();
      max.height += offset.TopBottom();

      if (max.width < maxSize.width &&
          stackSizing != StyleStackSizing::IgnoreHorizontal) {
        maxSize.width = max.width;
      }
      if (max.height < maxSize.height &&
          stackSizing != StyleStackSizing::IgnoreVertical) {
        maxSize.height = max.height;
      }
    }

    child = nsBox::GetNextXULBox(child);
  }

  AddBorderAndPadding(aBox, maxSize);

  return maxSize;
}


nscoord
nsStackLayout::GetAscent(nsIFrame* aBox, nsBoxLayoutState& aState)
{
  nscoord vAscent = 0;

  nsIFrame* child = nsBox::GetChildXULBox(aBox);
  while (child) {
    nscoord ascent = child->GetXULBoxAscent(aState);
    nsMargin margin;
    child->GetXULMargin(margin);
    ascent += margin.top;
    if (ascent > vAscent)
      vAscent = ascent;

    child = nsBox::GetNextXULBox(child);
  }

  return vAscent;
}

uint8_t
nsStackLayout::GetOffset(nsIFrame* aChild, nsMargin& aOffset)
{
  aOffset = nsMargin(0, 0, 0, 0);

  // get the left, right, top and bottom offsets

  // As an optimization, we cache the fact that we are not positioned to avoid
  // wasting time fetching attributes.
  if (aChild->IsXULBoxFrame() &&
      (aChild->GetStateBits() & NS_STATE_STACK_NOT_POSITIONED))
    return 0;

  uint8_t offsetSpecified = 0;
  nsIContent* content = aChild->GetContent();
  if (content) {
    bool ltr = aChild->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR;
    nsAutoString value;
    nsresult error;

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::start, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      if (ltr) {
        aOffset.left =
          nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
        offsetSpecified |= SPECIFIED_LEFT;
      } else {
        aOffset.right =
          nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
        offsetSpecified |= SPECIFIED_RIGHT;
      }
    }

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::end, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      if (ltr) {
        aOffset.right =
          nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
        offsetSpecified |= SPECIFIED_RIGHT;
      } else {
        aOffset.left =
          nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
        offsetSpecified |= SPECIFIED_LEFT;
      }
    }

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::left, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      aOffset.left =
        nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
      offsetSpecified |= SPECIFIED_LEFT;
    }

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::right, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      aOffset.right =
        nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
      offsetSpecified |= SPECIFIED_RIGHT;
    }

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::top, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      aOffset.top =
        nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
      offsetSpecified |= SPECIFIED_TOP;
    }

    content->GetAttr(kNameSpaceID_None, nsGkAtoms::bottom, value);
    if (!value.IsEmpty()) {
      value.Trim("%");
      aOffset.bottom =
        nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
      offsetSpecified |= SPECIFIED_BOTTOM;
    }
  }

  if (!offsetSpecified && aChild->IsXULBoxFrame()) {
    // If no offset was specified at all, then we cache this fact to avoid requerying
    // CSS or the content model.
    aChild->AddStateBits(NS_STATE_STACK_NOT_POSITIONED);
  }

  return offsetSpecified;
}


NS_IMETHODIMP
nsStackLayout::XULLayout(nsIFrame* aBox, nsBoxLayoutState& aState)
{
  nsRect clientRect;
  aBox->GetXULClientRect(clientRect);

  bool grow;

  do {
    nsIFrame* child = nsBox::GetChildXULBox(aBox);
    grow = false;

    while (child)
    {
      nsMargin margin;
      child->GetXULMargin(margin);
      nsRect childRect(clientRect);
      childRect.Deflate(margin);

      if (childRect.width < 0)
        childRect.width = 0;

      if (childRect.height < 0)
        childRect.height = 0;

      nsRect oldRect(child->GetRect());
      bool sizeChanged = !oldRect.IsEqualEdges(childRect);

      // only lay out dirty children or children whose sizes have changed
      if (sizeChanged || NS_SUBTREE_DIRTY(child)) {
          // add in the child's margin
          nsMargin margin;
          child->GetXULMargin(margin);

          // obtain our offset from the top left border of the stack's content box.
          nsMargin offset;
          uint8_t offsetSpecified = GetOffset(child, offset);

          // Set the position and size based on which offsets have been specified:
          //   left only - offset from left edge, preferred width
          //   right only - offset from right edge, preferred width
          //   left and right - offset from left and right edges, width in between this
          //   neither - no offset, full width of stack
          // Vertical direction is similar.
          //
          // Margins on the child are also included in the edge offsets
          if (offsetSpecified) {
            nsSize min = child->GetXULMinSize(aState);
            nsSize max = child->GetXULMaxSize(aState);
            if (offsetSpecified & SPECIFIED_LEFT) {
              childRect.x = clientRect.x + offset.left + margin.left;
              if (offsetSpecified & SPECIFIED_RIGHT) {
                nscoord width = clientRect.width - offset.LeftRight() - margin.LeftRight();
                childRect.width = clamped(width, min.width, max.width);
              }
              else {
                nscoord width = child->GetXULPrefSize(aState).width;
                childRect.width = clamped(width, min.width, max.width);
              }
            }
            else if (offsetSpecified & SPECIFIED_RIGHT) {
              nscoord width = child->GetXULPrefSize(aState).width;
              childRect.width = clamped(width, min.width, max.width);
              childRect.x = clientRect.XMost() - offset.right - margin.right - childRect.width;
            }

            if (offsetSpecified & SPECIFIED_TOP) {
              childRect.y = clientRect.y + offset.top + margin.top;
              if (offsetSpecified & SPECIFIED_BOTTOM) {
                nscoord height = clientRect.height - offset.TopBottom() - margin.TopBottom();
                childRect.height = clamped(height, min.height, max.height);
              }
              else {
                nscoord height = child->GetXULPrefSize(aState).height;
                childRect.height = clamped(height, min.height, max.height);
              }
            }
            else if (offsetSpecified & SPECIFIED_BOTTOM) {
              nscoord height = child->GetXULPrefSize(aState).height;
              childRect.height = clamped(height, min.height, max.height);
              childRect.y = clientRect.YMost() - offset.bottom - margin.bottom - childRect.height;
            }
          }

          // Now place the child.
          child->SetXULBounds(aState, childRect);

          // Flow the child.
          child->XULLayout(aState);

          // Get the child's new rect.
          childRect = child->GetRect();
          childRect.Inflate(margin);

          auto stackSizing = child->StyleXUL()->mStackSizing;
          if (stackSizing != StyleStackSizing::Ignore) {
            // Did the child push back on us and get bigger?
            if (offset.LeftRight() + childRect.width > clientRect.width &&
                stackSizing != StyleStackSizing::IgnoreHorizontal) {
              clientRect.width = childRect.width + offset.LeftRight();
              grow = true;
            }

            if (offset.TopBottom() + childRect.height > clientRect.height &&
                stackSizing != StyleStackSizing::IgnoreVertical) {
              clientRect.height = childRect.height + offset.TopBottom();
              grow = true;
            }
          }
       }

       child = nsBox::GetNextXULBox(child);
     }
   } while (grow);

   // if some HTML inside us got bigger we need to force ourselves to
   // get bigger
   nsRect bounds(aBox->GetRect());
   nsMargin bp;
   aBox->GetXULBorderAndPadding(bp);
   clientRect.Inflate(bp);

   if (clientRect.width > bounds.width || clientRect.height > bounds.height)
   {
     if (clientRect.width > bounds.width)
       bounds.width = clientRect.width;
     if (clientRect.height > bounds.height)
       bounds.height = clientRect.height;

     aBox->SetXULBounds(aState, bounds);
   }

   return NS_OK;
}