ui/gfx/platform_font_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/platform_font_pango.h"
   6
   7 #include <pango/pango.h>
   8
   9 #include <algorithm>
  10 #include <string>
  11
  12 #include "base/logging.h"
  13 #include "base/strings/string_piece.h"
  14 #include "base/strings/string_split.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "third_party/skia/include/core/SkPaint.h"
  17 #include "third_party/skia/include/core/SkString.h"
  18 #include "third_party/skia/include/core/SkTypeface.h"
  19 #include "ui/gfx/canvas.h"
  20 #include "ui/gfx/font.h"
  21 #include "ui/gfx/font_list.h"
  22 #include "ui/gfx/linux_font_delegate.h"
  23 #include "ui/gfx/pango_util.h"
  24 #include "ui/gfx/text_utils.h"
  25
  26 namespace {
  27
  28 // The font family name which is used when a user's application font for
  29 // GNOME/KDE is a non-scalable one. The name should be listed in the
  30 // IsFallbackFontAllowed function in skia/ext/SkFontHost_fontconfig_direct.cpp.
  31 const char* kFallbackFontFamilyName = "sans";
  32
  33 // Creates a SkTypeface for the passed-in Font::FontStyle and family. If a
  34 // fallback typeface is used instead of the requested family, |family| will be
  35 // updated to contain the fallback's family name.
  36 skia::RefPtr<SkTypeface> CreateSkTypeface(int style, std::string* family) {
  37   DCHECK(family);
  38
  39   int skia_style = SkTypeface::kNormal;
  40   if (gfx::Font::BOLD & style)
  41     skia_style |= SkTypeface::kBold;
  42   if (gfx::Font::ITALIC & style)
  43     skia_style |= SkTypeface::kItalic;
  44
  45   skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(SkTypeface::CreateFromName(
  46       family->c_str(), static_cast<SkTypeface::Style>(skia_style)));
  47   if (!typeface) {
  48     // A non-scalable font such as .pcf is specified. Fall back to a default
  49     // scalable font.
  50     typeface = skia::AdoptRef(SkTypeface::CreateFromName(
  51         kFallbackFontFamilyName, static_cast<SkTypeface::Style>(skia_style)));
  52     CHECK(typeface) << "Could not find any font: " << family << ", "
  53                     << kFallbackFontFamilyName;
  54     *family = kFallbackFontFamilyName;
  55   }
  56   return typeface;
  57 }
  58
  59 }  // namespace
  60
  61 namespace gfx {
  62
  63 // static
  64 Font* PlatformFontPango::default_font_ = NULL;
  65
  66 #if defined(OS_CHROMEOS)
  67 // static
  68 std::string* PlatformFontPango::default_font_description_ = NULL;
  69 #endif
  70
  71 ////////////////////////////////////////////////////////////////////////////////
  72 // PlatformFontPango, public:
  73
  74 PlatformFontPango::PlatformFontPango() {
  75   if (!default_font_) {
  76     scoped_ptr<ScopedPangoFontDescription> description;
  77 #if defined(OS_CHROMEOS)
  78     CHECK(default_font_description_);
  79     description.reset(
  80         new ScopedPangoFontDescription(*default_font_description_));
  81 #else
  82     const gfx::LinuxFontDelegate* delegate = gfx::LinuxFontDelegate::instance();
  83     if (delegate)
  84       description = delegate->GetDefaultPangoFontDescription();
  85 #endif
  86     if (!description || !description->get())
  87       description.reset(new ScopedPangoFontDescription("sans 10"));
  88     default_font_ = new Font(description->get());
  89   }
  90
  91   InitFromPlatformFont(
  92       static_cast<PlatformFontPango*>(default_font_->platform_font()));
  93 }
  94
  95 PlatformFontPango::PlatformFontPango(NativeFont native_font) {
  96   FontRenderParamsQuery query(false);
  97   base::SplitString(pango_font_description_get_family(native_font), ',',
  98                     &query.families);
  99
 100   const int pango_size =
 101       pango_font_description_get_size(native_font) / PANGO_SCALE;
 102   if (pango_font_description_get_size_is_absolute(native_font))
 103     query.pixel_size = pango_size;
 104   else
 105     query.point_size = pango_size;
 106
 107   query.style = gfx::Font::NORMAL;
 108   // TODO(davemoore): Support weights other than bold?
 109   if (pango_font_description_get_weight(native_font) == PANGO_WEIGHT_BOLD)
 110     query.style |= gfx::Font::BOLD;
 111   // TODO(davemoore): What about PANGO_STYLE_OBLIQUE?
 112   if (pango_font_description_get_style(native_font) == PANGO_STYLE_ITALIC)
 113     query.style |= gfx::Font::ITALIC;
 114
 115   std::string font_family;
 116   const FontRenderParams params = gfx::GetFontRenderParams(query, &font_family);
 117   InitFromDetails(skia::RefPtr<SkTypeface>(), font_family,
 118                   gfx::GetPangoFontSizeInPixels(native_font),
 119                   query.style, params);
 120 }
 121
 122 PlatformFontPango::PlatformFontPango(const std::string& font_name,
 123                                      int font_size_pixels) {
 124   FontRenderParamsQuery query(false);
 125   query.families.push_back(font_name);
 126   query.pixel_size = font_size_pixels;
 127   query.style = gfx::Font::NORMAL;
 128   InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size_pixels,
 129                   query.style, gfx::GetFontRenderParams(query, NULL));
 130 }
 131
 132 ////////////////////////////////////////////////////////////////////////////////
 133 // PlatformFontPango, PlatformFont implementation:
 134
 135 // static
 136 void PlatformFontPango::ReloadDefaultFont() {
 137   delete default_font_;
 138   default_font_ = NULL;
 139 }
 140
 141 #if defined(OS_CHROMEOS)
 142 // static
 143 void PlatformFontPango::SetDefaultFontDescription(
 144     const std::string& font_description) {
 145   delete default_font_description_;
 146   default_font_description_ = new std::string(font_description);
 147 }
 148
 149 #endif
 150
 151 Font PlatformFontPango::DeriveFont(int size_delta, int style) const {
 152   const int new_size = font_size_pixels_ + size_delta;
 153   DCHECK_GT(new_size, 0);
 154
 155   // If the style changed, we may need to load a new face.
 156   std::string new_family = font_family_;
 157   skia::RefPtr<SkTypeface> typeface =
 158       (style == style_) ? typeface_ : CreateSkTypeface(style, &new_family);
 159
 160   FontRenderParamsQuery query(false);
 161   query.families.push_back(new_family);
 162   query.pixel_size = new_size;
 163   query.style = style;
 164
 165   return Font(new PlatformFontPango(typeface, new_family, new_size, style,
 166                                     gfx::GetFontRenderParams(query, NULL)));
 167 }
 168
 169 int PlatformFontPango::GetHeight() const {
 170   return height_pixels_;
 171 }
 172
 173 int PlatformFontPango::GetBaseline() const {
 174   return ascent_pixels_;
 175 }
 176
 177 int PlatformFontPango::GetCapHeight() const {
 178   return cap_height_pixels_;
 179 }
 180
 181 int PlatformFontPango::GetExpectedTextWidth(int length) const {
 182   double char_width = const_cast<PlatformFontPango*>(this)->GetAverageWidth();
 183   return round(static_cast<float>(length) * char_width);
 184 }
 185
 186 int PlatformFontPango::GetStyle() const {
 187   return style_;
 188 }
 189
 190 std::string PlatformFontPango::GetFontName() const {
 191   return font_family_;
 192 }
 193
 194 std::string PlatformFontPango::GetActualFontNameForTesting() const {
 195   SkString family_name;
 196   typeface_->getFamilyName(&family_name);
 197   return family_name.c_str();
 198 }
 199
 200 int PlatformFontPango::GetFontSize() const {
 201   return font_size_pixels_;
 202 }
 203
 204 const FontRenderParams& PlatformFontPango::GetFontRenderParams() const {
 205   return font_render_params_;
 206 }
 207
 208 NativeFont PlatformFontPango::GetNativeFont() const {
 209   PangoFontDescription* pfd = pango_font_description_new();
 210   pango_font_description_set_family(pfd, GetFontName().c_str());
 211   // Set the absolute size to avoid overflowing UI elements.
 212   // pango_font_description_set_absolute_size() takes a size in Pango units.
 213   // There are PANGO_SCALE Pango units in one device unit.  Screen output
 214   // devices use pixels as their device units.
 215   pango_font_description_set_absolute_size(
 216       pfd, font_size_pixels_ * PANGO_SCALE);
 217
 218   switch (GetStyle()) {
 219     case gfx::Font::NORMAL:
 220       // Nothing to do, should already be PANGO_STYLE_NORMAL.
 221       break;
 222     case gfx::Font::BOLD:
 223       pango_font_description_set_weight(pfd, PANGO_WEIGHT_BOLD);
 224       break;
 225     case gfx::Font::ITALIC:
 226       pango_font_description_set_style(pfd, PANGO_STYLE_ITALIC);
 227       break;
 228     case gfx::Font::UNDERLINE:
 229       // TODO(deanm): How to do underline?  Where do we use it?  Probably have
 230       // to paint it ourselves, see pango_font_metrics_get_underline_position.
 231       break;
 232   }
 233
 234   return pfd;
 235 }
 236
 237 ////////////////////////////////////////////////////////////////////////////////
 238 // PlatformFontPango, private:
 239
 240 PlatformFontPango::PlatformFontPango(const skia::RefPtr<SkTypeface>& typeface,
 241                                      const std::string& name,
 242                                      int size_pixels,
 243                                      int style,
 244                                      const FontRenderParams& render_params) {
 245   InitFromDetails(typeface, name, size_pixels, style, render_params);
 246 }
 247
 248 PlatformFontPango::~PlatformFontPango() {}
 249
 250 void PlatformFontPango::InitFromDetails(
 251     const skia::RefPtr<SkTypeface>& typeface,
 252     const std::string& font_family,
 253     int font_size_pixels,
 254     int style,
 255     const FontRenderParams& render_params) {
 256   DCHECK_GT(font_size_pixels, 0);
 257
 258   font_family_ = font_family;
 259   typeface_ = typeface ? typeface : CreateSkTypeface(style, &font_family_);
 260
 261   font_size_pixels_ = font_size_pixels;
 262   style_ = style;
 263   font_render_params_ = render_params;
 264
 265   SkPaint paint;
 266   SkPaint::FontMetrics metrics;
 267   PaintSetup(&paint);
 268   paint.getFontMetrics(&metrics);
 269   ascent_pixels_ = SkScalarCeilToInt(-metrics.fAscent);
 270   height_pixels_ = ascent_pixels_ + SkScalarCeilToInt(metrics.fDescent);
 271   cap_height_pixels_ = SkScalarCeilToInt(metrics.fCapHeight);
 272
 273   pango_metrics_inited_ = false;
 274   average_width_pixels_ = 0.0f;
 275 }
 276
 277 void PlatformFontPango::InitFromPlatformFont(const PlatformFontPango* other) {
 278   typeface_ = other->typeface_;
 279   font_family_ = other->font_family_;
 280   font_size_pixels_ = other->font_size_pixels_;
 281   style_ = other->style_;
 282   font_render_params_ = other->font_render_params_;
 283   ascent_pixels_ = other->ascent_pixels_;
 284   height_pixels_ = other->height_pixels_;
 285   cap_height_pixels_ = other->cap_height_pixels_;
 286   pango_metrics_inited_ = other->pango_metrics_inited_;
 287   average_width_pixels_ = other->average_width_pixels_;
 288 }
 289
 290 void PlatformFontPango::PaintSetup(SkPaint* paint) const {
 291   paint->setAntiAlias(false);
 292   paint->setSubpixelText(false);
 293   paint->setTextSize(font_size_pixels_);
 294   paint->setTypeface(typeface_.get());
 295   paint->setFakeBoldText((gfx::Font::BOLD & style_) && !typeface_->isBold());
 296   paint->setTextSkewX((gfx::Font::ITALIC & style_) && !typeface_->isItalic() ?
 297                       -SK_Scalar1/4 : 0);
 298 }
 299
 300 void PlatformFontPango::InitPangoMetrics() {
 301   if (!pango_metrics_inited_) {
 302     pango_metrics_inited_ = true;
 303     ScopedPangoFontDescription pango_desc(GetNativeFont());
 304     PangoFontMetrics* pango_metrics = GetPangoFontMetrics(pango_desc.get());
 305
 306     // First get the Pango-based width (converting from Pango units to pixels).
 307     const double pango_width_pixels =
 308         pango_font_metrics_get_approximate_char_width(pango_metrics) /
 309         PANGO_SCALE;
 310
 311     // Yes, this is how Microsoft recommends calculating the dialog unit
 312     // conversions.
 313     const int text_width_pixels = GetStringWidth(
 314         base::ASCIIToUTF16(
 315             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"),
 316         FontList(Font(this)));
 317     const double dialog_units_pixels = (text_width_pixels / 26 + 1) / 2;
 318     average_width_pixels_ = std::min(pango_width_pixels, dialog_units_pixels);
 319   }
 320 }
 321
 322 double PlatformFontPango::GetAverageWidth() const {
 323   const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
 324   return average_width_pixels_;
 325 }
 326
 327 ////////////////////////////////////////////////////////////////////////////////
 328 // PlatformFont, public:
 329
 330 // static
 331 PlatformFont* PlatformFont::CreateDefault() {
 332   return new PlatformFontPango;
 333 }
 334
 335 // static
 336 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
 337   return new PlatformFontPango(native_font);
 338 }
 339
 340 // static
 341 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
 342                                                   int font_size) {
 343   return new PlatformFontPango(font_name, font_size);
 344 }
 345
 346 }  // namespace gfx