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

/* rendering object for HTML <frameset> elements */

#include "nsFrameSetFrame.h"

#include "gfxContext.h"

#include "gfxUtils.h"

#include "mozilla/ComputedStyle.h"

#include "mozilla/DebugOnly.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/gfx/Helpers.h"

#include "mozilla/Likely.h"

#include "nsGenericHTMLElement.h"

#include "nsAttrValueInlines.h"

#include "nsLeafFrame.h"

#include "nsContainerFrame.h"

#include "nsLayoutUtils.h"

#include "nsPresContext.h"

#include "nsIContentInlines.h"

#include "nsIPresShell.h"

#include "nsGkAtoms.h"

#include "nsStyleConsts.h"

#include "nsHTMLParts.h"

#include "nsNameSpaceManager.h"

#include "nsCSSAnonBoxes.h"

#include "mozilla/ServoStyleSet.h"

#include "mozilla/dom/Element.h"

#include "nsDisplayList.h"

#include "nsNodeUtils.h"

#include "mozAutoDocUpdate.h"

#include "mozilla/Preferences.h"

#include "mozilla/dom/HTMLFrameSetElement.h"

#include "mozilla/LookAndFeel.h"

#include "mozilla/MouseEvents.h"

#include "nsSubDocumentFrame.h"

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::gfx;

// masks for mEdgeVisibility

#define LEFT_VIS   0x0001

#define RIGHT_VIS  0x0002

#define TOP_VIS    0x0004

#define BOTTOM_VIS 0x0008

#define ALL_VIS    0x000F

#define NONE_VIS   0x0000

/*******************************************************************************

 * nsFramesetDrag

 ******************************************************************************/

nsFramesetDrag::nsFramesetDrag()

{

  UnSet();

}

void nsFramesetDrag::Reset(bool                 aVertical,

                           int32_t              aIndex,

                           int32_t              aChange,

                           nsHTMLFramesetFrame* aSource)

{

  mVertical = aVertical;

  mIndex    = aIndex;

  mChange   = aChange;

  mSource   = aSource;

}

void nsFramesetDrag::UnSet()

{

  mVertical = true;

  mIndex    = -1;

  mChange   = 0;

  mSource   = nullptr;

}

/*******************************************************************************

 * nsHTMLFramesetBorderFrame

 ******************************************************************************/

class nsHTMLFramesetBorderFrame final : public nsLeafFrame

{

public:

  NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBorderFrame)

#ifdef DEBUG_FRAME_DUMP

  virtual nsresult GetFrameName(nsAString& aResult) const override;

#endif

  virtual nsresult HandleEvent(nsPresContext* aPresContext,

                               WidgetGUIEvent* aEvent,

                               nsEventStatus* aEventStatus) override;

  virtual nsresult GetCursor(const nsPoint&    aPoint,

                             nsIFrame::Cursor& aCursor) override;

  virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                const nsDisplayListSet& aLists) override;

  virtual void Reflow(nsPresContext*           aPresContext,

                          ReflowOutput&     aDesiredSize,

                          const ReflowInput& aReflowInput,

                          nsReflowStatus&          aStatus) override;

  bool GetVisibility() { return mVisibility; }

  void SetVisibility(bool aVisibility);

  void SetColor(nscolor aColor);

  void PaintBorder(DrawTarget* aDrawTarget, nsPoint aPt);

protected:

  nsHTMLFramesetBorderFrame(ComputedStyle* aStyle, int32_t aWidth, bool aVertical, bool aVisible);

  virtual ~nsHTMLFramesetBorderFrame();

  virtual nscoord GetIntrinsicISize() override;

  virtual nscoord GetIntrinsicBSize() override;

  // the prev and next neighbors are indexes into the row (for a horizontal border) or col (for

  // a vertical border) of nsHTMLFramesetFrames or nsHTMLFrames

  int32_t mPrevNeighbor;

  int32_t mNextNeighbor;

  nscolor mColor;

  int32_t mWidth;

  bool mVertical;

  bool mVisibility;

  bool mCanResize;

  friend class nsHTMLFramesetFrame;

};

