Windows implementation of multiline RenderText

ui/gfx/render_text.cc

 // 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.
 
 #include "ui/gfx/render_text.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 288 matching lines @@
     style_[i] = styles_[i].GetBreak(position);
 }
 
 }  // namespace internal
 
 RenderText::~RenderText() {
 }
 
 void RenderText::SetText(const base::string16& text) {
   DCHECK(!composition_range_.IsValid());
+  if (text_ == text)
+    return;
   text_ = text;
 
+  // TODO: we might be displaying obscured_text... also move somewhere better.

[Alexei Svitkine (slow), 2013/07/09 15:35:13]

I think this should be done at the end of UpdateLayoutText() with
GetLayoutText() as input.

[ckocagil, 2013/07/13 16:05:10]

Done.

+  line_breaks_.clear();
+  base::i18n::BreakIterator iter(text_, base::i18n::BreakIterator::BREAK_LINE);
+  bool success = iter.Init();
+  CHECK(success);
+  do {
+    line_breaks_.push_back(iter.pos());
+  } while (iter.Advance());
+
   // Adjust ranged styles and colors to accommodate a new text length.
   const size_t text_length = text_.length();
   colors_.SetMax(text_length);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetMax(text_length);
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
@@ skipping 69 matching lines @@
 
   obscured_reveal_index_ = index;
   cached_bounds_and_offset_valid_ = false;
   UpdateObscuredText();
   ResetLayout();
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
   cached_bounds_and_offset_valid_ = false;
+  lines_valid_ = false;
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursor(BreakType break_type,
                             VisualCursorDirection direction,
                             bool select) {
   SelectionModel position(cursor_position(), selection_model_.caret_affinity());
@@ skipping 286 matching lines @@
     if (insert_mode) {
       x = (caret_affinity == CURSOR_BACKWARD) ? xspan.end() : xspan.start();
     } else {  // overtype mode
       x = xspan.GetMin();
       width = xspan.length();
     }
   }
   return Rect(ToViewPoint(Point(x, 0)), Size(width, size.height()));
 }
 
