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/stl_util.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);
 };
 
+struct LineSegment {
+  ui::Range x_pos; // x coord, in text coordinates.
+  ui::Range char_pos;
+};
+
+struct Line {
+  Line() : width(0),

[msw, 2013/07/17 06:47:18]

nit: make this all one line or indent intitializers to match |width|.

[ckocagil, 2013/07/19 19:40:50]

Done.

+    height(0),
+    preceding_heights(0),
+    baseline(0) {
+  }
+  Line(Line& other) {
+    *this = other;
+  }
+  Line& operator=(Line& other) {
+    width = other.width;
+    height = other.height;
+    preceding_heights = other.preceding_heights;
+    baseline = other.baseline;
+    segments.swap(other.segments);

[msw, 2013/07/17 06:47:18]

Swap makes this destructive to the right hand side of an assignment. Can you
avoid that, or is this okay because it's only used for STL containers? (if so
note that in a comment).

[ckocagil, 2013/07/19 19:40:50]

Yes, these are for STL containers only. I'm adding a comment for now. One way to
avoid this is to keep "ScopedVector<Line>" instead of "std::vector<Line>" which
would allow us to disallow copying and assigning. Let me know if you think the
latter solution would be better.

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

Use ScopedVector and avoid copy/assign if possible and not too complex.

+    return *this;
+  }
+  ScopedVector<LineSegment> segments;
+  int width;
+  int height; // Maximum text height of all runs on this line.

[msw, 2013/07/17 06:47:18]

See Yuki's ongoing work to find common heights and baselines in:
https://codereview.chromium.org/19352002/
We'll want to use that logic to find per-line values.

+  int preceding_heights; // Sum of |height| fields of preceding lines.
+  int baseline; // Maximum baseline of all runs on this line.
+};
+
 }  // 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);
 
+  bool multiline() const { return multiline_; }
+  void set_multiline(bool multiline) { multiline_ = 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 40 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<size_t>& line_breaks() const { return line_breaks_; }
+
+  const std::vector<internal::Line>& lines() const { return lines_; }
+  void set_lines(std::vector<internal::Line>* lines) { lines_.swap(*lines); }
+
+  bool lines_valid() const { return lines_valid_; }
+  void set_lines_valid(bool lines_valid) { lines_valid_ = lines_valid; }
+
   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;
 
   // 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(int line);

[msw, 2013/07/17 06:47:18]

Rename to |line_number| to clarify the arg; and use size_t.

[ckocagil, 2013/07/19 19:40:50]

Done.

 
   // Convert points from the text space to the view space and back.
   // Handles the display area, display offset, and the application LTR/RTL mode.

[msw, 2013/07/17 06:47:18]

Update the comment, to reflect the new multi-line handling. Consider:
"Handles display area, display offset, LTR/RTL, and multi-line."

[ckocagil, 2013/07/19 19:40:50]

Done.

   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> RangeToViewRects(const ui::Range& x);

[msw, 2013/07/17 06:47:18]

I'm trying to think of a better name, maybe: TextBoundsToViewBounds?

[ckocagil, 2013/07/19 19:40:50]

Changed to TextBoundsToViewBounds.

+
+  // Returns the line offset from the origin, taking into account text alignment
   // only.
-  Vector2d GetAlignmentOffset();
+  Vector2d GetAlignmentOffset(int line);

[msw, 2013/07/17 06:47:18]

Ditto: Rename to |line_number| to clarify the arg; and use size_t.

[ckocagil, 2013/07/19 19:40:50]

Done.

 
   // 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_;
 
+  // Positions at which we can break the line.
+  std::vector<size_t> line_breaks_;
+
+  // Lines computed by EnsureLayout. Valid when |lines_valid_| is true.
+  std::vector<internal::Line> lines_;
+
+  // Whether the current |lines_| is valid. |lines_| is invalidated whenever

[msw, 2013/07/17 06:47:18]

Since we reconstruct |lines_| on ComputeLines, can we just use an empty vector
via lines_.clear() to mark |lines_| invalid?

[ckocagil, 2013/07/19 19:40:50]

Done.

+  // the text, styles or |display_rect_| changes.
+  bool lines_valid_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_