/* callback to react to key press events */
static gboolean
key_press_cb(VteTerminal* vte, GdkEventKey* event)
{
if ((event->state & (TINYTERM_MODIFIER)) == (TINYTERM_MODIFIER)) {
switch (gdk_keyval_to_upper(event->keyval)) {
case TINYTERM_KEY_FONTSIZE_INCREASE:
{
const PangoFontDescription *font = vte_terminal_get_font(vte);
pango_font_description_set_size(font, (pango_font_description_get_size(font) / PANGO_SCALE + 1) * PANGO_SCALE);
vte_terminal_set_font(vte, font);
return TRUE;
}
case TINYTERM_KEY_FONTSIZE_DECREASE:
{
const PangoFontDescription *font = vte_terminal_get_font(vte);
const gint size = pango_font_description_get_size(font) / PANGO_SCALE - 1;
if (size > 0) {
pango_font_description_set_size(font, size * PANGO_SCALE);
vte_terminal_set_font(vte, font);
}
return TRUE;
}
}
}
return FALSE;
}
void clock_init_fonts()
{
if (!time1_font_desc) {
time1_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_weight(time1_font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size(time1_font_desc, pango_font_description_get_size(time1_font_desc));
}
if (!time2_font_desc) {
time2_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(time2_font_desc,
pango_font_description_get_size(time2_font_desc) - PANGO_SCALE);
}
}
/* Return the font size in Pango units for the font size setting */
gint
get_font_size(PangoFontDescription *font)
{
I7App *theapp = i7_app_get();
double size = pango_font_description_get_size(font);
if(pango_font_description_get_size_is_absolute(font))
size *= 96.0 / 72.0; /* a guess; not likely to be absolute anyway */
if(size == 0.0)
size = DEFAULT_SIZE_STANDARD * PANGO_SCALE;
switch(g_settings_get_enum(i7_app_get_prefs(theapp), PREFS_FONT_SIZE)) {
case FONT_SIZE_MEDIUM:
size *= RELATIVE_SIZE_MEDIUM;
break;
case FONT_SIZE_LARGE:
size *= RELATIVE_SIZE_LARGE;
break;
case FONT_SIZE_HUGE:
size *= RELATIVE_SIZE_HUGE;
break;
default:
size *= RELATIVE_SIZE_STANDARD;
}
return size;
}
void
gkbd_indicator_config_get_font_for_widget (GkbdIndicatorConfig *
ind_config, GtkWidget * widget,
gchar ** font_family,
int *font_size)
{
GtkStyleContext *context;
const PangoFontDescription *fd = NULL;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (ind_config->font_family != NULL &&
ind_config->font_family[0] != '\0') {
if (font_family)
*font_family = g_strdup (ind_config->font_family);
if (font_size)
*font_size = ind_config->font_size;
return;
}
context = gtk_widget_get_style_context (widget);
fd = gtk_style_context_get_font (context, GTK_STATE_FLAG_NORMAL);
if (font_family)
*font_family =
g_strdup (pango_font_description_get_family (fd));
if (font_size)
*font_size =
pango_font_description_get_size (fd) / PANGO_SCALE;
}
static gboolean
util_split_font_string(const gchar *font_name, gchar **name, gint *size)
{
PangoFontDescription *desc;
PangoFontMask mask;
gboolean retval = FALSE;
if (font_name == NULL) {
return FALSE;
}
mask = (PangoFontMask) (PANGO_FONT_MASK_FAMILY | PANGO_FONT_MASK_SIZE);
desc = pango_font_description_from_string(font_name);
if (!desc) {
return FALSE;
}
if ((pango_font_description_get_set_fields(desc) & mask) == mask) {
*size = PANGO_PIXELS(pango_font_description_get_size (desc));
*name = g_strdup(pango_font_description_get_family (desc));
retval = TRUE;
}
pango_font_description_free(desc);
return retval;
}
static void
font_size_action_ativated (GSimpleAction *action,
GVariant *parameter,
gpointer userdata)
{
VteTerminal *vtterm = window_get_term_widget (GTK_WINDOW (userdata));
const gint modifier = g_variant_get_int32 (parameter);
const PangoFontDescription *fontd = vte_terminal_get_font (vtterm);
gint old_size = pango_font_description_get_size (fontd);
if (default_font_size == 0)
default_font_size = old_size;
PangoFontDescription *new_fontd;
gint new_size;
switch (modifier) {
case 0:
old_size = default_font_size;
/* fall-through */
case 1:
case -1:
new_size = old_size + modifier * PANGO_SCALE;
new_fontd = pango_font_description_copy_static (fontd);
pango_font_description_set_size (new_fontd, new_size);
vte_terminal_set_font (vtterm, new_fontd);
break;
default:
g_printerr ("%s: invalid modifier '%i'", __func__, modifier);
return;
}
pango_font_description_free (new_fontd);
}
static void
apply_subtitle_style_to_layout (GtkStyleContext *context,
PangoLayout *layout,
GtkStateFlags flags)
{
PangoFontDescription *desc;
PangoAttrList *layout_attr;
PangoAttribute *attr_alpha;
gtk_style_context_save (context);
gtk_style_context_set_state (context, flags);
gtk_style_context_get (context, gtk_style_context_get_state (context),
"font", &desc,
NULL);
gtk_style_context_restore (context);
/* Set the font size */
pango_font_description_set_size (desc, pango_font_description_get_size (desc) * SUBTITLE_SIZE_PERCENTAGE);
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
/* Set the font alpha */
layout_attr = pango_attr_list_new ();
attr_alpha = pango_attr_foreground_alpha_new (SUBTITLE_DIM_PERCENTAGE * 65535);
pango_attr_list_insert (layout_attr, attr_alpha);
pango_layout_set_attributes (layout, layout_attr);
pango_attr_list_unref (layout_attr);
}
bool GtkToolkitUiSettings::GetDefaultFont(FontDetails& font)
{
gchararray font_face = 0;
g_object_get(m_settings, "gtk-font-name", &font_face, NULL);
PangoFontDescription* font_desc = pango_font_description_from_string(font_face);
g_free(font_face);
if (!font_desc)
return false;
const char* family = pango_font_description_get_family(font_desc);
if (family)
{
if (strcmp(family, "Sans") == 0)
font.type = SANSSERIF;
else if (strcmp(family, "Serif") == 0)
font.type = SERIF;
else if (strcmp(family, "Monospace") == 0)
font.type = MONOSPACE;
font.family = strdup(family);
}
font.weight = pango_font_description_get_weight(font_desc) / 100;
font.italic = pango_font_description_get_style(font_desc) == PANGO_STYLE_ITALIC;
font.smallcaps = pango_font_description_get_variant(font_desc) == PANGO_VARIANT_SMALL_CAPS;
double size = pango_font_description_get_size(font_desc) / PANGO_SCALE;
font.size = size;
pango_font_description_free(font_desc);
return true;
}
static void
gm_cell_renderer_bitext_update_style (GmCellRendererBitext* renderer,
GtkWidget* widget)
{
GtkStyleContext *style = NULL;
GtkStateFlags state;
PangoAttrList *attr_list = NULL;
PangoAttribute *attr_size = NULL;
const PangoFontDescription* font = NULL;
style = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
attr_list = pango_attr_list_new ();
/* we want the secondary text smaller */
gtk_style_context_get (style, state,
"font", &font,
NULL);
attr_size = pango_attr_size_new ((int) (pango_font_description_get_size (font) * 0.8));
attr_size->start_index = strlen (renderer->priv->primary_text) + 1;
attr_size->end_index = (guint) - 1;
pango_attr_list_insert (attr_list, attr_size);
g_object_set (renderer,
"visible", TRUE,
"weight", PANGO_WEIGHT_NORMAL,
"attributes", attr_list,
NULL);
pango_attr_list_unref (attr_list);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetFont
(JNIEnv *env, jobject obj, jobject font)
{
struct graphics2d *gr = NULL;
struct peerfont *pfont = NULL;
cairo_font_t *ft = NULL;
FT_Face face = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
pfont = (struct peerfont *)NSA_GET_FONT_PTR (env, font);
g_assert (pfont != NULL);
gdk_threads_enter ();
face = pango_ft2_font_get_face (pfont->font);
g_assert (face != NULL);
ft = cairo_ft_font_create_for_ft_face (face);
g_assert (ft != NULL);
if (gr->debug) printf ("cairo_set_font '%s'\n", face->family_name);
cairo_set_font (gr->cr, ft);
cairo_scale_font (gr->cr,
pango_font_description_get_size (pfont->desc) /
(double)PANGO_SCALE);
cairo_font_destroy (ft);
gdk_threads_leave ();
}
/* This function is based on reverse_engineer_stepper_box
* (and gtk2 sources) except it is for getting spin button
* size instead. It is not always right, and only returns
* a (hopefully more accurate) arrow box, not the entire
* button box, as the button box is passed correctly
* to paint_box and so only paint_arrow needs this.
*/
void
reverse_engineer_spin_button (GtkWidget *widget,
GtkArrowType arrow_type,
gint *x,
gint *y,
gint *width,
gint *height)
{
#ifdef GTK2
gint size = pango_font_description_get_size (widget->style->font_desc);
gint realheight, realwidth;
realwidth = MIN(PANGO_PIXELS (size), 30);
realwidth -= realwidth % 2; /* force even */
realwidth -= 2 * xthickness(widget->style);
realheight = ((widget->requisition.height) - 2 * ythickness(widget->style)) / 2;
realheight -= 1;
realwidth += 1;
*x += ((*width - realwidth) / 2);
*y += ((*height - realheight) / 2) + (arrow_type==GTK_ARROW_DOWN?1:-1);
*width = realwidth;
*height = realheight;
#endif
}
JNIEXPORT jint JNICALL
Java_org_gnome_pango_PangoFontDescription_pango_1font_1description_1get_1size
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gint result;
jint _result;
PangoFontDescription* self;
// convert parameter self
self = (PangoFontDescription*) _self;
// call function
result = pango_font_description_get_size(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jint) result;
// and finally
return _result;
}
bool PangoFontInfo::ParseFontDescription(const PangoFontDescription *desc) {
Clear();
const char* family = pango_font_description_get_family(desc);
if (!family) {
char* desc_str = pango_font_description_to_string(desc);
tprintf("WARNING: Could not parse family name from description: '%s'\n",
desc_str);
g_free(desc_str);
return false;
}
family_name_ = string(family);
desc_ = pango_font_description_copy(desc);
is_monospace_ = IsMonospaceFontFamily(family);
// Set font size in points
font_size_ = pango_font_description_get_size(desc);
if (!pango_font_description_get_size_is_absolute(desc)) {
font_size_ /= PANGO_SCALE;
}
PangoStyle style = pango_font_description_get_style(desc);
is_italic_ = (PANGO_STYLE_ITALIC == style ||
PANGO_STYLE_OBLIQUE == style);
is_smallcaps_ = (pango_font_description_get_variant(desc)
== PANGO_VARIANT_SMALL_CAPS);
is_bold_ = (pango_font_description_get_weight(desc) >= PANGO_WEIGHT_BOLD);
// We dont have a way to detect whether a font is of type Fraktur. The fonts
// we currently use all have "Fraktur" in their family name, so we do a
// fragile but functional check for that here.
is_fraktur_ = (strcasestr(family, "Fraktur") != NULL);
return true;
}
static gboolean
webkit_get_font_size (GValue *value,
GVariant *variant,
gpointer user_data)
{
PangoFontDescription *font = pango_font_description_from_string (
g_variant_get_string (variant, NULL));
int size;
if (font == NULL)
return FALSE;
size = pango_font_description_get_size (font) / PANGO_SCALE;
if (pango_font_description_get_size_is_absolute (font))
{
GdkScreen *screen = gdk_screen_get_default ();
double dpi;
if (screen != NULL)
dpi = gdk_screen_get_resolution (screen);
else
dpi = BORING_DPI_DEFAULT;
size = (gint) (size / (dpi / 72));
}
g_value_set_int (value, size);
pango_font_description_free (font);
return TRUE;
}
/**
* gwy_graph_label_new:
*
* Creates a new graph label.
*
* Returns: A new graph label widget as a #GtkWidget.
**/
GtkWidget*
gwy_graph_label_new()
{
GwyGraphLabel *label;
PangoFontDescription *description;
PangoContext *context;
gint size;
gwy_debug("");
label = g_object_new(GWY_TYPE_GRAPH_LABEL, NULL);
context = gtk_widget_get_pango_context(GTK_WIDGET(label));
description = pango_context_get_font_description(context);
/* Make major font a bit smaller */
label->font_desc = pango_font_description_copy(description);
size = pango_font_description_get_size(label->font_desc);
size = MAX(1, size*10/11);
pango_font_description_set_size(label->font_desc, size);
gtk_widget_set_events(GTK_WIDGET(label), 0);
return GTK_WIDGET(label);
}
static void
gimp_scale_combo_box_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GtkWidget *entry;
GtkRcStyle *rc_style;
gint font_size;
gdouble scale;
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget, "label-scale", &scale, NULL);
entry = gtk_bin_get_child (GTK_BIN (widget));
rc_style = gtk_widget_get_modifier_style (GTK_WIDGET (entry));
if (! rc_style->font_desc)
{
PangoContext *context;
PangoFontDescription *font_desc;
context = gtk_widget_get_pango_context (widget);
font_desc = pango_context_get_font_description (context);
rc_style->font_desc = pango_font_description_copy (font_desc);
}
font_size = pango_font_description_get_size (rc_style->font_desc);
pango_font_description_set_size (rc_style->font_desc, scale * font_size);
gtk_widget_modify_style (GTK_WIDGET (entry), rc_style);
}
static void
adjust_font_size(GtkWidget *widget, gpointer data, gint howmuch)
{
VteTerminal *terminal;
PangoFontDescription *desired;
gint newsize;
gint columns, rows, owidth, oheight;
/* Read the screen dimensions in cells. */
terminal = VTE_TERMINAL(widget);
columns = terminal->column_count;
rows = terminal->row_count;
/* Take into account padding and border overhead. */
gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight);
owidth -= terminal->char_width * terminal->column_count;
oheight -= terminal->char_height * terminal->row_count;
/* Calculate the new font size. */
desired = pango_font_description_copy(vte_terminal_get_font(terminal));
newsize = pango_font_description_get_size(desired) / PANGO_SCALE;
newsize += howmuch;
pango_font_description_set_size(desired,
CLAMP(newsize, 4, 144) * PANGO_SCALE);
/* Change the font, then resize the window so that we have the same
* number of rows and columns. */
vte_terminal_set_font(terminal, desired);
gtk_window_resize(GTK_WINDOW(data),
columns * terminal->char_width + owidth,
rows * terminal->char_height + oheight);
pango_font_description_free(desired);
}
void MapPainterSVG::GetTextDimension(const Projection& projection,
const MapParameter& parameter,
double fontSize,
const std::string& text,
double& xOff,
double& yOff,
double& width,
double& height)
{
#if defined(OSMSCOUT_MAP_SVG_HAVE_LIB_PANGO)
PangoFontDescription *font;
PangoLayout *layout=pango_layout_new(pangoContext);
PangoRectangle extends;
font=GetFont(projection,
parameter,
fontSize);
pango_layout_set_font_description(layout,font);
pango_layout_set_text(layout,text.c_str(),text.length());
pango_layout_get_pixel_extents(layout,&extends,NULL);
xOff=extends.x;
yOff=extends.y;
width=extends.width;
height=pango_font_description_get_size(font)/PANGO_SCALE;
g_object_unref(layout);
#endif
}
void RenderThemeGtk::systemFont(CSSValueID, FontDescription& fontDescription) const
{
GtkSettings* settings = gtk_settings_get_default();
if (!settings)
return;
// This will be a font selection string like "Sans 10" so we cannot use it as the family name.
GUniqueOutPtr<gchar> fontName;
g_object_get(settings, "gtk-font-name", &fontName.outPtr(), NULL);
PangoFontDescription* pangoDescription = pango_font_description_from_string(fontName.get());
if (!pangoDescription)
return;
fontDescription.setOneFamily(pango_font_description_get_family(pangoDescription));
int size = pango_font_description_get_size(pangoDescription) / PANGO_SCALE;
// If the size of the font is in points, we need to convert it to pixels.
if (!pango_font_description_get_size_is_absolute(pangoDescription))
size = size * (getScreenDPI() / 72.0);
fontDescription.setSpecifiedSize(size);
fontDescription.setIsAbsoluteSize(true);
fontDescription.setGenericFamily(FontDescription::NoFamily);
fontDescription.setWeight(FontWeightNormal);
fontDescription.setItalic(false);
pango_font_description_free(pangoDescription);
}
real
dia_font_get_size(const DiaFont* font)
{
if (!pango_font_description_get_size_is_absolute (font->pfd))
g_warning ("dia_font_get_size() : no absolute size");
return pdu_to_dcm(pango_font_description_get_size(font->pfd));
}
/* Taken from the Gtk+ file gtkfilechooserdefault.c
* Copyright (C) 2003, Red Hat, Inc.
*
* Changed by File-Roller authors
*
* Guesses a size based upon font sizes */
static int
get_font_size (GtkWidget *widget)
{
GtkStyleContext *context;
GtkStateFlags state;
int font_size;
GdkScreen *screen;
double resolution;
PangoFontDescription *font;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
screen = gtk_widget_get_screen (widget);
if (screen) {
resolution = gdk_screen_get_resolution (screen);
if (resolution < 0.0) /* will be -1 if the resolution is not defined in the GdkScreen */
resolution = 96.0;
}
else
resolution = 96.0; /* wheeee */
gtk_style_context_get (context, state, "font", &font, NULL);
font_size = pango_font_description_get_size (font);
font_size = PANGO_PIXELS (font_size) * resolution / 72.0;
return font_size;
}
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 gchar*
get_default_font (GtkWidget *widget)
{
PangoFontDescription *font_desc = widget->style->font_desc;
return g_strdup_printf ("%s %d",
pango_font_description_get_family (font_desc),
pango_font_description_get_size (font_desc) / PANGO_SCALE);
}
float
draw_get_font_size (drawctx_t *ctx) {
draw_init_font (ctx, NULL);
GdkScreen *screen = gdk_screen_get_default ();
float dpi = gdk_screen_get_resolution (screen);
PangoFontDescription *desc = ctx->font_style->font_desc;
return (float)(pango_font_description_get_size (desc) / PANGO_SCALE * dpi / 72);
}
void
mucharmap_mini_font_selection_set_font_desc (MucharmapMiniFontSelection *fontsel,
PangoFontDescription *font_desc)
{
GObject *object = G_OBJECT (fontsel);
PangoFontDescription *new_font_desc;
const char *new_font_family;
g_return_if_fail (MUCHARMAP_IS_MINI_FONT_SELECTION (fontsel));
g_return_if_fail (font_desc != NULL);
g_object_freeze_notify (object);
new_font_desc = pango_font_description_copy (font_desc);
new_font_family = pango_font_description_get_family (new_font_desc);
if (!new_font_family) {
pango_font_description_set_family (new_font_desc, "Sans");
new_font_family = pango_font_description_get_family (new_font_desc);
}
if ((!fontsel->font_desc ||
strcmp (pango_font_description_get_family (fontsel->font_desc), new_font_family) != 0) &&
pango_font_description_get_size (new_font_desc) > 0)
fontsel->default_size = pango_font_description_get_size (new_font_desc) / PANGO_SCALE;
if (fontsel->font_desc)
pango_font_description_free (fontsel->font_desc);
fontsel->font_desc = new_font_desc;
update_font_family_combo (fontsel);
/* treat oblique and italic both as italic */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fontsel->italic), pango_font_description_get_style (fontsel->font_desc) == PANGO_STYLE_ITALIC || pango_font_description_get_style (fontsel->font_desc) == PANGO_STYLE_OBLIQUE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fontsel->bold), pango_font_description_get_weight (fontsel->font_desc) > PANGO_WEIGHT_NORMAL);
gtk_adjustment_set_value (
GTK_ADJUSTMENT (fontsel->size_adj),
pango_font_description_get_size (fontsel->font_desc) / PANGO_SCALE);
g_object_notify (G_OBJECT (fontsel), "font-desc");
g_object_thaw_notify (object);
}
nsresult
nsSystemFontsGTK2::GetSystemFontInfo(GtkWidget *aWidget, nsString *aFontName,
gfxFontStyle *aFontStyle) const
{
#ifdef MOZ_PANGO
GtkSettings *settings = gtk_widget_get_settings(aWidget);
aFontStyle->style = FONT_STYLE_NORMAL;
gchar *fontname;
g_object_get(settings, "gtk-font-name", &fontname, NULL);
PangoFontDescription *desc;
desc = pango_font_description_from_string(fontname);
aFontStyle->systemFont = PR_TRUE;
g_free(fontname);
NS_NAMED_LITERAL_STRING(quote, "\"");
NS_ConvertUTF8toUTF16 family(pango_font_description_get_family(desc));
*aFontName = quote + family + quote;
aFontStyle->weight = pango_font_description_get_weight(desc);
// FIXME: Set aFontStyle->stretch correctly!
aFontStyle->stretch = NS_FONT_STRETCH_NORMAL;
float size = float(pango_font_description_get_size(desc)) / PANGO_SCALE;
// |size| is now either pixels or pango-points (not Mozilla-points!)
if (!MOZ_pango_font_description_get_size_is_absolute(desc)) {
// |size| is in pango-points, so convert to pixels.
size *= float(gfxPlatformGtk::GetDPI()) / POINTS_PER_INCH_FLOAT;
}
// |size| is now pixels
aFontStyle->size = size;
pango_font_description_free(desc);
#else
/* FIXME: DFB FT2 Hardcoding the system font info for now.. */
aFontStyle->style = FONT_STYLE_NORMAL;
aFontStyle->systemFont = PR_TRUE;
NS_NAMED_LITERAL_STRING(fontname, "\"Sans\"");
*aFontName = fontname;
aFontStyle->weight = 400;
aFontStyle->size = 40/3;
#endif
return NS_OK;
}
int ZLGtkPaintContext::stringHeight() const {
if (myFontDescription == 0) {
return 0;
}
if (myStringHeight == -1) {
#if GTK_CHECK_VERSION(2,10,0)
if (pango_font_description_get_size_is_absolute(myFontDescription)) {
myStringHeight = pango_font_description_get_size(myFontDescription) / PANGO_SCALE + 2;
} else {
static const int resolution = gdk_screen_get_resolution(gdk_screen_get_default());
myStringHeight = pango_font_description_get_size(myFontDescription) * resolution / 72 / PANGO_SCALE + 2;
}
#else // GTK_CHECK_VERSION(2,10,0)
myStringHeight = pango_font_description_get_size(myFontDescription) / PANGO_SCALE + 2;
#endif // GTK_CHECK_VERSION(2,10,0)
}
return myStringHeight;
}
int GtkPaintContext::stringHeight() const {
if (myFontDescription == 0) {
return 0;
}
if (myStringHeight == -1) {
myStringHeight = pango_font_description_get_size(myFontDescription) / PANGO_SCALE + 2;
}
return myStringHeight;
}
/* returns 0 if the font is safe, otherwise returns the size in points. */
static gint
font_dangerous (const char *font)
{
PangoFontDescription *pfd;
gboolean retval = 0;
pfd = pango_font_description_from_string (font);
if (pfd == NULL)
/* an invalid font was passed in. This isn't our problem. */
return 0;
if ((pango_font_description_get_set_fields (pfd) & PANGO_FONT_MASK_SIZE) &&
(pango_font_description_get_size (pfd) >= MAX_FONT_SIZE_WITHOUT_WARNING)) {
retval = pango_font_description_get_size (pfd)/1024;
}
pango_font_description_free (pfd);
return retval;
}
void wxFontRefData::InitFromNative()
{
// Get native info
PangoFontDescription *desc = m_nativeFontInfo.description;
// Pango sometimes needs to have a size
int pango_size = pango_font_description_get_size( desc );
if (pango_size == 0)
m_nativeFontInfo.SetPointSize(wxDEFAULT_FONT_SIZE);
}
