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

#ifndef TextOverflow_h_
#define TextOverflow_h_

#include "nsDisplayList.h"
#include "nsTHashSet.h"
#include "mozilla/Attributes.h"
#include "mozilla/Likely.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/WritingModes.h"
#include <algorithm>

class nsIScrollableFrame;
class nsBlockFrame;
class nsLineBox;

namespace mozilla {
namespace css {

/**
 * A class for rendering CSS3 text-overflow.
 * Usage:
 *  1. allocate an object using WillProcessLines
 *  2. then call ProcessLine for each line you are building display lists for
 *
 * Note that this class is non-reassignable; we don't want to be making
 * arbitrary copies. (But we do have a move constructor, since that's required
 * in order to be stored in Maybe<>).
 */
class TextOverflow final {
 private:
  /**
   * Private constructor, for internal use only. Client code should call
   * WillProcessLines(), which is basically the factory function for
   * TextOverflow instances.
   */
  TextOverflow(nsDisplayListBuilder* aBuilder, nsBlockFrame*);

 public:
  ~TextOverflow() = default;

  /**
   * Allocate an object for text-overflow processing. (Factory function.)
   * @return nullptr if no processing is necessary.  The caller owns the object.
   */
  static Maybe<TextOverflow> WillProcessLines(nsDisplayListBuilder* aBuilder,
                                              nsBlockFrame*);

  /**
   * This is a factory-constructed non-reassignable class, so we delete nearly
   * all constructors and reassignment operators.  We only provide a
   * move-constructor, because that's required for Maybe<TextOverflow> to work
   * (and that's what our factory method returns).
   */
  TextOverflow(TextOverflow&&) = default;

  TextOverflow() = delete;
  TextOverflow(const TextOverflow&) = delete;
  TextOverflow& operator=(const TextOverflow&) = delete;
  TextOverflow& operator=(TextOverflow&&) = delete;

  /**
   * Analyze the display lists for text overflow and what kind of item is at
   * the content edges.  Add display items for text-overflow markers as needed
   * and remove or clip items that would overlap a marker.
   */
  void ProcessLine(const nsDisplayListSet& aLists, nsLineBox* aLine,
                   uint32_t aLineNumber);

  /**
   * Get the resulting text-overflow markers (the list may be empty).
   * @return a DisplayList containing any text-overflow markers.
   */
  nsDisplayList& GetMarkers() { return mMarkerList; }

  // Returns whether aBlockFrame has text-overflow:clip on both sides.
  static bool HasClippedTextOverflow(nsIFrame* aBlockFrame);

  // Returns whether aBlockFrame has a block ellipsis on one of its lines.
  static bool HasBlockEllipsis(nsIFrame* aBlockFrame);

  // Returns whether the given block frame needs analysis for text overflow.
  // The BeforeReflow flag indicates whether we can be faster and more precise
  // for line-clamp ellipsis (only returning true iff the block actually uses
  // it).
  enum class BeforeReflow : bool { No, Yes };
  static bool CanHaveOverflowMarkers(nsBlockFrame*,
                                     BeforeReflow = BeforeReflow::No);

  typedef nsTHashSet<nsIFrame*> FrameHashtable;

 private:
  typedef mozilla::WritingMode WritingMode;
  typedef mozilla::LogicalRect LogicalRect;

  // Edges to align the IStart and IEnd markers to.
  struct AlignmentEdges {
    AlignmentEdges()
        : mIStart(0), mIEnd(0), mIEndOuter(0), mAssignedInner(false) {}
    void AccumulateInner(WritingMode aWM, const LogicalRect& aRect) {
      if (MOZ_LIKELY(mAssignedInner)) {
        mIStart = std::min(mIStart, aRect.IStart(aWM));
        mIEnd = std::max(mIEnd, aRect.IEnd(aWM));
      } else {
        mIStart = aRect.IStart(aWM);
        mIEnd = aRect.IEnd(aWM);
        mAssignedInner = true;
      }
    }
    void AccumulateOuter(WritingMode aWM, const LogicalRect& aRect) {
      mIEndOuter = std::max(mIEndOuter, aRect.IEnd(aWM));
    }
    nscoord ISize() { return mIEnd - mIStart; }

    // The outermost edges of all text and atomic inline-level frames that are
    // inside the area between the markers.
    nscoord mIStart;
    nscoord mIEnd;

