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>
 #include <utility>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/i18n/rtl.h"
+#include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/range/range.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
@@ skipping 78 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 {
+  // X coordinates of this line segment in text coordinate space.
+  ui::Range x_pos;
+
+  // The character range this segment corresponds to.
+  ui::Range char_pos;
+};
+
+// Holds a list of line segments and metrics for a line.
+struct Line {
+  Line();
+
+  // Destructive. Empties the |segments| field of the given Line.

[msw, 2013/08/15 02:44:17]

As per my comment on the old patch set, I hope we can use ScopedVector instead
of an std::vector of Line structs and then dissalow copy and assign here.

[Alexei Svitkine (slow), 2013/08/15 14:51:05]

Hmm, I'm not sure I like your proposed approach - then every line would have to
be be alloc'd from the heap, which will add even more overhead and memory
trashing.

[msw, 2013/08/15 15:42:09]

Do you have qualms with the ScopedVector<LineSegment> already used here? There's
always fewer lines than LineSegments, so I don't quite buy the argument. I'd
like DISALLOW_COPY_AND_ASSIGN to remove the destructive copy ctor and assignment
op, since I'm always reluctant to do premature performance optimization that
adds code or complexity, unless it's super obvious. I don't offhand suspect that
heap allocations have much perf impact compared to Layout overall, but since we
Layout for each Canvas::*Text call, I'd hear out your argument if you had data
showing a significant perf win of std::vector over ScopedVector in common cases.

[Alexei Svitkine (slow), 2013/08/15 17:27:42]

Yes, I do. I suggested merging LineSegmentWin to LineSegment, so that it's a
common struct and can be used in a regular std::vector. I proposed storing
run_index instead of a run pointer. But Cem pointed outed that this may not be
enough for other platforms than RenderTextWin, which is true since a run_index
is not useful to RenderTextLinux which uses Pango's linked list of runs. Which
is why I suggested that perhaps we should have a typedef for NativeTextRun, so
that LineSegment can have a member of that type and not need platform-specific
subclasses, so that we can use a std::vector for LineSegments.

[msw, 2013/08/15 17:59:14]

Okay, after more thought and talking with Alexei, I agree that std::vector
likely has measurably better performance for both Line and LineSegment lists.
Cem, ignore my ScopedVector suggestion and instead use a run index instead of a
specialized LineSegmentWin with a internal::TextRun* member so the LineSegment
ScopedVector can become an std::vector and we can trash the destructive copy
ctor and assignment operator for the Line struct. Run indicies should be okay
for now since RenderTextLinux will likely able to use built-in Pango
functionality to support multi-line layout instead of porting our RenderTextWin
multi-line solution. But if a cross-platform base class/struct for TextRun makes
more sense, then a std::vector<TextRun*> works for me too. Let me/us know if any
of that direction is unclear; thanks!

[ckocagil, 2013/08/20 21:25:07]

Done; using std::vector and a run index now.

+  Line(Line& other);
+
+  // Destructive. Empties the |segments| field of the Line on the rhs.
+  Line& operator=(Line& other);
+
+  // Segments that make up this line in visual order.
+  ScopedVector<LineSegment> segments;
+
+  // Sum of the widths of all segments on this line.
+  int width;

[msw, 2013/08/15 02:44:17]

optional nit: combine |width| and |height| as a gfx::Size.

[ckocagil, 2013/08/20 21:25:07]

Done.

+
+  // Maximum text height of all segments on this line.
+  int height;
+
+  // 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 48 matching lines @@
   bool focused() const { return focused_; }
   void set_focused(bool focused) { focused_ = focused; }
 
   bool clip_to_display_rect() const { return clip_to_display_rect_; }
   void set_clip_to_display_rect(bool clip) { clip_to_display_rect_ = clip; }
 
   // In an obscured (password) field, all text is drawn as asterisks or bullets.
   bool obscured() const { return obscured_; }
   void SetObscured(bool obscured);
 
+  // TODO(ckocagil): Multiline text rendering is currently only supported on
+  // Windows. Support other platforms.
+  bool multiline() const { return multiline_; }

[msw, 2013/08/15 02:44:17]

Order these after SetObscuredRevealIndex, ditto for the .cc def.

[ckocagil, 2013/08/20 21:25:07]

Done.

+  void SetMultiline(bool multiline);
+
   // 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);
 
   // 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.
@@ skipping 88 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); }

[msw, 2013/08/15 02:44:17]

Hmm, I'm not sure if vector ops are allowed for inlining.

[ckocagil, 2013/08/20 21:25:07]

This is okay as we talked on IM.

+
   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.
+  // Handles the display area, display offset, application LTR/RTL mode and

[msw, 2013/08/15 02:44:17]

nit: wrap this sentence above for a two-line comment.

[ckocagil, 2013/08/20 21:25:07]

Done.

+  // 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,
@@ skipping 96 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. Should be emptied whenever the text, styles
+  // or |display_rect_| changes.
+  std::vector<internal::Line> lines_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_