static void apply_values (void) { gchar *utf; grg_ctx_set_crypt_algo (gctx, tmp_pref_crypto); grg_ctx_set_hash_algo (gctx, tmp_pref_hash); grg_ctx_set_comp_algo (gctx, tmp_pref_comp); grg_ctx_set_comp_ratio (gctx, tmp_pref_ratio); g_free (grg_pref_file); grg_pref_file = g_strdup (gtk_entry_get_text (GTK_ENTRY (file_entry))); utf = g_filename_from_utf8 (grg_pref_file, -1, NULL, NULL, NULL); if (!g_file_test (utf, G_FILE_TEST_IS_REGULAR)) { g_free (grg_pref_file); grg_pref_file = NULL; gtk_entry_set_text (GTK_ENTRY (file_entry), ""); } g_free (utf); set_pref_font_string (pango_font_description_to_string (pango_context_get_font_description (gtk_widget_get_pango_context (gtk_bin_get_child (GTK_BIN (but_font)))))); set_editor_font (grg_prefs_editor_font); update_saveable (GRG_SAVE_ACTIVE); grg_save_prefs (); }
Glib::ustring font_factory::ConstructFontSpecification(PangoFontDescription *font) { Glib::ustring pangoString; g_assert(font); if (font) { // Once the format for the font specification is decided, it must be // kept.. if it is absolutely necessary to change it, the attribute // it is written to needs to have a new version so the legacy files // can be read. PangoFontDescription *copy = pango_font_description_copy(font); pango_font_description_unset_fields (copy, PANGO_FONT_MASK_SIZE); char * copyAsString = pango_font_description_to_string(copy); pangoString = copyAsString; g_free(copyAsString); copyAsString = 0; pango_font_description_free(copy); } return pangoString; }
static void tweet_window_style_set (GtkWidget *widget, GtkStyle *old_style) { TweetWindowPrivate *priv = TWEET_WINDOW (widget)->priv; ClutterColor active_color = { 0, }; ClutterColor text_color = { 0, }; ClutterColor bg_color = { 0, }; gchar *font_name; tweet_widget_get_base_color (widget, GTK_STATE_SELECTED, &active_color); tweet_widget_get_text_color (widget, GTK_STATE_NORMAL, &text_color); tweet_widget_get_bg_color (widget, GTK_STATE_NORMAL, &bg_color); font_name = pango_font_description_to_string (widget->style->font_desc); tidy_stylable_set (TIDY_STYLABLE (priv->scroll), "active-color", &active_color, "bg-color", &bg_color, NULL); tidy_stylable_set (TIDY_STYLABLE (priv->status_view), "active-color", &active_color, "bg-color", &bg_color, "text-color", &text_color, "font-name", font_name, NULL); g_free (font_name); }
gchar * gimp_font_util_pango_font_description_to_string (const PangoFontDescription *desc) { gchar *name; size_t wordlen; const gchar *p; g_return_val_if_fail (desc != NULL, NULL); name = pango_font_description_to_string (desc); p = getword (name, name + strlen (name), &wordlen); if (wordlen) { gchar *end; gdouble size; size = g_ascii_strtod (p, &end); if (end - p == wordlen) { gchar *new_name; new_name = g_strconcat (name, ",", NULL); g_free (name); name = new_name; } } return name; }
static void gimp_font_list_add_font (GimpFontList *list, PangoContext *context, PangoFontDescription *desc) { gchar *name; if (! desc) return; name = pango_font_description_to_string (desc); if (g_utf8_validate (name, -1, NULL)) { GimpFont *font; font = g_object_new (GIMP_TYPE_FONT, "name", name, "pango-context", context, NULL); gimp_container_add (GIMP_CONTAINER (list), GIMP_OBJECT (font)); g_object_unref (font); } g_free (name); }
static void st_entry_style_changed (StWidget *self) { StEntryPrivate *priv = ST_ENTRY_PRIV (self); StThemeNode *theme_node; ClutterColor color; const PangoFontDescription *font; gchar *font_string; gdouble size; theme_node = st_widget_get_theme_node (self); st_theme_node_get_foreground_color (theme_node, &color); clutter_text_set_color (CLUTTER_TEXT (priv->entry), &color); if (st_theme_node_lookup_length (theme_node, "caret-size", TRUE, &size)) clutter_text_set_cursor_size (CLUTTER_TEXT (priv->entry), (int)(.5 + size)); if (st_theme_node_lookup_color (theme_node, "caret-color", TRUE, &color)) clutter_text_set_cursor_color (CLUTTER_TEXT (priv->entry), &color); if (st_theme_node_lookup_color (theme_node, "selection-background-color", TRUE, &color)) clutter_text_set_selection_color (CLUTTER_TEXT (priv->entry), &color); if (st_theme_node_lookup_color (theme_node, "selected-color", TRUE, &color)) clutter_text_set_selected_text_color (CLUTTER_TEXT (priv->entry), &color); font = st_theme_node_get_font (theme_node); font_string = pango_font_description_to_string (font); clutter_text_set_font_name (CLUTTER_TEXT (priv->entry), font_string); g_free (font_string); ST_WIDGET_CLASS (st_entry_parent_class)->style_changed (self); }
G_MODULE_EXPORT void gw_settingswindow_sync_global_document_font_cb (GSettings *settings, gchar *KEY, gpointer data) { //Declarations GwSettingsWindow *window; GwSettingsWindowPrivate *priv; GwApplication *application; LwPreferences *preferences; gchar font[50]; gchar *font2; gchar *text; PangoFontDescription *desc; //Initializations window = GW_SETTINGSWINDOW (data); g_return_if_fail (window != NULL); priv = window->priv; application = gw_window_get_application (GW_WINDOW (window)); preferences = gw_application_get_preferences (application); lw_preferences_get_string_by_schema (preferences, font, LW_SCHEMA_GNOME_INTERFACE, LW_KEY_DOCUMENT_FONT_NAME, 50); desc = pango_font_description_from_string (font); pango_font_description_set_family (desc, "Serif"); font2 = pango_font_description_to_string (desc); if (font2) text = g_strdup_printf (gettext("_Use the System Document Font (%s)"), font2); g_free (font2); font2 = NULL; pango_font_description_free (desc); desc = NULL; if (text != NULL) { gtk_button_set_label (GTK_BUTTON (priv->system_font_checkbutton), text); g_free (text); } }
/** * static applet config functions */ static void matekbd_indicator_config_load_font (MatekbdIndicatorConfig * ind_config) { ind_config->font_family = g_settings_get_string (ind_config->settings, MATEKBD_INDICATOR_CONFIG_KEY_FONT_FAMILY); 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_to_string(fd)); } } xkl_debug (150, "font: [%s]\n", ind_config->font_family); }
gchar *get_font_name_from_widget(GtkWidget *widget) /* MUST BE FREED */ { GtkStyle *style; style = gtk_widget_get_style(widget); return pango_font_description_to_string(style->font_desc); }
/* compose_get_font */ static char const * _compose_get_font(Compose * compose) { char const * p; char * q; GtkSettings * settings; PangoFontDescription * desc; if((p = config_get(compose->config, NULL, "messages_font")) != NULL) return p; settings = gtk_settings_get_default(); g_object_get(G_OBJECT(settings), "gtk-font-name", &q, NULL); if(q != NULL) { desc = pango_font_description_from_string(q); g_free(q); pango_font_description_set_family(desc, "monospace"); q = pango_font_description_to_string(desc); config_set(compose->config, NULL, "messages_font", q); g_free(q); pango_font_description_free(desc); if((p = config_get(compose->config, NULL, "messages_font")) != NULL) return p; } return MAILER_MESSAGES_FONT; }
static void run_fontsel_settings_dlg(SettingsWidget *sw) { GtkWidget *dlg; const gchar *newfont; gchar *oldfont; dlg = gtk_font_selection_dialog_new(_("Select font")); gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dlg), gtk_label_get_text(GTK_LABEL(sw->widget))); if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { gtk_label_set_text(GTK_LABEL(sw->widget), gtk_font_selection_dialog_get_font_name( GTK_FONT_SELECTION_DIALOG(dlg))); } newfont = gtk_label_get_text(GTK_LABEL(sw->widget)); oldfont = pango_font_description_to_string( pango_context_get_font_description( gtk_widget_get_pango_context(GTK_WIDGET(sw->data)))); if (newfont && g_ascii_strcasecmp(oldfont, newfont) != 0) { string_replace(sw->conf, g_strdup(newfont)); jam_widget_set_font(sw->widget, newfont); jam_widget_set_font(sw->data, newfont); } g_free(oldfont); gtk_widget_destroy(dlg); }
JNIEXPORT jstring JNICALL Java_org_gnome_pango_PangoFontDescription_pango_1font_1description_1to_1string ( JNIEnv* env, jclass cls, jlong _self ) { char* result; jstring _result; PangoFontDescription* self; // convert parameter self self = (PangoFontDescription*) _self; // call function result = pango_font_description_to_string(self); // cleanup parameter self // translate return value to JNI type _result = (jstring) bindings_java_newString(env, result); // cleanup return value if (result != NULL) { g_free(result); } // and finally return _result; }
string PangoFontInfo::DescriptionName() const { if (!desc_) return ""; char* desc_str = pango_font_description_to_string(desc_); string desc_name(desc_str); g_free(desc_str); return desc_name; }
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; }
/** * he_helper_get_logical_font_desc: * @name: The logical font name (see he-helper.h for possible values) * * Returns a newly-allocated string that contains the string representation * of the Pango font description for the given logical string. This can be * used in the font_desc attribute of span elements in Pango markup. * * This function should be used to get the font desc for Pango markup in * special use cases (e.g. GtkTreeView, mixed-content GtkLabel). If you * want to set a logical font directly on a widget, you can use * #hildon_helper_set_logical_font (from Hildon 2.2) for this. * * The return value should be freed with g_free() after use. **/ gchar * he_helper_get_logical_font_desc (const gchar *name) { GtkSettings *settings = gtk_settings_get_default(); GtkStyle *style = gtk_rc_get_style_by_paths(settings, name, NULL, G_TYPE_NONE); return pango_font_description_to_string(style->font_desc); }
static void get_font_details_from_pattern (FontConfigFont * font, FcPattern * pattern) { int index; int slant; int weight; int width; int spacing; FcChar8 * file; FcChar8 * family; FcChar8 * style; g_assert(FcInit()); g_assert(FcPatternGetString(pattern, FC_FILE, 0, &file) == FcResultMatch); font_config_font_set_filepath(font, (const gchar *) file); font_config_font_set_owner(font, get_file_owner((const gchar *) file)); g_assert(FcPatternGetString(pattern, FC_FAMILY, 0, &family) == FcResultMatch); font_config_font_set_family(font, (const gchar *) family); if (FcPatternGetInteger(pattern, FC_INDEX, 0, &index) != FcResultMatch) index = 0; font_config_font_set_index(font, index); if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) != FcResultMatch) spacing = FC_PROPORTIONAL; font_config_font_set_spacing(font, spacing); if (FcPatternGetInteger(pattern, FC_SLANT, 0, &slant) != FcResultMatch) slant = FC_SLANT_ROMAN; font_config_font_set_slant(font, slant); if (FcPatternGetInteger(pattern, FC_WEIGHT, 0, &weight) != FcResultMatch) weight = FC_WEIGHT_MEDIUM; font_config_font_set_weight(font, weight); if (FcPatternGetInteger(pattern, FC_WIDTH, 0, &width) != FcResultMatch) width = FC_WIDTH_NORMAL; font_config_font_set_width(font, width); if (FcPatternGetString (pattern, FC_STYLE, 0, &style) != FcResultMatch) { /* Use the same style Pango would if none is given */ if (weight <= FC_WEIGHT_MEDIUM) { if (slant == FC_SLANT_ROMAN) font_config_font_set_style(font, "Regular"); else font_config_font_set_style(font, "Italic"); } else { if (slant == FC_SLANT_ROMAN) font_config_font_set_style(font, "Bold"); else font_config_font_set_style(font, "Bold Italic"); } } else { font_config_font_set_style(font, (const gchar *) style); } PangoFontDescription * descr = pango_fc_font_description_from_pattern(pattern, FALSE); gchar * desc_string = pango_font_description_to_string(descr); font_config_font_set_description(font, desc_string); pango_font_description_free(descr); g_free0(desc_string); return; }
static char * font_description_value_to_string (const GValue *value) { const PangoFontDescription *desc = g_value_get_boxed (value); if (desc == NULL) return g_strdup ("none"); return pango_font_description_to_string (desc); }
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 preferences_set_font (const char *key, const PangoFontDescription *font) { if (font != NULL) { char *str; str = pango_font_description_to_string (font); preferences_set_string (key, str); } else { preferences_set_string (key, NULL); } }
static void termomix_increase_font(GtkWidget *widget, void *data) { gint new_size; /* Increment font size one unit */ new_size = pango_font_description_get_size(termomix.font) + PANGO_SCALE; pango_font_description_set_size(termomix.font, new_size); termomix_set_font(); termomix_set_size(termomix.columns, termomix.rows); termomix_set_config_string("font", pango_font_description_to_string(termomix.font)); }
static void winfont_to_fontspec (char *spec, CHOOSEFONT *cf) { PangoFontDescription *pfd; char *fstr; pfd = pango_win32_font_description_from_logfont(cf->lpLogFont); pango_font_description_set_size(pfd, PANGO_SCALE * cf->iPointSize / 10); fstr = pango_font_description_to_string(pfd); strcpy(spec, fstr); g_free(fstr); pango_font_description_free(pfd); }
static gchar * font_name (PangoFont *font) { PangoFontDescription *desc; gchar *name; desc = pango_font_describe (font); name = pango_font_description_to_string (desc); pango_font_description_free (desc); return name; }
static char * mdm_get_font (const char *theme_name) { char *font_name; char *theme_dir; char *file_name; char buf[512]; GtkStyle *style; FILE *fp; style = gtk_widget_get_default_style (); font_name = pango_font_description_to_string (style->font_desc); theme_dir = gtk_rc_get_theme_dir (); file_name = g_build_filename (theme_dir, theme_name, INDEX_FILE1, NULL); if ( ! g_file_test (file_name, G_FILE_TEST_EXISTS)) { g_free (file_name); file_name = g_build_filename (theme_dir, theme_name, INDEX_FILE2, NULL); if ( ! g_file_test (file_name, G_FILE_TEST_EXISTS)) { g_free (theme_dir); g_free (file_name); return font_name; } } g_free (theme_dir); /* * FIXME: this is evil! */ fp = fopen (file_name, "r"); if (fp != NULL) { while (fgets (buf, 512, fp) != NULL) { if (strncmp ("ApplicationFont", buf, 15) == 0) { char *tmp_name; tmp_name = strchr (buf, '='); if (tmp_name != NULL) { g_free (font_name); font_name = strdup (tmp_name + 1); } fclose (fp); g_free (file_name); return font_name; } } fclose (fp); } g_free (file_name); return font_name; }
static void termomix_decrease_font(GtkWidget *widget, void *data) { gint new_size; /* Decrement font size one unit */ new_size=pango_font_description_get_size(termomix.font)-PANGO_SCALE; /* Set a minimal size */ if (new_size >= FONT_MINIMAL_SIZE ) { pango_font_description_set_size(termomix.font, new_size); termomix_set_font(); termomix_set_size(termomix.columns, termomix.rows); termomix_set_config_string("font", pango_font_description_to_string(termomix.font)); } }
/** * _st_set_text_from_style: * @text: Target #ClutterText * @theme_node: Source #StThemeNode * * Set various GObject properties of the @text object using * CSS information from @theme_node. */ void _st_set_text_from_style (ClutterText *text, StThemeNode *theme_node) { ClutterColor color; StTextDecoration decoration; PangoAttrList *attribs; const PangoFontDescription *font; gchar *font_string; StTextAlign align; st_theme_node_get_foreground_color (theme_node, &color); clutter_text_set_color (text, &color); font = st_theme_node_get_font (theme_node); font_string = pango_font_description_to_string (font); clutter_text_set_font_name (text, font_string); g_free (font_string); attribs = pango_attr_list_new (); decoration = st_theme_node_get_text_decoration (theme_node); if (decoration & ST_TEXT_DECORATION_UNDERLINE) { PangoAttribute *underline = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE); pango_attr_list_insert (attribs, underline); } if (decoration & ST_TEXT_DECORATION_LINE_THROUGH) { PangoAttribute *strikethrough = pango_attr_strikethrough_new (TRUE); pango_attr_list_insert (attribs, strikethrough); } /* Pango doesn't have an equivalent attribute for _OVERLINE, and we deliberately * skip BLINK (for now...) */ clutter_text_set_attributes (text, attribs); pango_attr_list_unref (attribs); align = st_theme_node_get_text_align (theme_node); if(align == ST_TEXT_ALIGN_JUSTIFY) { clutter_text_set_justify (text, TRUE); clutter_text_set_line_alignment (text, PANGO_ALIGN_LEFT); } else { clutter_text_set_justify (text, FALSE); clutter_text_set_line_alignment (text, (PangoAlignment) align); } }
char* iupdrvGetSystemFont(void) { static char systemfont[200] = ""; GtkStyle* style; GtkWidget* widget = gtk_invisible_new(); gtk_widget_realize(widget); style = gtk_widget_get_style(widget); if (!style || !style->font_desc) strcpy(systemfont, "Sans, 10"); else strcpy(systemfont, pango_font_description_to_string(style->font_desc)); gtk_widget_unrealize(widget); gtk_widget_destroy(widget); return systemfont; }
static void font_description_value_print (const GValue *value, GString *string) { const PangoFontDescription *desc = g_value_get_boxed (value); if (desc == NULL) g_string_append (string, "none"); else { char *s = pango_font_description_to_string (desc); g_string_append (string, s); g_free (s); } }
wxString wxNativeFontInfo::ToString() const { wxGtkString str(pango_font_description_to_string( description )); wxString desc = wxPANGO_CONV_BACK(str); // Augment the string with the attributes not handled by Pango. // // Notice that we must add them in the same order they are extracted in // FromString() above. if (m_strikethrough) desc.insert(0, wxS("strikethrough ")); if (m_underlined) desc.insert(0, wxS("underlined ")); return desc; }
void font_factory::UnrefFace(font_instance *who) { if ( who ) { FaceMapType& loadedFaces = *static_cast<FaceMapType*>(loadedPtr); if ( loadedFaces.find(who->descr) == loadedFaces.end() ) { // not found char *tc = pango_font_description_to_string(who->descr); g_warning("unrefFace %p=%s: failed\n",who,tc); g_free(tc); } else { loadedFaces.erase(loadedFaces.find(who->descr)); // printf("unrefFace %p: success\n",who); } } }
/** awesome global table. * \param L The Lua VM state. * \return The number of elements pushed on stack. * \luastack * \lfield font The default font. * \lfield font_height The default font height. * \lfield conffile The configuration file which has been loaded. */ static int luaA_awesome_index(lua_State *L) { if(luaA_usemetatable(L, 1, 2)) return 1; size_t len; const char *buf = luaL_checklstring(L, 2, &len); switch(a_tokenize(buf, len)) { case A_TK_FONT: { char *font = pango_font_description_to_string(globalconf.font->desc); lua_pushstring(L, font); g_free(font); } break; case A_TK_FONT_HEIGHT: lua_pushnumber(L, globalconf.font->height); break; case A_TK_CONFFILE: lua_pushstring(L, globalconf.conffile); break; case A_TK_FG: luaA_pushxcolor(L, globalconf.colors.fg); break; case A_TK_BG: luaA_pushxcolor(L, globalconf.colors.bg); break; case A_TK_VERSION: lua_pushliteral(L, AWESOME_VERSION); break; case A_TK_RELEASE: lua_pushliteral(L, AWESOME_RELEASE); break; case A_TK_STARTUP_ERRORS: if (globalconf.startup_errors.len == 0) return 0; lua_pushstring(L, globalconf.startup_errors.s); default: return 0; } return 1; }