/*******************************************************************************

 * nsHTMLFramesetBlankFrame

 ******************************************************************************/

class nsHTMLFramesetBlankFrame final : public nsLeafFrame

{

public:

  NS_DECL_QUERYFRAME

  NS_DECL_FRAMEARENA_HELPERS(nsHTMLFramesetBlankFrame)

#ifdef DEBUG_FRAME_DUMP

  virtual nsresult GetFrameName(nsAString& aResult) const override

  {

    return MakeFrameName(NS_LITERAL_STRING("FramesetBlank"), aResult);

  }

#endif

  virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                const nsDisplayListSet& aLists) override;

  virtual void Reflow(nsPresContext*           aPresContext,

                          ReflowOutput&     aDesiredSize,

                          const ReflowInput& aReflowInput,

                          nsReflowStatus&          aStatus) override;

protected:

  explicit nsHTMLFramesetBlankFrame(ComputedStyle* aStyle)

    : nsLeafFrame(aStyle, kClassID)

  {}

  virtual ~nsHTMLFramesetBlankFrame();

  virtual nscoord GetIntrinsicISize() override;

  virtual nscoord GetIntrinsicBSize() override;

  friend class nsHTMLFramesetFrame;

  friend class nsHTMLFrameset;

};

/*******************************************************************************

 * nsHTMLFramesetFrame

 ******************************************************************************/

bool    nsHTMLFramesetFrame::gDragInProgress = false;

#define DEFAULT_BORDER_WIDTH_PX 6

nsHTMLFramesetFrame::nsHTMLFramesetFrame(ComputedStyle* aStyle)

  : nsContainerFrame(aStyle, kClassID)

{

  mNumRows             = 0;

  mNumCols             = 0;

  mEdgeVisibility      = 0;

  mParentFrameborder   = eFrameborder_Yes; // default

  mParentBorderWidth   = -1; // default not set

  mParentBorderColor   = NO_COLOR; // default not set

  mFirstDragPoint.x     = mFirstDragPoint.y = 0;

  mMinDrag             = nsPresContext::CSSPixelsToAppUnits(2);

  mNonBorderChildCount = 0;

  mNonBlankChildCount  = 0;

  mDragger             = nullptr;

  mChildCount          = 0;

  mTopLevelFrameset    = nullptr;

  mEdgeColors.Set(NO_COLOR);

}

nsHTMLFramesetFrame::~nsHTMLFramesetFrame()

{

}

NS_QUERYFRAME_HEAD(nsHTMLFramesetFrame)

  NS_QUERYFRAME_ENTRY(nsHTMLFramesetFrame)

NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

void

nsHTMLFramesetFrame::Init(nsIContent*       aContent,

                          nsContainerFrame* aParent,

                          nsIFrame*         aPrevInFlow)

