Implement Pango RenderText for Linux.

ui/gfx/gtk_util.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/gtk_util.h"
 
+#include <cairo/cairo.h>
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
+#include <pango/pango.h>
+#include <pango/pangocairo.h>
 #include <stdlib.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/linux_util.h"
+#include "base/logging.h"
+#include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/skia_util.h"
+#include "ui/gfx/font.h"
 #include "ui/gfx/rect.h"
 
 namespace {
 
 // A process wide singleton that manages our usage of gdk
 // cursors. gdk_cursor_new() hits the disk in several places and GdkCursor
 // instances can be reused throughout the process.
 class GdkCursorCache {
  public:
    GdkCursorCache() {}
@@ skipping 50 matching lines @@
         ret.append(target);
       }
     } else {
       ret.push_back(label[i]);
     }
   }
 
   return ret;
 }
 
+const gunichar kAcceleratorChar = '&';

[msw, 2011/08/23 08:01:01]

I think constants are usually defined above all functions in cc files.
Also, give it a comment.

[xji, 2011/08/23 23:52:52]

done comment.
moved those to pango_util

+
+// Font settings that we initialize once and then use when drawing text in
+// DrawStringInt().
+cairo_font_options_t* cairo_font_options = NULL;

[msw, 2011/08/23 08:01:01]

Can you make this a function static in UpdateCairoFontOptions rather than a
global? You can have UpdateCairoFontOptions return the pointer or its value for
SetupPangoLayout (and I suppose you should rename UpdateCairoFontOptions to
GetCairoFontOptions or something).

[xji, 2011/08/23 23:52:52]

this is defined in unnamed scope, so should be the same as file scoped static.

UpdateCairoFontOptions creates cairo_font_options_t and set attributes on it,
not only Get it.

+
+// Update |cairo_font_options| based on GtkSettings, allocating it if needed.
+void UpdateCairoFontOptions() {
+  if (!cairo_font_options)
+    cairo_font_options = cairo_font_options_create();
+
+  gint antialias = 0;
+  gint hinting = 0;
+  gchar* hint_style = NULL;
+  gchar* rgba_style = NULL;
+
+#if !defined(USE_WAYLAND)
+  GtkSettings* gtk_settings = gtk_settings_get_default();

[xji, 2011/08/23 23:52:52]

hm.. this has gtk dependency. Oshima, could you check whether this cause
problem?

+  g_object_get(gtk_settings,
+               "gtk-xft-antialias", &antialias,
+               "gtk-xft-hinting", &hinting,
+               "gtk-xft-hintstyle", &hint_style,
+               "gtk-xft-rgba", &rgba_style,
+               NULL);
+#endif
+
+  // g_object_get() doesn't tell us whether the properties were present or not,
+  // but if they aren't (because gnome-settings-daemon isn't running), we'll get
+  // NULL values for the strings.
+  if (hint_style && rgba_style) {
+    if (!antialias) {
+      cairo_font_options_set_antialias(cairo_font_options,
+                                       CAIRO_ANTIALIAS_NONE);
+    } else if (strcmp(rgba_style, "none") == 0) {
+      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 (strcmp(rgba_style, "rgb") == 0) {
+        cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_RGB;
+      } else if (strcmp(rgba_style, "bgr") == 0) {
+        cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_BGR;
+      } else if (strcmp(rgba_style, "vrgb") == 0) {
+        cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VRGB;
+      } else if (strcmp(rgba_style, "vbgr") == 0) {
+        cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VBGR;
+      }
+      cairo_font_options_set_subpixel_order(cairo_font_options,
+                                            cairo_subpixel_order);
+    }
+
+    cairo_hint_style_t cairo_hint_style = CAIRO_HINT_STYLE_DEFAULT;
+    if (hinting == 0 || strcmp(hint_style, "hintnone") == 0) {
+      cairo_hint_style = CAIRO_HINT_STYLE_NONE;
+    } else if (strcmp(hint_style, "hintslight") == 0) {
+      cairo_hint_style = CAIRO_HINT_STYLE_SLIGHT;
+    } else if (strcmp(hint_style, "hintmedium") == 0) {
+      cairo_hint_style = CAIRO_HINT_STYLE_MEDIUM;
+    } else if (strcmp(hint_style, "hintfull") == 0) {
+      cairo_hint_style = CAIRO_HINT_STYLE_FULL;
+    }
+    cairo_font_options_set_hint_style(cairo_font_options, cairo_hint_style);
+  }
+
+  if (hint_style)
+    g_free(hint_style);
+  if (rgba_style)
+    g_free(rgba_style);
+}
 }  // namespace

