Windows implementation of multiline RenderText

ui/gfx/render_text.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_GFX_RENDER_TEXT_H_
 #define UI_GFX_RENDER_TEXT_H_
 
 #include <algorithm>
 #include <cstring>
 #include <string>
@@ skipping 93 matching lines @@
  private:
   BreakList<SkColor> colors_;
   std::vector<BreakList<bool> > styles_;
 
   BreakList<SkColor>::const_iterator color_;
   std::vector<BreakList<bool>::const_iterator> style_;
 
   DISALLOW_COPY_AND_ASSIGN(StyleIterator);
 };
 
+// Line segments are slices of the layout text to be rendered on a single line.
+// This structure holds the logical and visual position information for a line
+// segment.
+struct LineSegment {
+  LineSegment();
+
+  // X coordinates of this line segment in text coordinate space.
+  ui::Range x_range;
+
+  // The character range this segment corresponds to.
+  ui::Range char_range;
+
+  // Index of the text run that generated this segment.
+  size_t run;
+};
+
+// Holds a list of line segments and metrics for a line.
+struct Line {
+  Line();
+
+  // Segments that make up this line in visual order.
+  std::vector<LineSegment> segments;
+
+  // Total size of this line. Width is the sum of |segment| widths, height is
+  // the maximum height among |segments|.
+  Size size;
+
+  // Sum of the |height| fields of preceding lines.
+  int preceding_heights;
+
+  // Maximum baseline of all runs on this line.
+  int baseline;
+};
+
 }  // namespace internal
 
 // RenderText represents an abstract model of styled text and its corresponding
 // visual layout. Support is built in for a cursor, a selection, simple styling,
 // complex scripts, and bi-directional text. Implementations provide mechanisms
 // for rendering and translation between logical and visual data.
 class UI_EXPORT RenderText {
  public:
   virtual ~RenderText();
 
@@ skipping 55 matching lines @@
   bool obscured() const { return obscured_; }
   void SetObscured(bool obscured);
 
   // Makes a char in obscured text at |index| to be revealed. |index| should be
   // a UTF16 text index. If there is a previous revealed index, the previous one
   // is cleared and only the last set index will be revealed. If |index| is -1
   // or out of range, no char will be revealed. The revealed index is also
   // cleared when SetText or SetObscured is called.
   void SetObscuredRevealIndex(int index);
 
+  // TODO(ckocagil): Multiline text rendering is currently only supported on
+  // Windows. Support other platforms.
+  bool multiline() const { return multiline_; }
+  void SetMultiline(bool multiline);
+
   // Set the maximum length of the displayed layout text, not the actual text.
   // A |length| of 0 forgoes a hard limit, but does not guarantee proper
   // functionality of very long strings. Applies to subsequent SetText calls.
   // WARNING: Only use this for system limits, it lacks complex text support.
   void set_truncate_length(size_t length) { truncate_length_ = length; }
 
   const Rect& display_rect() const { return display_rect_; }
   void SetDisplayRect(const Rect& r);
 
   void set_fade_head(bool fade_head) { fade_head_ = fade_head; }
@@ skipping 81 matching lines @@
   // of the text, considering only the dominant direction returned by
   // |GetTextDirection()|, not the direction of a particular run.
   VisualCursorDirection GetVisualDirectionOfLogicalEnd();
 
   // Returns the size in pixels of the entire string. For the height, this will
   // return the maximum height among the different fonts in the text runs.
   // Note that this returns the raw size of the string, which does not include
   // the margin area of text shadows.
   virtual Size GetStringSize() = 0;
 
+  // Returns the size required to display the current multiline text, which is
+  // horizontally capped by the width of |display_rect()|.
+  // TODO(ckocagil): Merge with GetContentWidth.
+  virtual Size GetMultilineTextSize() = 0;
+
   // Returns the width of content, which reserves room for the cursor if
   // |cursor_enabled_| is true.
   int GetContentWidth();
 
   // Returns the common baseline of the text. The returned value is the vertical
   // offset from the top of |display_rect| to the text baseline, in pixels.
   virtual int GetBaseline() = 0;
 
   void Draw(Canvas* canvas);
 
@@ skipping 41 matching lines @@
   // specifies the character range for which the corresponding font has been
   // chosen.
   virtual std::vector<FontSpan> GetFontSpansForTesting() = 0;
 
  protected:
   RenderText();
 
   const BreakList<SkColor>& colors() const { return colors_; }
   const std::vector<BreakList<bool> >& styles() const { return styles_; }
 
+  const std::vector<internal::Line>& lines() const { return lines_; }
+  void set_lines(std::vector<internal::Line>* lines) { lines_.swap(*lines); }
+
   const Vector2d& GetUpdatedDisplayOffset();
 
   void set_cached_bounds_and_offset_valid(bool valid) {
     cached_bounds_and_offset_valid_ = valid;
   }
 
   // Get the selection model that visually neighbors |position| by |break_type|.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel GetAdjacentSelectionModel(const SelectionModel& current,
                                            BreakType break_type,
@@ skipping 38 matching lines @@
   virtual size_t TextIndexToLayoutIndex(size_t index) const = 0;
   virtual size_t LayoutIndexToTextIndex(size_t index) const = 0;
 
   // Return true if cursor can appear in front of the character at |position|,
   // which means it is a grapheme boundary or the first character in the text.
   virtual bool IsCursorablePosition(size_t position) = 0;
 
   // Reset the layout to be invalid.
   virtual void ResetLayout() = 0;
 
-  // Ensure the text is laid out.
+  // Ensure the text is laid out, lines are computed, and |lines_| is valid.
   virtual void EnsureLayout() = 0;
 
   // Draw the text.
   virtual void DrawVisualText(Canvas* canvas) = 0;
 
   // Returns the text used for layout, which may be obscured or truncated.
   const base::string16& GetLayoutText() const;
 
+  // Returns layout text positions that are suitable for breaking lines at.
+  const BreakList<size_t>& GetLineBreaks();
+
   // Apply (and undo) temporary composition underlines and selection colors.
   void ApplyCompositionAndSelectionStyles();
   void UndoCompositionAndSelectionStyles();
 
-  // Returns the text offset from the origin after applying text alignment and
+  // Returns the line offset from the origin after applying text alignment and
   // display offset.
-  Vector2d GetTextOffset();
+  Vector2d GetLineOffset(size_t line_number);
 
-  // Convert points from the text space to the view space and back.
-  // Handles the display area, display offset, and the application LTR/RTL mode.
+  // Convert points from the text space to the view space and back. Handles the
+  // display area, display offset, application LTR/RTL mode and multi-line.
   Point ToTextPoint(const Point& point);
   Point ToViewPoint(const Point& point);
 
-  // Returns the text offset from the origin, taking into account text alignment
+  // Convert the range in text coordinates to rects in view coordinates that
+  // cover the given range.
+  std::vector<Rect> TextBoundsToViewBounds(const ui::Range& x);
+
+  // Returns the line offset from the origin, taking into account text alignment
   // only.
-  Vector2d GetAlignmentOffset();
+  Vector2d GetAlignmentOffset(size_t line_number);
 
   // Applies fade effects to |renderer|.
   void ApplyFadeEffects(internal::SkiaTextRenderer* renderer);
 
   // Applies text shadows to |renderer|.
   void ApplyTextShadows(internal::SkiaTextRenderer* renderer);
 
   // A convenience function to check whether the glyph attached to the caret
   // is within the given range.
   static bool RangeContainsCaret(const ui::Range& range,
                                  size_t caret_pos,
                                  LogicalCursorDirection caret_affinity);
 
  private:
   friend class RenderTextTest;
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, DefaultStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, SetColorAndStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ApplyColorAndStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ObscuredText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, RevealObscuredText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, TruncatedText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, TruncatedObscuredText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, GraphemePositions);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, EdgeSelectionModels);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, GetTextOffset);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL);
+  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, Multiline_MinWidth);
+  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, Multiline_NormalWidth);
 
   // Set the cursor to |position|, with the caret trailing the previous
   // grapheme, or if there is no previous grapheme, leading the cursor position.
   // If |select| is false, the selection start is moved to the same position.
   // If the |position| is not a cursorable position (not on grapheme boundary),
   // it is a NO-OP.
   void MoveCursorTo(size_t position, bool select);
 
   // Updates |layout_text_| if the text is obscured or truncated.
   void UpdateLayoutText();
