Implement move by word, fix rendering of Arabic shape joining

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 "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "ui/gfx/canvas_skia.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.
@@ skipping 156 matching lines @@
 
 SelectionModel RenderTextLinux::GetLeftSelectionModel(
     const SelectionModel& current,
     BreakType break_type) {
   EnsureLayout();
 
   if (break_type == LINE_BREAK || text().empty())
     return LeftEndSelectionModel();
   if (break_type == CHARACTER_BREAK)
     return LeftSelectionModel(current);
-  // TODO(xji): not implemented yet.
-  return RenderText::GetLeftSelectionModel(current, break_type);
+  return LeftSelectionModelByWord(current);

[msw, 2011/09/15 01:26:00]

DCHECK(break_type == WORD_BREAK); before this to ensure someone doesn't
introduce a different break type that gets inadvertantly handled as a word here.
Same for GetRightSelectionModel below.

[xji, 2011/09/15 22:58:09]

Done.

 }
 
 SelectionModel RenderTextLinux::GetRightSelectionModel(
     const SelectionModel& current,
     BreakType break_type) {
   EnsureLayout();
 
   if (break_type == LINE_BREAK || text().empty())
     return RightEndSelectionModel();
   if (break_type == CHARACTER_BREAK)
     return RightSelectionModel(current);
-  // TODO(xji): not implemented yet.
-  return RenderText::GetRightSelectionModel(current, break_type);
+  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.
         size_t caret = Utf8IndexToUtf16Index(item->offset);
@@ skipping 209 matching lines @@
   // 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);
 }
 