[msw, 2011/08/23 08:01:01]

Add a blank line here.

[xji, 2011/08/23 23:52:52]

Done.

 
 namespace gfx {
 
 void GtkInitFromCommandLine(const CommandLine& command_line) {
   const std::vector<std::string>& args = command_line.argv();
   int argc = args.size();
   scoped_array<char *> argv(new char *[argc + 1]);
   for (size_t i = 0; i < args.size(); ++i) {
     // TODO(piman@google.com): can gtk_init modify argv? Just being safe
     // here.
@@ skipping 60 matching lines @@
                                   const std::vector<Rect>& cutouts) {
   for (size_t i = 0; i < cutouts.size(); ++i) {
     GdkRectangle rect = cutouts[i].ToGdkRectangle();
     GdkRegion* rect_region = gdk_region_rectangle(&rect);
     gdk_region_subtract(region, rect_region);
     // TODO(deanm): It would be nice to be able to reuse the GdkRegion here.
     gdk_region_destroy(rect_region);
   }
 }
 
+// Pass a width > 0 to force wrapping and elliding.

[msw, 2011/08/23 08:01:01]

remove the extra L from "eliding"; use the phrase "greater than" instead of '>'.

[xji, 2011/08/23 23:52:52]

Done.

+void SetupPangoLayout(PangoLayout* layout,
+                      const string16& text,
+                      const Font& font,
+                      int width,
+                      base::i18n::TextDirection text_direction,
+                      int flags) {
+  if (!cairo_font_options)
+    UpdateCairoFontOptions();
+  // 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);
+
+  // Callers of DrawStringInt handle RTL layout themselves, so tell pango to not
+  // scope out RTL characters.
+  pango_layout_set_auto_dir(layout, FALSE);
+
+  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);
+  }
+
+  PangoFontDescription* desc = font.GetNativeFont();
+  pango_layout_set_font_description(layout, desc);
+  pango_font_description_free(desc);
+
+  // Set text and accelerator character if needed.
+  std::string utf8 = UTF16ToUTF8(text);
+  if (flags & Canvas::SHOW_PREFIX) {
+    // Escape the text string to be used as markup.
+    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 if (flags & Canvas::HIDE_PREFIX) {
+    // Remove the ampersand character.  A double ampersand is output as
+    // a single ampersand.
+    DCHECK_EQ(1, g_unichar_to_utf8(kAcceleratorChar, NULL));
+    const std::string accelerator_removed =
+        RemoveAcceleratorChar(utf8, static_cast<char>(kAcceleratorChar));
+
+    pango_layout_set_text(layout,
+        accelerator_removed.data(), accelerator_removed.size());
+  } else {
+    pango_layout_set_text(layout, utf8.data(), utf8.size());
+  }
+}
+
 PangoContext* GetPangoContext() {
 #if defined(USE_WAYLAND)
   PangoFontMap* font_map = pango_cairo_font_map_get_default();
   PangoContext* default_context = pango_font_map_create_context(font_map);
 #else
   PangoContext* default_context = gdk_pango_context_get();
 #endif
   return default_context;
 }
 
@@ skipping 36 matching lines @@
       new_pixels[idx + 1] = pixels[idx + 1];
       new_pixels[idx + 2] = pixels[idx];
       new_pixels[idx + 3] = pixels[idx + 3];
     }
   }
 
   return new_pixels;
 }
 
 }  // namespace gfx