Draw text via Skia in RenderTextLinux.

ui/gfx/render_text_linux.cc

 // Copyright (c) 2011 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_linux.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
+#include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "ui/gfx/canvas_skia.h"
+#include "ui/gfx/font.h"
 #include "ui/gfx/pango_util.h"
 #include "unicode/uchar.h"
 #include "unicode/ustring.h"
 
 namespace {
 
 // TODO(xji): instead of converting each R or G or B from 8-bit to 16-bit,
 // it should also massage A in the conversion.
 int ConvertColorFrom8BitTo16Bit(int c) {
   return (c << 8) + c;
 }
 
+// Returns whether the given Pango item is Left to Right.
+bool IsRunLTR(const PangoItem* item) {
+  return (item->analysis.level & 1) == 0;
+}
+
+// Checks whether |range| contains |index|. This is not the same as calling
+// |range.Contains(ui::Range(index))| - as that would return true when
+// |index| == |range.end()|.
+bool IndexInRange(const ui::Range& range, size_t index) {
+  return index >= range.start() && index < range.end();
+}
+
 }  // namespace
 
 // TODO(xji): index saved in upper layer is utf16 index. Pango uses utf8 index.
 // Since caret_pos is used internally, we could save utf8 index for caret_pos
 // to avoid conversion.
 
 namespace gfx {
 
 RenderTextLinux::RenderTextLinux()
     : layout_(NULL),
@@ skipping 112 matching lines @@
   DCHECK(break_type == WORD_BREAK);
   return RightSelectionModelByWord(current);
 }
 
 SelectionModel RenderTextLinux::LeftEndSelectionModel() {
   if (GetTextDirection() == base::i18n::RIGHT_TO_LEFT) {
     if (current_line_->runs) {
       PangoLayoutRun* first_visual_run =
           reinterpret_cast<PangoLayoutRun*>(current_line_->runs->data);
       PangoItem* item = first_visual_run->item;
-      if (item->analysis.level % 2 == 0) {  // LTR.
+      if (IsRunLTR(item)) {

[xji, 2011/12/07 19:52:26]

thanks for making those changes.

         size_t caret = Utf8IndexToUtf16Index(item->offset);
         return SelectionModel(text().length(), caret, SelectionModel::LEADING);
       } else {  // RTL.
         size_t caret = Utf16IndexOfAdjacentGrapheme(item->offset + item->length,
                                                     false);
         return SelectionModel(text().length(), caret, SelectionModel::TRAILING);
       }
     }
   }
   return SelectionModel(0, 0, SelectionModel::LEADING);
 }
 
 SelectionModel RenderTextLinux::RightEndSelectionModel() {
   if (GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
     PangoLayoutRun* last_visual_run = GetLastRun();
     if (last_visual_run) {
       PangoItem* item = last_visual_run->item;
-      if (item->analysis.level % 2 == 0) {  // LTR.
+      if (IsRunLTR(item)) {
         size_t caret = Utf16IndexOfAdjacentGrapheme(item->offset + item->length,
                                                     false);
         return SelectionModel(text().length(), caret, SelectionModel::TRAILING);
       } else {  // RTL.
         size_t caret = Utf8IndexToUtf16Index(item->offset);
         return SelectionModel(text().length(), caret, SelectionModel::LEADING);
       }
     }
   }
   return SelectionModel(0, 0, SelectionModel::LEADING);
@@ skipping 67 matching lines @@
     pango_layout_line_ref(current_line_);
 
     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
 
     layout_text_ = pango_layout_get_text(layout_);
     layout_text_len_ = strlen(layout_text_);
   }
 }
 
 void RenderTextLinux::DrawVisualText(Canvas* canvas) {
-  Rect bounds(display_rect());
+  DCHECK(layout_);
 
-  // Clip the canvas to the text display area.
-  SkCanvas* canvas_skia = canvas->GetSkCanvas();
+  Point offset(GetOriginForSkiaDrawing());
+  SkScalar x = SkIntToScalar(offset.x());
+  SkScalar y = SkIntToScalar(offset.y());
 
-  skia::ScopedPlatformPaint scoped_platform_paint(canvas_skia);
-  cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
-  cairo_save(cr);
-  cairo_rectangle(cr, bounds.x(), bounds.y(), bounds.width(), bounds.height());
-  cairo_clip(cr);
+  std::vector<SkPoint> pos;
+  std::vector<uint16> glyphs;
 
-  int text_width, text_height;
-  pango_layout_get_pixel_size(layout_, &text_width, &text_height);
-  Point offset(ToViewPoint(Point()));
-  // Vertically centered.
-  int text_y = offset.y() + ((bounds.height() - text_height) / 2);
-  // TODO(xji): need to use SkCanvas->drawPosText() for gpu acceleration.
-  cairo_move_to(cr, offset.x(), text_y);
-  pango_cairo_show_layout(cr, layout_);
+  StyleRanges styles(style_ranges());
+  ApplyCompositionAndSelectionStyles(&styles);
 
-  cairo_restore(cr);
+  // Pre-calculate UTF8 indices from UTF16 indices.
+  // TODO(asvitkine): Can we cache these?
+  std::vector<ui::Range> style_ranges_utf8;
+  style_ranges_utf8.reserve(styles.size());
+  size_t start_index = 0;
+  for (size_t i = 0; i < styles.size(); ++i) {
+    size_t end_index = Utf16IndexToUtf8Index(styles[i].range.end());
+    style_ranges_utf8.push_back(ui::Range(start_index, end_index));
+    start_index = end_index;
+  }
+
+  internal::SkiaTextRenderer renderer(canvas);
+  for (GSList* it = current_line_->runs; it; it = it->next) {
+    PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
+    int glyph_count = run->glyphs->num_glyphs;
+    if (glyph_count == 0)
+      continue;
+
+    size_t run_start = run->item->offset;
+    size_t first_glyph_byte_index = run_start + run->glyphs->log_clusters[0];
+    size_t style_increment = IsRunLTR(run->item) ? 1 : -1;
+
+    // Find the initial style for this run.
+    // TODO(asvitkine): Can we avoid looping here, e.g. by caching this per run?
+    int style = -1;
+    for (size_t i = 0; i < style_ranges_utf8.size(); ++i) {
+      if (IndexInRange(style_ranges_utf8[i], first_glyph_byte_index)) {

[xji, 2011/12/07 19:52:26]

Ah, sorry that I just realized does this (using glyph index to search for style,
such as foreground) work for 'fi' ligature? Need to check with Behdad.

The questions are:
'fi' ligature is one glyph, right? If it is, then, can it have different
foreground for 'f' and 'i'? If it can, then, above logic is not correct for 'fi'
ligature, then, what should be the alternatives?

[Alexei Svitkine (slow), 2011/12/07 19:59:25]

I am not sure how its possible to render a single glyph using multiple styles.
In the case of "fi", you might argue that you can split it with a vertical line
and everything on the left of it would be one style and the right would be
another. But I don't think you can say that in general - in other cases the
combining glyph will have overlaps between the different parts. So as long as we
choose one of the two styles in such a case, whatever we deem to be the right
one - i.e. whatever is more intuitive, I think should be okay? Or is my mental
model of this flawed?

[xji, 2011/12/07 23:17:42]

I am not sure about this part.
I remember that you can highlight part of 'fi' ligature glyph. then, can you
draw part of it using different foreground color?
For example, if the 'fi' ligature is green, when, select part of it, the
foreground changed to kSelectedTextColor,
then, are we able to draw the foreground correctly?

It might be a rare case or not practical (say we never use different color to
draw text) that we could address it later. But I'd like to check with Behdad.

I just pinged him again. And he will look at it now.

[behdad_google, 2011/12/07 23:35:05]

Yeah, this is broken.  That's why I suggested that you highlight using Skia. 
But get the bounds from Pango.  Pango knows how to handle the size.  Well, it
just linearly divides the cluster width by the number of cursor positions in the
cluster.

[xji, 2011/12/08 00:27:56]

Does pango handle using 2 different foregrounds (not background) to draw 'fi'
ligature? How?

by "linearly divides", do you mean "evenly" divides?

Skia draws glyph by glyph, if you look at loop starts at line 334, even if you
can adjust pos[i] (at line 337) and glyph_x (at line 339) to count part of the
'fi' glyph, how can you pass half of the glyph to glyphs[i] (at line 336)?

[xji, 2011/12/08 00:27:56]

'fi' ligature is different. it is one glyph, but 2 graphemes , logically you can
select part of it.
http://en.wikipedia.org/wiki/Typographic_ligature

Behdad, correct me if I am wrong.

[behdad_google, 2011/12/14 06:29:11]

No.  Pango doesn't by itself.  But if you try selection in gedit it works. 
That's because gtk implements selection by clipping through cairo.
Yes, right.
The idea is that you draw the entire paragraph.  Then clip to selection region
only, and draw with different color.  So, you are drawing twice.

+        style = i;
+        break;
+      }
+    }
+    DCHECK_GE(style, 0);

[xji, 2011/12/07 19:52:26]

nit: do you want to dcheck "style < style_ranges.utf8.size()" too?

[Alexei Svitkine (slow), 2011/12/07 19:59:25]

It's not possible given the above loop.

[xji, 2011/12/07 23:17:42]

Ah, you right.

+
+    PangoFontDescription* native_font =
+        pango_font_describe(run->item->analysis.font);
+    renderer.SetFont(gfx::Font(native_font));
+    pango_font_description_free(native_font);
+
+    SkScalar glyph_x = x;
+    SkScalar start_x = x;
+    int start = 0;
+
+    glyphs.resize(glyph_count);
+    pos.resize(glyph_count);
+
+    for (int i = 0; i < glyph_count; ++i) {
+      const PangoGlyphInfo& glyph = run->glyphs->glyphs[i];
+      glyphs[i] = static_cast<uint16>(glyph.glyph);
+      pos[i].set(glyph_x + PANGO_PIXELS(glyph.geometry.x_offset),
+                 y + PANGO_PIXELS(glyph.geometry.y_offset));
+      glyph_x += PANGO_PIXELS(glyph.geometry.width);
+
+      // If this glyph is beyond the current style, draw the glyphs so far and
+      // advance to the next style.
+      size_t glyph_byte_index = run_start + run->glyphs->log_clusters[i];
+      if (!IndexInRange(style_ranges_utf8[style], glyph_byte_index)) {

[xji, 2011/12/07 19:52:26]

same question for whether glyph's style set works for 'fi' ligature.

+        renderer.SetForegroundColor(styles[style].foreground);
+        renderer.DrawPosText(&pos[start], &glyphs[start], i - start);
+        if (styles[style].underline || styles[style].strike) {
+          renderer.DrawDecorations(start_x, y, glyph_x - start_x,
+                                   styles[style].underline,
+                                   styles[style].strike);
+        }
+
+        style += style_increment;
+        start = i;
+        start_x = glyph_x;
+      }
+    }
+
+    // Draw the remaining glyphs.
+    renderer.SetForegroundColor(styles[style].foreground);
+    renderer.DrawPosText(&pos[start], &glyphs[start], glyph_count - start);
+    if (styles[style].underline || styles[style].strike) {
+       renderer.DrawDecorations(start_x, y, glyph_x - start_x,
+                                styles[style].underline,
+                                styles[style].strike);
+    }
+
+    x = glyph_x;
+  }
 }
 
 size_t RenderTextLinux::IndexOfAdjacentGrapheme(size_t index, bool next) {
   EnsureLayout();
   return Utf16IndexOfAdjacentGrapheme(Utf16IndexToUtf8Index(index), next);
 }
 
 GSList* RenderTextLinux::GetRunContainingPosition(size_t position) const {
   GSList* run = current_line_->runs;
   while (run) {
@@ skipping 79 matching lines @@
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   GSList* run = GetRunContainingPosition(caret);
   DCHECK(run);
 
   PangoLayoutRun* layout_run = reinterpret_cast<PangoLayoutRun*>(run->data);
   PangoItem* item = layout_run->item;
   size_t run_start = Utf8IndexToUtf16Index(item->offset);
   size_t run_end = Utf8IndexToUtf16Index(item->offset + item->length);
 
-  if (item->analysis.level % 2 == 0) {  // LTR run.
+  if (IsRunLTR(item)) {
     if (caret_placement == SelectionModel::TRAILING)
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     else if (caret > run_start) {
       caret = GetIndexOfPreviousGrapheme(caret);
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     }
   } else {  // RTL run.
     if (caret_placement == SelectionModel::LEADING) {
       size_t cursor = GetIndexOfNextGrapheme(caret);
       return SelectionModel(cursor, caret, SelectionModel::TRAILING);
     } else if (selection.selection_end() < run_end) {
       caret = GetIndexOfNextGrapheme(caret);
       size_t cursor = GetIndexOfNextGrapheme(caret);
       return SelectionModel(cursor, caret, SelectionModel::TRAILING);
     }
   }
 
   // The character is at the begin of its run; advance to the previous visual
   // run.
   PangoLayoutRun* prev_run = GetPreviousRun(layout_run);
   if (!prev_run)
     return LeftEndSelectionModel();
 
   item = prev_run->item;
-  return (item->analysis.level % 2) ? FirstSelectionModelInsideRun(item) :
-                                      LastSelectionModelInsideRun(item);
+  return IsRunLTR(item) ? LastSelectionModelInsideRun(item) :
+                          FirstSelectionModelInsideRun(item);
 }
 
 // Assume caret_pos in |current| is n, 'l' represents leading in
 // caret_placement and 't' represents trailing in caret_placement. Following
 // is the calculation from (caret_pos, caret_placement) in |current| to
 // (selection_end, caret_pos, caret_placement) when moving cursor right by
 // one grapheme (for simplicity, assume each grapheme is one character).
 // If n is in LTR run,
 // (n, l) ---> (n+1, n, t).
 // (n, t) ---> (n+2, n+1, t) if n is inside run (not at boundary).
@@ skipping 11 matching lines @@
     const SelectionModel& selection) {
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   GSList* run = GetRunContainingPosition(caret);
   DCHECK(run);
 
   PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
   size_t run_start = Utf8IndexToUtf16Index(item->offset);
   size_t run_end = Utf8IndexToUtf16Index(item->offset + item->length);
 
-  if (item->analysis.level % 2 == 0) {  // LTR run.
+  if (IsRunLTR(item)) {
     if (caret_placement == SelectionModel::LEADING) {
       size_t cursor = GetIndexOfNextGrapheme(caret);
       return SelectionModel(cursor, caret, SelectionModel::TRAILING);
     } else if (selection.selection_end() < run_end) {
       caret = GetIndexOfNextGrapheme(caret);
       size_t cursor = GetIndexOfNextGrapheme(caret);
       return SelectionModel(cursor, caret, SelectionModel::TRAILING);
     }
   } else {  // RTL run.
     if (caret_placement == SelectionModel::TRAILING)
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     else if (caret > run_start) {
       caret = GetIndexOfPreviousGrapheme(caret);
       return SelectionModel(caret, caret, SelectionModel::LEADING);
     }
   }
 
   // The character is at the end of its run; advance to the next visual run.
   GSList* next_run = run->next;
   if (!next_run)
     return RightEndSelectionModel();
 
   item = reinterpret_cast<PangoLayoutRun*>(next_run->data)->item;
-  return (item->analysis.level % 2) ? LastSelectionModelInsideRun(item) :
-                                      FirstSelectionModelInsideRun(item);
+  return IsRunLTR(item) ? FirstSelectionModelInsideRun(item) :
+                          LastSelectionModelInsideRun(item);
 }
 
 SelectionModel RenderTextLinux::LeftSelectionModelByWord(
     const SelectionModel& selection) {
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return selection;
 
   SelectionModel left_end = LeftEndSelectionModel();
   SelectionModel left(selection);
   while (!left.Equals(left_end)) {
     left = LeftSelectionModel(left);
     size_t caret = left.caret_pos();
     GSList* run = GetRunContainingPosition(caret);
     DCHECK(run);
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t cursor = left.selection_end();
-    if (item->analysis.level % 2 == 0) {  // LTR run.
+    if (IsRunLTR(item)) {
       if (iter.IsStartOfWord(cursor))
         return left;
     } else {  // RTL run.
       if (iter.IsEndOfWord(cursor))
         return left;
     }
   }
 
   return left_end;
 }
 
 SelectionModel RenderTextLinux::RightSelectionModelByWord(
     const SelectionModel& selection) {
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return selection;
 
   SelectionModel right_end = RightEndSelectionModel();
   SelectionModel right(selection);
   while (!right.Equals(right_end)) {
     right = RightSelectionModel(right);
     size_t caret = right.caret_pos();
     GSList* run = GetRunContainingPosition(caret);
     DCHECK(run);
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t cursor = right.selection_end();
-    if (item->analysis.level % 2 == 0) {  // LTR run.
+    if (IsRunLTR(item)) {
       if (iter.IsEndOfWord(cursor))
         return right;
     } else {  // RTL run.
       if (iter.IsStartOfWord(cursor))
         return right;
     }
   }
 
   return right_end;
 }
@@ skipping 157 matching lines @@
 }
 
 void RenderTextLinux::GetSelectionBounds(std::vector<Rect>* bounds) {
   if (selection_visual_bounds_.empty())
     CalculateSubstringBounds(GetSelectionStart(), GetCursorPosition(),
                              &selection_visual_bounds_);
   *bounds = selection_visual_bounds_;
 }
 
 }  // namespace gfx