/* 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); }