G_MODULE_EXPORT void action_font_activate_cb(GtkWidget *widget, EDITOR *e) { GtkWidget *dialog; gchar *selected_text = NULL; gchar *size = NULL; #ifdef HAVE_GTK_32 dialog = gtk_font_chooser_dialog_new("Select font", NULL); gtk_font_chooser_set_font((GtkFontChooser *)dialog, #else dialog = gtk_font_selection_dialog_new("Select font"); gtk_font_selection_dialog_set_font_name((GtkFontSelectionDialog *) dialog, #endif "Droid Sans 14"); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { #ifdef HAVE_GTK_32 const gchar *fontname = gtk_font_chooser_get_font((GtkFontChooser *)dialog); #else const gchar *fontname = gtk_font_selection_dialog_get_font_name((GtkFontSelectionDialog *)dialog); #endif GString *name = g_string_new(fontname); size = get_font_size_from_name(name); g_string_free(name, TRUE); selected_text = editor_get_selected_text(e); #ifdef HAVE_GTK_32 PangoFontDescription *font_description = gtk_font_chooser_get_font_desc((GtkFontChooser *) dialog); fontname = pango_font_description_get_family(font_description); #else PangoFontDescription *font_description = pango_font_description_from_string(fontname); fontname = pango_font_description_get_family(font_description); #endif gchar *script = g_strdup_printf("<SPAN STYLE=\"font-family:%s;font-size:%spx;\">%s</SPAN>", fontname, size, selected_text); editor_insert_html(script, e); g_free(script); } if (size) g_free(size); if (selected_text) g_free(selected_text); gtk_widget_destroy(dialog); }
static void webkit_pref_callback_font_family (GSettings *settings, const char *key, gpointer data) { char *webkit_pref = data; char *value = NULL; char *schema = NULL; g_object_get (settings, "schema-id", &schema, NULL); /* If we are changing a GNOME font value and we are not using GNOME fonts in * Epiphany, return. */ if (g_strcmp0 (schema, EPHY_PREFS_WEB_SCHEMA) != 0 && g_settings_get_boolean (EPHY_SETTINGS_WEB, EPHY_PREFS_WEB_USE_GNOME_FONTS) != TRUE) { g_free (schema); return; } g_free (schema); value = g_settings_get_string (settings, key); if (value) { PangoFontDescription *desc; const char *family = NULL; desc = pango_font_description_from_string (value); family = pango_font_description_get_family (desc); g_object_set (webkit_settings, webkit_pref, family, NULL); pango_font_description_free (desc); } g_free (value); }
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); }
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; }
GtkWidget * make_families_menu () { GtkWidget *combo; int n_families; PangoFontFamily **families; GList *family_list = NULL; int i; pango_context_list_families (context, &families, &n_families); qsort (families, n_families, sizeof(char *), cmp_families); for (i=0; i<n_families; i++) family_list = g_list_prepend (family_list, pango_font_family_get_name (families[i])); family_list = g_list_reverse (family_list); combo = gtk_combo_new (); gtk_combo_set_popdown_strings (GTK_COMBO (combo), family_list); gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE); gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE); gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), pango_font_description_get_family(font_description)); gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed", GTK_SIGNAL_FUNC (set_family), NULL); g_list_free (family_list); return combo; }
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; }
JNIEXPORT jstring JNICALL Java_org_gnome_pango_PangoFontDescription_pango_1font_1description_1get_1family ( JNIEnv* env, jclass cls, jlong _self ) { const char* result; jstring _result; PangoFontDescription* self; // convert parameter self self = (PangoFontDescription*) _self; // call function result = pango_font_description_get_family(self); // cleanup parameter self // translate return value to JNI type _result = (jstring) bindings_java_newString(env, result); // and finally return _result; }
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; }
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 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 update_font_family_combo (MucharmapMiniFontSelection *fontsel) { GtkTreeModel *model = GTK_TREE_MODEL (fontsel->family_store); GtkTreeIter iter; const char *font_family; gboolean found = FALSE; font_family = pango_font_description_get_family (fontsel->font_desc); if (!font_family || !font_family[0]) { gtk_combo_box_set_active (GTK_COMBO_BOX (fontsel->family), -1); return; } if (!gtk_tree_model_get_iter_first (model, &iter)) return; do { char *family; gtk_tree_model_get (model, &iter, COL_FAMILIY, &family, -1); found = family && strcmp (family, font_family) == 0; g_free (family); } while (!found && gtk_tree_model_iter_next (model, &iter)); if (found) { gtk_combo_box_set_active_iter (GTK_COMBO_BOX (fontsel->family), &iter); } else { gtk_combo_box_set_active (GTK_COMBO_BOX (fontsel->family), -1); } }
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); }
static GtkCssValue * gtk_css_value_initial_compute (GtkCssValue *value, guint property_id, GtkStyleProviderPrivate *provider, GtkCssStyle *style, GtkCssStyle *parent_style) { GtkSettings *settings; switch (property_id) { case GTK_CSS_PROPERTY_DPI: settings = _gtk_style_provider_private_get_settings (provider); if (settings) { GdkScreen *screen = _gtk_settings_get_screen (settings); double resolution = gdk_screen_get_resolution (screen); if (resolution > 0.0) return _gtk_css_number_value_new (resolution, GTK_CSS_NUMBER); } break; case GTK_CSS_PROPERTY_FONT_FAMILY: settings = _gtk_style_provider_private_get_settings (provider); if (settings) { PangoFontDescription *description; char *font_name; GtkCssValue *value; g_object_get (settings, "gtk-font-name", &font_name, NULL); description = pango_font_description_from_string (font_name); g_free (font_name); if (description == NULL) break; if (pango_font_description_get_set_fields (description) & PANGO_FONT_MASK_FAMILY) { value = _gtk_css_array_value_new (_gtk_css_string_value_new (pango_font_description_get_family (description))); pango_font_description_free (description); return value; } pango_font_description_free (description); } break; default: break; } return _gtk_css_value_compute (_gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (property_id)), property_id, provider, style, parent_style); }
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; }
GR_Font * GR_UnixCairoGraphics::getGUIFont(void) { if (!m_pPFontGUI) { // get the font resource #if GTK_CHECK_VERSION(3,0,0) GtkStyleContext *tempCtxt = gtk_style_context_new(); GtkWidgetPath *path = gtk_widget_path_new(); gtk_widget_path_append_type (path, GTK_TYPE_WINDOW); gtk_style_context_set_path(tempCtxt, path); gtk_widget_path_free(path); const char *guiFontName = pango_font_description_get_family(gtk_style_context_get_font(tempCtxt, GTK_STATE_FLAG_NORMAL)); #else GtkStyle *tempStyle = gtk_style_new(); const char *guiFontName = pango_font_description_get_family(tempStyle->font_desc); #endif if (!guiFontName) guiFontName = "'Times New Roman'"; UT_UTF8String s = XAP_EncodingManager::get_instance()->getLanguageISOName(); const char * pCountry = XAP_EncodingManager::get_instance()->getLanguageISOTerritory(); if(pCountry) { s += "-"; s += pCountry; } m_pPFontGUI = new GR_PangoFont(guiFontName, 11.0, this, s.utf8_str(), true); #if GTK_CHECK_VERSION(3,0,0) g_object_unref(G_OBJECT(tempCtxt)); #else g_object_unref(G_OBJECT(tempStyle)); #endif UT_ASSERT(m_pPFontGUI); } return m_pPFontGUI; }
static void gnm_font_button_update_font_data (GnmFontButton *font_button) { GnmFontButtonPrivate *priv = font_button->priv; PangoFontFamily **families; PangoFontFace **faces; gint n_families, n_faces, i; const gchar *family; g_assert (priv->font_desc != NULL); priv->fontname = pango_font_description_to_string (priv->font_desc); family = pango_font_description_get_family (priv->font_desc); if (family == NULL) return; n_families = 0; families = NULL; pango_context_list_families (gtk_widget_get_pango_context (GTK_WIDGET (font_button)), &families, &n_families); n_faces = 0; faces = NULL; for (i = 0; i < n_families; i++) { const gchar *name = pango_font_family_get_name (families[i]); if (!g_ascii_strcasecmp (name, family)) { priv->font_family = g_object_ref (families[i]); pango_font_family_list_faces (families[i], &faces, &n_faces); break; } } g_free (families); for (i = 0; i < n_faces; i++) { PangoFontDescription *tmp_desc = pango_font_face_describe (faces[i]); if (font_description_style_equal (tmp_desc, priv->font_desc)) { priv->font_face = g_object_ref (faces[i]); pango_font_description_free (tmp_desc); break; } else pango_font_description_free (tmp_desc); } g_free (faces); }
void WindowCheckKeyterms::set_fonts() { extern Settings *settings; if (!settings->genconfig.text_editor_font_default_get()) { PangoFontDescription *desired_font_description = pango_font_description_from_string(settings->genconfig.text_editor_font_name_get().c_str()); const char * desired_font_family = pango_font_description_get_family (desired_font_description); WebKitWebSettings * webkit_settings = webkit_web_view_get_settings (WEBKIT_WEB_VIEW (webview_terms)); g_object_set (G_OBJECT (webkit_settings), "default-font-family", desired_font_family, NULL); pango_font_description_free (desired_font_description); } }
static int compare_font_descriptions (const PangoFontDescription *a, const PangoFontDescription *b) { int val = strcmp (pango_font_description_get_family(a), pango_font_description_get_family(b)); if (val != 0) return val; if (pango_font_description_get_weight(a) != pango_font_description_get_weight(b)) return pango_font_description_get_weight(a) - pango_font_description_get_weight(b); if (pango_font_description_get_style(a) != pango_font_description_get_style(b)) return pango_font_description_get_style(a) - pango_font_description_get_style(b); if (pango_font_description_get_stretch(a) != pango_font_description_get_stretch(b)) return pango_font_description_get_stretch(a) - pango_font_description_get_stretch(b); if (pango_font_description_get_stretch(a) != pango_font_description_get_stretch(b)) return pango_font_description_get_stretch(a) - pango_font_description_get_stretch(b); return 0; }
static void matekbd_indicator_config_load_font (MatekbdIndicatorConfig * ind_config) { GError *gerror = NULL; ind_config->font_family = mateconf_client_get_string (ind_config->conf_client, MATEKBD_INDICATOR_CONFIG_KEY_FONT_FAMILY, &gerror); if (gerror != NULL) { g_warning ("Error reading configuration:%s\n", gerror->message); ind_config->font_family = g_strdup ("Helvetica"); g_error_free (gerror); gerror = NULL; } ind_config->font_size = mateconf_client_get_int (ind_config->conf_client, MATEKBD_INDICATOR_CONFIG_KEY_FONT_SIZE, &gerror); if (gerror != NULL) { g_warning ("Error reading configuration:%s\n", gerror->message); ind_config->font_size = 10; g_error_free (gerror); gerror = NULL; } if (ind_config->font_family == NULL || ind_config->font_family[0] == '\0') { PangoFontDescription *fd = NULL; GtkStyle *style = gtk_rc_get_style_by_paths (gtk_settings_get_default (), GTK_STYLE_PATH, GTK_STYLE_PATH, GTK_TYPE_LABEL); if (style != NULL) fd = style->font_desc; if (fd != NULL) { ind_config->font_family = g_strdup (pango_font_description_get_family (fd)); ind_config->font_size = pango_font_description_get_size (fd) / PANGO_SCALE; } } xkl_debug (150, "font: [%s], size %d\n", ind_config->font_family, ind_config->font_size); }
DiaFont* dia_font_new(const char *family, DiaFontStyle style, real height) { DiaFont* font = dia_font_new_from_style(style, height); gboolean changed; changed = family != NULL && strcmp (pango_font_description_get_family(font->pfd), family) != 0; pango_font_description_set_family(font->pfd, family); if (changed) _dia_font_adjust_size (font, font->height, TRUE); return font; }
const std::string ZLGtkPaintContext::realFontFamilyName(std::string &fontFamily) const { if (myContext == 0) { return fontFamily; } PangoFontDescription *description = pango_font_description_new(); pango_font_description_set_family(description, fontFamily.c_str()); pango_font_description_set_size(description, 12); PangoFont *font = pango_context_load_font(myContext, description); pango_font_description_free(description); description = pango_font_describe(font); std::string realFamily = pango_font_description_get_family(description); pango_font_description_free(description); return realFamily; }
gchar * tbo_tool_text_get_font_name (TboToolText *self) { PangoFontDescription *pango_font = NULL; if (self->font) { pango_font = pango_font_description_from_string ( gtk_font_button_get_font_name (GTK_FONT_BUTTON (self->font))); return (gchar *)pango_font_description_get_family (pango_font); } return NULL; }
void dia_font_set_any_family(DiaFont* font, const char* family) { gboolean changed; g_return_if_fail(font != NULL); changed = strcmp (pango_font_description_get_family(font->pfd), family) != 0; pango_font_description_set_family(font->pfd, family); if (changed) /* force recalculation on name change */ _dia_font_adjust_size (font, font->height, TRUE); if (font->legacy_name) { g_free(font->legacy_name); font->legacy_name = NULL; } }
static gboolean webkit_get_font_family (GValue *value, GVariant *variant, gpointer user_data) { PangoFontDescription *font = pango_font_description_from_string ( g_variant_get_string (variant, NULL)); if (font == NULL) return FALSE; g_value_set_string (value, pango_font_description_get_family (font)); pango_font_description_free (font); return TRUE; }
/** * rpt_common_rptfont_from_pango_description: * @description: a #PangoFontDescription. * * Returns: a new allocated #RptFont from a #PangoFontDescription. */ RptFont *rpt_common_rptfont_from_pango_description (const PangoFontDescription *description) { RptFont *font; font = rpt_common_rptfont_new (); font->name = (gchar *)pango_font_description_get_family (description); font->size = pango_font_description_get_size (description) / PANGO_SCALE; font->bold = (pango_font_description_get_weight (description) == PANGO_WEIGHT_BOLD); font->italic = (pango_font_description_get_style (description) == PANGO_STYLE_ITALIC); font->underline = PANGO_UNDERLINE_NONE; font->strike = FALSE; font->color = rpt_common_rptcolor_new (); font->color->a = 1.0; return font; }
void ZLGtkPaintContext::setFont(const std::string &family, int size, bool bold, bool italic) { bool fontChanged = false; if (myFontDescription == 0) { myFontDescription = pango_font_description_new(); fontChanged = true; } const char *oldFamily = pango_font_description_get_family(myFontDescription); if ((oldFamily == 0) || (family != oldFamily)) { pango_font_description_set_family(myFontDescription, family.c_str()); fontChanged = true; } int newSize = size * PANGO_SCALE; if (pango_font_description_get_size(myFontDescription) != newSize) { pango_font_description_set_size(myFontDescription, newSize); fontChanged = true; } PangoWeight newWeight = bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL; if (pango_font_description_get_weight(myFontDescription) != newWeight) { pango_font_description_set_weight(myFontDescription, newWeight); fontChanged = true; } PangoStyle newStyle = italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL; if (pango_font_description_get_style(myFontDescription) != newStyle) { pango_font_description_set_style(myFontDescription, newStyle); fontChanged = true; } if (fontChanged) { if (myContext != 0) { myAnalysis.font = pango_context_load_font(myContext, myFontDescription); myAnalysis.shape_engine = pango_font_find_shaper(myAnalysis.font, 0, 0); PangoFontMetrics *metrics = pango_font_get_metrics(myAnalysis.font, myAnalysis.language); myDescent = pango_font_metrics_get_descent(metrics) / PANGO_SCALE; } myStringHeight = -1; mySpaceWidth = -1; } }
/* * Wrap calls to pango_font_description_get_family * and replace some of the pango font names with generic css names * http://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#generic-font-families * * This function should be called in place of pango_font_description_get_family() */ const char *sp_font_description_get_family(PangoFontDescription const *fontDescr) { static std::map<Glib::ustring, Glib::ustring> fontNameMap; std::map<Glib::ustring, Glib::ustring>::iterator it; if (fontNameMap.empty()) { fontNameMap.insert(std::make_pair("Sans", "sans-serif")); fontNameMap.insert(std::make_pair("Serif", "serif")); fontNameMap.insert(std::make_pair("Monospace", "monospace")); } const char *pangoFamily = pango_font_description_get_family(fontDescr); if (pangoFamily && ((it = fontNameMap.find(pangoFamily)) != fontNameMap.end())) { return ((Glib::ustring)it->second).c_str(); } return pangoFamily; }
static void contact_begin_print (GtkPrintOperation *operation, GtkPrintContext *context, EContactPrintContext *ctxt) { GtkPageSetup *setup; gdouble page_width; e_contact_build_style (ctxt->style); setup = gtk_print_context_get_page_setup (context); page_width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS); ctxt->context = context; ctxt->x = ctxt->y = .0; ctxt->column = 0; ctxt->first_contact = TRUE; ctxt->first_section = TRUE; ctxt->section = NULL; ctxt->column_spacing = gtk_print_context_get_dpi_x (context) / 4; ctxt->column_width = (page_width + ctxt->column_spacing) / ctxt->style->num_columns - ctxt->column_spacing; ctxt->letter_heading_font = pango_font_description_new (); pango_font_description_set_family ( ctxt->letter_heading_font, pango_font_description_get_family ( ctxt->style->headings_font)); pango_font_description_set_size ( ctxt->letter_heading_font, pango_font_description_get_size ( ctxt->style->headings_font) * 1.5); if (ctxt->contact_list != NULL) { ctxt->page_nr = -1; ctxt->pages = 1; g_slist_foreach (ctxt->contact_list, (GFunc) contact_draw, ctxt); gtk_print_operation_set_n_pages (operation, ctxt->pages); } }
static gboolean utils_font_desc_check_monospace(PangoContext *pc, PangoFontDescription *desc) { PangoFontFamily **families; gint n_families, i; const gchar *font; gboolean ret = TRUE; font = pango_font_description_get_family(desc); pango_context_list_families(pc, &families, &n_families); for (i = 0; i < n_families; i++) { if (utils_str_equal(font, pango_font_family_get_name(families[i]))) { if (!pango_font_family_is_monospace(families[i])) { ret = FALSE; } } } g_free(families); return ret; }