{

  nsContainerFrame::Init(aContent, aParent, aPrevInFlow);

  // find the highest ancestor that is a frameset

  nsIFrame* parentFrame = GetParent();

  mTopLevelFrameset = this;

  while (parentFrame) {

    nsHTMLFramesetFrame* frameset = do_QueryFrame(parentFrame);

    if (frameset) {

      mTopLevelFrameset = frameset;

      parentFrame = parentFrame->GetParent();

    } else {

      break;

    }

  }

  nsPresContext* presContext = PresContext();

  nsIPresShell* shell = presContext->PresShell();

  nsFrameborder  frameborder = GetFrameBorder();

  int32_t borderWidth = GetBorderWidth(presContext, false);

  nscolor borderColor = GetBorderColor();

  // Get the rows= cols= data

  HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);

  NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");

  const nsFramesetSpec* rowSpecs = nullptr;

  const nsFramesetSpec* colSpecs = nullptr;

  // GetRowSpec and GetColSpec can fail, but when they do they set

  // mNumRows and mNumCols respectively to 0, so we deal with it fine.

  ourContent->GetRowSpec(&mNumRows, &rowSpecs);

  ourContent->GetColSpec(&mNumCols, &colSpecs);

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscoord),

                "Maximum value of mNumRows and mNumCols is NS_MAX_FRAMESET_SPEC_COUNT");

  mRowSizes  = MakeUnique<nscoord[]>(mNumRows);

  mColSizes  = MakeUnique<nscoord[]>(mNumCols);

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT,

                "Should not overflow numCells");

  int32_t numCells = mNumRows*mNumCols;

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nsHTMLFramesetBorderFrame*),

                "Should not overflow nsHTMLFramesetBorderFrame");

  mVerBorders    = MakeUnique<nsHTMLFramesetBorderFrame*[]>(mNumCols);  // 1 more than number of ver borders

  for (int verX  = 0; verX < mNumCols; verX++)

    mVerBorders[verX]    = nullptr;

  mHorBorders    = MakeUnique<nsHTMLFramesetBorderFrame*[]>(mNumRows);  // 1 more than number of hor borders

  for (int horX = 0; horX < mNumRows; horX++)

    mHorBorders[horX]    = nullptr;

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT

                   < UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT,

                "Should not overflow numCells");

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT

                   < UINT_MAX / sizeof(nsFrameborder) / NS_MAX_FRAMESET_SPEC_COUNT,

                "Should not overflow numCells");

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT

                   < UINT_MAX / sizeof(nsBorderColor) / NS_MAX_FRAMESET_SPEC_COUNT,

                "Should not overflow numCells");

  mChildFrameborder  = MakeUnique<nsFrameborder[]>(numCells);

  mChildBorderColors  = MakeUnique<nsBorderColor[]>(numCells);

  // create the children frames; skip content which isn't <frameset> or <frame>

  mChildCount = 0; // number of <frame> or <frameset> children

  for (nsIContent* child = mContent->GetFirstChild();

       child;

       child = child->GetNextSibling()) {

    if (mChildCount == numCells) { // we have more <frame> or <frameset> than cells

      // Clear the lazy bits in the remaining children.  Also clear

      // the restyle flags, like nsCSSFrameConstructor::ProcessChildren does.

      for (; child; child = child->GetNextSibling()) {

        child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);

      }

      break;

    }

    child->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);

    // IMPORTANT: This must match the conditions in

    // nsCSSFrameConstructor::ContentAppended/Inserted/Removed

    if (!child->IsHTMLElement()) {

      continue;

    }

    if (!child->IsAnyOfHTMLElements(nsGkAtoms::frameset, nsGkAtoms::frame)) {

      continue;

    }

    RefPtr<ComputedStyle> kidSC =

      shell->StyleSet()->ResolveStyleFor(child->AsElement(),

                                         LazyComputeBehavior::Allow);

    nsIFrame* frame;

    if (child->IsHTMLElement(nsGkAtoms::frameset)) {

      frame = NS_NewHTMLFramesetFrame(shell, kidSC);

      nsHTMLFramesetFrame* childFrame = (nsHTMLFramesetFrame*)frame;

      childFrame->SetParentFrameborder(frameborder);

      childFrame->SetParentBorderWidth(borderWidth);

      childFrame->SetParentBorderColor(borderColor);

      frame->Init(child, this, nullptr);

      mChildBorderColors[mChildCount].Set(childFrame->GetBorderColor());

    } else { // frame

      frame = NS_NewSubDocumentFrame(shell, kidSC);

      frame->Init(child, this, nullptr);

      mChildFrameborder[mChildCount] = GetFrameBorder(child);

      mChildBorderColors[mChildCount].Set(GetBorderColor(child));

    }

    child->SetPrimaryFrame(frame);

    mFrames.AppendFrame(nullptr, frame);

    mChildCount++;

  }

  mNonBlankChildCount = mChildCount;

  // add blank frames for frameset cells that had no content provided

  for (int blankX = mChildCount; blankX < numCells; blankX++) {

    RefPtr<ComputedStyle> pseudoComputedStyle;

    pseudoComputedStyle = shell->StyleSet()->

      ResolveNonInheritingAnonymousBoxStyle(nsCSSAnonBoxes::framesetBlank());

    // XXX the blank frame is using the content of its parent - at some point it

    // should just have null content, if we support that

    nsHTMLFramesetBlankFrame* blankFrame = new (shell) nsHTMLFramesetBlankFrame(pseudoComputedStyle);

    blankFrame->Init(mContent, this, nullptr);

    mFrames.AppendFrame(nullptr, blankFrame);

    mChildBorderColors[mChildCount].Set(NO_COLOR);

    mChildCount++;

  }

  mNonBorderChildCount = mChildCount;

}