@@ skipping 70 matching lines @@
   bool obscured_;
   // The index at which the char should be revealed in the obscured text.
   int obscured_reveal_index_;
 
   // The maximum length of text to display, 0 forgoes a hard limit.
   size_t truncate_length_;
 
   // The obscured and/or truncated text that will be displayed.
   base::string16 layout_text_;
 
+  // Whether the text should be broken into multiple lines. Uses the width of
+  // |display_rect_| as the width cap.
+  bool multiline_;
+
   // Fade text head and/or tail, if text doesn't fit into |display_rect_|.
   bool fade_head_;
   bool fade_tail_;
 
   // Is the background transparent (either partially or fully)?
   bool background_is_transparent_;
 
   // The local display area for rendering the text.
   Rect display_rect_;
 
   // Flag to work around a Skia bug with the PDF path (http://crbug.com/133548)
   // that results in incorrect clipping when drawing to the document margins.
   // This field allows disabling clipping to work around the issue.
   // TODO(asvitkine): Remove this when the underlying Skia bug is fixed.
   bool clip_to_display_rect_;
 
   // The offset for the text to be drawn, relative to the display area.
   // Get this point with GetUpdatedDisplayOffset (or risk using a stale value).
   Vector2d display_offset_;
 
   // The cached bounds and offset are invalidated by changes to the cursor,
   // selection, font, and other operations that adjust the visible text bounds.
   bool cached_bounds_and_offset_valid_;
 
   // Text shadows to be drawn.
   ShadowValues text_shadows_;
 
+  // BreakList to find valid positions to break the line at.
+  BreakList<size_t> line_breaks_;
+
+  // Lines computed by EnsureLayout. These should be invalidated with
+  // ResetLayout and on |display_rect_| changes.
+  std::vector<internal::Line> lines_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_