static void
gst_time_overlay_init (GstTimeOverlay * overlay, GstTimeOverlayClass * klass)
{
PangoFontDescription *font_description;
GstTextOverlay *textoverlay;
PangoContext *context;
textoverlay = GST_TEXT_OVERLAY (overlay);
context = GST_TEXT_OVERLAY_CLASS (klass)->pango_context;
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family_static (font_description, "Monospace");
pango_font_description_set_style (font_description, PANGO_STYLE_NORMAL);
pango_font_description_set_variant (font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight (font_description, PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch (font_description, PANGO_STRETCH_NORMAL);
pango_font_description_set_size (font_description, 18 * PANGO_SCALE);
pango_context_set_font_description (context, font_description);
pango_font_description_free (font_description);
textoverlay->valign = GST_TEXT_OVERLAY_VALIGN_TOP;
textoverlay->halign = GST_TEXT_OVERLAY_HALIGN_LEFT;
}
/*! DEPRECATED: there should be only one "measure context" */
void
dia_font_pop_context() {
g_object_unref(pango_context);
pango_context = (PangoContext*)pango_contexts->data;
pango_context_set_language (pango_context, gtk_get_default_language ());
pango_contexts = g_list_next(pango_contexts);
}
static bool
pango_load (Lisp_Font *f)
{
PangoLanguage *language;
PangoFontDescription *fontdesc;
PangoFont *font;
PangoFontMetrics *metrics;
if (pango_context)
{
language = pango_context_get_language (pango_context);
}
else
{
char *langname, *p;
#ifdef HAVE_PANGO_XFT
pango_context = pango_xft_get_context (dpy, screen_num);
#endif
langname = g_strdup (setlocale (LC_CTYPE, NULL));
p = strchr (langname, '.');
if (p)
*p = 0;
p = strchr (langname, '@');
if (p)
*p = 0;
language = pango_language_from_string (langname);
pango_context_set_language (pango_context, language);
g_free (langname);
}
fontdesc = pango_font_description_from_string (rep_STR (f->name));
if (!pango_font_description_get_family (fontdesc))
pango_font_description_set_family (fontdesc, "Sans");
if (pango_font_description_get_size (fontdesc) <= 0)
pango_font_description_set_size (fontdesc, 12 * PANGO_SCALE);
pango_context_set_font_description (pango_context, fontdesc);
font = pango_context_load_font (pango_context, fontdesc);
if (!font) {
pango_font_description_free(fontdesc);
return FALSE;
}
metrics = pango_font_get_metrics (font, language);
f->ascent = metrics->ascent / PANGO_SCALE;
f->descent = metrics->descent / PANGO_SCALE;
pango_font_metrics_unref (metrics);
f->font = fontdesc; /* We save the font description, not the font itself!
That's because it seems we can't recover it perfectly
later, and the layout routines want a description */
return TRUE;
}
static void
gst_time_overlay_class_init (GstTimeOverlayClass * klass)
{
GstTextOverlayClass *gsttextoverlay_class;
PangoContext *context;
PangoFontDescription *font_description;
gsttextoverlay_class = (GstTextOverlayClass *) klass;
gsttextoverlay_class->get_text = gst_time_overlay_get_text;
g_mutex_lock (GST_TEXT_OVERLAY_CLASS (klass)->pango_lock);
context = GST_TEXT_OVERLAY_CLASS (klass)->pango_context;
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family_static (font_description, "Monospace");
pango_font_description_set_style (font_description, PANGO_STYLE_NORMAL);
pango_font_description_set_variant (font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight (font_description, PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch (font_description, PANGO_STRETCH_NORMAL);
pango_font_description_set_size (font_description, 18 * PANGO_SCALE);
pango_context_set_font_description (context, font_description);
pango_font_description_free (font_description);
g_mutex_unlock (GST_TEXT_OVERLAY_CLASS (klass)->pango_lock);
}
static void
workrave_timebar_init_ui(WorkraveTimebar *self)
{
WorkraveTimebarPrivate *priv = WORKRAVE_TIMEBAR_GET_PRIVATE(self);
priv->style_context = gtk_style_context_new();
GtkWidgetPath *path = gtk_widget_path_new();
gtk_widget_path_append_type(path, GTK_TYPE_BUTTON);
gtk_style_context_set_path(priv->style_context, path);
gtk_style_context_add_class(priv->style_context, GTK_STYLE_CLASS_TROUGH);
GdkScreen *screen = gdk_screen_get_default();
priv->pango_context = gdk_pango_context_get_for_screen(screen);
const PangoFontDescription *font_desc = gtk_style_context_get_font(priv->style_context, GTK_STATE_FLAG_ACTIVE);
pango_context_set_language(priv->pango_context, gtk_get_default_language());
pango_context_set_font_description(priv->pango_context, font_desc);
priv->pango_layout = pango_layout_new(priv->pango_context);
pango_layout_set_text(priv->pango_layout, "-9:59:59", -1);
pango_layout_get_pixel_size(priv->pango_layout, &priv->width, &priv->height);
priv->width = MAX(priv->width + 2 * MARGINX, MIN_HORIZONTAL_BAR_WIDTH);
priv->height = MAX(priv->height + 2 * MARGINY, MIN_HORIZONTAL_BAR_HEIGHT);
gtk_widget_path_free(path);
}
/*! DEPRECATED: there should be only one "measure context" */
void
dia_font_push_context(PangoContext *pcontext)
{
pango_contexts = g_list_prepend(pango_contexts, pango_context);
pango_context = pcontext;
pango_context_set_language (pango_context, gtk_get_default_language ());
g_object_ref(pcontext);
}
/*! DEPRECATED: there should be only one "measure context" */
void
dia_font_push_context(PangoContext *pcontext)
{
dia_font_init (pcontext); /* not needed, just testing */
pango_contexts = g_list_prepend(pango_contexts, pango_context);
pango_context = pcontext;
pango_context_set_language (pango_context, gtk_get_default_language ());
g_object_ref(pcontext);
}
cdCtxCanvas *cdgdkCreateCanvas(cdCanvas* canvas, GdkDrawable* wnd, GdkScreen* scr, GdkVisual* vis)
{
cdCtxCanvas *ctxcanvas = (cdCtxCanvas *)malloc(sizeof(cdCtxCanvas));
memset(ctxcanvas, 0, sizeof(cdCtxCanvas));
ctxcanvas->scr = scr;
ctxcanvas->vis = vis;
ctxcanvas->wnd = wnd;
ctxcanvas->gc = gdk_gc_new(wnd);
if (!ctxcanvas->gc)
{
free(canvas);
return NULL;
}
ctxcanvas->fontcontext = gdk_pango_context_get();
#if PANGO_VERSION_CHECK(1,16,0)
pango_context_set_language(ctxcanvas->fontcontext, pango_language_get_default());
#endif
ctxcanvas->canvas = canvas;
canvas->ctxcanvas = ctxcanvas;
gdk_drawable_get_size(wnd, &ctxcanvas->canvas->w, &ctxcanvas->canvas->h);
ctxcanvas->depth = gdk_drawable_get_depth(wnd);
canvas->bpp = ctxcanvas->depth;
canvas->xres = ((double)gdk_screen_get_width(scr) / (double)gdk_screen_get_width_mm(scr));
canvas->yres = ((double)gdk_screen_get_height(scr) / (double)gdk_screen_get_height_mm(scr));
canvas->w_mm = ((double)canvas->w) / canvas->xres;
canvas->h_mm = ((double)canvas->h) / canvas->yres;
canvas->invert_yaxis = 1;
if (canvas->bpp <= 8)
{
ctxcanvas->colormap = gdk_gc_get_colormap(ctxcanvas->gc);
if (!ctxcanvas->colormap)
{
ctxcanvas->colormap = gdk_colormap_get_system();
gdk_gc_set_colormap(ctxcanvas->gc, ctxcanvas->colormap);
}
ctxcanvas->num_colors = ctxcanvas->colormap->size;
}
cdRegisterAttribute(canvas, &gc_attrib);
cdRegisterAttribute(canvas, &rotate_attrib);
cdRegisterAttribute(canvas, &pangoversion_attrib);
cdRegisterAttribute(canvas, &imgdither_attrib);
cdRegisterAttribute(canvas, &interp_attrib);
return ctxcanvas;
}
void wxMemoryDC::Init()
{
m_ok = false;
m_cmap = gtk_widget_get_default_colormap();
m_context = gdk_pango_context_get();
// Note: The Sun customised version of Pango shipping with Solaris 10
// crashes if the language is left NULL (see bug 1374114)
pango_context_set_language( m_context, gtk_get_default_language() );
m_layout = pango_layout_new( m_context );
m_fontdesc = pango_font_description_copy( pango_context_get_font_description( m_context ) );
}
static void
gst_imx_g2d_time_overlay_class_init (GstImxG2DTimeOverlayClass * klass)
{
GstElementClass *gstelement_class;
GstImxG2DBaseTextOverlayClass *gsttextoverlay_class;
GObjectClass *gobject_class;
PangoContext *context;
PangoFontDescription *font_description;
gsttextoverlay_class = (GstImxG2DBaseTextOverlayClass *) klass;
gstelement_class = (GstElementClass *) klass;
gobject_class = (GObjectClass *) klass;
gst_element_class_set_static_metadata (gstelement_class, "Time overlay",
"Filter/Editor/Video",
"Overlays buffer time stamps on a video stream",
"Tim-Philipp Müller <*****@*****.**>");
gsttextoverlay_class->get_text = gst_imx_g2d_time_overlay_get_text;
gobject_class->set_property = gst_imx_g2d_time_overlay_set_property;
gobject_class->get_property = gst_imx_g2d_time_overlay_get_property;
g_object_class_install_property (gobject_class, PROP_TIME_LINE,
g_param_spec_enum ("time-mode", "Time Mode", "What time to show",
GST_TYPE_IMX_G2D_TIME_OVERLAY_TIME_LINE, DEFAULT_TIME_LINE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_TIMEALIGNMENT,
g_param_spec_enum ("time-alignment", "Time alignment",
"Time alignment of the text", GST_TYPE_IMX_G2D_TIME_OVERLAY_TIMEALIGN,
DEFAULT_PROP_TIMEALIGNMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_mutex_lock (gsttextoverlay_class->pango_lock);
context = gsttextoverlay_class->pango_context;
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family_static (font_description, "Monospace");
pango_font_description_set_style (font_description, PANGO_STYLE_NORMAL);
pango_font_description_set_variant (font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight (font_description, PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch (font_description, PANGO_STRETCH_NORMAL);
pango_font_description_set_size (font_description, 18 * PANGO_SCALE);
pango_context_set_font_description (context, font_description);
pango_font_description_free (font_description);
g_mutex_unlock (gsttextoverlay_class->pango_lock);
}
static PangoFontMetrics *
pango_cairo_win32_font_get_metrics (PangoFont *font,
PangoLanguage *language)
{
PangoWin32Font *win32font = PANGO_WIN32_FONT (font);
PangoCairoWin32Font *cwfont = PANGO_CAIRO_WIN32_FONT (font);
PangoWin32MetricsInfo *info = NULL; /* Quiet gcc */
GSList *tmp_list;
const char *sample_str = pango_language_get_sample_string (language);
tmp_list = cwfont->metrics_by_lang;
while (tmp_list)
{
info = tmp_list->data;
if (info->sample_str == sample_str) /* We _don't_ need strcmp */
break;
tmp_list = tmp_list->next;
}
if (!tmp_list)
{
PangoContext *context;
if (!win32font->fontmap)
return pango_font_metrics_new ();
info = g_slice_new0 (PangoWin32MetricsInfo);
cwfont->metrics_by_lang = g_slist_prepend (cwfont->metrics_by_lang,
info);
info->sample_str = sample_str;
context = pango_context_new ();
pango_context_set_font_map (context, win32font->fontmap);
pango_context_set_language (context, language);
pango_cairo_context_set_font_options (context, cwfont->options);
info->metrics = create_metrics_for_context (font, context);
g_object_unref (context);
}
return pango_font_metrics_ref (info->metrics);
}
static void
gst_clock_overlay_class_init (GstClockOverlayClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseTextOverlayClass *gsttextoverlay_class;
PangoContext *context;
PangoFontDescription *font_description;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gsttextoverlay_class = (GstBaseTextOverlayClass *) klass;
gobject_class->finalize = gst_clock_overlay_finalize;
gobject_class->set_property = gst_clock_overlay_set_property;
gobject_class->get_property = gst_clock_overlay_get_property;
gst_element_class_set_static_metadata (gstelement_class, "Clock overlay",
"Filter/Editor/Video",
"Overlays the current clock time on a video stream",
"Tim-Philipp Müller <*****@*****.**>");
gsttextoverlay_class->get_text = gst_clock_overlay_get_text;
g_object_class_install_property (gobject_class, PROP_TIMEFORMAT,
g_param_spec_string ("time-format", "Date/Time Format",
"Format to use for time and date value, as in strftime.",
DEFAULT_PROP_TIMEFORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_mutex_lock (gsttextoverlay_class->pango_lock);
context = gsttextoverlay_class->pango_context;
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family_static (font_description, "Monospace");
pango_font_description_set_style (font_description, PANGO_STYLE_NORMAL);
pango_font_description_set_variant (font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight (font_description, PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch (font_description, PANGO_STRETCH_NORMAL);
pango_font_description_set_size (font_description, 18 * PANGO_SCALE);
pango_context_set_font_description (context, font_description);
pango_font_description_free (font_description);
g_mutex_unlock (gsttextoverlay_class->pango_lock);
}
/**
* gnm_pango_context_get:
*
* Simple wrapper to handle windowless operation
* Returns: (transfer full):
**/
PangoContext *
gnm_pango_context_get (void)
{
if (!context) {
GdkScreen *screen = gdk_screen_get_default ();
if (screen != NULL) {
context = gdk_pango_context_get_for_screen (screen);
} else {
if (!fontmap)
fontmap = pango_cairo_font_map_new ();
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (fontmap), 96);
context = pango_font_map_create_context (PANGO_FONT_MAP (fontmap));
}
pango_context_set_language (context, gtk_get_default_language ());
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
}
return g_object_ref (context);
}
static void
workrave_timebar_init_ui(WorkraveTimebar *self)
{
WorkraveTimebarPrivate *priv = WORKRAVE_TIMEBAR_GET_PRIVATE(self);
GdkScreen *screen = gdk_screen_get_default();
priv->pango_context = gdk_pango_context_get_for_screen(screen);
const PangoFontDescription *font_desc = pango_font_description_from_string("Sans 10");
pango_context_set_language(priv->pango_context, gtk_get_default_language());
pango_context_set_font_description(priv->pango_context, font_desc);
priv->pango_layout = pango_layout_new(priv->pango_context);
pango_layout_set_text(priv->pango_layout, "-9:59:59", -1);
pango_layout_get_pixel_size(priv->pango_layout, &priv->width, &priv->height);
priv->width = MAX(priv->width + 2 * MARGINX, MIN_HORIZONTAL_BAR_WIDTH);
priv->height = MAX(priv->height + 2 * MARGINY, MIN_HORIZONTAL_BAR_HEIGHT);
}
void wxScreenDCImpl::Init()
{
m_ok = false;
m_cmap = gdk_colormap_get_system();
m_gdkwindow = gdk_get_default_root_window();
m_context = gdk_pango_context_get();
// Note: The Sun customised version of Pango shipping with Solaris 10
// crashes if the language is left NULL (see bug 1374114)
pango_context_set_language( m_context, gtk_get_default_language() );
m_layout = pango_layout_new( m_context );
// m_fontdesc = pango_font_description_copy( widget->style->font_desc );
m_isScreenDC = true;
SetUpDC();
gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
gdk_gc_set_subwindow( m_brushGC, GDK_INCLUDE_INFERIORS );
gdk_gc_set_subwindow( m_textGC, GDK_INCLUDE_INFERIORS );
gdk_gc_set_subwindow( m_bgGC, GDK_INCLUDE_INFERIORS );
}
static void
gst_clock_overlay_class_init (GstClockOverlayClass * klass)
{
GObjectClass *gobject_class;
GstTextOverlayClass *gsttextoverlay_class;
PangoContext *context;
PangoFontDescription *font_description;
gobject_class = (GObjectClass *) klass;
gsttextoverlay_class = (GstTextOverlayClass *) klass;
gobject_class->finalize = gst_clock_overlay_finalize;
gobject_class->set_property = gst_clock_overlay_set_property;
gobject_class->get_property = gst_clock_overlay_get_property;
gsttextoverlay_class->get_text = gst_clock_overlay_get_text;
g_object_class_install_property (gobject_class, PROP_TIMEFORMAT,
g_param_spec_string ("time-format", "Date/Time Format",
"Format to use for time and date value, as in strftime.",
DEFAULT_PROP_TIMEFORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_mutex_lock (GST_TEXT_OVERLAY_CLASS (klass)->pango_lock);
context = GST_TEXT_OVERLAY_CLASS (klass)->pango_context;
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family_static (font_description, "Monospace");
pango_font_description_set_style (font_description, PANGO_STYLE_NORMAL);
pango_font_description_set_variant (font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight (font_description, PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch (font_description, PANGO_STRETCH_NORMAL);
pango_font_description_set_size (font_description, 18 * PANGO_SCALE);
pango_context_set_font_description (context, font_description);
pango_font_description_free (font_description);
g_mutex_unlock (GST_TEXT_OVERLAY_CLASS (klass)->pango_lock);
}
static PangoCairoFontHexBoxInfo *
_pango_cairo_font_private_get_hex_box_info (PangoCairoFontPrivate *cf_priv)
{
static const char hexdigits[] = "0123456789ABCDEF";
char c[2] = {0, 0};
PangoFont *mini_font;
PangoCairoFontHexBoxInfo *hbi;
/* for metrics hinting */
double scale_x = 1., scale_x_inv = 1., scale_y = 1., scale_y_inv = 1.;
gboolean is_hinted;
int i;
int rows;
double pad;
double width = 0;
double height = 0;
cairo_font_options_t *font_options;
cairo_font_extents_t font_extents;
double size, mini_size;
PangoFontDescription *desc;
cairo_scaled_font_t *scaled_font, *scaled_mini_font;
PangoMatrix pango_ctm;
cairo_matrix_t cairo_ctm;
PangoGravity gravity;
if (!cf_priv)
return NULL;
if (cf_priv->hbi)
return cf_priv->hbi;
scaled_font = _pango_cairo_font_private_get_scaled_font (cf_priv);
if (G_UNLIKELY (scaled_font == NULL || cairo_scaled_font_status (scaled_font) != CAIRO_STATUS_SUCCESS))
return NULL;
is_hinted = cf_priv->is_hinted;
font_options = cairo_font_options_create ();
desc = pango_font_describe_with_absolute_size ((PangoFont *)cf_priv->cfont);
size = pango_font_description_get_size (desc) / (1.*PANGO_SCALE);
gravity = pango_font_description_get_gravity (desc);
cairo_scaled_font_get_ctm (scaled_font, &cairo_ctm);
cairo_scaled_font_get_font_options (scaled_font, font_options);
/* I started adding support for vertical hexboxes here, but it's too much
* work. Easier to do with cairo user fonts and vertical writing mode
* support in cairo.
*/
/*cairo_matrix_rotate (&cairo_ctm, pango_gravity_to_rotation (gravity));*/
pango_ctm.xx = cairo_ctm.xx;
pango_ctm.yx = cairo_ctm.yx;
pango_ctm.xy = cairo_ctm.xy;
pango_ctm.yy = cairo_ctm.yy;
pango_ctm.x0 = cairo_ctm.x0;
pango_ctm.y0 = cairo_ctm.y0;
if (is_hinted)
{
/* prepare for some hinting */
double x, y;
x = 1.; y = 0.;
cairo_matrix_transform_distance (&cairo_ctm, &x, &y);
scale_x = sqrt (x*x + y*y);
scale_x_inv = 1 / scale_x;
x = 0.; y = 1.;
cairo_matrix_transform_distance (&cairo_ctm, &x, &y);
scale_y = sqrt (x*x + y*y);
scale_y_inv = 1 / scale_y;
}
/* we hint to the nearest device units */
#define HINT(value, scale, scale_inv) (ceil ((value-1e-5) * scale) * scale_inv)
#define HINT_X(value) HINT ((value), scale_x, scale_x_inv)
#define HINT_Y(value) HINT ((value), scale_y, scale_y_inv)
/* create mini_font description */
{
PangoFontMap *fontmap;
PangoContext *context;
/* XXX this is racy. need a ref'ing getter... */
fontmap = pango_font_get_font_map ((PangoFont *)cf_priv->cfont);
if (!fontmap)
return NULL;
fontmap = g_object_ref (fontmap);
/* we inherit most font properties for the mini font. just
* change family and size. means, you get bold hex digits
* in the hexbox for a bold font.
*/
/* We should rotate the box, not glyphs */
pango_font_description_unset_fields (desc, PANGO_FONT_MASK_GRAVITY);
pango_font_description_set_family_static (desc, "monospace");
rows = 2;
mini_size = size / 2.2;
if (is_hinted)
{
mini_size = HINT_Y (mini_size);
if (mini_size < 6.0)
{
rows = 1;
mini_size = MIN (MAX (size - 1, 0), 6.0);
}
}
pango_font_description_set_absolute_size (desc, pango_units_from_double (mini_size));
/* load mini_font */
context = pango_font_map_create_context (fontmap);
pango_context_set_matrix (context, &pango_ctm);
pango_context_set_language (context, pango_script_get_sample_language (PANGO_SCRIPT_LATIN));
pango_cairo_context_set_font_options (context, font_options);
mini_font = pango_font_map_load_font (fontmap, context, desc);
g_object_unref (context);
g_object_unref (fontmap);
}
pango_font_description_free (desc);
cairo_font_options_destroy (font_options);
scaled_mini_font = pango_cairo_font_get_scaled_font ((PangoCairoFont *) mini_font);
for (i = 0 ; i < 16 ; i++)
{
cairo_text_extents_t extents;
c[0] = hexdigits[i];
cairo_scaled_font_text_extents (scaled_mini_font, c, &extents);
width = MAX (width, extents.width);
height = MAX (height, extents.height);
}
cairo_scaled_font_extents (scaled_font, &font_extents);
if (font_extents.ascent + font_extents.descent <= 0)
{
font_extents.ascent = PANGO_UNKNOWN_GLYPH_HEIGHT;
font_extents.descent = 0;
}
pad = (font_extents.ascent + font_extents.descent) / 43;
pad = MIN (pad, mini_size);
hbi = g_slice_new (PangoCairoFontHexBoxInfo);
hbi->font = (PangoCairoFont *) mini_font;
hbi->rows = rows;
hbi->digit_width = width;
hbi->digit_height = height;
hbi->pad_x = pad;
hbi->pad_y = pad;
if (is_hinted)
{
hbi->digit_width = HINT_X (hbi->digit_width);
hbi->digit_height = HINT_Y (hbi->digit_height);
hbi->pad_x = HINT_X (hbi->pad_x);
hbi->pad_y = HINT_Y (hbi->pad_y);
}
hbi->line_width = MIN (hbi->pad_x, hbi->pad_y);
hbi->box_height = 3 * hbi->pad_y + rows * (hbi->pad_y + hbi->digit_height);
if (rows == 1 || hbi->box_height <= font_extents.ascent)
{
hbi->box_descent = 2 * hbi->pad_y;
}
else if (hbi->box_height <= font_extents.ascent + font_extents.descent - 2 * hbi->pad_y)
{
hbi->box_descent = 2 * hbi->pad_y + hbi->box_height - font_extents.ascent;
}
else
{
hbi->box_descent = font_extents.descent * hbi->box_height /
(font_extents.ascent + font_extents.descent);
}
if (is_hinted)
{
hbi->box_descent = HINT_Y (hbi->box_descent);
}
cf_priv->hbi = hbi;
return hbi;
}
PangoFontMetrics *
_pango_cairo_font_get_metrics (PangoFont *font,
PangoLanguage *language)
{
PangoCairoFont *cfont = (PangoCairoFont *) font;
PangoCairoFontPrivate *cf_priv = PANGO_CAIRO_FONT_PRIVATE (font);
PangoCairoFontMetricsInfo *info = NULL; /* Quiet gcc */
GSList *tmp_list;
const char *sample_str = pango_language_get_sample_string (language);
tmp_list = cf_priv->metrics_by_lang;
while (tmp_list)
{
info = tmp_list->data;
if (info->sample_str == sample_str) /* We _don't_ need strcmp */
break;
tmp_list = tmp_list->next;
}
if (!tmp_list)
{
PangoFontMap *fontmap;
PangoContext *context;
cairo_font_options_t *font_options;
int height, shift;
/* XXX this is racy. need a ref'ing getter... */
fontmap = pango_font_get_font_map (font);
if (!fontmap)
return pango_font_metrics_new ();
fontmap = g_object_ref (fontmap);
info = g_slice_new0 (PangoCairoFontMetricsInfo);
cf_priv->metrics_by_lang = g_slist_prepend (cf_priv->metrics_by_lang, info);
info->sample_str = sample_str;
context = pango_font_map_create_context (fontmap);
pango_context_set_language (context, language);
font_options = cairo_font_options_create ();
cairo_scaled_font_get_font_options (_pango_cairo_font_private_get_scaled_font (cf_priv), font_options);
pango_cairo_context_set_font_options (context, font_options);
cairo_font_options_destroy (font_options);
info->metrics = (* PANGO_CAIRO_FONT_GET_IFACE (font)->create_metrics_for_context) (cfont, context);
/* We may actually reuse ascent/descent we got from cairo here. that's
* in cf_priv->font_extents.
*/
height = info->metrics->ascent + info->metrics->descent;
switch (cf_priv->gravity)
{
default:
case PANGO_GRAVITY_AUTO:
case PANGO_GRAVITY_SOUTH:
break;
case PANGO_GRAVITY_NORTH:
info->metrics->ascent = info->metrics->descent;
break;
case PANGO_GRAVITY_EAST:
case PANGO_GRAVITY_WEST:
{
int ascent = height / 2;
if (cf_priv->is_hinted)
ascent = PANGO_UNITS_ROUND (ascent);
info->metrics->ascent = ascent;
}
}
shift = (height - info->metrics->ascent) - info->metrics->descent;
info->metrics->descent += shift;
info->metrics->underline_position -= shift;
info->metrics->strikethrough_position -= shift;
info->metrics->ascent = height - info->metrics->descent;
g_object_unref (context);
g_object_unref (fontmap);
}
return pango_font_metrics_ref (info->metrics);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d P A N G O I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadPANGOImage() reads an image in the Pango Markup Language Format.
%
% The format of the ReadPANGOImage method is:
%
% Image *ReadPANGOImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadPANGOImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
cairo_font_options_t
*font_options;
cairo_surface_t
*surface;
char
*caption,
*property;
cairo_t
*cairo_image;
const char
*option;
DrawInfo
*draw_info;
Image
*image;
MagickBooleanType
status;
PangoAlignment
align;
PangoContext
*context;
PangoFontMap
*fontmap;
PangoGravity
gravity;
PangoLayout
*layout;
PangoRectangle
extent;
PixelInfo
fill_color;
RectangleInfo
page;
register unsigned char
*p;
size_t
stride;
ssize_t
y;
unsigned char
*pixels;
/*
Initialize Image structure.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info,exception);
(void) ResetImagePage(image,"0x0+0+0");
/*
Format caption.
*/
option=GetImageArtifact(image,"filename");
if (option == (const char *) NULL)
property=InterpretImageProperties(image_info,image,image_info->filename,
exception);
else
if (LocaleNCompare(option,"pango:",6) == 0)
property=InterpretImageProperties(image_info,image,option+6,exception);
else
property=InterpretImageProperties(image_info,image,option,exception);
(void) SetImageProperty(image,"caption",property,exception);
property=DestroyString(property);
caption=ConstantString(GetImageProperty(image,"caption",exception));
/*
Get context.
*/
fontmap=pango_cairo_font_map_new();
pango_cairo_font_map_set_resolution(PANGO_CAIRO_FONT_MAP(fontmap),
image->resolution.x == 0.0 ? 90.0 : image->resolution.x);
font_options=cairo_font_options_create();
option=GetImageArtifact(image,"pango:hinting");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"none") != 0)
cairo_font_options_set_hint_style(font_options,CAIRO_HINT_STYLE_NONE);
if (LocaleCompare(option,"full") != 0)
cairo_font_options_set_hint_style(font_options,CAIRO_HINT_STYLE_FULL);
}
context=pango_font_map_create_context(fontmap);
pango_cairo_context_set_font_options(context,font_options);
cairo_font_options_destroy(font_options);
option=GetImageArtifact(image,"pango:language");
if (option != (const char *) NULL)
pango_context_set_language(context,pango_language_from_string(option));
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
pango_context_set_base_dir(context,draw_info->direction ==
RightToLeftDirection ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR);
switch (draw_info->gravity)
{
case NorthGravity:
{
gravity=PANGO_GRAVITY_NORTH;
break;
}
case NorthWestGravity:
case WestGravity:
case SouthWestGravity:
{
gravity=PANGO_GRAVITY_WEST;
break;
}
case NorthEastGravity:
case EastGravity:
case SouthEastGravity:
{
gravity=PANGO_GRAVITY_EAST;
break;
}
case SouthGravity:
{
gravity=PANGO_GRAVITY_SOUTH;
break;
}
default:
{
gravity=PANGO_GRAVITY_AUTO;
break;
}
}
pango_context_set_base_gravity(context,gravity);
option=GetImageArtifact(image,"pango:gravity-hint");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"line") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_LINE);
if (LocaleCompare(option,"natural") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_NATURAL);
if (LocaleCompare(option,"strong") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_STRONG);
}
/*
Configure layout.
*/
layout=pango_layout_new(context);
option=GetImageArtifact(image,"pango:auto-dir");
if (option != (const char *) NULL)
pango_layout_set_auto_dir(layout,1);
option=GetImageArtifact(image,"pango:ellipsize");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"end") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_END);
if (LocaleCompare(option,"middle") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_MIDDLE);
if (LocaleCompare(option,"none") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_NONE);
if (LocaleCompare(option,"start") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_START);
}
option=GetImageArtifact(image,"pango:justify");
if (IfMagickTrue(IsStringTrue(option)))
pango_layout_set_justify(layout,1);
option=GetImageArtifact(image,"pango:single-paragraph");
if (IfMagickTrue(IsStringTrue(option)))
pango_layout_set_single_paragraph_mode(layout,1);
option=GetImageArtifact(image,"pango:wrap");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_CHAR);
if (LocaleCompare(option,"word") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD);
if (LocaleCompare(option,"word-char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD_CHAR);
}
option=GetImageArtifact(image,"pango:indent");
if (option != (const char *) NULL)
pango_layout_set_indent(layout,(int) ((StringToLong(option)*
(image->resolution.x == 0.0 ? 90.0 : image->resolution.x)*PANGO_SCALE+36)/
90.0+0.5));
switch (draw_info->align)
{
case CenterAlign: align=PANGO_ALIGN_CENTER; break;
case RightAlign: align=PANGO_ALIGN_RIGHT; break;
case LeftAlign: align=PANGO_ALIGN_LEFT; break;
default:
{
if (draw_info->gravity == CenterGravity)
{
align=PANGO_ALIGN_CENTER;
break;
}
align=PANGO_ALIGN_LEFT;
break;
}
}
if ((align != PANGO_ALIGN_CENTER) &&
(draw_info->direction == RightToLeftDirection))
align=(PangoAlignment) (PANGO_ALIGN_LEFT+PANGO_ALIGN_RIGHT-align);
pango_layout_set_alignment(layout,align);
if (draw_info->font != (char *) NULL)
{
PangoFontDescription
*description;
/*
Set font.
*/
description=pango_font_description_from_string(draw_info->font);
pango_font_description_set_size(description,(int) (PANGO_SCALE*
draw_info->pointsize+0.5));
pango_layout_set_font_description(layout,description);
pango_font_description_free(description);
}
option=GetImageArtifact(image,"pango:markup");
if ((option != (const char *) NULL) && (IsStringTrue(option) == MagickFalse))
pango_layout_set_text(layout,caption,-1);
else
{
GError
*error;
error=(GError *) NULL;
if (pango_parse_markup(caption,-1,0,NULL,NULL,NULL,&error) == 0)
(void) ThrowMagickException(exception,GetMagickModule(),CoderError,
error->message,"`%s'",image_info->filename);
pango_layout_set_markup(layout,caption,-1);
}
pango_layout_context_changed(layout);
page.x=0;
page.y=0;
if (image_info->page != (char *) NULL)
(void) ParseAbsoluteGeometry(image_info->page,&page);
if (image->columns == 0)
{
pango_layout_get_extents(layout,NULL,&extent);
image->columns=(extent.x+extent.width+PANGO_SCALE/2)/PANGO_SCALE+2*page.x;
}
else
{
image->columns-=2*page.x;
pango_layout_set_width(layout,(int) ((PANGO_SCALE*image->columns*
(image->resolution.x == 0.0 ? 90.0 : image->resolution.x)+45.0)/90.0+
0.5));
}
if (image->rows == 0)
{
pango_layout_get_extents(layout,NULL,&extent);
image->rows=(extent.y+extent.height+PANGO_SCALE/2)/PANGO_SCALE+2*page.y;
}
else
{
image->rows-=2*page.y;
pango_layout_set_height(layout,(int) ((PANGO_SCALE*image->rows*
(image->resolution.y == 0.0 ? 90.0 : image->resolution.y)+45.0)/90.0+
0.5));
}
/*
Render markup.
*/
stride=(size_t) cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,
image->columns);
pixels=(unsigned char *) AcquireQuantumMemory(image->rows,stride*
sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
{
draw_info=DestroyDrawInfo(draw_info);
caption=DestroyString(caption);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
surface=cairo_image_surface_create_for_data(pixels,CAIRO_FORMAT_ARGB32,
image->columns,image->rows,stride);
cairo_image=cairo_create(surface);
cairo_set_operator(cairo_image,CAIRO_OPERATOR_CLEAR);
cairo_paint(cairo_image);
cairo_set_operator(cairo_image,CAIRO_OPERATOR_OVER);
cairo_translate(cairo_image,page.x,page.y);
pango_cairo_show_layout(cairo_image,layout);
cairo_destroy(cairo_image);
cairo_surface_destroy(surface);
g_object_unref(layout);
g_object_unref(fontmap);
/*
Convert surface to image.
*/
(void) SetImageBackgroundColor(image,exception);
p=pixels;
GetPixelInfo(image,&fill_color);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*q;
register ssize_t
x;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
double
gamma;
fill_color.blue=(double) ScaleCharToQuantum(*p++);
fill_color.green=(double) ScaleCharToQuantum(*p++);
fill_color.red=(double) ScaleCharToQuantum(*p++);
fill_color.alpha=(double) ScaleCharToQuantum(*p++);
/*
Disassociate alpha.
*/
gamma=1.0-QuantumScale*fill_color.alpha;
gamma=PerceptibleReciprocal(gamma);
fill_color.blue*=gamma;
fill_color.green*=gamma;
fill_color.red*=gamma;
CompositePixelOver(image,&fill_color,fill_color.alpha,q,(double)
GetPixelAlpha(image,q),q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
}
/*
Relinquish resources.
*/
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
draw_info=DestroyDrawInfo(draw_info);
caption=DestroyString(caption);
return(GetFirstImageInList(image));
}
void iupdrvFontInit(void)
{
gtk_fonts = iupArrayCreate(50, sizeof(IgtkFont));
gtk_fonts_context = gdk_pango_context_get();
pango_context_set_language(gtk_fonts_context, gtk_get_default_language());
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkFontPeer_setFont
(JNIEnv *env, jobject self, jstring family_name_str, jint style_int, jint size, jboolean useGraphics2D)
{
struct peerfont *pfont = NULL;
char const *family_name = NULL;
enum java_awt_font_style style;
PangoFT2FontMap *ft2_map;
gdk_threads_enter ();
style = (enum java_awt_font_style) style_int;
g_assert (self != NULL);
pfont = (struct peerfont *)NSA_GET_FONT_PTR (env, self);
g_assert (pfont != NULL);
if (pfont->ctx != NULL)
g_object_unref (pfont->ctx);
if (pfont->font != NULL)
g_object_unref (pfont->font);
if (pfont->desc != NULL)
pango_font_description_free (pfont->desc);
pfont->desc = pango_font_description_new ();
g_assert (pfont->desc != NULL);
family_name = (*env)->GetStringUTFChars(env, family_name_str, 0);
g_assert (family_name != NULL);
pango_font_description_set_family (pfont->desc, family_name);
(*env)->ReleaseStringUTFChars(env, family_name_str, family_name);
if (style & java_awt_font_BOLD)
pango_font_description_set_weight (pfont->desc, PANGO_WEIGHT_BOLD);
if (style & java_awt_font_ITALIC)
pango_font_description_set_style (pfont->desc, PANGO_STYLE_ITALIC);
if (useGraphics2D)
{
pango_font_description_set_size (pfont->desc, size * PANGO_SCALE);
if (pfont->ctx == NULL)
{
ft2_map = PANGO_FT2_FONT_MAP(pango_ft2_font_map_for_display ());
pfont->ctx = pango_ft2_font_map_create_context (ft2_map);
}
}
else
{
/* GDK uses a slightly different DPI setting. */
pango_font_description_set_size (pfont->desc,
size * dpi_conversion_factor);
if (pfont->ctx == NULL)
pfont->ctx = gdk_pango_context_get();
}
g_assert (pfont->ctx != NULL);
if (pfont->font != NULL)
{
g_object_unref (pfont->font);
pfont->font = NULL;
}
pango_context_set_font_description (pfont->ctx, pfont->desc);
pango_context_set_language (pfont->ctx, gtk_get_default_language());
pfont->font = pango_context_load_font (pfont->ctx, pfont->desc);
g_assert (pfont->font != NULL);
if (pfont->layout == NULL)
pfont->layout = pango_layout_new (pfont->ctx);
g_assert (pfont->layout != NULL);
gdk_threads_leave ();
}
static Image *ReadCAPTIONImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
char
*caption,
*property;
const char
*option;
DrawInfo
*draw_info;
FT_Bitmap
*canvas;
Image
*image;
PangoAlignment
align;
PangoContext
*context;
PangoFontDescription
*description;
PangoFontMap
*fontmap;
PangoGravity
gravity;
PangoLayout
*layout;
PangoRectangle
extent;
PixelPacket
fill_color;
RectangleInfo
page;
register PixelPacket
*q;
register unsigned char
*p;
ssize_t
y;
/*
Initialize Image structure.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
(void) ResetImagePage(image,"0x0+0+0");
/*
Get context.
*/
fontmap=(PangoFontMap *) pango_ft2_font_map_new();
pango_ft2_font_map_set_resolution((PangoFT2FontMap *) fontmap,
image->x_resolution,image->y_resolution);
option=GetImageOption(image_info,"caption:hinting");
pango_ft2_font_map_set_default_substitute((PangoFT2FontMap *) fontmap,
PangoSubstitute,(char *) option,NULL);
context=pango_font_map_create_context(fontmap);
option=GetImageOption(image_info,"caption:language");
if (option != (const char *) NULL)
pango_context_set_language(context,pango_language_from_string(option));
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
pango_context_set_base_dir(context,draw_info->direction ==
RightToLeftDirection ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR);
switch (draw_info->gravity)
{
case NorthGravity: gravity=PANGO_GRAVITY_NORTH; break;
case WestGravity: gravity=PANGO_GRAVITY_WEST; break;
case EastGravity: gravity=PANGO_GRAVITY_EAST; break;
case SouthGravity: gravity=PANGO_GRAVITY_SOUTH; break;
default: gravity=PANGO_GRAVITY_AUTO; break;
}
pango_context_set_base_gravity(context,gravity);
option=GetImageOption(image_info,"caption:gravity-hint");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"line") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_LINE);
if (LocaleCompare(option,"natural") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_NATURAL);
if (LocaleCompare(option,"strong") == 0)
pango_context_set_gravity_hint(context,PANGO_GRAVITY_HINT_STRONG);
}
/*
Configure layout.
*/
layout=pango_layout_new(context);
option=GetImageOption(image_info,"caption:auto-dir");
if (option != (const char *) NULL)
pango_layout_set_auto_dir(layout,1);
option=GetImageOption(image_info,"caption:ellipsize");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"end") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_END);
if (LocaleCompare(option,"middle") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_MIDDLE);
if (LocaleCompare(option,"none") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_NONE);
if (LocaleCompare(option,"start") == 0)
pango_layout_set_ellipsize(layout,PANGO_ELLIPSIZE_START);
}
option=GetImageOption(image_info,"caption:justify");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_justify(layout,1);
option=GetImageOption(image_info,"caption:single-paragraph");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_single_paragraph_mode(layout,1);
option=GetImageOption(image_info,"caption:wrap");
if (option != (const char *) NULL)
{
if (LocaleCompare(option,"char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_CHAR);
if (LocaleCompare(option,"word") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD);
if (LocaleCompare(option,"word-char") == 0)
pango_layout_set_wrap(layout,PANGO_WRAP_WORD_CHAR);
}
option=GetImageOption(image_info,"caption:indent");
if (option != (const char *) NULL)
pango_layout_set_indent(layout,(StringToLong(option)*image->x_resolution*
PANGO_SCALE+36)/72);
switch (draw_info->align)
{
case CenterAlign: align=PANGO_ALIGN_CENTER; break;
case RightAlign: align=PANGO_ALIGN_RIGHT; break;
case LeftAlign:
default: align=PANGO_ALIGN_LEFT; break;
}
if ((align != PANGO_ALIGN_CENTER) &&
(draw_info->direction == RightToLeftDirection))
align=(PangoAlignment) (PANGO_ALIGN_LEFT+PANGO_ALIGN_RIGHT-align);
pango_layout_set_alignment(layout,align);
description=pango_font_description_from_string(draw_info->font ==
(char *) NULL ? "helvetica" : draw_info->font);
pango_font_description_set_size(description,PANGO_SCALE*draw_info->pointsize);
pango_layout_set_font_description(layout,description);
pango_font_description_free(description);
property=InterpretImageProperties(image_info,image,image_info->filename);
(void) SetImageProperty(image,"caption",property);
property=DestroyString(property);
caption=ConstantString(GetImageProperty(image,"caption"));
/*
Render caption.
*/
option=GetImageOption(image_info,"caption:markup");
if ((option != (const char *) NULL) && (IsMagickTrue(option) != MagickFalse))
pango_layout_set_markup(layout,caption,-1);
else
pango_layout_set_text(layout,caption,-1);
pango_layout_context_changed(layout);
page.x=0;
page.y=0;
if (image_info->page != (char *) NULL)
(void) ParseAbsoluteGeometry(image_info->page,&page);
if (image->columns == 0)
{
pango_layout_get_pixel_extents(layout,NULL,&extent);
image->columns=extent.x+extent.width;
}
else
{
image->columns-=2*page.x;
pango_layout_set_width(layout,(PANGO_SCALE*image->columns*
image->x_resolution+36.0)/72.0);
}
if (image->rows == 0)
{
pango_layout_get_pixel_extents(layout,NULL,&extent);
image->rows=extent.y+extent.height;
}
else
{
image->rows-=2*page.y;
pango_layout_set_height(layout,(PANGO_SCALE*image->rows*
image->y_resolution+36.0)/72.0);
}
/*
Create canvas.
*/
canvas=(FT_Bitmap *) AcquireMagickMemory(sizeof(*canvas));
if (canvas == (FT_Bitmap *) NULL)
{
draw_info=DestroyDrawInfo(draw_info);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
canvas->width=image->columns;
canvas->pitch=(canvas->width+3) & ~3;
canvas->rows=image->rows;
canvas->buffer=(unsigned char *) AcquireQuantumMemory(canvas->pitch,
canvas->rows*sizeof(*canvas->buffer));
if (canvas->buffer == (unsigned char *) NULL)
{
draw_info=DestroyDrawInfo(draw_info);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
canvas->num_grays=256;
canvas->pixel_mode=ft_pixel_mode_grays;
ResetMagickMemory(canvas->buffer,0x00,canvas->pitch*canvas->rows);
pango_ft2_render_layout(canvas,layout,0,0);
/*
Convert caption to image.
*/
image->columns+=2*page.x;
image->rows+=2*page.y;
if (SetImageBackgroundColor(image) == MagickFalse)
{
draw_info=DestroyDrawInfo(draw_info);
canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
caption=DestroyString(caption);
image=DestroyImageList(image);
return((Image *) NULL);
}
p=canvas->buffer;
for (y=page.y; y < (ssize_t) (image->rows-page.y); y++)
{
register ssize_t
x;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
q+=page.x;
for (x=page.x; x < (ssize_t) (image->columns-page.x); x++)
{
MagickRealType
fill_opacity;
(void) GetFillColor(draw_info,x,y,&fill_color);
fill_opacity=QuantumRange-(*p)/canvas->num_grays*(QuantumRange-
fill_color.opacity);
if (draw_info->text_antialias == MagickFalse)
fill_opacity=fill_opacity >= 0.5 ? 1.0 : 0.0;
MagickCompositeOver(&fill_color,fill_opacity,q,q->opacity,q);
p++;
q++;
}
for ( ; x < (ssize_t) ((canvas->width+3) & ~3); x++)
p++;
}
/*
Relinquish resources.
*/
draw_info=DestroyDrawInfo(draw_info);
canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);
canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);
caption=DestroyString(caption);
return(GetFirstImageInList(image));
}
unsigned Gosu::pango::textWidth(const std::wstring& text,
const std::wstring& fontFace, unsigned fontHeight,
unsigned fontFlags)
{
g_type_init();
int dpi_x = 100, dpi_y = 100;
context = pango_ft2_get_context(dpi_x, dpi_y);
pango_context_set_language(context, pango_language_from_string ("en_US"));
PangoDirection init_dir = PANGO_DIRECTION_LTR;
pango_context_set_base_dir(context, init_dir);
// static PangoFontDescription *font_description;
font_description = pango_font_description_new();
pango_font_description_set_family(font_description,
g_strdup(narrow(fontFace).c_str()));
pango_font_description_set_style(font_description,
(fontFlags & ffItalic) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
pango_font_description_set_variant(font_description, PANGO_VARIANT_NORMAL);
pango_font_description_set_weight(font_description,
(fontFlags & ffBold) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
pango_font_description_set_stretch(font_description, PANGO_STRETCH_NORMAL);
int init_scale = int(fontHeight/2.0 + 0.5);
pango_font_description_set_size(font_description, init_scale * PANGO_SCALE);
pango_context_set_font_description(context, font_description);
layout = pango_layout_new(context);
if(fontFlags & ffUnderline)
{
// PangoAttribute *attr;
attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
attr->start_index = 0;
attr->end_index = text.length();
// PangoAttrList* attrList;
attrList = pango_attr_list_new();
pango_attr_list_insert(attrList, attr);
pango_layout_set_attributes(layout, attrList);
pango_attr_list_unref(attrList);
}
// IMPR: Catch errors? (Last NULL-Pointer)
gchar* utf8Str = g_ucs4_to_utf8((gunichar*)text.c_str(), text.length(), NULL, NULL, NULL);
pango_layout_set_text(layout, utf8Str, -1);
g_free(utf8Str);
PangoDirection base_dir = pango_context_get_base_dir(context);
pango_layout_set_alignment(layout,
base_dir == PANGO_DIRECTION_LTR ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT);
pango_layout_set_width(layout, -1);
PangoRectangle logical_rect;
pango_layout_get_pixel_extents(layout, NULL, &logical_rect);
height = logical_rect.height;
width = logical_rect.width;
return width;
}
static PangoLayout *
rsvg_text_create_layout (RsvgDrawingCtx * ctx,
RsvgState * state, const char *text, PangoContext * context)
{
PangoFontDescription *font_desc;
PangoLayout *layout;
PangoAttrList *attr_list;
PangoAttribute *attribute;
if (state->lang)
pango_context_set_language (context, pango_language_from_string (state->lang));
if (state->unicode_bidi == UNICODE_BIDI_OVERRIDE || state->unicode_bidi == UNICODE_BIDI_EMBED)
pango_context_set_base_dir (context, state->text_dir);
font_desc = pango_font_description_copy (pango_context_get_font_description (context));
if (state->font_family)
pango_font_description_set_family_static (font_desc, state->font_family);
pango_font_description_set_style (font_desc, state->font_style);
pango_font_description_set_variant (font_desc, state->font_variant);
pango_font_description_set_weight (font_desc, state->font_weight);
pango_font_description_set_stretch (font_desc, state->font_stretch);
pango_font_description_set_size (font_desc,
_rsvg_css_normalize_font_size (state, ctx) *
PANGO_SCALE / ctx->dpi_y * 72);
layout = pango_layout_new (context);
pango_layout_set_font_description (layout, font_desc);
pango_font_description_free (font_desc);
attr_list = pango_attr_list_new ();
attribute = pango_attr_letter_spacing_new (_rsvg_css_normalize_length (&state->letter_spacing,
ctx, 'h') * PANGO_SCALE);
attribute->start_index = 0;
attribute->end_index = G_MAXINT;
pango_attr_list_insert (attr_list, attribute);
if (state->has_font_decor && text) {
if (state->font_decor & TEXT_UNDERLINE) {
attribute = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
attribute->start_index = 0;
attribute->end_index = -1;
pango_attr_list_insert (attr_list, attribute);
}
if (state->font_decor & TEXT_STRIKE) {
attribute = pango_attr_strikethrough_new (TRUE);
attribute->start_index = 0;
attribute->end_index = -1;
pango_attr_list_insert (attr_list, attribute);
}
}
pango_layout_set_attributes (layout, attr_list);
pango_attr_list_unref (attr_list);
if (text)
pango_layout_set_text (layout, text, -1);
else
pango_layout_set_text (layout, NULL, 0);
pango_layout_set_alignment (layout, (state->text_dir == PANGO_DIRECTION_LTR ||
state->text_dir == PANGO_DIRECTION_TTB_LTR) ?
PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT);
return layout;
}
int
main (int argc, char **argv)
{
char *text;
GtkWidget *window;
GtkWidget *scrollwin;
GtkWidget *vbox, *hbox;
GtkWidget *frame;
GtkWidget *checkbutton;
gtk_init (&argc, &argv);
if (argc != 2)
{
fprintf (stderr, "Usage: %s FILE\n", g_get_prgname ());
exit(1);
}
/* Create the list of paragraphs from the supplied file
*/
text = read_file (argv[1]);
if (!text)
exit(1);
context = pango_win32_get_context ();
paragraphs = split_paragraphs (text);
pango_context_set_language (context, pango_language_from_string ("en_US"));
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
font_description = pango_font_description_new ();
pango_font_description_set_family(font_description, "sans");
pango_font_description_set_size(font_description, 16 * PANGO_SCALE);
#if 0 /* default init ok? */
font_description.style = PANGO_STYLE_NORMAL;
font_description.variant = PANGO_VARIANT_NORMAL;
font_description.weight = 500;
font_description.stretch = PANGO_STRETCH_NORMAL;
#endif
pango_context_set_font_description (context, font_description);
/* Create the user interface
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = make_font_selector ();
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrollwin, TRUE, TRUE, 0);
layout = gtk_layout_new (NULL, NULL);
gtk_widget_set_events (layout, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_app_paintable (layout, TRUE);
gtk_signal_connect (GTK_OBJECT (layout), "size_allocate",
GTK_SIGNAL_FUNC (size_allocate), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
GTK_SIGNAL_FUNC (expose), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "draw",
GTK_SIGNAL_FUNC (draw), paragraphs);
gtk_signal_connect (GTK_OBJECT (layout), "button_press_event",
GTK_SIGNAL_FUNC (button_press), paragraphs);
#if GTK_CHECK_VERSION (1,3,2)
gtk_widget_set_double_buffered (layout, FALSE);
#endif
gtk_container_add (GTK_CONTAINER (scrollwin), layout);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
message_label = gtk_label_new ("Current char:");
gtk_misc_set_padding (GTK_MISC (message_label), 1, 1);
gtk_misc_set_alignment (GTK_MISC (message_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), message_label);
checkbutton = gtk_check_button_new_with_label ("Use RTL global direction");
gtk_signal_connect (GTK_OBJECT (checkbutton), "toggled",
GTK_SIGNAL_FUNC (checkbutton_toggled), NULL);
gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
PangoFontMetrics *
_pango_cairo_font_get_metrics (PangoFont *font,
PangoLanguage *language)
{
PangoCairoFont *cfont = (PangoCairoFont *) font;
PangoCairoFontPrivate *cf_priv = PANGO_CAIRO_FONT_PRIVATE (font);
PangoCairoFontMetricsInfo *info = NULL; /* Quiet gcc */
GSList *tmp_list;
const char *sample_str = pango_language_get_sample_string (language);
tmp_list = cf_priv->metrics_by_lang;
while (tmp_list)
{
info = tmp_list->data;
if (info->sample_str == sample_str) /* We _don't_ need strcmp */
break;
tmp_list = tmp_list->next;
}
if (!tmp_list)
{
PangoFontMap *fontmap;
PangoContext *context;
cairo_font_options_t *font_options;
PangoLayout *layout;
PangoRectangle extents;
PangoFontDescription *desc;
cairo_scaled_font_t *scaled_font;
cairo_matrix_t cairo_matrix;
PangoMatrix pango_matrix;
PangoMatrix identity = PANGO_MATRIX_INIT;
int height, shift;
/* XXX this is racy. need a ref'ing getter... */
fontmap = pango_font_get_font_map (font);
if (!fontmap)
return pango_font_metrics_new ();
fontmap = g_object_ref (fontmap);
info = g_slice_new0 (PangoCairoFontMetricsInfo);
cf_priv->metrics_by_lang = g_slist_prepend (cf_priv->metrics_by_lang, info);
info->sample_str = sample_str;
scaled_font = _pango_cairo_font_private_get_scaled_font (cf_priv);
context = pango_font_map_create_context (fontmap);
pango_context_set_language (context, language);
font_options = cairo_font_options_create ();
cairo_scaled_font_get_font_options (scaled_font, font_options);
pango_cairo_context_set_font_options (context, font_options);
cairo_font_options_destroy (font_options);
info->metrics = (* PANGO_CAIRO_FONT_GET_IFACE (font)->create_base_metrics_for_context) (cfont, context);
/* We now need to adjust the base metrics for ctm */
cairo_scaled_font_get_ctm (scaled_font, &cairo_matrix);
pango_matrix.xx = cairo_matrix.xx;
pango_matrix.yx = cairo_matrix.yx;
pango_matrix.xy = cairo_matrix.xy;
pango_matrix.yy = cairo_matrix.yy;
pango_matrix.x0 = 0;
pango_matrix.y0 = 0;
if (G_UNLIKELY (0 != memcmp (&identity, &pango_matrix, 4 * sizeof (double))))
{
double xscale = pango_matrix_get_font_scale_factor (&pango_matrix);
if (xscale) xscale = 1 / xscale;
info->metrics->ascent *= xscale;
info->metrics->descent *= xscale;
info->metrics->underline_position *= xscale;
info->metrics->underline_thickness *= xscale;
info->metrics->strikethrough_position *= xscale;
info->metrics->strikethrough_thickness *= xscale;
}
/* Set the matrix on the context so we don't have to adjust the derived
* metrics. */
pango_context_set_matrix (context, &pango_matrix);
/* Update approximate_*_width now */
layout = pango_layout_new (context);
desc = pango_font_describe_with_absolute_size (font);
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
pango_layout_set_text (layout, sample_str, -1);
pango_layout_get_extents (layout, NULL, &extents);
info->metrics->approximate_char_width = extents.width / pango_utf8_strwidth (sample_str);
pango_layout_set_text (layout, "0123456789", -1);
info->metrics->approximate_digit_width = max_glyph_width (layout);
g_object_unref (layout);
/* We may actually reuse ascent/descent we got from cairo here. that's
* in cf_priv->font_extents.
*/
height = info->metrics->ascent + info->metrics->descent;
switch (cf_priv->gravity)
{
default:
case PANGO_GRAVITY_AUTO:
case PANGO_GRAVITY_SOUTH:
break;
case PANGO_GRAVITY_NORTH:
info->metrics->ascent = info->metrics->descent;
break;
case PANGO_GRAVITY_EAST:
case PANGO_GRAVITY_WEST:
{
int ascent = height / 2;
if (cf_priv->is_hinted)
ascent = PANGO_UNITS_ROUND (ascent);
info->metrics->ascent = ascent;
}
}
shift = (height - info->metrics->ascent) - info->metrics->descent;
info->metrics->descent += shift;
info->metrics->underline_position -= shift;
info->metrics->strikethrough_position -= shift;
info->metrics->ascent = height - info->metrics->descent;
g_object_unref (context);
g_object_unref (fontmap);
}
return pango_font_metrics_ref (info->metrics);
}
JNIEXPORT jobject JNICALL
Java_gnu_java_awt_peer_gtk_GdkFontPeer_getGlyphVector
(JNIEnv *env, jobject self,
jstring chars,
jobject font,
jobject fontRenderContext)
{
struct peerfont *pfont = NULL;
GList *items = NULL, *i = NULL;
gchar *str = NULL;
int len, j;
double *native_extents;
int *native_codes;
jintArray java_codes = NULL;
jdoubleArray java_extents = NULL;
gdk_threads_enter ();
pfont = (struct peerfont *)NSA_GET_FONT_PTR (env, self);
g_assert (pfont != NULL);
len = (*gdk_env())->GetStringUTFLength (env, chars);
str = (gchar *)(*env)->GetStringUTFChars (env, chars, NULL);
g_assert (str != NULL);
if (attrs == NULL)
attrs = pango_attr_list_new ();
if (len > 0 && str[len-1] == '\0')
len--;
items = pango_itemize (pfont->ctx, str, 0, len, attrs, NULL);
i = g_list_first (items);
if (i == NULL)
{
java_extents = (*env)->NewDoubleArray (env, 0);
java_codes = (*env)->NewIntArray (env, 0);
}
else
{
PangoGlyphString *glyphs;
PangoItem *item = (PangoItem *)i->data;
pango_context_set_font_description (pfont->ctx, pfont->desc);
pango_context_set_language (pfont->ctx, gtk_get_default_language());
pango_context_load_font (pfont->ctx, pfont->desc);
glyphs = pango_glyph_string_new ();
g_assert (glyphs != NULL);
pango_shape (str + item->offset, item->length,
&(item->analysis), glyphs);
if (glyphs->num_glyphs > 0)
{
int x = 0;
double scale = ((double) PANGO_SCALE);
java_extents = (*env)->NewDoubleArray (env, glyphs->num_glyphs * NUM_GLYPH_METRICS);
java_codes = (*env)->NewIntArray (env, glyphs->num_glyphs);
native_extents = (*env)->GetDoubleArrayElements (env, java_extents, NULL);
native_codes = (*env)->GetIntArrayElements (env, java_codes, NULL);
for (j = 0; j < glyphs->num_glyphs; ++j)
{
PangoRectangle ink;
PangoRectangle logical;
PangoGlyphGeometry *geom = &glyphs->glyphs[j].geometry;
pango_font_get_glyph_extents (pfont->font,
glyphs->glyphs[j].glyph,
&ink, &logical);
native_codes[j] = glyphs->glyphs[j].glyph;
native_extents[ GLYPH_LOG_X(j) ] = (logical.x) / scale;
native_extents[ GLYPH_LOG_Y(j) ] = (- logical.y) / scale;
native_extents[ GLYPH_LOG_WIDTH(j) ] = (logical.width) / scale;
native_extents[ GLYPH_LOG_HEIGHT(j) ] = (logical.height) / scale;
native_extents[ GLYPH_INK_X(j) ] = (ink.x) / scale;
native_extents[ GLYPH_INK_Y(j) ] = (- ink.y) / scale;
native_extents[ GLYPH_INK_WIDTH(j) ] = (ink.width) / scale;
native_extents[ GLYPH_INK_HEIGHT(j) ] = (ink.height) / scale;
native_extents[ GLYPH_POS_X(j) ] = (x + geom->x_offset) / scale;
native_extents[ GLYPH_POS_Y(j) ] = ( - geom->y_offset) / scale;
x += geom->width;
}
(*env)->ReleaseDoubleArrayElements (env, java_extents, native_extents, 0);
(*env)->ReleaseIntArrayElements (env, java_codes, native_codes, 0);
}
pango_glyph_string_free (glyphs);
}
(*env)->ReleaseStringUTFChars (env, chars, str);
for (i = g_list_first (items); i != NULL; i = g_list_next (i))
g_free (i->data);
g_list_free (items);
gdk_threads_leave ();
return (*env)->NewObject (env,
glyphVector_class,
glyphVector_ctor,
java_extents, java_codes,
font, fontRenderContext);
}