void

nsHTMLFramesetFrame::SetInitialChildList(ChildListID  aListID,

                                         nsFrameList& aChildList)

{

  // We do this weirdness where we create our child frames in Init().  On the

  // other hand, we're going to get a SetInitialChildList() with an empty list

  // and null list name after the frame constructor is done creating us.  So

  // just ignore that call.

  if (aListID == kPrincipalList && aChildList.IsEmpty()) {

    return;

  }

  nsContainerFrame::SetInitialChildList(aListID, aChildList);

}

// XXX should this try to allocate twips based on an even pixel boundary?

void nsHTMLFramesetFrame::Scale(nscoord  aDesired,

                                int32_t  aNumIndicies,

                                int32_t* aIndicies,

                                int32_t  aNumItems,

                                int32_t* aItems)

{

  int32_t actual = 0;

  int32_t i, j;

  // get the actual total

  for (i = 0; i < aNumIndicies; i++) {

    j = aIndicies[i];

    actual += aItems[j];

  }

  if (actual > 0) {

    float factor = (float)aDesired / (float)actual;

    actual = 0;

    // scale the items up or down

    for (i = 0; i < aNumIndicies; i++) {

      j = aIndicies[i];

      aItems[j] = NSToCoordRound((float)aItems[j] * factor);

      actual += aItems[j];

    }

  } else if (aNumIndicies != 0) {

    // All the specs say zero width, but we have to fill up space

    // somehow.  Distribute it equally.

    nscoord width = NSToCoordRound((float)aDesired / (float)aNumIndicies);

    actual = width * aNumIndicies;

    for (i = 0; i < aNumIndicies; i++) {

      aItems[aIndicies[i]] = width;

    }

  }

  if (aNumIndicies > 0 && aDesired != actual) {

    int32_t unit = (aDesired > actual) ? 1 : -1;

    for (i=0; (i < aNumIndicies) && (aDesired != actual); i++) {

      j = aIndicies[i];

      if (j < aNumItems) {

        aItems[j] += unit;

        actual += unit;

      }

    }

  }

}

/**

  * Translate the rows/cols specs into an array of integer sizes for

  * each cell in the frameset. Sizes are allocated based on the priorities of the

  * specifier - fixed sizes have the highest priority, percentage sizes have the next

  * highest priority and relative sizes have the lowest.

  */

void nsHTMLFramesetFrame::CalculateRowCol(nsPresContext*        aPresContext,

                                          nscoord               aSize,

                                          int32_t               aNumSpecs,

                                          const nsFramesetSpec* aSpecs,

                                          nscoord*              aValues)

