Separate selection highlight from pango layout

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 {
@@ skipping 39 matching lines @@
 }
 
 int RenderTextLinux::GetStringWidth() {
   PangoLayout* layout = EnsureLayout();
   int width;
   pango_layout_get_pixel_size(layout, &width, NULL);
   return width;
 }
 
 void RenderTextLinux::Draw(Canvas* canvas) {
-  PangoLayout* layout = EnsureLayout();
-  Rect bounds(display_rect());
-
-  // Clip the canvas to the text display area.
-  SkCanvas* canvas_skia = canvas->GetSkCanvas();
-
-  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);
-
-  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);
-
-  cairo_restore(cr);
-
-  // Paint cursor.
-  bounds = GetUpdatedCursorBounds();
-  if (cursor_visible() && focused())
-      canvas->DrawRectInt(kCursorColor,
-                          bounds.x(),
-                          bounds.y(),
-                          bounds.width(),
-                          bounds.height());
+  EnsureLayout();
+  RenderText::Draw(canvas);
 }
 
 SelectionModel RenderTextLinux::FindCursorPosition(const Point& point) {
   PangoLayout* layout = EnsureLayout();
 
   if (text().empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
 
   Point p(ToTextPoint(point));
 
@@ skipping 104 matching lines @@
         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);
 }
 
+void RenderTextLinux::SetSelectionModel(const SelectionModel& selection_model) {
+  if (GetSelectionStart() != selection_model.selection_start() ||
+      GetCursorPosition() != selection_model.selection_end())
+    selection_visual_bounds_.clear();
+
+  RenderText::SetSelectionModel(selection_model);
+}
+
+void RenderTextLinux::GetSubstringBounds(size_t from,
+                                         size_t to,
+                                         std::vector<Rect>* bounds) {
+  DCHECK(from <= text().length());
+  DCHECK(to <= text().length());
+
+  bounds->clear();
+  if (from == to)
+    return;
+
+  EnsureLayout();
+
+  if (from == GetSelectionStart() && to == GetCursorPosition())
+    GetSelectionBounds(bounds);
+  else
+    CalculateSubstringBounds(from, to, bounds);
+}
+
 bool RenderTextLinux::IsCursorablePosition(size_t position) {
   if (position == 0 && text().empty())
     return true;
 
   EnsureLayout();
   return (position < static_cast<size_t>(num_log_attrs_) &&
           log_attrs_[position].is_cursor_position);
 }
 
 void RenderTextLinux::UpdateLayout() {
   ResetLayout();
 }
 
+void RenderTextLinux::DrawVisualText(Canvas* canvas) {
+  Rect bounds(display_rect());
+
+  // Clip the canvas to the text display area.
+  SkCanvas* canvas_skia = canvas->GetSkCanvas();
+
+  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);
+
+  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_);
+
+  cairo_restore(cr);
+}
+
 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) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t run_start = Utf8IndexToUtf16Index(item->offset);
@@ skipping 272 matching lines @@
   }
   if (current_line_) {
     pango_layout_line_unref(current_line_);
     current_line_ = NULL;
   }
   if (log_attrs_) {
     g_free(log_attrs_);
     log_attrs_ = NULL;
     num_log_attrs_ = 0;
   }
+  if (!selection_visual_bounds_.empty())
+    selection_visual_bounds_.clear();
   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();
 
+  PangoAttribute* pango_attr;
   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());
+    size_t start = std::min(i->range.start(), text().length());
+    size_t end = std::min(i->range.end(), text().length());
     if (start >= end)
       continue;
 
     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)
@@ skipping 74 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;
 }
 
+void RenderTextLinux::CalculateSubstringBounds(size_t from,
+                                               size_t to,
+                                               std::vector<Rect>* bounds) {
+  int* ranges;
+  int n_ranges;
+  size_t from_in_utf8 = Utf16IndexToUtf8Index(from);
+  size_t to_in_utf8 = Utf16IndexToUtf8Index(to);
+  pango_layout_line_get_x_ranges(
+      current_line_,
+      std::min(from_in_utf8, to_in_utf8),
+      std::max(from_in_utf8, to_in_utf8),
+      &ranges,
+      &n_ranges);
+
+  int height;
+  pango_layout_get_pixel_size(layout_, NULL, &height);
+
+  int y = (display_rect().height() - height) / 2;
+
+  for (int i = 0; i < n_ranges; ++i) {
+    int x = PANGO_PIXELS(ranges[2 * i]);
+    int width = PANGO_PIXELS(ranges[2 * i + 1]) - x;
+    Rect rect(x, y, width, height);
+    rect.set_origin(ToViewPoint(rect.origin()));
+    bounds->push_back(rect);
+  }
+  g_free(ranges);
+}
+
+void RenderTextLinux::GetSelectionBounds(std::vector<Rect>* bounds) {
+  if (selection_visual_bounds_.empty())
+    CalculateSubstringBounds(GetSelectionStart(), GetCursorPosition(),
+                             &selection_visual_bounds_);
+  *bounds = selection_visual_bounds_;
+}
+
 }  // namespace gfx