Windows implementation of multiline RenderText

ui/gfx/render_text_win.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_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/rtl.h"
@@ skipping 129 matching lines @@
       return ui::Range(run.logical_clusters[range.end() - 1],
           range.start() > 0 ? run.logical_clusters[range.start() - 1]
                             : run.glyph_count);
     } else {
       return ui::Range(run.logical_clusters[range.start()],
           range.end() < run.range.length() ? run.logical_clusters[range.end()]
                                            : run.glyph_count);
     }
 }
 
+// Starting from |start_char|, finds the first character that doesn't fit the
+// given |width_cap|. If |width_cap| is reached, returns true and fills the
+// output arguments with overflow and rollback info. Otherwise returns false and
+// only fills |width|.
+// |overflow|: Index of the first character that doesn't fit the given width.
+// |width|: If the run doesn't fit, holds the width of [start_char, *overflow].
+//          Otherwise, holds the width of [start_char, run.range.end()).
+// |char_rollback_width|: Width of |*overflow|.
+// |word_rollback_pos|: Index of the last word break before |*overflow|.
+// |word_rollback_width|: Width of [*word_rollback_pos, *overflow].
+bool BreakRun(const internal::TextRun& run, const BreakList<size_t>& breaks,
+              size_t start_char, int width_cap, int* width, size_t* overflow,
+              int* char_rollback_width, size_t* word_rollback_pos,
+              int* word_rollback_width) {
+  DCHECK(run.range.Contains(ui::Range(start_char)));
+  size_t current_word = start_char;
+  int current_word_x = 0; // x from |current_word|
+  int x = 0;
+
+  for (size_t i = start_char; i < run.range.end(); ++i) {
+    const size_t offset = i - run.range.start();
+
+    size_t next_word = std::max(breaks.GetBreak(i)->first, start_char);
+    if (next_word != current_word) {
+      current_word = next_word;
+      current_word_x = 0;
+    }
+
+    ui::Range glyphs = CharRangeToGlyphRange(run,
+                                             ui::Range(offset, offset + 1));
+    int char_width = 0;
+    for (size_t j = glyphs.start(); j < glyphs.end(); ++j)
+      char_width += run.advance_widths[j];
+
+    x += char_width;
+    current_word_x += char_width;
+
+    if (x > width_cap) {
+      *overflow = i;
+      *width = x;
+      *char_rollback_width = char_width;
+      *word_rollback_pos = current_word;
+      *word_rollback_width = current_word_x;
+      return true;
+    }
+  }
+
+  *width = x;
+  return false;
+}
+
 }  // namespace
 
 namespace internal {
 
 TextRun::TextRun()
   : font_style(0),
     strike(false),
     diagonal_strike(false),
     underline(false),
     width(0),
@@ skipping 23 matching lines @@
       run->glyph_count,
       run->logical_clusters.get(),
       run->visible_attributes.get(),
       run->advance_widths.get(),
       &run->script_analysis,
       &x);
   DCHECK(SUCCEEDED(hr));
   return run->preceding_run_widths + x;
 }
 