+std::vector<Rect> RenderText::RangeToViewRects(const ui::Range& x, int y) {
+  std::vector<Rect> rects;
+
+  int height = GetStringSize().height();

[msw, 2013/07/10 04:01:56]

This is fine for the single line case, but each line in multi-line should have
its height computed as the max of the LineSegments' heights.

[ckocagil, 2013/07/13 16:05:10]

Done.

+
+  if (!multiline()) {
+    Point start(x.GetMin(), y);
+    rects.push_back(Rect(ToViewPoint(start), Size(x.length(), height)));
+    return rects;
+  }
+
+  EnsureLayout();
+  ComputeLines();

[msw, 2013/07/10 04:01:56]

EnsureLayout should ComputeLines as needed, don't invoke it explicitly here.

[ckocagil, 2013/07/13 16:05:10]

Done.

+
+  for (size_t line = 0; line < lines().size(); ++line) {

[msw, 2013/07/10 04:01:56]

Add a comment to explain what's happening here, it seems odd.

[ckocagil, 2013/07/13 16:05:10]

Done.

+    int line_x = 0;
+    for (size_t i = 0; i < lines()[line].size(); ++i) {
+      const internal::LineSegment* segment = lines()[line][i];
+      ui::Range intersection = segment->x_pos.Intersect(x);
+      if (!intersection.is_empty()) {
+        Rect rect(line_x + intersection.start() - segment->x_pos.start(),
+                  y + line * height, intersection.length(), height);

[msw, 2013/07/10 04:01:56]

You need to use the proper per-line heights; at least add a TODO.

[ckocagil, 2013/07/13 16:05:10]

Done, it uses per-line heights now.

+        rect += GetTextOffset(LineWidth(line));

[msw, 2013/07/10 04:01:56]

Cache the line's offset in the outer loop.

[ckocagil, 2013/07/13 16:05:10]

Done.

+        rects.push_back(rect);
+      }
+      line_x += segment->x_pos.length();
+    }
+  }
+
+  return rects;
+}
+
 const Rect& RenderText::GetUpdatedCursorBounds() {
   UpdateCachedBoundsAndOffset();
   return cursor_bounds_;
 }
 
 size_t RenderText::IndexOfAdjacentGrapheme(size_t index,
     LogicalCursorDirection direction) {
   if (index > text().length())
     return text().length();
 
@@ skipping 40 matching lines @@
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       selection_background_unfocused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(ui::Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
+      multiline_(false),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
-      cached_bounds_and_offset_valid_(false) {
+      cached_bounds_and_offset_valid_(false),
+      lines_valid_(false) {
 }
 
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
@@ skipping 44 matching lines @@
 }
 
 void RenderText::UndoCompositionAndSelectionStyles() {
   // Restore the underline and color breaks to undo the temporary styles.
   DCHECK(composition_and_selection_styles_applied_);
   colors_ = saved_colors_;
   styles_[UNDERLINE] = saved_underlines_;
   composition_and_selection_styles_applied_ = false;
 }
 
-Vector2d RenderText::GetTextOffset() {
+Vector2d RenderText::GetTextOffset(int line_width) {
   Vector2d offset = display_rect().OffsetFromOrigin();
-  offset.Add(GetUpdatedDisplayOffset());
-  offset.Add(GetAlignmentOffset());
+  if (!multiline())

[msw, 2013/07/10 04:01:56]

Why ignore the display offset for multi-line? Eventually we'll need to be able
to scroll multi-line text too.

[ckocagil, 2013/07/13 16:05:10]

I ignored it for now because multi-line vertical scrolling requires further work
in UpdateCachedBoundsAndOffset. Added a TODO there.

+    offset.Add(GetUpdatedDisplayOffset());
+  offset.Add(GetAlignmentOffset(line_width));
   return offset;
 }
 
 Point RenderText::ToTextPoint(const Point& point) {
-  return point - GetTextOffset();
+  return point - GetTextOffset(GetContentWidth());
+  // TODO: implement multiline

[Alexei Svitkine (slow), 2013/07/09 15:35:13]

TODO(ckocagil)

[ckocagil, 2013/07/13 16:05:10]

Done.

 }
 
 Point RenderText::ToViewPoint(const Point& point) {
-  return point + GetTextOffset();
+  if (!multiline())
+    return point + GetTextOffset(GetContentWidth());
+
+  ComputeLines();

[msw, 2013/07/10 04:01:56]

Don't explicitly call this here, EnsureLayout or [D]CHECK(lines_valid_).

[ckocagil, 2013/07/13 16:05:10]

Done.

+  int x = point.x();
+  unsigned int line = 0;
+  while (line < lines_.size() && x > LineWidth(line)) {
+    x -= LineWidth(line);

[Alexei Svitkine (slow), 2013/07/09 15:35:13]

Can you refactor this code to not call LineWidth() twice per line?

[ckocagil, 2013/07/13 16:05:10]

I will rewrite this method to support RTL soon (before we land this).

+    ++line;
+  }
+  return Point(x, point.y() + line * GetStringSize().height()) +

[msw, 2013/07/10 04:01:56]

Again, this needs per-line heights.

[ckocagil, 2013/07/13 16:05:10]

Done.

+      GetTextOffset(LineWidth(line));
 }
 
-Vector2d RenderText::GetAlignmentOffset() {
+Vector2d RenderText::GetAlignmentOffset(int line_width) {
+

[msw, 2013/07/10 04:01:56]

nit: remove blank line.

[ckocagil, 2013/07/13 16:05:10]

Done.

   Vector2d offset;
   if (horizontal_alignment_ != ALIGN_LEFT) {
-    offset.set_x(display_rect().width() - GetContentWidth());
+    offset.set_x(display_rect().width() - (multiline() ? line_width

[msw, 2013/07/10 04:01:56]

Always use |line_width|, you pass in GetContentWidth() correctly.

[ckocagil, 2013/07/13 16:05:10]

I now pass 0 for single-line mode. Single-line mode will generate a Line struct
in the future and we won't need this conditional expression.

+                                                       : GetContentWidth()));
     if (horizontal_alignment_ == ALIGN_CENTER)
       offset.set_x(offset.x() / 2);
   }
   if (vertical_alignment_ != ALIGN_TOP) {
-    offset.set_y(display_rect().height() - GetStringSize().height());
+    offset.set_y(display_rect().height() - GetMultilineTextSize().height());
     if (vertical_alignment_ == ALIGN_VCENTER)
       offset.set_y(offset.y() / 2);
   }
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   if (!fade_head() && !fade_tail())
     return;
 
@@ skipping 25 matching lines @@
     left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
     solid_part.Inset(gradient_width, 0, 0, 0);
   }
   if (fade_right) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
-  text_rect.Inset(GetAlignmentOffset().x(), 0, 0, 0);
+  text_rect.Inset(GetAlignmentOffset(GetContentWidth()).x(), 0, 0, 0);
 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
   skia::RefPtr<SkShader> shader = CreateFadeShader(
       text_rect, left_part, right_part, colors_.breaks().front().second);
   if (shader)
     renderer->SetShader(shader.get(), display_rect());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(text_shadows_);
@@ skipping 92 matching lines @@
 void RenderText::DrawSelection(Canvas* canvas) {
   const SkColor color = focused() ?
       selection_background_focused_color_ :
       selection_background_unfocused_color_;
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, color);
 }
 
 }  // namespace gfx