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 162 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);
+  DCHECK(break_type == WORD_BREAK);
+  return LeftSelectionModelByWord(current);
 }
 
 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);
+  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.
         size_t caret = Utf8IndexToUtf16Index(item->offset);
@@ skipping 211 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;
+    // In Pango, different fonts means different runs, and it breaks Arabic
+    // shaping acorss run boundaries. So, set font only when it is different
+    // from the default faont.
+    // TODO(xji): 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)
+    if (font.platform_font() != default_platform_font) {
+      PangoFontDescription* desc = font.GetNativeFont();
+      pango_attr = pango_attr_font_desc_new(desc);
+      AppendPangoAttribute(start, end, pango_attr, attrs);
+      pango_font_description_free(desc);
+    }
 
     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->underline) {
+      pango_attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+      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 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