+struct LineSegmentWin : LineSegment {
+  internal::TextRun* run;
+};
+
+// Internal class to help break a text into lines.
+class LineBreaker {
+ public:
+  LineBreaker() : preceding_line_heights_(0),
+                  pos_(0),
+                  text_x_(0),
+                  line_x_(0),
+                  current_pos_(0),
+                  current_delta_(0) {}
+
+  // Breaks the given |runs| into |lines|. Should be called at most once for
+  // each instance. If |multiline| is false, doesn't do any breaking and fills
+  // |lines| with a single Line.
+  void Break(const ScopedVector<internal::TextRun>& runs,
+             const BreakList<size_t>& words,
+             int max_width,
+             bool multiline,
+             int* visual_to_logical,
+             std::vector<internal::Line>* lines) {
+    SkipLine();
+
+    for (size_t i = 0; i < runs.size(); ++i) {
+      internal::TextRun* run = runs[visual_to_logical[i]];
+
+      pos_ = run->range.start();
+      current_pos_ = run->range.start();
+
+      int width = run->width;
+      size_t overflow;
+      int char_rollback_width;
+      size_t word_rollback_pos;
+      int word_rollback_width;
+      // Break the run until it fits the current line.
+      while (multiline &&

[Alexei Svitkine (slow), 2013/07/22 20:52:05]

It would be less confusing if the multline check was in an if statement
surrounding this code. Consider refactoring the while loop out into a separate
function.

[ckocagil, 2013/08/07 12:59:20]

Done (well, it's a ternary operation now). Done.

+             BreakRun(*run, words, pos_, max_width - line_x_,
+                      &width, &overflow, &char_rollback_width,
+                      &word_rollback_pos, &word_rollback_width)) {
+        DCHECK(pos_ < run->range.end());
+        Advance(overflow + 1, width);
+        // First, try rolling back one word to move it to the next line. If
+        // it's not possible, roll back one character. If neither of these
+        // could be done, don't do any rollback since each line must have at
+        // least one character.
+        if (line_x_ > 0 || word_rollback_width < width)
+          Rollback(word_rollback_pos, word_rollback_width);
+        else if (line_x_ > 0 || char_rollback_width < width)
+          Rollback(overflow, char_rollback_width);
+        CommitSegment(run);
+        SkipLine();
+      }
+
+      // Remaining part of the run fits the line, add it.
+      Advance(run->range.end(), width);
+      CommitSegment(run);
+    }
+
+    lines->swap(lines_);
+  }
+
+ private:
+  // RTL runs are broken in logical order but displayed in visual order. To find
+  // the text-space coordinate (where it would fall in a single-line text)
+  // |x_pos| of RTL segments, text-space coordinate of the run beginning is
+  // saved and the segment widths are applied in reverse order.
+  // e.g. {[5, 10], [10, 40]} will become {[35, 40], [5, 35]}.
+  struct RtlData {
+    int run_x_; // Beginning of the RTL run in text-space.
+    std::vector<LineSegment*> segments_;
+  };
+
+  // Applies |rtl_data_|.
+  void PopRtl() {
+    int x = rtl_data_.run_x_;
+    while (!rtl_data_.segments_.empty()) {
+      LineSegment* segment = rtl_data_.segments_.back();
+      rtl_data_.segments_.pop_back();
+      segment->x_pos = ui::Range(x, x + segment->x_pos.length());
+      x += segment->x_pos.length();
+    }
+  }
+
+  void Advance(size_t new_pos, int amount) {
+    current_pos_ = new_pos;
+    current_delta_ += amount;
+  }
+
+  void Rollback(size_t new_pos, int amount) {
+    Advance(new_pos, -amount);
+  }
+
+  void SkipLine() {
+    if (!lines_.empty())
+      preceding_line_heights_ += lines_.back().height;
+    line_x_ = 0;
+    lines_.push_back(internal::Line());
+  }
+
+  void CommitSegment(internal::TextRun* run) {
+    if (pos_ == current_pos_) {
+      DCHECK(current_delta_ == 0);
+      return;
+    }
+    internal::LineSegmentWin* segment = new internal::LineSegmentWin;
+    segment->run = run;
+    segment->char_pos = ui::Range(pos_, current_pos_);
+    segment->x_pos = ui::Range(text_x_, text_x_ + current_delta_);
+    lines_.back().segments.push_back(segment);
+    lines_.back().width += segment->x_pos.length();
+    lines_.back().height = std::max(lines_.back().height,
+                                    segment->run->font.GetHeight());
+    lines_.back().baseline = std::max(lines_.back().baseline,
+                                      segment->run->font.GetBaseline());
+    lines_.back().preceding_heights = preceding_line_heights_;
+    if (run->script_analysis.fRTL) {
+      if (pos_ == run->range.start())
+        rtl_data_.run_x_ = text_x_;
+      rtl_data_.segments_.push_back(segment);
+      if (current_pos_ == run->range.end())
+        PopRtl();
+    }
+    pos_ = current_pos_;
+    text_x_ += current_delta_;
+    line_x_ += current_delta_;
+    current_delta_ = 0;
+  }
+
+  std::vector<internal::Line> lines_;
+  int preceding_line_heights_;
+  size_t pos_;
+  int text_x_;
+  int line_x_;
+  size_t current_pos_;
+  int current_delta_;
+  RtlData rtl_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(LineBreaker);
+};
+
 }  // namespace internal
 
 // static
 HDC RenderTextWin::cached_hdc_ = NULL;
 
 // static
 std::map<std::string, Font> RenderTextWin::successful_substitute_fonts_;
 
 RenderTextWin::RenderTextWin()
     : RenderText(),
       common_baseline_(0),
       needs_layout_(false) {
   set_truncate_length(kMaxUniscribeTextLength);
 
   memset(&script_control_, 0, sizeof(script_control_));
   memset(&script_state_, 0, sizeof(script_state_));
 
   MoveCursorTo(EdgeSelectionModel(CURSOR_LEFT));
 }
 
 RenderTextWin::~RenderTextWin() {
 }
 
 Size RenderTextWin::GetStringSize() {
   EnsureLayout();
-  return string_size_;
+  return Size(string_size_.width(), string_size_.height());
+}
+
+Size RenderTextWin::GetMultilineTextSize() {
+  EnsureLayout();
+  if (!multiline())
+    return Size(display_rect().width(), string_size_.height());
+  return Size(display_rect().width(),
+              lines().back().preceding_heights + lines().back().height);
 }
 
 int RenderTextWin::GetBaseline() {
   EnsureLayout();
   return common_baseline_;
 }
 
 SelectionModel RenderTextWin::FindCursorPosition(const Point& point) {
   if (text().empty())
     return SelectionModel();
@@ skipping 140 matching lines @@
                    GetGlyphXBoundary(run, layout_index, true));
 }
 
 std::vector<Rect> RenderTextWin::GetSubstringBounds(const ui::Range& range) {
   DCHECK(!needs_layout_);
   DCHECK(ui::Range(0, text().length()).Contains(range));
   ui::Range layout_range(TextIndexToLayoutIndex(range.start()),
                          TextIndexToLayoutIndex(range.end()));
   DCHECK(ui::Range(0, GetLayoutText().length()).Contains(layout_range));
 
-  std::vector<Rect> bounds;
+  std::vector<ui::Range> bounds;
+  std::vector<Rect> rects;
   if (layout_range.is_empty())
-    return bounds;
+    return rects;
 
-  // Add a Rect for each run/selection intersection.
+  // Add a Range for each run/selection intersection.
   // TODO(msw): The bounds should probably not always be leading the range ends.
   for (size_t i = 0; i < runs_.size(); ++i) {
     const internal::TextRun* run = runs_[visual_to_logical_[i]];
     ui::Range intersection = run->range.Intersect(layout_range);
     if (intersection.IsValid()) {
       DCHECK(!intersection.is_reversed());
       ui::Range range_x(GetGlyphXBoundary(run, intersection.start(), false),
                         GetGlyphXBoundary(run, intersection.end(), false));
-      Rect rect(range_x.GetMin(), 0, range_x.length(), run->font.GetHeight());
-      rect.set_origin(ToViewPoint(rect.origin()));
-      // Union this with the last rect if they're adjacent.
-      if (!bounds.empty() && rect.SharesEdgeWith(bounds.back())) {
-        rect.Union(bounds.back());
+      if (range_x.is_empty())
+        continue;
+      range_x = ui::Range(range_x.GetMin(), range_x.GetMax());
+      // Union this with the last range if they're adjacent.
+      DCHECK(bounds.empty() || bounds.back().GetMin() != range_x.GetMax());
+      if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) {
+        range_x = ui::Range(bounds.back().GetMin(), range_x.GetMax());
         bounds.pop_back();
       }
-      bounds.push_back(rect);
+      bounds.push_back(range_x);
     }
   }
-  return bounds;
+  for (size_t i = 0; i < bounds.size(); ++i) {
+    std::vector<Rect> current_rects = TextBoundsToViewBounds(bounds[i]);
+    rects.insert(rects.end(), current_rects.begin(), current_rects.end());
+  }
+  return rects;
 }
 
 size_t RenderTextWin::TextIndexToLayoutIndex(size_t index) const {
   DCHECK_LE(index, text().length());
   ptrdiff_t i = obscured() ? ui::UTF16IndexToOffset(text(), 0, index) : index;
   CHECK_GE(i, 0);
   // Clamp layout indices to the length of the text actually used for layout.
   return std::min<size_t>(GetLayoutText().length(), i);
 }
 