+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 (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 (iter.IsEndOfWord(cursor))
+        return right;
+    } else {  // RTL run.
+      if (iter.IsStartOfWord(cursor))
+        return right;
+    }
+  }
+
+  return right_end;
+}
+
 PangoLayout* RenderTextLinux::EnsureLayout() {
   if (layout_ == NULL) {
     CanvasSkia canvas(display_rect().width(), display_rect().height(), false);
     skia::ScopedPlatformPaint scoped_platform_paint(&canvas);
     cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
 
     layout_ = pango_cairo_create_layout(cr);
     SetupPangoLayout(
         layout_,
         text(),
@@ skipping 38 matching lines @@
     log_attrs_ = NULL;
     num_log_attrs_ = 0;
   }
   layout_text_ = NULL;
   layout_text_len_ = 0;
 }
 
 void RenderTextLinux::SetupPangoAttributes(PangoLayout* layout) {
   PangoAttrList* attrs = pango_attr_list_new();
   // Set selection background color.
+  // TODO(xji): There's a bug in pango that it can't use two colors in one
+  // glyph. Please refer to https://bugzilla.gnome.org/show_bug.cgi?id=648157
+  // for detail. So for example, if a font has "ffi" ligature, but you select
+  // half of that glyph, you either get the entire "ffi" ligature
+  // selection-colored, or none of it.
+  // We could use clipping to render selection.
+  // Use pango_glyph_item_get_logical_widths to find the exact boundaries of
+  // selection, then cairo_clip that, paint background, set color to white and
+  // redraw the layout.
   SkColor selection_color =
       focused() ? kFocusedSelectionColor : kUnfocusedSelectionColor;
   size_t start = std::min(MinOfSelection(), text().length());
   size_t end = std::min(MaxOfSelection(), text().length());
   PangoAttribute* pango_attr;
   if (end > start) {
     pango_attr = pango_attr_background_new(
         ConvertColorFrom8BitTo16Bit(SkColorGetR(selection_color)),
         ConvertColorFrom8BitTo16Bit(SkColorGetG(selection_color)),
         ConvertColorFrom8BitTo16Bit(SkColorGetB(selection_color)));
     AppendPangoAttribute(start, end, pango_attr, attrs);
   }
 
   StyleRanges ranges_of_style(style_ranges());
   ApplyCompositionAndSelectionStyles(&ranges_of_style);
 
+  PlatformFont* default_platform_font = default_style().font.platform_font();
+
   for (StyleRanges::const_iterator i = ranges_of_style.begin();
        i < ranges_of_style.end(); ++i) {
     start = std::min(i->range.start(), text().length());
     end = std::min(i->range.end(), text().length());
     if (start >= end)
       continue;
 
-    const Font& font = !i->underline ? i->font :
-        i->font.DeriveFont(0, i->font.GetStyle() | Font::UNDERLINED);
-    PangoFontDescription* desc = font.GetNativeFont();
-    pango_attr = pango_attr_font_desc_new(desc);
-    AppendPangoAttribute(start, end, pango_attr, attrs);
-    pango_font_description_free(desc);
+    const Font& font = i->font;
+    if (font.platform_font() != default_platform_font) {

[msw, 2011/09/15 01:26:00]

I want to make sure this is correct. If you don't AppendPangoAttribute, it just
uses the default font right? (If it uses the previous run's font, then this is
incorrect.)

Still, this will break Arabic shaping if the two runs hosting that text have the
same non-default font. It may not occur in practice now, but this would
AppendPangoAttribute and split up the text for each half with a custom font.

I think we'll eventually need to split up StyleRange into components
(ColorRange, FontRange, etc.) so that we can combine adjacent ranges with the
same Fonts (to avoid unnecessarily splitting up runs).

[xji, 2011/09/15 22:58:09]

Yes.
You are right.
You are right. I added a TODO.

+      // In pango, different fonts means different runs, and it breaks Arabic

[msw, 2011/09/15 01:26:00]

Capitalize Pango?, also this comment probably belongs just above and outside
this conditional block.

[xji, 2011/09/15 22:58:09]

Done.

+      // shaping acorss run boundaries. So, set font to the largest range.
+      PangoFontDescription* desc = font.GetNativeFont();
+      pango_attr = pango_attr_font_desc_new(desc);
+      AppendPangoAttribute(start, end, pango_attr, attrs);
+      pango_font_description_free(desc);
+    }
+
+    if (i->underline) {
+      pango_attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+      AppendPangoAttribute(start, end, pango_attr, attrs);
+    }
 
     SkColor foreground = i->foreground;
     pango_attr = pango_attr_foreground_new(
         ConvertColorFrom8BitTo16Bit(SkColorGetR(foreground)),
         ConvertColorFrom8BitTo16Bit(SkColorGetG(foreground)),
         ConvertColorFrom8BitTo16Bit(SkColorGetB(foreground)));
     AppendPangoAttribute(start, end, pango_attr, attrs);
 
     if (i->strike) {
       pango_attr = pango_attr_strikethrough_new(true);
       AppendPangoAttribute(start, end, pango_attr, attrs);
     }
   }
 
   pango_layout_set_attributes(layout, attrs);
   pango_attr_list_unref(attrs);
 }
 
 void RenderTextLinux::AppendPangoAttribute(size_t start,
                                            size_t end,
                                            PangoAttribute* pango_attr,
                                            PangoAttrList* attrs) {
   pango_attr->start_index = Utf16IndexToUtf8Index(start);
   pango_attr->end_index = Utf16IndexToUtf8Index(end);
   pango_attr_list_insert(attrs, pango_attr);
 }
 
+// TODO(xji): keep a vector of runs to avoid use single-linked list.

[msw, 2011/09/15 01:26:00]

Nits: "*K*eep", "us*ing*", "singl*y*" and "list*s*"

[xji, 2011/09/15 22:58:09]

done except "lists", it is one list.

[msw, 2011/09/17 00:27:10]

Technically that's grammatically incorrect, you'll need a preposition with a
singular noun in that case:
"... to avoid using *a* singly-linked list."

 PangoLayoutRun* RenderTextLinux::GetPreviousRun(PangoLayoutRun* run) const {
   GSList* current = current_line_->runs;
   GSList* prev = NULL;
   while (current) {
     if (reinterpret_cast<PangoLayoutRun*>(current->data) == run)
       return prev ? reinterpret_cast<PangoLayoutRun*>(prev->data) : NULL;
     prev = current;
     current = current->next;
   }
   return NULL;
@@ skipping 26 matching lines @@
 size_t RenderTextLinux::Utf8IndexToUtf16Index(size_t index) const {
   int32_t utf16_index = 0;
   UErrorCode ec = U_ZERO_ERROR;
   u_strFromUTF8(NULL, 0, &utf16_index, layout_text_, index, &ec);
   DCHECK(ec == U_BUFFER_OVERFLOW_ERROR ||
          ec == U_STRING_NOT_TERMINATED_WARNING);
   return utf16_index;
 }
 
 }  // namespace gfx