    // The closest IEnd edge of all text and atomic inline-level frames that
    // fall completely before the IStart edge of the content area.  (Used to
    // align a block ellipsis when there are no visible frames to align to.)
    nscoord mIEndOuter;

    bool mAssignedInner;
  };

  struct InnerClipEdges {
    InnerClipEdges()
        : mIStart(0), mIEnd(0), mAssignedIStart(false), mAssignedIEnd(false) {}
    void AccumulateIStart(WritingMode aWM, const LogicalRect& aRect) {
      if (MOZ_LIKELY(mAssignedIStart)) {
        mIStart = std::max(mIStart, aRect.IStart(aWM));
      } else {
        mIStart = aRect.IStart(aWM);
        mAssignedIStart = true;
      }
    }
    void AccumulateIEnd(WritingMode aWM, const LogicalRect& aRect) {
      if (MOZ_LIKELY(mAssignedIEnd)) {
        mIEnd = std::min(mIEnd, aRect.IEnd(aWM));
      } else {
        mIEnd = aRect.IEnd(aWM);
        mAssignedIEnd = true;
      }
    }
    nscoord mIStart;
    nscoord mIEnd;
    bool mAssignedIStart;
    bool mAssignedIEnd;
  };

  LogicalRect GetLogicalScrollableOverflowRectRelativeToBlock(
      nsIFrame* aFrame) const {
    return LogicalRect(
        mBlockWM,
        aFrame->ScrollableOverflowRect() + aFrame->GetOffsetTo(mBlock),
        mBlockSize);
  }

  /**
   * Examines frames on the line to determine whether we should draw a left
   * and/or right marker, and if so, which frames should be completely hidden
   * and the bounds of what will be displayed between the markers.
   * @param aLine the line we're processing
   * @param aFramesToHide frames that should have their display items removed
   * @param aAlignmentEdges edges the markers will be aligned to, including
   *   the outermost edges of all text and atomic inline-level frames that
   *   are inside the content area, and the closest IEnd edge of such a frame
   *   outside the content area
   * @return the area inside which we should add any markers;
   *   this is the block's content area narrowed by any floats on this line.
   */
  LogicalRect ExamineLineFrames(nsLineBox* aLine, FrameHashtable* aFramesToHide,
                                AlignmentEdges* aAlignmentEdges);

  /**
   * LineHasOverflowingText calls this to analyze edges, both the block's
   * content edges and the hypothetical marker edges aligned at the block edges.
   * @param aFrame the descendant frame of mBlock that we're analyzing
   * @param aContentArea the block's content area
   * @param aInsideMarkersArea the rectangle between the markers
   * @param aFramesToHide frames that should have their display items removed
   * @param aAlignmentEdges edges the markers will be aligned to, including
   *   the outermost edges of all text and atomic inline-level frames that
   *   are inside the content area, and the closest IEnd edge of such a frame
   *   outside the content area
   * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic
   *   inline-level frame is visible between the marker edges
   * @param aClippedMarkerEdges the innermost edges of all text and atomic
   *   inline-level frames that are clipped by the current marker width
   */
  void ExamineFrameSubtree(nsIFrame* aFrame, const LogicalRect& aContentArea,
                           const LogicalRect& aInsideMarkersArea,
                           FrameHashtable* aFramesToHide,
                           AlignmentEdges* aAlignmentEdges,
                           bool* aFoundVisibleTextOrAtomic,
                           InnerClipEdges* aClippedMarkerEdges);

  /**
   * ExamineFrameSubtree calls this to analyze a frame against the hypothetical
   * marker edges (aInsideMarkersArea) for text frames and atomic inline-level
   * elements.  A text frame adds its extent inside aInsideMarkersArea where
   * grapheme clusters are fully visible.  An atomic adds its border box if
   * it's fully inside aInsideMarkersArea, otherwise the frame is added to
   * aFramesToHide.
   * @param aFrame the descendant frame of mBlock that we're analyzing
   * @param aFrameType aFrame's frame type
   * @param aInsideMarkersArea the rectangle between the markers
   * @param aFramesToHide frames that should have their display items removed
   * @param aAlignmentEdges the outermost edges of all text and atomic
   *   inline-level frames that are inside the area between the markers
   *                       inside aInsideMarkersArea
   * @param aAlignmentEdges edges the markers will be aligned to, including
   *   the outermost edges of all text and atomic inline-level frames that
   *   are inside aInsideMarkersArea, and the closest IEnd edge of such a frame
   *   outside the content area
   * @param aFoundVisibleTextOrAtomic is set to true if a text or atomic
   *   inline-level frame is visible between the marker edges
   * @param aClippedMarkerEdges the innermost edges of all text and atomic
   *   inline-level frames that are clipped by the current marker width
   */
  void AnalyzeMarkerEdges(nsIFrame* aFrame, mozilla::LayoutFrameType aFrameType,
                          const LogicalRect& aInsideMarkersArea,
                          FrameHashtable* aFramesToHide,
                          AlignmentEdges* aAlignmentEdges,
                          bool* aFoundVisibleTextOrAtomic,
                          InnerClipEdges* aClippedMarkerEdges);

