layout/generic/nsAbsoluteContainingBlock.h
author Nika Layzell <nika@thelayzells.com>
Tue, 25 Sep 2018 17:34:53 +0200
changeset 507828 5e6dae0c1e5a4939ccd406f14607f7fafffd45a7
parent 443692 e4815e8465a2cc7d09d479dd76e7143a09927fd3
child 508163 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1448426 - Wrap windows.h to avoid problematic define statements, r=froydnj,glandium By default, windows.h exposes a large number of problematic define statements which are UpperCamelCase, such as a define from `CreateWindow` to `CreateWindow{A,W}`. As many of these names are generic (e.g. CreateFile, CreateWindow), they can mess up Gecko code that may legitimately have its own methods with the same names. The header also defines some traditional SCREAMING_SNAKE_CASE defines which can mess up our code by conflicting with local values. This patch adds a simple code generator which generates wrappers for these defines, and uses them to wrap the windows.h wrapper using the `stl_wrappers` mechanism, allowing us to use windows.h in more places. Differential Revision: https://phabricator.services.mozilla.com/D10932

/* -*- 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/. */

/*
 * code for managing absolutely positioned children of a rendering
 * object that is a containing block for them
 */

#ifndef nsAbsoluteContainingBlock_h___
#define nsAbsoluteContainingBlock_h___

#include "nsFrameList.h"
#include "nsIFrame.h"
#include "mozilla/TypedEnumBits.h"

class nsContainerFrame;
class nsPresContext;

/**
 * This class contains the logic for being an absolute containing block.  This
 * class is used within viewport frames (for frames representing content with
 * fixed position) and blocks (for frames representing absolutely positioned
 * content), since each set of frames is absolutely positioned with respect to
 * its parent.
 *
 * There is no principal child list, just a named child list which contains
 * the absolutely positioned frames (kAbsoluteList or kFixedList).
 *
 * All functions include as the first argument the frame that is delegating
 * the request.
 */
class nsAbsoluteContainingBlock
{
  using ReflowInput = mozilla::ReflowInput;

public:
  typedef nsIFrame::ChildListID ChildListID;

  explicit nsAbsoluteContainingBlock(ChildListID aChildListID)
#ifdef DEBUG
    : mChildListID(aChildListID)
#endif
  {
    MOZ_ASSERT(mChildListID == nsIFrame::kAbsoluteList ||
               mChildListID == nsIFrame::kFixedList,
               "should either represent position:fixed or absolute content");
  }

  const nsFrameList& GetChildList() const { return mAbsoluteFrames; }
  void AppendChildList(nsTArray<nsIFrame::ChildList>* aLists,
                       ChildListID aListID) const
  {
    NS_ASSERTION(aListID == mChildListID, "wrong list ID");
    GetChildList().AppendIfNonempty(aLists, aListID);
  }

  void SetInitialChildList(nsIFrame*       aDelegatingFrame,
                           ChildListID     aListID,
                           nsFrameList&    aChildList);
  void AppendFrames(nsIFrame*      aDelegatingFrame,
                    ChildListID    aListID,
                    nsFrameList&   aFrameList);
  void InsertFrames(nsIFrame*      aDelegatingFrame,
                    ChildListID    aListID,
                    nsIFrame*      aPrevFrame,
                    nsFrameList&   aFrameList);
  void RemoveFrame(nsIFrame*      aDelegatingFrame,
                   ChildListID    aListID,
                   nsIFrame*      aOldFrame);

  enum class AbsPosReflowFlags {
    eConstrainHeight   = 0x1,
    eCBWidthChanged    = 0x2,
    eCBHeightChanged   = 0x4,
    eCBWidthAndHeightChanged = eCBWidthChanged | eCBHeightChanged,
    eIsGridContainerCB = 0x8,
  };

  /**
   * Called by the delegating frame after it has done its reflow first. This
   * function will reflow any absolutely positioned child frames that need to
   * be reflowed, e.g., because the absolutely positioned child frame has
   * 'auto' for an offset, or a percentage based width or height.
   *
   * @param aOverflowAreas, if non-null, is unioned with (in the local
   * coordinate space) the overflow areas of the absolutely positioned
   * children.
   *
   * @param aReflowStatus is assumed to be already-initialized, e.g. with the
   * status of the delegating frame's main reflow. This function merges in the
   * statuses of the absolutely positioned children's reflows.
   *
   * @param aFlags zero or more AbsPosReflowFlags
   */
  void Reflow(nsContainerFrame*        aDelegatingFrame,
              nsPresContext*           aPresContext,
              const ReflowInput& aReflowInput,
              nsReflowStatus&          aReflowStatus,
              const nsRect&            aContainingBlock,
              AbsPosReflowFlags        aFlags,
              nsOverflowAreas*         aOverflowAreas);

  using PostDestroyData = nsIFrame::PostDestroyData;
  void DestroyFrames(nsIFrame* aDelegatingFrame,
                     nsIFrame* aDestructRoot,
                     PostDestroyData& aPostDestroyData);

  bool HasAbsoluteFrames() const { return mAbsoluteFrames.NotEmpty(); }

  /**
   * Mark our size-dependent absolute frames with NS_FRAME_HAS_DIRTY_CHILDREN
   * so that we'll make sure to reflow them.
   */
  void MarkSizeDependentFramesDirty();

  /**
   * Mark all our absolute frames with NS_FRAME_IS_DIRTY.
   */
  void MarkAllFramesDirty();

protected:
  /**
   * Returns true if the position of aFrame depends on the position of
   * its placeholder or if the position or size of aFrame depends on a
   * containing block dimension that changed.
   */
  bool FrameDependsOnContainer(nsIFrame* aFrame, bool aCBWidthChanged,
                               bool aCBHeightChanged);

  /**
   * After an abspos child's size is known, this method can be used to
   * resolve size-dependent values in the ComputedLogicalOffsets on its
   * reflow state. (This may involve resolving the inline dimension of
   * aLogicalCBSize, too; hence, that variable is an in/outparam.)
   *
   * aKidSize, aMargin, aOffsets, and aLogicalCBSize are all expected to be
   * represented in terms of the absolute containing block's writing-mode.
   */
  void ResolveSizeDependentOffsets(nsPresContext* aPresContext,
                                   ReflowInput& aKidReflowInput,
                                   const mozilla::LogicalSize& aKidSize,
                                   const mozilla::LogicalMargin& aMargin,
                                   mozilla::LogicalMargin* aOffsets,
                                   mozilla::LogicalSize* aLogicalCBSize);

  void ReflowAbsoluteFrame(nsIFrame*                aDelegatingFrame,
                           nsPresContext*           aPresContext,
                           const ReflowInput& aReflowInput,
                           const nsRect&            aContainingBlockRect,
                           AbsPosReflowFlags        aFlags,
                           nsIFrame*                aKidFrame,
                           nsReflowStatus&          aStatus,
                           nsOverflowAreas*         aOverflowAreas);

  /**
   * Mark our absolute frames dirty.
   * @param aMarkAllDirty if true, all will be marked with NS_FRAME_IS_DIRTY.
   * Otherwise, the size-dependant ones will be marked with
   * NS_FRAME_HAS_DIRTY_CHILDREN.
   */
  void DoMarkFramesDirty(bool aMarkAllDirty);

protected:
  nsFrameList mAbsoluteFrames;  // additional named child list

#ifdef DEBUG
  ChildListID const mChildListID; // kFixedList or kAbsoluteList
#endif
};

namespace mozilla {
  MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsAbsoluteContainingBlock::AbsPosReflowFlags)
}
#endif /* nsnsAbsoluteContainingBlock_h___ */