{

  static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(int32_t),

                "aNumSpecs maximum value is NS_MAX_FRAMESET_SPEC_COUNT");

  int32_t  fixedTotal = 0;

  int32_t  numFixed = 0;

  auto fixed = MakeUnique<int32_t[]>(aNumSpecs);

  int32_t  numPercent = 0;

  auto percent = MakeUnique<int32_t[]>(aNumSpecs);

  int32_t  relativeSums = 0;

  int32_t  numRelative = 0;

  auto relative = MakeUnique<int32_t[]>(aNumSpecs);

  if (MOZ_UNLIKELY(!fixed || !percent || !relative)) {

    return; // NS_ERROR_OUT_OF_MEMORY

  }

  int32_t i, j;

  // initialize the fixed, percent, relative indices, allocate the fixed sizes and zero the others

  for (i = 0; i < aNumSpecs; i++) {

    aValues[i] = 0;

    switch (aSpecs[i].mUnit) {

      case eFramesetUnit_Fixed:

        aValues[i] = nsPresContext::CSSPixelsToAppUnits(aSpecs[i].mValue);

        fixedTotal += aValues[i];

        fixed[numFixed] = i;

        numFixed++;

        break;

      case eFramesetUnit_Percent:

        percent[numPercent] = i;

        numPercent++;

        break;

      case eFramesetUnit_Relative:

        relative[numRelative] = i;

        numRelative++;

        relativeSums += aSpecs[i].mValue;

        break;

    }

  }

  // scale the fixed sizes if they total too much (or too little and there aren't any percent or relative)

  if ((fixedTotal > aSize) || ((fixedTotal < aSize) && (0 == numPercent) && (0 == numRelative))) {

    Scale(aSize, numFixed, fixed.get(), aNumSpecs, aValues);

    return;

  }

  int32_t percentMax = aSize - fixedTotal;

  int32_t percentTotal = 0;

  // allocate the percentage sizes from what is left over from the fixed allocation

  for (i = 0; i < numPercent; i++) {

    j = percent[i];

    aValues[j] = NSToCoordRound((float)aSpecs[j].mValue * (float)aSize / 100.0f);

    percentTotal += aValues[j];

  }

  // scale the percent sizes if they total too much (or too little and there aren't any relative)

  if ((percentTotal > percentMax) || ((percentTotal < percentMax) && (0 == numRelative))) {

    Scale(percentMax, numPercent, percent.get(), aNumSpecs, aValues);

    return;

  }

  int32_t relativeMax = percentMax - percentTotal;

  int32_t relativeTotal = 0;

  // allocate the relative sizes from what is left over from the percent allocation

  for (i = 0; i < numRelative; i++) {

    j = relative[i];

    aValues[j] = NSToCoordRound((float)aSpecs[j].mValue * (float)relativeMax / (float)relativeSums);

    relativeTotal += aValues[j];

  }

  // scale the relative sizes if they take up too much or too little

  if (relativeTotal != relativeMax) {

    Scale(relativeMax, numRelative, relative.get(), aNumSpecs, aValues);

  }

}

/**

  * Translate the rows/cols integer sizes into an array of specs for

  * each cell in the frameset.  Reverse of CalculateRowCol() behaviour.

  * This allows us to maintain the user size info through reflows.

  */

void nsHTMLFramesetFrame::GenerateRowCol(nsPresContext*        aPresContext,

                                         nscoord               aSize,

                                         int32_t               aNumSpecs,

                                         const nsFramesetSpec* aSpecs,

                                         nscoord*              aValues,

                                         nsString&             aNewAttr)

{

  int32_t i;

  for (i = 0; i < aNumSpecs; i++) {

    if (!aNewAttr.IsEmpty())

      aNewAttr.Append(char16_t(','));

    switch (aSpecs[i].mUnit) {

      case eFramesetUnit_Fixed:

        aNewAttr.AppendInt(nsPresContext::AppUnitsToIntCSSPixels(aValues[i]));

        break;

      case eFramesetUnit_Percent: // XXX Only accurate to 1%, need 1 pixel

      case eFramesetUnit_Relative:

        // Add 0.5 to the percentage to make rounding work right.

        aNewAttr.AppendInt(uint32_t((100.0*aValues[i])/aSize + 0.5));

        aNewAttr.Append(char16_t('%'));

        break;

    }

  }

}

int32_t nsHTMLFramesetFrame::GetBorderWidth(nsPresContext* aPresContext,

                                            bool aTakeForcingIntoAccount)

{

  nsFrameborder frameborder = GetFrameBorder();

  if (frameborder == eFrameborder_No) {

    return 0;

  }

  nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);

  if (content) {

    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::border);

    if (attr) {

      int32_t intVal = 0;

      if (attr->Type() == nsAttrValue::eInteger) {

        intVal = attr->GetIntegerValue();

        if (intVal < 0) {

          intVal = 0;

        }

      }

      return nsPresContext::CSSPixelsToAppUnits(intVal);

    }

  }

  if (mParentBorderWidth >= 0) {

    return mParentBorderWidth;

  }

  return nsPresContext::CSSPixelsToAppUnits(DEFAULT_BORDER_WIDTH_PX);

}

void

