diff options
Diffstat (limited to 'chromium/ui/gfx/pango_util.cc')
| -rw-r--r-- | chromium/ui/gfx/pango_util.cc | 416 |
1 files changed, 416 insertions, 0 deletions
diff --git a/chromium/ui/gfx/pango_util.cc b/chromium/ui/gfx/pango_util.cc new file mode 100644 index 00000000000..3f96d4b140d --- /dev/null +++ b/chromium/ui/gfx/pango_util.cc @@ -0,0 +1,416 @@ +// Copyright (c) 2012 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/pango_util.h" + +#include <cairo/cairo.h> +#include <fontconfig/fontconfig.h> +#include <pango/pango.h> +#include <pango/pangocairo.h> +#include <string> + +#include <algorithm> +#include <map> +#include <vector> + +#include "base/logging.h" +#include "base/strings/utf_string_conversions.h" +#include "ui/gfx/canvas.h" +#include "ui/gfx/font.h" +#include "ui/gfx/font_render_params_linux.h" +#include "ui/gfx/platform_font_pango.h" +#include "ui/gfx/rect.h" +#include "ui/gfx/text_utils.h" + +#if defined(TOOLKIT_GTK) +#include <gdk/gdk.h> +#endif + +namespace gfx { + +namespace { + +// Marker for accelerators in the text. +const gunichar kAcceleratorChar = '&'; + +// Multiply by the text height to determine how much text should be faded +// when elliding. +const double kFadeWidthFactor = 1.5; + +// End state of the elliding fade. +const double kFadeFinalAlpha = 0.15; + +// Return |cairo_font_options|. If needed, allocate and update it. +// TODO(derat): Return font-specific options: http://crbug.com/125235 +cairo_font_options_t* GetCairoFontOptions() { + // Font settings that we initialize once and then use when drawing text. + static cairo_font_options_t* cairo_font_options = NULL; + if (cairo_font_options) + return cairo_font_options; + + cairo_font_options = cairo_font_options_create(); + + const FontRenderParams& params = GetDefaultFontRenderParams(); + FontRenderParams::SubpixelRendering subpixel = params.subpixel_rendering; + if (!params.antialiasing) { + cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_NONE); + } else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_NONE) { + cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY); + } else { + cairo_font_options_set_antialias(cairo_font_options, + CAIRO_ANTIALIAS_SUBPIXEL); + cairo_subpixel_order_t cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT; + if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_RGB) + cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_RGB; + else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_BGR) + cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_BGR; + else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VRGB) + cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VRGB; + else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VBGR) + cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VBGR; + else + NOTREACHED() << "Unhandled subpixel rendering type " << subpixel; + cairo_font_options_set_subpixel_order(cairo_font_options, + cairo_subpixel_order); + } + + if (params.hinting == FontRenderParams::HINTING_NONE || + params.subpixel_positioning) { + cairo_font_options_set_hint_style(cairo_font_options, + CAIRO_HINT_STYLE_NONE); + cairo_font_options_set_hint_metrics(cairo_font_options, + CAIRO_HINT_METRICS_OFF); + } else { + cairo_hint_style_t cairo_hint_style = CAIRO_HINT_STYLE_DEFAULT; + if (params.hinting == FontRenderParams::HINTING_SLIGHT) + cairo_hint_style = CAIRO_HINT_STYLE_SLIGHT; + else if (params.hinting == FontRenderParams::HINTING_MEDIUM) + cairo_hint_style = CAIRO_HINT_STYLE_MEDIUM; + else if (params.hinting == FontRenderParams::HINTING_FULL) + cairo_hint_style = CAIRO_HINT_STYLE_FULL; + else + NOTREACHED() << "Unhandled hinting style " << params.hinting; + cairo_font_options_set_hint_style(cairo_font_options, cairo_hint_style); + cairo_font_options_set_hint_metrics(cairo_font_options, + CAIRO_HINT_METRICS_ON); + } + + return cairo_font_options; +} + +// Returns the number of pixels in a point. +// - multiply a point size by this to get pixels ("device units") +// - divide a pixel size by this to get points +float GetPixelsInPoint() { + static float pixels_in_point = 1.0; + static bool determined_value = false; + + if (!determined_value) { + // http://goo.gl/UIh5m: "This is a scale factor between points specified in + // a PangoFontDescription and Cairo units. The default value is 96, meaning + // that a 10 point font will be 13 units high. (10 * 96. / 72. = 13.3)." + double pango_dpi = GetPangoResolution(); + if (pango_dpi <= 0) + pango_dpi = 96.0; + pixels_in_point = pango_dpi / 72.0; // 72 points in an inch + determined_value = true; + } + + return pixels_in_point; +} + +} // namespace + +PangoContext* GetPangoContext() { +#if defined(TOOLKIT_GTK) + return gdk_pango_context_get(); +#else + PangoFontMap* font_map = pango_cairo_font_map_get_default(); + return pango_font_map_create_context(font_map); +#endif +} + +double GetPangoResolution() { + static double resolution; + static bool determined_resolution = false; + if (!determined_resolution) { + determined_resolution = true; + PangoContext* default_context = GetPangoContext(); + resolution = pango_cairo_context_get_resolution(default_context); + g_object_unref(default_context); + } + return resolution; +} + +void DrawTextOntoCairoSurface(cairo_t* cr, + const base::string16& text, + const gfx::Font& font, + const gfx::Rect& bounds, + const gfx::Rect& clip, + SkColor text_color, + int flags) { + PangoLayout* layout = pango_cairo_create_layout(cr); + base::i18n::TextDirection text_direction = + base::i18n::GetFirstStrongCharacterDirection(text); + DCHECK(!bounds.IsEmpty()); + + gfx::SetupPangoLayout( + layout, text, font, bounds.width(), text_direction, flags); + + pango_layout_set_height(layout, bounds.height() * PANGO_SCALE); + + cairo_save(cr); + cairo_rectangle(cr, clip.x(), clip.y(), clip.width(), clip.height()); + cairo_clip(cr); + + int width = 0, height = 0; + pango_layout_get_pixel_size(layout, &width, &height); + Rect text_rect(bounds.x(), bounds.y(), width, height); + // Vertically center |text_rect| in |bounds|. + text_rect += gfx::Vector2d(0, (bounds.height() - text_rect.height()) / 2); + + DrawPangoLayout(cr, layout, font, bounds, text_rect, + text_color, text_direction, flags); + + cairo_restore(cr); + g_object_unref(layout); +} + +// Pass a width greater than 0 to force wrapping and eliding. +static void SetupPangoLayoutWithoutFont( + PangoLayout* layout, + const base::string16& text, + int width, + base::i18n::TextDirection text_direction, + int flags) { + cairo_font_options_t* cairo_font_options = GetCairoFontOptions(); + + // If we got an explicit request to turn off subpixel rendering, disable it on + // a copy of the static font options object. + bool copied_cairo_font_options = false; + if ((flags & Canvas::NO_SUBPIXEL_RENDERING) && + (cairo_font_options_get_antialias(cairo_font_options) == + CAIRO_ANTIALIAS_SUBPIXEL)) { + cairo_font_options = cairo_font_options_copy(cairo_font_options); + copied_cairo_font_options = true; + cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY); + } + + // This needs to be done early on; it has no effect when called just before + // pango_cairo_show_layout(). + pango_cairo_context_set_font_options( + pango_layout_get_context(layout), cairo_font_options); + + if (copied_cairo_font_options) { + cairo_font_options_destroy(cairo_font_options); + cairo_font_options = NULL; + } + + // Set Pango's base text direction explicitly from |text_direction|. + pango_layout_set_auto_dir(layout, FALSE); + pango_context_set_base_dir(pango_layout_get_context(layout), + (text_direction == base::i18n::RIGHT_TO_LEFT ? + PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR)); + + if (width > 0) + pango_layout_set_width(layout, width * PANGO_SCALE); + + if (flags & Canvas::TEXT_ALIGN_CENTER) { + // We don't support center aligned w/ eliding. + DCHECK(gfx::Canvas::NO_ELLIPSIS); + pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); + } else if (flags & Canvas::TEXT_ALIGN_RIGHT) { + pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT); + } + + if (flags & Canvas::NO_ELLIPSIS) { + pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE); + if (flags & Canvas::MULTI_LINE) { + pango_layout_set_wrap(layout, + (flags & Canvas::CHARACTER_BREAK) ? + PANGO_WRAP_WORD_CHAR : PANGO_WRAP_WORD); + } + } else if (text_direction == base::i18n::RIGHT_TO_LEFT) { + pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END); + } else { + // Fading the text will be handled in the draw operation. + // Ensure that the text is only on one line. + pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE); + pango_layout_set_width(layout, -1); + } + + // Set the resolution to match that used by Gtk. If we don't set the + // resolution and the resolution differs from the default, Gtk and Chrome end + // up drawing at different sizes. + double resolution = GetPangoResolution(); + if (resolution > 0) { + pango_cairo_context_set_resolution(pango_layout_get_context(layout), + resolution); + } + + // Set text and accelerator character if needed. + if (flags & Canvas::SHOW_PREFIX) { + // Escape the text string to be used as markup. + std::string utf8 = UTF16ToUTF8(text); + gchar* escaped_text = g_markup_escape_text(utf8.c_str(), utf8.size()); + pango_layout_set_markup_with_accel(layout, + escaped_text, + strlen(escaped_text), + kAcceleratorChar, NULL); + g_free(escaped_text); + } else { + std::string utf8; + + // Remove the ampersand character. A double ampersand is output as + // a single ampersand. + if (flags & Canvas::HIDE_PREFIX) { + DCHECK_EQ(1, g_unichar_to_utf8(kAcceleratorChar, NULL)); + base::string16 accelerator_removed = + RemoveAcceleratorChar(text, static_cast<char16>(kAcceleratorChar), + NULL, NULL); + utf8 = UTF16ToUTF8(accelerator_removed); + } else { + utf8 = UTF16ToUTF8(text); + } + + pango_layout_set_text(layout, utf8.data(), utf8.size()); + } +} + +void SetupPangoLayout(PangoLayout* layout, + const base::string16& text, + const Font& font, + int width, + base::i18n::TextDirection text_direction, + int flags) { + SetupPangoLayoutWithoutFont(layout, text, width, text_direction, flags); + + ScopedPangoFontDescription desc(font.GetNativeFont()); + pango_layout_set_font_description(layout, desc.get()); +} + +void SetupPangoLayoutWithFontDescription( + PangoLayout* layout, + const base::string16& text, + const std::string& font_description, + int width, + base::i18n::TextDirection text_direction, + int flags) { + SetupPangoLayoutWithoutFont(layout, text, width, text_direction, flags); + + ScopedPangoFontDescription desc( + pango_font_description_from_string(font_description.c_str())); + pango_layout_set_font_description(layout, desc.get()); +} + +void DrawPangoLayout(cairo_t* cr, + PangoLayout* layout, + const Font& font, + const gfx::Rect& bounds, + const gfx::Rect& text_rect, + SkColor text_color, + base::i18n::TextDirection text_direction, + int flags) { + double r = SkColorGetR(text_color) / 255.0, + g = SkColorGetG(text_color) / 255.0, + b = SkColorGetB(text_color) / 255.0, + a = SkColorGetA(text_color) / 255.0; + + cairo_pattern_t* pattern = NULL; + + cairo_save(cr); + + // If we're not eliding, use a fixed color. + // Otherwise, create a gradient pattern to use as the source. + if (text_direction == base::i18n::RIGHT_TO_LEFT || + (flags & gfx::Canvas::NO_ELLIPSIS) || + text_rect.width() <= bounds.width()) { + cairo_set_source_rgba(cr, r, g, b, a); + } else { + // Fade to semi-transparent to elide. + int fade_width = static_cast<double>(text_rect.height()) * kFadeWidthFactor; + if (fade_width > bounds.width() / 2) { + // Don't fade more than half the text. + fade_width = bounds.width() / 2; + } + int fade_x = bounds.x() + bounds.width() - fade_width; + + pattern = cairo_pattern_create_linear( + fade_x, bounds.y(), bounds.x() + bounds.width(), bounds.y()); + cairo_pattern_add_color_stop_rgba(pattern, 0, r, g, b, a); + cairo_pattern_add_color_stop_rgba(pattern, 1, r, g, b, kFadeFinalAlpha); + cairo_set_source(cr, pattern); + } + + cairo_move_to(cr, text_rect.x(), text_rect.y()); + pango_cairo_show_layout(cr, layout); + + if (font.GetStyle() & gfx::Font::UNDERLINE) { + gfx::PlatformFontPango* platform_font = + static_cast<gfx::PlatformFontPango*>(font.platform_font()); + DrawPangoTextUnderline(cr, platform_font, 0.0, text_rect); + } + + if (pattern) + cairo_pattern_destroy(pattern); + + cairo_restore(cr); +} + +void DrawPangoTextUnderline(cairo_t* cr, + gfx::PlatformFontPango* platform_font, + double extra_edge_width, + const Rect& text_rect) { + const double underline_y = + static_cast<double>(text_rect.y()) + text_rect.height() + + platform_font->underline_position(); + cairo_set_line_width( + cr, platform_font->underline_thickness() + 2 * extra_edge_width); + cairo_move_to(cr, + text_rect.x() - extra_edge_width, + underline_y); + cairo_line_to(cr, + text_rect.x() + text_rect.width() + extra_edge_width, + underline_y); + cairo_stroke(cr); +} + +size_t GetPangoFontSizeInPixels(PangoFontDescription* pango_font) { + size_t size_in_pixels = pango_font_description_get_size(pango_font); + if (pango_font_description_get_size_is_absolute(pango_font)) { + // If the size is absolute, then it's in Pango units rather than points. + // There are PANGO_SCALE Pango units in a device unit (pixel). + size_in_pixels /= PANGO_SCALE; + } else { + // Otherwise, we need to convert from points. + size_in_pixels = size_in_pixels * GetPixelsInPoint() / PANGO_SCALE; + } + return size_in_pixels; +} + +PangoFontMetrics* GetPangoFontMetrics(PangoFontDescription* desc) { + static std::map<int, PangoFontMetrics*>* desc_to_metrics = NULL; + static PangoContext* context = NULL; + + if (!context) { + context = GetPangoContext(); + pango_context_set_language(context, pango_language_get_default()); + } + + if (!desc_to_metrics) + desc_to_metrics = new std::map<int, PangoFontMetrics*>(); + + const int desc_hash = pango_font_description_hash(desc); + std::map<int, PangoFontMetrics*>::iterator i = + desc_to_metrics->find(desc_hash); + + if (i == desc_to_metrics->end()) { + PangoFontMetrics* metrics = pango_context_get_metrics(context, desc, NULL); + desc_to_metrics->insert(std::make_pair(desc_hash, metrics)); + return metrics; + } + return i->second; +} + +} // namespace gfx |