  /**
   * Clip or remove items given the final marker edges. ("clip" here just means
   * assigning mVisIStartEdge/mVisIEndEdge for any nsCharClipDisplayItem that
   * needs it; see nsDisplayList.h for a description of that item).
   * @param aFramesToHide remove display items for these frames
   * @param aInsideMarkersArea is the area inside the markers
   */
  void PruneDisplayListContents(nsDisplayList* aList,
                                const FrameHashtable& aFramesToHide,
                                const LogicalRect& aInsideMarkersArea);

  /**
   * ProcessLine calls this to create display items for the markers and insert
   * them into mMarkerList.
   * @param aLine the line we're processing
   * @param aCreateIStart if true, create a marker on the inline start side
   * @param aCreateIEnd if true, create a marker on the inline end side
   * @param aInsideMarkersArea is the area inside the markers
   * @param aContentArea is the area inside which we should add the markers;
   *   this is the block's content area narrowed by any floats on this line.
   */
  void CreateMarkers(const nsLineBox* aLine, bool aCreateIStart,
                     bool aCreateIEnd, const LogicalRect& aInsideMarkersArea,
                     const LogicalRect& aContentArea, uint32_t aLineNumber);

  LogicalRect mContentArea;
  nsDisplayListBuilder* mBuilder;
  nsIFrame* mBlock;
  nsIScrollableFrame* mScrollableFrame;
  nsDisplayList mMarkerList;
  nsSize mBlockSize;
  WritingMode mBlockWM;
  bool mCanHaveInlineAxisScrollbar;
  // When we're in a -webkit-line-clamp context, we should ignore inline-end
  // text-overflow markers. See nsBlockFrame::IsInLineClampContext.
  const bool mInLineClampContext;
  bool mAdjustForPixelSnapping;

  class Marker {
   public:
    void Init(const StyleTextOverflowSide& aStyle) {
      mInitialized = false;
      mISize = 0;
      mStyle = &aStyle;
      mIntrinsicISize = 0;
      mHasOverflow = false;
      mHasBlockEllipsis = false;
      mActive = false;
      mEdgeAligned = false;
    }

    /**
     * Setup the marker string and calculate its size, if not done already.
     */
    void SetupString(nsIFrame* aFrame);

    bool IsSuppressed(bool aInLineClampContext) const {
      if (aInLineClampContext) {
        return !mHasBlockEllipsis;
      }
      return mStyle->IsClip();
    }
    bool IsNeeded() const { return mHasOverflow || mHasBlockEllipsis; }
    void Reset() {
      mHasOverflow = false;
      mHasBlockEllipsis = false;
      mEdgeAligned = false;
    }

    // The current width of the marker, the range is [0 .. mIntrinsicISize].
    nscoord mISize;
    // The intrinsic width of the marker.
    nscoord mIntrinsicISize;
    // The text-overflow style for this side.  Ignored if we're rendering a
    // block ellipsis.
    const StyleTextOverflowSide* mStyle;
    // True if there is visible overflowing inline content on this side.
    bool mHasOverflow;
    // True if this side has a block ellipsis (from -webkit-line-clamp).
    bool mHasBlockEllipsis;
    // True if mISize and mIntrinsicISize have been setup from style.
    bool mInitialized;
    // True if the style is not text-overflow:clip on this side and the marker
    // won't cause the line to become empty.
    bool mActive;
    // True if this marker is aligned to the edge of the content box, so that
    // when scrolling the marker doesn't jump around.
    bool mEdgeAligned;
  };

  Marker mIStart;  // the inline start marker
  Marker mIEnd;    // the inline end marker
};

}  // namespace css
}  // namespace mozilla

#endif /* !defined(TextOverflow_h_) */