nsHTMLFramesetFrame::GetDesiredSize(nsPresContext*           aPresContext,

                                    const ReflowInput& aReflowInput,

                                    ReflowOutput&     aDesiredSize)

{

  WritingMode wm = aReflowInput.GetWritingMode();

  LogicalSize desiredSize(wm);

  nsHTMLFramesetFrame* framesetParent = do_QueryFrame(GetParent());

  if (nullptr == framesetParent) {

    if (aPresContext->IsPaginated()) {

      // XXX This needs to be changed when framesets paginate properly

      desiredSize.ISize(wm) = aReflowInput.AvailableISize();

      desiredSize.BSize(wm) = aReflowInput.AvailableBSize();

    } else {

      LogicalSize area(wm, aPresContext->GetVisibleArea().Size());

      desiredSize.ISize(wm) = area.ISize(wm);

      desiredSize.BSize(wm) = area.BSize(wm);

    }

  } else {

    LogicalSize size(wm);

    framesetParent->GetSizeOfChild(this, wm, size);

    desiredSize.ISize(wm) = size.ISize(wm);

    desiredSize.BSize(wm) = size.BSize(wm);

  }

  aDesiredSize.SetSize(wm, desiredSize);

}

// only valid for non border children

void nsHTMLFramesetFrame::GetSizeOfChildAt(int32_t  aIndexInParent,

                                           WritingMode aWM,

                                           LogicalSize&  aSize,

                                           nsIntPoint& aCellIndex)

{

  int32_t row = aIndexInParent / mNumCols;

  int32_t col = aIndexInParent - (row * mNumCols); // remainder from dividing index by mNumCols

  if ((row < mNumRows) && (col < mNumCols)) {

    aSize.ISize(aWM) = mColSizes[col];

    aSize.BSize(aWM) = mRowSizes[row];

    aCellIndex.x = col;

    aCellIndex.y = row;

  } else {

    aSize.SizeTo(aWM, 0, 0);

    aCellIndex.x = aCellIndex.y = 0;

  }

}

// only valid for non border children

void nsHTMLFramesetFrame::GetSizeOfChild(nsIFrame* aChild,

                                         WritingMode aWM,

                                         LogicalSize& aSize)

{

  // Reflow only creates children frames for <frameset> and <frame> content.

  // this assumption is used here

  int i = 0;

  for (nsIFrame* child : mFrames) {

    if (aChild == child) {

      nsIntPoint ignore;

      GetSizeOfChildAt(i, aWM, aSize, ignore);

      return;

    }

    i++;

  }

  aSize.SizeTo(aWM, 0, 0);

}

nsresult nsHTMLFramesetFrame::HandleEvent(nsPresContext* aPresContext,

                                           WidgetGUIEvent* aEvent,

                                           nsEventStatus* aEventStatus)

{

  NS_ENSURE_ARG_POINTER(aEventStatus);

  if (mDragger) {

    // the nsFramesetBorderFrame has captured NS_MOUSE_DOWN

    switch (aEvent->mMessage) {

      case eMouseMove:

        MouseDrag(aPresContext, aEvent);

        break;

      case eMouseUp:

        if (aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {

          EndMouseDrag(aPresContext);

        }

        break;

      default:

        break;

    }

    *aEventStatus = nsEventStatus_eConsumeNoDefault;

  } else {

    *aEventStatus = nsEventStatus_eIgnore;

  }

  return NS_OK;

}

nsresult

nsHTMLFramesetFrame::GetCursor(const nsPoint&    aPoint,

                               nsIFrame::Cursor& aCursor)

{

  aCursor.mLoading = false;

  if (mDragger) {

    aCursor.mCursor = (mDragger->mVertical) ? NS_STYLE_CURSOR_EW_RESIZE : NS_STYLE_CURSOR_NS_RESIZE;

  } else {

    aCursor.mCursor = NS_STYLE_CURSOR_DEFAULT;

  }

  return NS_OK;

}

void

nsHTMLFramesetFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                      const nsDisplayListSet& aLists)