@@ skipping 17 matching lines @@
   return ui::IsValidCodePointIndex(text(), position) &&
          GetGlyphBounds(position) != GetGlyphBounds(position - 1);
 }
 
 void RenderTextWin::ResetLayout() {
   // Layout is performed lazily as needed for drawing/metrics.
   needs_layout_ = true;
 }
 
 void RenderTextWin::EnsureLayout() {
-  if (!needs_layout_)
-    return;
-  // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
-  ItemizeLogicalText();
-  if (!runs_.empty())
-    LayoutVisualText();
-  needs_layout_ = false;
+  if (needs_layout_) {
+    // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
+    ItemizeLogicalText();
+    if (!runs_.empty())
+      LayoutVisualText();
+    needs_layout_ = false;
+    std::vector<internal::Line> lines;
+    set_lines(&lines);
+  }
+  // Compute lines if they're not valid. This is separate from the layout steps
+  // above to avoid text layout and shaping when we resize |display_rect_|.
+  if (lines().empty())
+    ComputeLines();
+}
+
+void RenderTextWin::ComputeLines() {
+  DCHECK(!needs_layout_);
+  std::vector<internal::Line> lines;
+  internal::LineBreaker line_breaker;
+  line_breaker.Break(runs_, line_breaks(), display_rect().width(), multiline(),
+                     visual_to_logical_.get(), &lines);
+  set_lines(&lines);
 }
 
 void RenderTextWin::DrawVisualText(Canvas* canvas) {
   DCHECK(!needs_layout_);
-
-  // Skia will draw glyphs with respect to the baseline.
-  Vector2d offset(GetTextOffset() + Vector2d(0, common_baseline_));
-
-  SkScalar x = SkIntToScalar(offset.x());
-  SkScalar y = SkIntToScalar(offset.y());
+  DCHECK(!multiline() || !lines().empty());
 
   std::vector<SkPoint> pos;
 
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   ApplyTextShadows(&renderer);
 
   bool smoothing_enabled;
   bool cleartype_enabled;
   GetCachedFontSmoothingSettings(&smoothing_enabled, &cleartype_enabled);
   // Note that |cleartype_enabled| corresponds to Skia's |enable_lcd_text|.
   renderer.SetFontSmoothingSettings(
       smoothing_enabled, cleartype_enabled && !background_is_transparent());
 
   ApplyCompositionAndSelectionStyles();
 
-  for (size_t i = 0; i < runs_.size(); ++i) {
-    // Get the run specified by the visual-to-logical map.
-    internal::TextRun* run = runs_[visual_to_logical_[i]];
+  SkScalar glyph_x = SkIntToScalar(0);
 
-    if (run->glyph_count == 0)
-      continue;
+  for (size_t line = 0; line < lines().size(); ++line) {
+    Vector2d offset(0, lines()[line].baseline);
+    offset += GetLineOffset(line);
+    for (size_t i = 0; i < lines()[line].segments.size(); ++i) {
+      const internal::LineSegmentWin* segment =
+          static_cast<internal::LineSegmentWin*>(lines()[line].segments[i]);
+      internal::TextRun* run = segment->run;
+      DCHECK(!segment->char_pos.is_empty());
+      DCHECK(run->range.Contains(segment->char_pos));
+      ui::Range glyphs = CharRangeToGlyphRange(*run,
+          ui::Range(segment->char_pos.start() - run->range.start(),
+                    segment->char_pos.end() - run->range.start()));
+      if (glyphs.is_empty()) {
+        DCHECK(segment->x_pos.is_empty());
+        continue;
+      }
+      pos.resize(glyphs.length());
+      for (size_t g = glyphs.start(); g < glyphs.end(); ++g) {
+        pos[g - glyphs.start()].set(glyph_x + offset.x() + run->offsets[g].du,
+                                    offset.y() + run->offsets[g].dv);
+        glyph_x += SkIntToScalar(run->advance_widths[g]);
+      }
+      renderer.SetTextSize(run->font.GetFontSize());
+      renderer.SetFontFamilyWithStyle(run->font.GetFontName(), run->font_style);
 
-    // Based on WebCore::skiaDrawText.
-    pos.resize(run->glyph_count);
-    SkScalar glyph_x = x;
-    for (int glyph = 0; glyph < run->glyph_count; glyph++) {
-      pos[glyph].set(glyph_x + run->offsets[glyph].du,
-                     y + run->offsets[glyph].dv);
-      glyph_x += SkIntToScalar(run->advance_widths[glyph]);
+      for (BreakList<SkColor>::const_iterator it =
+               colors().GetBreak(run->range.start());
+           it != colors().breaks().end() && it->first < run->range.end();
+           ++it) {
+        ui::Range intersection = colors().GetRange(it).Intersect(
+            segment->char_pos);
+        ui::Range colored_glyphs = CharRangeToGlyphRange(*run,
+            ui::Range(intersection.start() - run->range.start(),
+                      intersection.end() - run->range.start()));
+        DCHECK(glyphs.Contains(colored_glyphs));
+        renderer.SetForegroundColor(it->second);
+        renderer.DrawPosText(&pos[colored_glyphs.start() - glyphs.start()],
+                             &run->glyphs[colored_glyphs.start()],
+                             colored_glyphs.length());
+        SkScalar width = (colored_glyphs.end() < glyphs.end()
+                          ? pos[colored_glyphs.end() - glyphs.start()].x()
+                          : pos[0].x() + SkIntToScalar(segment->x_pos.length()))
+            - pos[colored_glyphs.start() - glyphs.start()].x();
+        renderer.DrawDecorations(
+            pos[colored_glyphs.start() - glyphs.start()].x(), offset.y(),
+            SkScalarCeilToInt(width), run->underline, run->strike,
+            run->diagonal_strike);
+      }
     }
 
-    renderer.SetTextSize(run->font.GetFontSize());
-    renderer.SetFontFamilyWithStyle(run->font.GetFontName(), run->font_style);
-
-    for (BreakList<SkColor>::const_iterator it =
-             colors().GetBreak(run->range.start());
-         it != colors().breaks().end() && it->first < run->range.end();
-         ++it) {
-      ui::Range intersection = colors().GetRange(it).Intersect(run->range);
-      ui::Range glyphs = CharRangeToGlyphRange(*run,
-          ui::Range(intersection.start() - run->range.start(),
-                    intersection.end() - run->range.start()));
-      renderer.SetForegroundColor(it->second);
-      renderer.DrawPosText(&pos[glyphs.start()], &run->glyphs[glyphs.start()],
-                           glyphs.length());
-      SkScalar width = (static_cast<int>(glyphs.end()) < run->glyph_count ?
-          pos[glyphs.end()].x() : pos[0].x() + SkIntToScalar(run->width))
-          - pos[glyphs.start()].x();
-      renderer.DrawDecorations(pos[glyphs.start()].x(), y,
-                               SkScalarCeilToInt(width), run->underline,
-                               run->strike, run->diagonal_strike);
-    }
-
-    x = glyph_x;
+    glyph_x = SkIntToScalar(0);
   }
 
   UndoCompositionAndSelectionStyles();
 }
 
 void RenderTextWin::ItemizeLogicalText() {
   runs_.clear();
   string_size_ = Size(0, GetFont().GetHeight());
   common_baseline_ = 0;
 
@@ skipping 336 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx