Home | History | Annotate | Download | only in gfx 
      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/pango_util.h"
      6 
      7 #include <cairo/cairo.h>
      8 #include <pango/pango.h>
      9 #include <pango/pangocairo.h>
     10 #include <string>
     11 
     12 #include <algorithm>
     13 #include <map>
     14 
     15 #include "base/logging.h"
     16 #include "base/strings/utf_string_conversions.h"
     17 #include "ui/gfx/canvas.h"
     18 #include "ui/gfx/font_list.h"
     19 #include "ui/gfx/font_render_params.h"
     20 #include "ui/gfx/linux_font_delegate.h"
     21 #include "ui/gfx/platform_font_pango.h"
     22 #include "ui/gfx/text_utils.h"
     23 
     24 namespace gfx {
     25 
     26 namespace {
     27 
     28 // Marker for accelerators in the text.
     29 const gunichar kAcceleratorChar = '&';
     30 
     31 // Creates and returns a PangoContext. The caller owns the context.
     32 PangoContext* GetPangoContext() {
     33   PangoFontMap* font_map = pango_cairo_font_map_get_default();
     34   return pango_font_map_create_context(font_map);
     35 }
     36 
     37 // Creates a new cairo_font_options_t based on |params|.
     38 cairo_font_options_t* CreateCairoFontOptions(const FontRenderParams& params) {
     39   cairo_font_options_t* cairo_font_options = cairo_font_options_create();
     40 
     41   FontRenderParams::SubpixelRendering subpixel = params.subpixel_rendering;
     42   if (!params.antialiasing) {
     43     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_NONE);
     44   } else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_NONE) {
     45     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY);
     46   } else {
     47     cairo_font_options_set_antialias(cairo_font_options,
     48                                      CAIRO_ANTIALIAS_SUBPIXEL);
     49     cairo_subpixel_order_t cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
     50     if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_RGB)
     51       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_RGB;
     52     else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_BGR)
     53       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_BGR;
     54     else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VRGB)
     55       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VRGB;
     56     else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VBGR)
     57       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VBGR;
     58     else
     59       NOTREACHED() << "Unhandled subpixel rendering type " << subpixel;
     60     cairo_font_options_set_subpixel_order(cairo_font_options,
     61                                           cairo_subpixel_order);
     62   }
     63 
     64   if (params.hinting == FontRenderParams::HINTING_NONE ||
     65       params.subpixel_positioning) {
     66     cairo_font_options_set_hint_style(cairo_font_options,
     67                                       CAIRO_HINT_STYLE_NONE);
     68     cairo_font_options_set_hint_metrics(cairo_font_options,
     69                                         CAIRO_HINT_METRICS_OFF);
     70   } else {
     71     cairo_hint_style_t cairo_hint_style = CAIRO_HINT_STYLE_DEFAULT;
     72     if (params.hinting == FontRenderParams::HINTING_SLIGHT)
     73       cairo_hint_style = CAIRO_HINT_STYLE_SLIGHT;
     74     else if (params.hinting == FontRenderParams::HINTING_MEDIUM)
     75       cairo_hint_style = CAIRO_HINT_STYLE_MEDIUM;
     76     else if (params.hinting == FontRenderParams::HINTING_FULL)
     77       cairo_hint_style = CAIRO_HINT_STYLE_FULL;
     78     else
     79       NOTREACHED() << "Unhandled hinting style " << params.hinting;
     80     cairo_font_options_set_hint_style(cairo_font_options, cairo_hint_style);
     81     cairo_font_options_set_hint_metrics(cairo_font_options,
     82                                         CAIRO_HINT_METRICS_ON);
     83   }
     84 
     85   return cairo_font_options;
     86 }
     87 
     88 // Returns the DPI that should be used by Pango.
     89 double GetPangoDPI() {
     90   static double dpi = -1.0;
     91   if (dpi < 0.0) {
     92     const gfx::LinuxFontDelegate* delegate = gfx::LinuxFontDelegate::instance();
     93     if (delegate)
     94       dpi = delegate->GetFontDPI();
     95     if (dpi <= 0.0)
     96       dpi = 96.0;
     97   }
     98   return dpi;
     99 }
    100 
    101 // Returns the number of pixels in a point.
    102 // - multiply a point size by this to get pixels ("device units")
    103 // - divide a pixel size by this to get points
    104 double GetPixelsInPoint() {
    105   static double pixels_in_point = GetPangoDPI() / 72.0;  // 72 points in an inch
    106   return pixels_in_point;
    107 }
    108 
    109 }  // namespace
    110 
    111 void SetUpPangoLayout(
    112     PangoLayout* layout,
    113     const base::string16& text,
    114     const FontList& font_list,
    115     base::i18n::TextDirection text_direction,
    116     int flags) {
    117   cairo_font_options_t* cairo_font_options = CreateCairoFontOptions(
    118       font_list.GetPrimaryFont().GetFontRenderParams());
    119 
    120   // If we got an explicit request to turn off subpixel rendering, disable it.
    121   if ((flags & Canvas::NO_SUBPIXEL_RENDERING) &&
    122       (cairo_font_options_get_antialias(cairo_font_options) ==
    123        CAIRO_ANTIALIAS_SUBPIXEL))
    124     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY);
    125 
    126   // This needs to be done early on; it has no effect when called just before
    127   // pango_cairo_show_layout().
    128   pango_cairo_context_set_font_options(
    129       pango_layout_get_context(layout), cairo_font_options);
    130   cairo_font_options_destroy(cairo_font_options);
    131   cairo_font_options = NULL;
    132 
    133   // Set Pango's base text direction explicitly from |text_direction|.
    134   pango_layout_set_auto_dir(layout, FALSE);
    135   pango_context_set_base_dir(pango_layout_get_context(layout),
    136       (text_direction == base::i18n::RIGHT_TO_LEFT ?
    137        PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR));
    138 
    139   if (flags & Canvas::TEXT_ALIGN_CENTER) {
    140     // We don't support center aligned w/ eliding.
    141     DCHECK(gfx::Canvas::NO_ELLIPSIS);
    142     pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
    143   } else if (flags & Canvas::TEXT_ALIGN_RIGHT) {
    144     pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
    145   }
    146 
    147   if (flags & Canvas::NO_ELLIPSIS) {
    148     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
    149     if (flags & Canvas::MULTI_LINE) {
    150       pango_layout_set_wrap(layout,
    151           (flags & Canvas::CHARACTER_BREAK) ?
    152               PANGO_WRAP_WORD_CHAR : PANGO_WRAP_WORD);
    153     }
    154   } else if (text_direction == base::i18n::RIGHT_TO_LEFT) {
    155     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
    156   } else {
    157     // Fading the text will be handled in the draw operation.
    158     // Ensure that the text is only on one line.
    159     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
    160     pango_layout_set_width(layout, -1);
    161   }
    162 
    163   // Set the layout's resolution to match the resolution used to convert from
    164   // points to pixels.
    165   pango_cairo_context_set_resolution(pango_layout_get_context(layout),
    166                                      GetPangoDPI());
    167 
    168   // Set text and accelerator character if needed.
    169   if (flags & Canvas::SHOW_PREFIX) {
    170     // Escape the text string to be used as markup.
    171     std::string utf8 = base::UTF16ToUTF8(text);
    172     gchar* escaped_text = g_markup_escape_text(utf8.c_str(), utf8.size());
    173     pango_layout_set_markup_with_accel(layout,
    174                                        escaped_text,
    175                                        strlen(escaped_text),
    176                                        kAcceleratorChar, NULL);
    177     g_free(escaped_text);
    178   } else {
    179     std::string utf8;
    180 
    181     // Remove the ampersand character.  A double ampersand is output as
    182     // a single ampersand.
    183     if (flags & Canvas::HIDE_PREFIX) {
    184       DCHECK_EQ(1, g_unichar_to_utf8(kAcceleratorChar, NULL));
    185       base::string16 accelerator_removed =
    186           RemoveAcceleratorChar(text,
    187                                 static_cast<base::char16>(kAcceleratorChar),
    188                                 NULL, NULL);
    189       utf8 = base::UTF16ToUTF8(accelerator_removed);
    190     } else {
    191       utf8 = base::UTF16ToUTF8(text);
    192     }
    193 
    194     pango_layout_set_text(layout, utf8.data(), utf8.size());
    195   }
    196 
    197   ScopedPangoFontDescription desc(pango_font_description_from_string(
    198       font_list.GetFontDescriptionString().c_str()));
    199   pango_layout_set_font_description(layout, desc.get());
    200 }
    201 
    202 int GetPangoFontSizeInPixels(PangoFontDescription* pango_font) {
    203   // If the size is absolute, then it's in Pango units rather than points. There
    204   // are PANGO_SCALE Pango units in a device unit (pixel).
    205   if (pango_font_description_get_size_is_absolute(pango_font))
    206     return pango_font_description_get_size(pango_font) / PANGO_SCALE;
    207 
    208   // Otherwise, we need to convert from points.
    209   return static_cast<int>(GetPixelsInPoint() *
    210       pango_font_description_get_size(pango_font) / PANGO_SCALE + 0.5);
    211 }
    212 
    213 PangoFontMetrics* GetPangoFontMetrics(PangoFontDescription* desc) {
    214   static std::map<int, PangoFontMetrics*>* desc_to_metrics = NULL;
    215   static PangoContext* context = NULL;
    216 
    217   if (!context) {
    218     context = GetPangoContext();
    219     pango_context_set_language(context, pango_language_get_default());
    220   }
    221 
    222   if (!desc_to_metrics)
    223     desc_to_metrics = new std::map<int, PangoFontMetrics*>();
    224 
    225   const int desc_hash = pango_font_description_hash(desc);
    226   std::map<int, PangoFontMetrics*>::iterator i =
    227       desc_to_metrics->find(desc_hash);
    228 
    229   if (i == desc_to_metrics->end()) {
    230     PangoFontMetrics* metrics = pango_context_get_metrics(context, desc, NULL);
    231     desc_to_metrics->insert(std::make_pair(desc_hash, metrics));
    232     return metrics;
    233   }
    234   return i->second;
    235 }
    236 
    237 }  // namespace gfx
    238