{

  BuildDisplayListForInline(aBuilder, aLists);

  if (mDragger && aBuilder->IsForEventDelivery()) {

    aLists.Content()->AppendToTop(

      MakeDisplayItem<nsDisplayEventReceiver>(aBuilder, this));

  }

}

void

nsHTMLFramesetFrame::ReflowPlaceChild(nsIFrame*                aChild,

                                      nsPresContext*           aPresContext,

                                      const ReflowInput& aReflowInput,

                                      nsPoint&                 aOffset,

                                      nsSize&                  aSize,

                                      nsIntPoint*              aCellIndex)

{

  // reflow the child

  ReflowInput reflowInput(aPresContext, aReflowInput, aChild,

                                LogicalSize(aChild->GetWritingMode(), aSize));

  reflowInput.SetComputedWidth(std::max(0, aSize.width - reflowInput.ComputedPhysicalBorderPadding().LeftRight()));

  reflowInput.SetComputedHeight(std::max(0, aSize.height - reflowInput.ComputedPhysicalBorderPadding().TopBottom()));

  ReflowOutput reflowOutput(aReflowInput);

  reflowOutput.Width() = aSize.width;

  reflowOutput.Height() = aSize.height;

  nsReflowStatus status;

  ReflowChild(aChild, aPresContext, reflowOutput, reflowInput, aOffset.x,

              aOffset.y, 0, status);

  NS_ASSERTION(status.IsComplete(), "bad status");

  // Place and size the child

  reflowOutput.Width() = aSize.width;

  reflowOutput.Height() = aSize.height;

  FinishReflowChild(aChild, aPresContext, reflowOutput, nullptr, aOffset.x, aOffset.y, 0);

}

static

nsFrameborder GetFrameBorderHelper(nsGenericHTMLElement* aContent)

{

  if (nullptr != aContent) {

    const nsAttrValue* attr = aContent->GetParsedAttr(nsGkAtoms::frameborder);

    if (attr && attr->Type() == nsAttrValue::eEnum) {

      switch (attr->GetEnumValue())

      {

        case NS_STYLE_FRAME_YES:

        case NS_STYLE_FRAME_1:

          return eFrameborder_Yes;

        case NS_STYLE_FRAME_NO:

        case NS_STYLE_FRAME_0:

          return eFrameborder_No;

      }

    }

  }

  return eFrameborder_Notset;

}

nsFrameborder nsHTMLFramesetFrame::GetFrameBorder()

{

  nsFrameborder result = eFrameborder_Notset;

  nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);

  if (content) {

    result = GetFrameBorderHelper(content);

  }

  if (eFrameborder_Notset == result) {

    return mParentFrameborder;

  }

  return result;

}

nsFrameborder nsHTMLFramesetFrame::GetFrameBorder(nsIContent* aContent)

{

  nsFrameborder result = eFrameborder_Notset;

  nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(aContent);

  if (content) {

    result = GetFrameBorderHelper(content);

  }

  if (eFrameborder_Notset == result) {

    return GetFrameBorder();

  }

  return result;

}

nscolor nsHTMLFramesetFrame::GetBorderColor()

{

  nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(mContent);

  if (content) {

    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);

    if (attr) {

      nscolor color;

      if (attr->GetColorValue(color)) {

        return color;

      }

    }

  }

  return mParentBorderColor;

}

nscolor nsHTMLFramesetFrame::GetBorderColor(nsIContent* aContent)

{

  nsGenericHTMLElement *content = nsGenericHTMLElement::FromNode(aContent);

  if (content) {

    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::bordercolor);

    if (attr) {

      nscolor color;

      if (attr->GetColorValue(color)) {

        return color;

      }

    }

  }

  return GetBorderColor();

}

void

nsHTMLFramesetFrame::Reflow(nsPresContext*           aPresContext,

                            ReflowOutput&     aDesiredSize,

                            const ReflowInput& aReflowInput,

                            nsReflowStatus&          aStatus)

