Add m-esr52 at 52.6.0

1 files changed, 546 insertions, 0 deletions

diff --git a/layout/base/nsBidiPresUtils.h b/layout/base/nsBidiPresUtils.h
new file mode 100644
index 000000000..707df8343
--- /dev/null
+++ b/layout/base/nsBidiPresUtils.h
@@ -0,0 +1,546 @@
+/* -*- 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/. */
+
+#ifndef nsBidiPresUtils_h___
+#define nsBidiPresUtils_h___
+
+#include "nsBidi.h"
+#include "nsBidiUtils.h"
+#include "nsHashKeys.h"
+#include "nsCoord.h"
+#include "nsRenderingContext.h"
+
+#ifdef DrawText
+#undef DrawText
+#endif
+
+struct BidiParagraphData;
+struct BidiLineData;
+class nsFontMetrics;
+class nsIFrame;
+class nsBlockFrame;
+class nsPresContext;
+class nsRenderingContext;
+class nsBlockInFlowLineIterator;
+class nsStyleContext;
+struct nsSize;
+template<class T> class nsTHashtable;
+namespace mozilla {
+  class WritingMode;
+  class LogicalMargin;
+} // namespace mozilla
+
+/**
+ * A structure representing some continuation state for each frame on the line,
+ * used to determine the first and the last continuation frame for each
+ * continuation chain on the line.
+ */
+struct nsFrameContinuationState : public nsVoidPtrHashKey
+{
+  explicit nsFrameContinuationState(const void *aFrame) : nsVoidPtrHashKey(aFrame) {}
+
+  /**
+   * The first visual frame in the continuation chain containing this frame, or
+   * nullptr if this frame is the first visual frame in the chain.
+   */
+  nsIFrame* mFirstVisualFrame;
+
+  /**
+   * The number of frames in the continuation chain containing this frame, if
+   * this frame is the first visual frame of the chain, or 0 otherwise.
+   */
+  uint32_t mFrameCount;
+
+  /**
+   * TRUE if this frame is the first visual frame of its continuation chain on
+   * this line and the chain has some frames on the previous lines.
+   */
+  bool mHasContOnPrevLines;
+
+  /**
+   * TRUE if this frame is the first visual frame of its continuation chain on
+   * this line and the chain has some frames left for next lines.
+   */
+  bool mHasContOnNextLines;
+};
+
+/*
+ * Following type is used to pass needed hashtable to reordering methods
+ */
+typedef nsTHashtable<nsFrameContinuationState> nsContinuationStates;
+
+/**
+ * A structure representing a logical position which should be resolved
+ * into its visual position during BiDi processing.
+ */
+struct nsBidiPositionResolve
+{
+  // [in] Logical index within string.
+  int32_t logicalIndex;
+  // [out] Visual index within string.
+  // If the logical position was not found, set to kNotFound.
+  int32_t visualIndex;
+  // [out] Visual position of the character, from the left (on the X axis), in twips.
+  // Eessentially, this is the X position (relative to the rendering context) where the text was drawn + the font metric of the visual string to the left of the given logical position.
+  // If the logical position was not found, set to kNotFound.
+  int32_t visualLeftTwips;
+  // [out] Visual width of the character, in twips.
+  // If the logical position was not found, set to kNotFound.
+  int32_t visualWidth;
+};
+
+class nsBidiPresUtils {
+public:
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+
+  nsBidiPresUtils();
+  ~nsBidiPresUtils();
+  
+  /**
+   * Interface for the processor used by ProcessText. Used by process text to
+   * collect information about the width of subruns and to notify where each
+   * subrun should be rendered.
+   */
+  class BidiProcessor {
+  public:
+    virtual ~BidiProcessor() { }
+
+    /**
+     * Sets the current text with the given length and the given direction.
+     *
+     * @remark The reason that the function gives a string instead of an index
+     *  is that ProcessText copies and modifies the string passed to it, so
+     *  passing an index would be impossible.
+     *
+     * @param aText The string of text.
+     * @param aLength The length of the string of text.
+     * @param aDirection The direction of the text. The string will never have
+     *  mixed direction.
+     */
+    virtual void SetText(const char16_t*   aText,
+                         int32_t           aLength,
+                         nsBidiDirection   aDirection) = 0;
+
+    /**
+     * Returns the measured width of the text given in SetText. If SetText was
+     * not called with valid parameters, the result of this call is undefined.
+     * This call is guaranteed to only be called once between SetText calls.
+     * Will be invoked before DrawText.
+     */
+    virtual nscoord GetWidth() = 0;
+
+    /**
+     * Draws the text given in SetText to a rendering context. If SetText was
+     * not called with valid parameters, the result of this call is undefined.
+     * This call is guaranteed to only be called once between SetText calls.
+     * 
+     * @param aXOffset The offset of the left side of the substring to be drawn
+     *  from the beginning of the overall string passed to ProcessText.
+     * @param aWidth The width returned by GetWidth.
+     */
+    virtual void DrawText(nscoord   aXOffset,
+                          nscoord   aWidth) = 0;
+  };
+
+  /**
+   * Make Bidi engine calculate the embedding levels of the frames that are
+   * descendants of a given block frame.
+   *
+   * @param aBlockFrame          The block frame
+   *
+   *  @lina 06/18/2000
+   */
+  static nsresult Resolve(nsBlockFrame* aBlockFrame);
+  static nsresult ResolveParagraph(BidiParagraphData* aBpd);
+  static void ResolveParagraphWithinBlock(BidiParagraphData* aBpd);
+
+  /**
+   * Reorder this line using Bidi engine.
+   * Update frame array, following the new visual sequence.
+   *
+   * @return total inline size
+   * 
+   * @lina 05/02/2000
+   */
+  static nscoord ReorderFrames(nsIFrame* aFirstFrameOnLine,
+                               int32_t aNumFramesOnLine,
+                               mozilla::WritingMode aLineWM,
+                               const nsSize& aContainerSize,
+                               nscoord aStart);
+
+  /**
+   * Format Unicode text, taking into account bidi capabilities
+   * of the platform. The formatting includes: reordering, Arabic shaping,
+   * symmetric and numeric swapping, removing control characters.
+   *
+   * @lina 06/18/2000 
+   */
+  static nsresult FormatUnicodeText(nsPresContext*  aPresContext,
+                                    char16_t*       aText,
+                                    int32_t&        aTextLength,
+                                    nsCharType      aCharType);
+
+  /**
+   * Reorder plain text using the Unicode Bidi algorithm and send it to
+   * a rendering context for rendering.
+   *
+   * @param[in] aText  the string to be rendered (in logical order)
+   * @param aLength the number of characters in the string
+   * @param aBaseLevel the base embedding level of the string
+   *  odd values are right-to-left; even values are left-to-right, plus special
+   *  constants as follows (defined in nsBidi.h)
+   *  NSBIDI_LTR - left-to-right string
+   *  NSBIDI_RTL - right-to-left string
+   *  NSBIDI_DEFAULT_LTR - auto direction determined by first strong character,
+   *                       default is left-to-right
+   *  NSBIDI_DEFAULT_RTL - auto direction determined by first strong character,
+   *                       default is right-to-left
+   *
+   * @param aPresContext the presentation context
+   * @param aRenderingContext the rendering context to render to
+   * @param aTextRunConstructionContext the rendering context to be used to construct the textrun (affects font hinting)
+   * @param aX the x-coordinate to render the string
+   * @param aY the y-coordinate to render the string
+   * @param[in,out] aPosResolve array of logical positions to resolve into visual positions; can be nullptr if this functionality is not required
+   * @param aPosResolveCount number of items in the aPosResolve array
+   */
+  static nsresult RenderText(const char16_t*       aText,
+                             int32_t                aLength,
+                             nsBidiLevel            aBaseLevel,
+                             nsPresContext*         aPresContext,
+                             nsRenderingContext&    aRenderingContext,
+                             DrawTarget*            aTextRunConstructionDrawTarget,
+                             nsFontMetrics&         aFontMetrics,
+                             nscoord                aX,
+                             nscoord                aY,
+                             nsBidiPositionResolve* aPosResolve = nullptr,
+                             int32_t                aPosResolveCount = 0)
+  {
+    return ProcessTextForRenderingContext(aText, aLength, aBaseLevel, aPresContext, aRenderingContext,
+                                          aTextRunConstructionDrawTarget,
+                                          aFontMetrics,
+                                          MODE_DRAW, aX, aY, aPosResolve, aPosResolveCount, nullptr);
+  }
+  
+  static nscoord MeasureTextWidth(const char16_t*     aText,
+                                  int32_t              aLength,
+                                  nsBidiLevel          aBaseLevel,
+                                  nsPresContext*       aPresContext,
+                                  nsRenderingContext&  aRenderingContext,
+                                  nsFontMetrics&       aFontMetrics)
+  {
+    nscoord length;
+    nsresult rv = ProcessTextForRenderingContext(aText, aLength, aBaseLevel, aPresContext,
+                                                 aRenderingContext,
+                                                 aRenderingContext.GetDrawTarget(),
+                                                 aFontMetrics,
+                                                 MODE_MEASURE, 0, 0, nullptr, 0, &length);
+    return NS_SUCCEEDED(rv) ? length : 0;
+  }
+
+  /**
+   * Check if a line is reordered, i.e., if the child frames are not
+   * all laid out left-to-right.
+   * @param aFirstFrameOnLine : first frame of the line to be tested
+   * @param aNumFramesOnLine : number of frames on this line
+   * @param[out] aLeftMost : leftmost frame on this line
+   * @param[out] aRightMost : rightmost frame on this line
+   */
+  static bool CheckLineOrder(nsIFrame*  aFirstFrameOnLine,
+                               int32_t    aNumFramesOnLine,
+                               nsIFrame** aLeftmost,
+                               nsIFrame** aRightmost);
+
+  /**
+   * Get the frame to the right of the given frame, on the same line.
+   * @param aFrame : We're looking for the frame to the right of this frame.
+   *                 If null, return the leftmost frame on the line.
+   * @param aFirstFrameOnLine : first frame of the line to be tested
+   * @param aNumFramesOnLine : number of frames on this line
+   */
+  static nsIFrame* GetFrameToRightOf(const nsIFrame*  aFrame,
+                                     nsIFrame*        aFirstFrameOnLine,
+                                     int32_t          aNumFramesOnLine);
+    
+  /**
+   * Get the frame to the left of the given frame, on the same line.
+   * @param aFrame : We're looking for the frame to the left of this frame.
+   *                 If null, return the rightmost frame on the line.
+   * @param aFirstFrameOnLine : first frame of the line to be tested
+   * @param aNumFramesOnLine : number of frames on this line
+   */
+  static nsIFrame* GetFrameToLeftOf(const nsIFrame*  aFrame,
+                                    nsIFrame*        aFirstFrameOnLine,
+                                    int32_t          aNumFramesOnLine);
+
+  static nsIFrame* GetFirstLeaf(nsIFrame* aFrame);
+    
+  /**
+   * Get the bidi data of the given (inline) frame.
+   */
+  static mozilla::FrameBidiData GetFrameBidiData(nsIFrame* aFrame);
+
+  /**
+   * Get the bidi embedding level of the given (inline) frame.
+   */
+  static nsBidiLevel GetFrameEmbeddingLevel(nsIFrame* aFrame);
+
+  /**
+   * Get the bidi base level of the given (inline) frame.
+   */
+  static nsBidiLevel GetFrameBaseLevel(nsIFrame* aFrame);
+
+  /**
+   * Get an nsBidiDirection representing the direction implied by the
+   * bidi base level of the frame.
+   * @return NSBIDI_LTR (left-to-right) or NSBIDI_RTL (right-to-left)
+   *  NSBIDI_MIXED will never be returned.
+   */
+  static nsBidiDirection ParagraphDirection(nsIFrame* aFrame) {
+    return DIRECTION_FROM_LEVEL(GetFrameBaseLevel(aFrame));
+  }
+
+  /**
+   * Get an nsBidiDirection representing the direction implied by the
+   * bidi embedding level of the frame.
+   * @return NSBIDI_LTR (left-to-right) or NSBIDI_RTL (right-to-left)
+   *  NSBIDI_MIXED will never be returned.
+   */
+  static nsBidiDirection FrameDirection(nsIFrame* aFrame) {
+    return DIRECTION_FROM_LEVEL(GetFrameEmbeddingLevel(aFrame));
+  }
+
+  static bool IsFrameInParagraphDirection(nsIFrame* aFrame) {
+    return ParagraphDirection(aFrame) == FrameDirection(aFrame);
+  }
+
+  enum Mode { MODE_DRAW, MODE_MEASURE };
+
+  /**
+   * Reorder plain text using the Unicode Bidi algorithm and send it to
+   * a processor for rendering or measuring
+   *
+   * @param[in] aText  the string to be processed (in logical order)
+   * @param aLength the number of characters in the string
+   * @param aBaseLevel the base embedding level of the string
+   *  odd values are right-to-left; even values are left-to-right, plus special
+   *  constants as follows (defined in nsBidi.h)
+   *  NSBIDI_LTR - left-to-right string
+   *  NSBIDI_RTL - right-to-left string
+   *  NSBIDI_DEFAULT_LTR - auto direction determined by first strong character,
+   *                       default is left-to-right
+   *  NSBIDI_DEFAULT_RTL - auto direction determined by first strong character,
+   *                       default is right-to-left
+   *
+   * @param aPresContext the presentation context
+   * @param aprocessor the bidi processor
+   * @param aMode the operation to process
+   *  MODE_DRAW - invokes DrawText on the processor for each substring
+   *  MODE_MEASURE - does not invoke DrawText on the processor
+   *  Note that the string is always measured, regardless of mode
+   * @param[in,out] aPosResolve array of logical positions to resolve into
+   *  visual positions; can be nullptr if this functionality is not required
+   * @param aPosResolveCount number of items in the aPosResolve array
+   * @param[out] aWidth Pointer to where the width will be stored (may be null)
+   */
+  static nsresult ProcessText(const char16_t*       aText,
+                              int32_t                aLength,
+                              nsBidiLevel            aBaseLevel,
+                              nsPresContext*         aPresContext,
+                              BidiProcessor&         aprocessor,
+                              Mode                   aMode,
+                              nsBidiPositionResolve* aPosResolve,
+                              int32_t                aPosResolveCount,
+                              nscoord*               aWidth,
+                              nsBidi*                aBidiEngine);
+
+  /**
+   * Use style attributes to determine the base paragraph level to pass to the
+   * bidi algorithm.
+   *
+   * If |unicode-bidi| is set to "[-moz-]plaintext", returns NSBIDI_DEFAULT_LTR,
+   * in other words the direction is determined from the first strong character
+   * in the text according to rules P2 and P3 of the bidi algorithm, or LTR if
+   * there is no strong character.
+   *
+   * Otherwise returns NSBIDI_LTR or NSBIDI_RTL depending on the value of
+   * |direction|
+   */
+  static nsBidiLevel BidiLevelFromStyle(nsStyleContext* aStyleContext);
+
+private:
+  static nsresult
+  ProcessTextForRenderingContext(const char16_t*       aText,
+                                 int32_t                aLength,
+                                 nsBidiLevel            aBaseLevel,
+                                 nsPresContext*         aPresContext,
+                                 nsRenderingContext&    aRenderingContext,
+                                 DrawTarget*            aTextRunConstructionDrawTarget,
+                                 nsFontMetrics&         aFontMetrics,
+                                 Mode                   aMode,
+                                 nscoord                aX, // DRAW only
+                                 nscoord                aY, // DRAW only
+                                 nsBidiPositionResolve* aPosResolve,  /* may be null */
+                                 int32_t                aPosResolveCount,
+                                 nscoord*               aWidth /* may be null */);
+
+  /**
+   * Traverse the child frames of the block element and:
+   *  Set up an array of the frames in logical order
+   *  Create a string containing the text content of all the frames
+   *  If we encounter content that requires us to split the element into more
+   *  than one paragraph for bidi resolution, resolve the paragraph up to that
+   *  point.
+   */
+  static void TraverseFrames(nsBlockInFlowLineIterator* aLineIter,
+                             nsIFrame*                  aCurrentFrame,
+                             BidiParagraphData*         aBpd);
+
+  /**
+   * Position ruby content frames (ruby base/text frame).
+   * Called from RepositionRubyFrame.
+   */
+  static void RepositionRubyContentFrame(
+    nsIFrame* aFrame, mozilla::WritingMode aFrameWM,
+    const mozilla::LogicalMargin& aBorderPadding);
+
+  /*
+   * Position ruby frames. Called from RepositionFrame.
+   */
+  static nscoord RepositionRubyFrame(
+    nsIFrame* aFrame,
+    const nsContinuationStates* aContinuationStates,
+    const mozilla::WritingMode aContainerWM,
+    const mozilla::LogicalMargin& aBorderPadding);
+
+  /*
+   * Position aFrame and its descendants to their visual places. Also if aFrame
+   * is not leaf, resize it to embrace its children.
+   *
+   * @param aFrame               The frame which itself and its children are
+   *                             going to be repositioned
+   * @param aIsEvenLevel         TRUE means the embedding level of this frame
+   *                             is even (LTR)
+   * @param aStartOrEnd          The distance to the start or the end of aFrame
+   *                             without considering its inline margin. If the
+   *                             container is reordering frames in reverse
+   *                             direction, it's the distance to the end,
+   *                             otherwise, it's the distance to the start.
+   * @param aContinuationStates  A map from nsIFrame* to nsFrameContinuationState
+   * @return                     The isize aFrame takes, including margins.
+   */
+  static nscoord RepositionFrame(nsIFrame* aFrame,
+                                 bool aIsEvenLevel,
+                                 nscoord aStartOrEnd,
+                                 const nsContinuationStates* aContinuationStates,
+                                 mozilla::WritingMode aContainerWM,
+                                 bool aContainerReverseOrder,
+                                 const nsSize& aContainerSize);
+
+  /*
+   * Initialize the continuation state(nsFrameContinuationState) to
+   * (nullptr, 0) for aFrame and its descendants.
+   *
+   * @param aFrame               The frame which itself and its descendants will
+   *                             be initialized
+   * @param aContinuationStates  A map from nsIFrame* to nsFrameContinuationState
+   */
+  static void InitContinuationStates(nsIFrame*              aFrame,
+                                     nsContinuationStates*  aContinuationStates);
+
+  /*
+   * Determine if aFrame is first or last, and set aIsFirst and
+   * aIsLast values. Also set continuation states of
+   * aContinuationStates.
+   *
+   * A frame is first if it's the first appearance of its continuation
+   * chain on the line and the chain is on its first line.
+   * A frame is last if it's the last appearance of its continuation
+   * chain on the line and the chain is on its last line.
+   *
+   * N.B: "First appearance" and "Last appearance" in the previous
+   * paragraph refer to the frame's inline direction, not necessarily
+   * the line's.
+   *
+   * @param aContinuationStates        A map from nsIFrame* to
+   *                                    nsFrameContinuationState
+   * @param[in] aSpanDirMatchesLineDir TRUE means that the inline
+   *                                    direction of aFrame is the same
+   *                                    as its container
+   * @param[out] aIsFirst              TRUE means aFrame is first frame
+   *                                    or continuation
+   * @param[out] aIsLast               TRUE means aFrame is last frame
+   *                                    or continuation
+   */
+   static void IsFirstOrLast(nsIFrame* aFrame,
+                             const nsContinuationStates* aContinuationStates,
+                             bool aSpanInLineOrder /* in */,
+                             bool& aIsFirst /* out */,
+                             bool& aIsLast /* out */);
+
+  /**
+   *  Adjust frame positions following their visual order
+   *
+   *  @param aFirstChild the first kid
+   *  @return total inline size
+   *
+   *  @lina 04/11/2000
+   */
+  static nscoord RepositionInlineFrames(BidiLineData* aBld,
+                                        mozilla::WritingMode aLineWM,
+                                        const nsSize& aContainerSize,
+                                        nscoord aStart);
+  
+  /**
+   * Helper method for Resolve()
+   * Truncate a text frame to the end of a single-directional run and possibly
+   * create a continuation frame for the remainder of its content.
+   *
+   * @param aFrame       the original frame
+   * @param aNewFrame    [OUT] the new frame that was created
+   * @param aStart       [IN] the start of the content mapped by aFrame (and 
+   *                          any fluid continuations)
+   * @param aEnd         [IN] the offset of the end of the single-directional
+   *                          text run.
+   * @see Resolve()
+   * @see RemoveBidiContinuation()
+   */
+  static inline
+  nsresult EnsureBidiContinuation(nsIFrame*       aFrame,
+                                  nsIFrame**      aNewFrame,
+                                  int32_t         aStart,
+                                  int32_t         aEnd);
+
+  /**
+   * Helper method for Resolve()
+   * Convert one or more bidi continuation frames created in a previous reflow by
+   * EnsureBidiContinuation() into fluid continuations.
+   * @param aFrame       the frame whose continuations are to be removed
+   * @param aFirstIndex  index of aFrame in mLogicalFrames
+   * @param aLastIndex   index of the last frame to be removed
+   *
+   * @see Resolve()
+   * @see EnsureBidiContinuation()
+   */
+  static void RemoveBidiContinuation(BidiParagraphData* aBpd,
+                                     nsIFrame*          aFrame,
+                                     int32_t            aFirstIndex,
+                                     int32_t            aLastIndex);
+  static void CalculateCharType(nsBidi*          aBidiEngine,
+                                const char16_t* aText,
+                                int32_t&         aOffset,
+                                int32_t          aCharTypeLimit,
+                                int32_t&         aRunLimit,
+                                int32_t&         aRunLength,
+                                int32_t&         aRunCount,
+                                uint8_t&         aCharType,
+                                uint8_t&         aPrevCharType);
+  
+  static void StripBidiControlCharacters(char16_t* aText,
+                                         int32_t&   aTextLength);
+};
+
+#endif /* nsBidiPresUtils_h___ */