ui/gfx/render_text_pango.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/render_text_pango.h"
   6
   7 #include <pango/pangocairo.h>
   8 #include <algorithm>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/i18n/break_iterator.h"
  13 #include "base/logging.h"
  14 #include "third_party/skia/include/core/SkTypeface.h"
  15 #include "ui/gfx/canvas.h"
  16 #include "ui/gfx/font.h"
  17 #include "ui/gfx/font_list.h"
  18 #include "ui/gfx/font_render_params.h"
  19 #include "ui/gfx/pango_util.h"
  20 #include "ui/gfx/platform_font_pango.h"
  21 #include "ui/gfx/utf16_indexing.h"
  22
  23 namespace gfx {
  24
  25 namespace {
  26
  27 // Returns the preceding element in a GSList (O(n)).
  28 GSList* GSListPrevious(GSList* head, GSList* item) {
  29   GSList* prev = NULL;
  30   for (GSList* cur = head; cur != item; cur = cur->next) {
  31     DCHECK(cur);
  32     prev = cur;
  33   }
  34   return prev;
  35 }
  36
  37 // Returns true if the given visual cursor |direction| is logically forward
  38 // motion in the given Pango |item|.
  39 bool IsForwardMotion(VisualCursorDirection direction, const PangoItem* item) {
  40   bool rtl = item->analysis.level & 1;
  41   return rtl == (direction == CURSOR_LEFT);
  42 }
  43
  44 // Checks whether |range| contains |index|. This is not the same as calling
  45 // range.Contains(Range(index)), which returns true if |index| == |range.end()|.
  46 bool IndexInRange(const Range& range, size_t index) {
  47   return index >= range.start() && index < range.end();
  48 }
  49
  50 // Sets underline metrics on |renderer| according to Pango font |desc|.
  51 void SetPangoUnderlineMetrics(PangoFontDescription *desc,
  52                               internal::SkiaTextRenderer* renderer) {
  53   PangoFontMetrics* metrics = GetPangoFontMetrics(desc);
  54   int thickness = pango_font_metrics_get_underline_thickness(metrics);
  55   // Pango returns the position "above the baseline". Change its sign to convert
  56   // it to a vertical offset from the baseline.
  57   int position = -pango_font_metrics_get_underline_position(metrics);
  58
  59   // Note: pango_quantize_line_geometry() guarantees pixel boundaries, so
  60   //       PANGO_PIXELS() is safe to use.
  61   pango_quantize_line_geometry(&thickness, &position);
  62   int thickness_pixels = PANGO_PIXELS(thickness);
  63   int position_pixels = PANGO_PIXELS(position);
  64
  65   // Ugly hack: make sure that underlines don't get clipped. See
  66   // http://crbug.com/393117.
  67   int descent_pixels = PANGO_PIXELS(pango_font_metrics_get_descent(metrics));
  68   position_pixels = std::min(position_pixels,
  69                              descent_pixels - thickness_pixels);
  70
  71   renderer->SetUnderlineMetrics(thickness_pixels, position_pixels);
  72 }
  73
  74 }  // namespace
  75
  76 // TODO(xji): index saved in upper layer is utf16 index. Pango uses utf8 index.
  77 // Since caret_pos is used internally, we could save utf8 index for caret_pos
  78 // to avoid conversion.
  79
  80 RenderTextPango::RenderTextPango()
  81     : layout_(NULL),
  82       current_line_(NULL),
  83       log_attrs_(NULL),
  84       num_log_attrs_(0),
  85       layout_text_(NULL) {
  86 }
  87
  88 RenderTextPango::~RenderTextPango() {
  89   ResetLayout();
  90 }
  91
  92 Size RenderTextPango::GetStringSize() {
  93   EnsureLayout();
  94   int width = 0, height = 0;
  95   pango_layout_get_pixel_size(layout_, &width, &height);
  96
  97   // Pango returns 0 widths for very long strings (of 0x40000 chars or more).
  98   // This is caused by an int overflow in pango_glyph_string_extents_range.
  99   // Absurdly long strings may even report non-zero garbage values for width;
 100   // while detecting that isn't worthwhile, this handles the 0 width cases.
 101   const long kAbsurdLength = 100000;
 102   if (width == 0 && g_utf8_strlen(layout_text_, -1) > kAbsurdLength)
 103     width = font_list().GetExpectedTextWidth(g_utf8_strlen(layout_text_, -1));
 104
 105   // Keep a consistent height between this particular string's PangoLayout and
 106   // potentially larger text supported by the FontList.
 107   // For example, if a text field contains a Japanese character, which is
 108   // smaller than Latin ones, and then later a Latin one is inserted, this
 109   // ensures that the text baseline does not shift.
 110   return Size(width, std::max(height, font_list().GetHeight()));
 111 }
 112
 113 SelectionModel RenderTextPango::FindCursorPosition(const Point& point) {
 114   EnsureLayout();
 115
 116   if (text().empty())
 117     return SelectionModel(0, CURSOR_FORWARD);
 118
 119   Point p(ToTextPoint(point));
 120
 121   // When the point is outside of text, return HOME/END position.
 122   if (p.x() < 0)
 123     return EdgeSelectionModel(CURSOR_LEFT);
 124   if (p.x() > GetStringSize().width())
 125     return EdgeSelectionModel(CURSOR_RIGHT);
 126
 127   int caret_pos = 0, trailing = 0;
 128   pango_layout_xy_to_index(layout_, p.x() * PANGO_SCALE, p.y() * PANGO_SCALE,
 129                            &caret_pos, &trailing);
 130
 131   DCHECK_GE(trailing, 0);
 132   if (trailing > 0) {
 133     caret_pos = g_utf8_offset_to_pointer(layout_text_ + caret_pos,
 134                                          trailing) - layout_text_;
 135     DCHECK_LE(static_cast<size_t>(caret_pos), strlen(layout_text_));
 136   }
 137
 138   return SelectionModel(LayoutIndexToTextIndex(caret_pos),
 139                         (trailing > 0) ? CURSOR_BACKWARD : CURSOR_FORWARD);
 140 }
 141
 142 std::vector<RenderText::FontSpan> RenderTextPango::GetFontSpansForTesting() {
 143   EnsureLayout();
 144
 145   std::vector<RenderText::FontSpan> spans;
 146   for (GSList* it = current_line_->runs; it; it = it->next) {
 147     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(it->data)->item;
 148     const int start = LayoutIndexToTextIndex(item->offset);
 149     const int end = LayoutIndexToTextIndex(item->offset + item->length);
 150     const Range range(start, end);
 151
 152     ScopedPangoFontDescription desc(pango_font_describe(item->analysis.font));
 153     spans.push_back(RenderText::FontSpan(Font(desc.get()), range));
 154   }
 155
 156   return spans;
 157 }
 158
 159 int RenderTextPango::GetLayoutTextBaseline() {
 160   EnsureLayout();
 161   return PANGO_PIXELS(pango_layout_get_baseline(layout_));
 162 }
 163
 164 SelectionModel RenderTextPango::AdjacentCharSelectionModel(
 165     const SelectionModel& selection,
 166     VisualCursorDirection direction) {
 167   GSList* run = GetRunContainingCaret(selection);
 168   if (!run) {
 169     // The cursor is not in any run: we're at the visual and logical edge.
 170     SelectionModel edge = EdgeSelectionModel(direction);
 171     if (edge.caret_pos() == selection.caret_pos())
 172       return edge;
 173     else
 174       run = (direction == CURSOR_RIGHT) ?
 175           current_line_->runs : g_slist_last(current_line_->runs);
 176   } else {
 177     // If the cursor is moving within the current run, just move it by one
 178     // grapheme in the appropriate direction.
 179     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
 180     size_t caret = selection.caret_pos();
 181     if (IsForwardMotion(direction, item)) {
 182       if (caret < LayoutIndexToTextIndex(item->offset + item->length)) {
 183         caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD);
 184         return SelectionModel(caret, CURSOR_BACKWARD);
 185       }
 186     } else {
 187       if (caret > LayoutIndexToTextIndex(item->offset)) {
 188         caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD);
 189         return SelectionModel(caret, CURSOR_FORWARD);
 190       }
 191     }
 192     // The cursor is at the edge of a run; move to the visually adjacent run.
 193     // TODO(xji): Keep a vector of runs to avoid using a singly-linked list.
 194     run = (direction == CURSOR_RIGHT) ?
 195         run->next : GSListPrevious(current_line_->runs, run);
 196     if (!run)
 197       return EdgeSelectionModel(direction);
 198   }
 199   PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
 200   return IsForwardMotion(direction, item) ?
 201       FirstSelectionModelInsideRun(item) : LastSelectionModelInsideRun(item);
 202 }
 203
 204 SelectionModel RenderTextPango::AdjacentWordSelectionModel(
 205     const SelectionModel& selection,
 206     VisualCursorDirection direction) {
 207   if (obscured())
 208     return EdgeSelectionModel(direction);
 209
 210   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
 211   bool success = iter.Init();
 212   DCHECK(success);
 213   if (!success)
 214     return selection;
 215
 216   SelectionModel cur(selection);
 217   for (;;) {
 218     cur = AdjacentCharSelectionModel(cur, direction);
 219     GSList* run = GetRunContainingCaret(cur);
 220     if (!run)
 221       break;
 222     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
 223     size_t cursor = cur.caret_pos();
 224     if (IsForwardMotion(direction, item) ?
 225         iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor))
 226       break;
 227   }
 228
 229   return cur;
 230 }
 231
 232 Range RenderTextPango::GetGlyphBounds(size_t index) {
 233   EnsureLayout();
 234   PangoRectangle pos;
 235   pango_layout_index_to_pos(layout_, TextIndexToLayoutIndex(index), &pos);
 236   // TODO(derat): Support fractional ranges for subpixel positioning?
 237   return Range(PANGO_PIXELS(pos.x), PANGO_PIXELS(pos.x + pos.width));
 238 }
 239
 240 std::vector<Rect> RenderTextPango::GetSubstringBounds(const Range& range) {
 241   DCHECK_LE(range.GetMax(), text().length());
 242   if (range.is_empty())
 243     return std::vector<Rect>();
 244
 245   EnsureLayout();
 246   int* ranges = NULL;
 247   int n_ranges = 0;
 248   pango_layout_line_get_x_ranges(current_line_,
 249                                  TextIndexToLayoutIndex(range.GetMin()),
 250                                  TextIndexToLayoutIndex(range.GetMax()),
 251                                  &ranges,
 252                                  &n_ranges);
 253
 254   const int height = GetStringSize().height();
 255
 256   std::vector<Rect> bounds;
 257   for (int i = 0; i < n_ranges; ++i) {
 258     // TODO(derat): Support fractional bounds for subpixel positioning?
 259     int x = PANGO_PIXELS(ranges[2 * i]);
 260     int width = PANGO_PIXELS(ranges[2 * i + 1]) - x;
 261     Rect rect(x, 0, width, height);
 262     rect.set_origin(ToViewPoint(rect.origin()));
 263     bounds.push_back(rect);
 264   }
 265   g_free(ranges);
 266   return bounds;
 267 }
 268
 269 size_t RenderTextPango::TextIndexToLayoutIndex(size_t index) const {
 270   DCHECK(layout_);
 271   ptrdiff_t offset = UTF16IndexToOffset(text(), 0, index);
 272   // Clamp layout indices to the length of the text actually used for layout.
 273   offset = std::min<size_t>(offset, g_utf8_strlen(layout_text_, -1));
 274   const char* layout_pointer = g_utf8_offset_to_pointer(layout_text_, offset);
 275   return (layout_pointer - layout_text_);
 276 }
 277
 278 size_t RenderTextPango::LayoutIndexToTextIndex(size_t index) const {
 279   DCHECK(layout_);
 280   const char* layout_pointer = layout_text_ + index;
 281   const long offset = g_utf8_pointer_to_offset(layout_text_, layout_pointer);
 282   return UTF16OffsetToIndex(text(), 0, offset);
 283 }
 284
 285 bool RenderTextPango::IsValidCursorIndex(size_t index) {
 286   if (index == 0 || index == text().length())
 287     return true;
 288   if (!IsValidLogicalIndex(index))
 289     return false;
 290
 291   EnsureLayout();
 292   ptrdiff_t offset = UTF16IndexToOffset(text(), 0, index);
 293   // Check that the index is marked as a legitimate cursor position by Pango.
 294   return offset < num_log_attrs_ && log_attrs_[offset].is_cursor_position;
 295 }
 296
 297 void RenderTextPango::ResetLayout() {
 298   // set_cached_bounds_and_offset_valid(false) is done in RenderText for every
 299   // operation that triggers ResetLayout().
 300   if (layout_) {
 301     // TODO(msw): Keep |layout_| across text changes, etc.; it can be re-used.
 302     g_object_unref(layout_);
 303     layout_ = NULL;
 304   }
 305   if (current_line_) {
 306     pango_layout_line_unref(current_line_);
 307     current_line_ = NULL;
 308   }
 309   if (log_attrs_) {
 310     g_free(log_attrs_);
 311     log_attrs_ = NULL;
 312     num_log_attrs_ = 0;
 313   }
 314   layout_text_ = NULL;
 315 }
 316
 317 void RenderTextPango::EnsureLayout() {
 318   if (layout_ == NULL) {
 319     cairo_surface_t* surface =
 320         cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
 321     CHECK_EQ(CAIRO_STATUS_SUCCESS, cairo_surface_status(surface));
 322     cairo_t* cr = cairo_create(surface);
 323     CHECK_EQ(CAIRO_STATUS_SUCCESS, cairo_status(cr));
 324
 325     layout_ = pango_cairo_create_layout(cr);
 326     CHECK_NE(static_cast<PangoLayout*>(NULL), layout_);
 327     cairo_destroy(cr);
 328     cairo_surface_destroy(surface);
 329
 330     SetUpPangoLayout(layout_, GetLayoutText(), font_list(), GetTextDirection(),
 331                      Canvas::DefaultCanvasTextAlignment());
 332
 333     // No width set so that the x-axis position is relative to the start of the
 334     // text. ToViewPoint and ToTextPoint take care of the position conversion
 335     // between text space and view spaces.
 336     pango_layout_set_width(layout_, -1);
 337     // TODO(xji): If RenderText will be used for displaying purpose, such as
 338     // label, we will need to remove the single-line-mode setting.
 339     pango_layout_set_single_paragraph_mode(layout_, true);
 340
 341     layout_text_ = pango_layout_get_text(layout_);
 342     SetupPangoAttributes(layout_);
 343
 344     current_line_ = pango_layout_get_line_readonly(layout_, 0);
 345     CHECK_NE(static_cast<PangoLayoutLine*>(NULL), current_line_);
 346     pango_layout_line_ref(current_line_);
 347
 348     pango_layout_get_log_attrs(layout_, &log_attrs_, &num_log_attrs_);
 349   }
 350 }
 351
 352 void RenderTextPango::SetupPangoAttributes(PangoLayout* layout) {
 353   PangoAttrList* attrs = pango_attr_list_new();
 354
 355   // Splitting text runs to accommodate styling can break Arabic glyph shaping.
 356   // Only split text runs as needed for bold and italic font styles changes.
 357   BreakList<bool>::const_iterator bold = styles()[BOLD].breaks().begin();
 358   BreakList<bool>::const_iterator italic = styles()[ITALIC].breaks().begin();
 359   while (bold != styles()[BOLD].breaks().end() &&
 360          italic != styles()[ITALIC].breaks().end()) {
 361     const int style = (bold->second ? Font::BOLD : 0) |
 362                       (italic->second ? Font::ITALIC : 0);
 363     const size_t bold_end = styles()[BOLD].GetRange(bold).end();
 364     const size_t italic_end = styles()[ITALIC].GetRange(italic).end();
 365     const size_t style_end = std::min(bold_end, italic_end);
 366     if (style != font_list().GetFontStyle()) {
 367       // TODO(derat): Don't interpret gfx::FontList font descriptions as Pango
 368       // font descriptions: http://crbug.com/393067
 369       FontList derived_font_list = font_list().DeriveWithStyle(style);
 370       ScopedPangoFontDescription desc(
 371           derived_font_list.GetFontDescriptionString());
 372
 373       PangoAttribute* pango_attr = pango_attr_font_desc_new(desc.get());
 374       pango_attr->start_index =
 375           TextIndexToLayoutIndex(std::max(bold->first, italic->first));
 376       pango_attr->end_index = TextIndexToLayoutIndex(style_end);
 377       pango_attr_list_insert(attrs, pango_attr);
 378     }
 379     bold += bold_end == style_end ? 1 : 0;
 380     italic += italic_end == style_end ? 1 : 0;
 381   }
 382   DCHECK(bold == styles()[BOLD].breaks().end());
 383   DCHECK(italic == styles()[ITALIC].breaks().end());
 384
 385   pango_layout_set_attributes(layout, attrs);
 386   pango_attr_list_unref(attrs);
 387 }
 388
 389 void RenderTextPango::DrawVisualText(Canvas* canvas) {
 390   DCHECK(layout_);
 391
 392   // Skia will draw glyphs with respect to the baseline.
 393   Vector2d offset(GetLineOffset(0) + Vector2d(0, GetLayoutTextBaseline()));
 394
 395   SkScalar x = SkIntToScalar(offset.x());
 396   SkScalar y = SkIntToScalar(offset.y());
 397
 398   std::vector<SkPoint> pos;
 399   std::vector<uint16> glyphs;
 400
 401   internal::SkiaTextRenderer renderer(canvas);
 402   ApplyFadeEffects(&renderer);
 403   ApplyTextShadows(&renderer);
 404   renderer.SetFontRenderParams(
 405       font_list().GetPrimaryFont().GetFontRenderParams(),
 406       background_is_transparent());
 407
 408   // Temporarily apply composition underlines and selection colors.
 409   ApplyCompositionAndSelectionStyles();
 410
 411   internal::StyleIterator style(colors(), styles());
 412   for (GSList* it = current_line_->runs; it; it = it->next) {
 413     // Skip painting runs outside the display area.
 414     if (SkScalarTruncToInt(x) >= display_rect().right())
 415       break;
 416
 417     PangoLayoutRun* run = reinterpret_cast<PangoLayoutRun*>(it->data);
 418     int glyph_count = run->glyphs->num_glyphs;
 419     if (glyph_count == 0)
 420       continue;
 421
 422     ScopedPangoFontDescription desc(
 423         pango_font_describe(run->item->analysis.font));
 424     const std::string family_name =
 425         pango_font_description_get_family(desc.get());
 426     renderer.SetTextSize(GetPangoFontSizeInPixels(desc.get()));
 427
 428     glyphs.resize(glyph_count);
 429     pos.resize(glyph_count);
 430
 431     // Track the current glyph and the glyph at the start of its styled range.
 432     int glyph_index = 0;
 433     int style_start_glyph_index = glyph_index;
 434
 435     // Track the x-coordinates for each styled range (|x| marks the current).
 436     SkScalar style_start_x = x;
 437
 438     // Track the current style and its text (not layout) index range.
 439     style.UpdatePosition(GetGlyphTextIndex(run, style_start_glyph_index));
 440     Range style_range = style.GetRange();
 441
 442     do {
 443       const PangoGlyphInfo& glyph = run->glyphs->glyphs[glyph_index];
 444       glyphs[glyph_index] = static_cast<uint16>(glyph.glyph);
 445       // Use pango_units_to_double() rather than PANGO_PIXELS() here, so units
 446       // are not rounded to the pixel grid if subpixel positioning is enabled.
 447       pos[glyph_index].set(x + pango_units_to_double(glyph.geometry.x_offset),
 448                            y + pango_units_to_double(glyph.geometry.y_offset));
 449       x += pango_units_to_double(glyph.geometry.width);
 450
 451       ++glyph_index;
 452       // If this is the last glyph of the range or the last glyph inside the
 453       // display area (which would cause early termination of the loop), paint
 454       // the range.
 455       const size_t glyph_text_index = (glyph_index == glyph_count) ?
 456           style_range.end() : GetGlyphTextIndex(run, glyph_index);
 457       if (!IndexInRange(style_range, glyph_text_index) ||
 458           SkScalarTruncToInt(x) >= display_rect().right()) {
 459         // TODO(asvitkine): For cases like "fi", where "fi" is a single glyph
 460         //                  but can span multiple styles, Pango splits the
 461         //                  styles evenly over the glyph. We can do this too by
 462         //                  clipping and drawing the glyph several times.
 463         renderer.SetForegroundColor(style.color());
 464         const int font_style = (style.style(BOLD) ? Font::BOLD : 0) |
 465                                (style.style(ITALIC) ? Font::ITALIC : 0);
 466         renderer.SetFontFamilyWithStyle(family_name, font_style);
 467         renderer.DrawPosText(&pos[style_start_glyph_index],
 468                              &glyphs[style_start_glyph_index],
 469                              glyph_index - style_start_glyph_index);
 470         if (style.style(UNDERLINE))
 471           SetPangoUnderlineMetrics(desc.get(), &renderer);
 472         renderer.DrawDecorations(style_start_x, y, x - style_start_x,
 473                                  style.style(UNDERLINE), style.style(STRIKE),
 474                                  style.style(DIAGONAL_STRIKE));
 475         style.UpdatePosition(glyph_text_index);
 476         style_range = style.GetRange();
 477         style_start_glyph_index = glyph_index;
 478         style_start_x = x;
 479       }
 480       // Terminates loop when the end of the range has been reached or the next
 481       // glyph falls outside the display area.
 482     } while (glyph_index < glyph_count &&
 483              SkScalarTruncToInt(x) < display_rect().right());
 484   }
 485
 486   renderer.EndDiagonalStrike();
 487
 488   // Undo the temporarily applied composition underlines and selection colors.
 489   UndoCompositionAndSelectionStyles();
 490 }
 491
 492 GSList* RenderTextPango::GetRunContainingCaret(
 493     const SelectionModel& caret) const {
 494   size_t position = TextIndexToLayoutIndex(caret.caret_pos());
 495   LogicalCursorDirection affinity = caret.caret_affinity();
 496   GSList* run = current_line_->runs;
 497   while (run) {
 498     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
 499     Range item_range(item->offset, item->offset + item->length);
 500     if (RangeContainsCaret(item_range, position, affinity))
 501       return run;
 502     run = run->next;
 503   }
 504   return NULL;
 505 }
 506
 507 SelectionModel RenderTextPango::FirstSelectionModelInsideRun(
 508     const PangoItem* item) {
 509   size_t caret = IndexOfAdjacentGrapheme(
 510       LayoutIndexToTextIndex(item->offset), CURSOR_FORWARD);
 511   return SelectionModel(caret, CURSOR_BACKWARD);
 512 }
 513
 514 SelectionModel RenderTextPango::LastSelectionModelInsideRun(
 515     const PangoItem* item) {
 516   size_t caret = IndexOfAdjacentGrapheme(
 517       LayoutIndexToTextIndex(item->offset + item->length), CURSOR_BACKWARD);
 518   return SelectionModel(caret, CURSOR_FORWARD);
 519 }
 520
 521 size_t RenderTextPango::GetGlyphTextIndex(PangoLayoutRun* run,
 522                                           int glyph_index) const {
 523   return LayoutIndexToTextIndex(run->item->offset +
 524                                 run->glyphs->log_clusters[glyph_index]);
 525 }
 526
 527 RenderText* RenderText::CreateNativeInstance() {
 528   return new RenderTextPango;
 529 }
 530
 531 }  // namespace gfx