{

  MarkInReflow();

  DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetFrame");

  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);

  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  nsIPresShell *shell = aPresContext->PresShell();

  ServoStyleSet* styleSet = shell->StyleSet();

  GetParent()->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);

  //printf("FramesetFrame2::Reflow %X (%d,%d) \n", this, aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight());

  // Always get the size so that the caller knows how big we are

  GetDesiredSize(aPresContext, aReflowInput, aDesiredSize);

  nscoord width  = (aDesiredSize.Width() <= aReflowInput.AvailableWidth())

    ? aDesiredSize.Width() : aReflowInput.AvailableWidth();

  nscoord height = (aDesiredSize.Height() <= aReflowInput.AvailableHeight())

    ? aDesiredSize.Height() : aReflowInput.AvailableHeight();

  // We might be reflowed more than once with NS_FRAME_FIRST_REFLOW;

  // that's allowed.  (Though it will only happen for misuse of frameset

  // that includes it within other content.)  So measure firstTime by

  // what we care about, which is whether we've processed the data we

  // process below if firstTime is true.

  MOZ_ASSERT(!mChildFrameborder == !mChildBorderColors);

  bool firstTime = !!mChildFrameborder;

  // subtract out the width of all of the potential borders. There are

  // only borders between <frame>s. There are none on the edges (e.g the

  // leftmost <frame> has no left border).

  int32_t borderWidth = GetBorderWidth(aPresContext, true);

  width  -= (mNumCols - 1) * borderWidth;

  if (width < 0) width = 0;

  height -= (mNumRows - 1) * borderWidth;

  if (height < 0) height = 0;

  HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromNode(mContent);

  NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");

  const nsFramesetSpec* rowSpecs = nullptr;

  const nsFramesetSpec* colSpecs = nullptr;

  int32_t rows = 0;

  int32_t cols = 0;

  ourContent->GetRowSpec(&rows, &rowSpecs);

  ourContent->GetColSpec(&cols, &colSpecs);

  // If the number of cols or rows has changed, the frame for the frameset

  // will be re-created.

  if (mNumRows != rows || mNumCols != cols) {

    mDrag.UnSet();

    NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);

    return;

  }

  CalculateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get());

  CalculateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get());

  UniquePtr<bool[]>  verBordersVis; // vertical borders visibility

  UniquePtr<nscolor[]> verBorderColors;

  UniquePtr<bool[]>  horBordersVis; // horizontal borders visibility

  UniquePtr<nscolor[]> horBorderColors;

  nscolor                 borderColor = GetBorderColor();

  nsFrameborder           frameborder = GetFrameBorder();

  if (firstTime) {

    // Check for overflow in memory allocations using mNumCols and mNumRows

    // which have a maxium value of NS_MAX_FRAMESET_SPEC_COUNT.

    static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(bool),

                  "Check for overflow");

    static_assert(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscolor),

                  "Check for overflow");

    verBordersVis = MakeUnique<bool[]>(mNumCols);

    verBorderColors = MakeUnique<nscolor[]>(mNumCols);

    for (int verX  = 0; verX < mNumCols; verX++) {

      verBordersVis[verX] = false;

      verBorderColors[verX] = NO_COLOR;

    }

    horBordersVis = MakeUnique<bool[]>(mNumRows);

    horBorderColors = MakeUnique<nscolor[]>(mNumRows);

    for (int horX = 0; horX < mNumRows; horX++) {

      horBordersVis[horX] = false;

      horBorderColors[horX] = NO_COLOR;

    }

  }

  // reflow the children

  int32_t lastRow = 0;

  int32_t lastCol = 0;

  int32_t borderChildX = mNonBorderChildCount; // index of border children

  nsHTMLFramesetBorderFrame* borderFrame = nullptr;

  nsPoint offset(0,0);

  nsSize size, lastSize;

  WritingMode wm = GetWritingMode();

  LogicalSize logicalSize(wm);

  nsIFrame* child = mFrames.FirstChild();

  for (int32_t childX = 0; childX < mNonBorderChildCount; childX++) {

    nsIntPoint cellIndex;

    GetSizeOfChildAt(childX, wm, logicalSize, cellIndex);

    size = logicalSize.GetPhysicalSize(wm);

    if (lastRow != cellIndex.y) {  // changed to next row

      offset.x = 0;