bool FontPlatformData::init()
{
static bool initialized = false;
if (initialized)
return true;
initialized = true;
if (!m_fontMap)
m_fontMap = pango_cairo_font_map_get_default();
if (!m_hashTable) {
PangoFontFamily** families = 0;
int n_families = 0;
m_hashTable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
pango_font_map_list_families(m_fontMap, &families, &n_families);
for (int family = 0; family < n_families; family++)
g_hash_table_insert(m_hashTable,
g_strdup(pango_font_family_get_name(families[family])),
g_object_ref(families[family]));
g_free(families);
}
return true;
}
static void
gimp_font_list_load_names (GimpFontList *list,
PangoFontMap *fontmap,
PangoContext *context)
{
PangoFontFamily **families;
PangoFontFace **faces;
gint n_families;
gint n_faces;
gint i, j;
pango_font_map_list_families (fontmap, &families, &n_families);
for (i = 0; i < n_families; i++)
{
pango_font_family_list_faces (families[i], &faces, &n_faces);
for (j = 0; j < n_faces; j++)
{
PangoFontDescription *desc;
desc = pango_font_face_describe (faces[j]);
gimp_font_list_add_font (list, context, desc);
pango_font_description_free (desc);
}
}
g_free (families);
}
int main(int argc, char **argv) {
PangoFontMap* map;
PangoFontFamily **families;
int n_families;
int i;
PangoFontFace **faces;
int n_faces;
int j;
gtk_init(&argc, &argv);
map = pango_cairo_font_map_get_default();
pango_font_map_list_families(map, &families, &n_families);
for (i = 0; i < n_families; i++) {
g_print("%s\n", pango_font_family_get_name(families[i]));
pango_font_family_list_faces(families[i], &faces, &n_faces);
for (j = 0; j < n_faces; j++) {
g_print(" %s\n", pango_font_face_get_face_name(faces[j]));
}
}
return 0;
}
gboolean
gtkutil_find_font (const char *fontname)
{
int i;
int n_families;
const char *family_name;
PangoFontMap *fontmap;
PangoFontFamily *family;
PangoFontFamily **families;
fontmap = pango_cairo_font_map_get_default ();
pango_font_map_list_families (fontmap, &families, &n_families);
for (i = 0; i < n_families; i++)
{
family = families[i];
family_name = pango_font_family_get_name (family);
if (!g_ascii_strcasecmp (family_name, fontname))
{
g_free (families);
return TRUE;
}
}
g_free (families);
return FALSE;
}
struct PP_Var
ppb_font_dev_get_font_families(PP_Instance instance)
{
PangoFontFamily **families;
int n, k, total_len;
pango_font_map_list_families(tables_get_pango_font_map(), &families, &n);
total_len = 0;
for (k = 0; k < n; k ++) {
const char *name = pango_font_family_get_name(families[k]);
total_len += strlen(name) + 1; // with '\0' at the end
}
char *s = malloc(total_len);
char *ptr = s;
for (k = 0; k < n; k ++) {
const char *name = pango_font_family_get_name(families[k]);
const int len = strlen(name);
memcpy(ptr, name, len + 1); // with '\0' at the end
ptr += len + 1;
}
struct PP_Var var = ppb_var_var_from_utf8(s, total_len);
free(s);
g_free(families);
return var;
}
static void ListFontFamilies(PangoFontFamily*** families,
int* n_families) {
InitFontconfig();
PangoFontMap* font_map = pango_cairo_font_map_get_default();
DISABLE_HEAP_LEAK_CHECK;
pango_font_map_list_families(font_map, families, n_families);
}
void pangox_layout_list_fonts(FILE *fp, PangoLayout *layout)
{
PangoContext *context;
PangoFontMap *fontmap;
PangoFontFamily **families;
int n, i;
context = pango_layout_get_context(layout);
fontmap = pango_context_get_font_map(context);
pango_font_map_list_families(fontmap, &families, &n);
fprintf(fp, "Found %d fonts\n", n);
for (i = 0; i < n; i++) {
fprintf(fp, " %s\n", pango_font_family_get_name(families[i]));
}
g_free(families);
}
StringList Font::familiesAvailable()
{
PangoFontMap* map = pango_cairo_font_map_get_default();
PangoFontFamily** families;
int count;
pango_font_map_list_families(map, &families, &count);
StringList result;
for(int i = 0; i < count; ++i) {
PangoFontFamily* family = families[i];
result.push_back(pango_font_family_get_name(family));
}
free(families);
return result;
}
static VALUE
rg_families(VALUE self)
{
int n_families;
PangoFontFamily** families;
int i;
VALUE result;
pango_font_map_list_families(_SELF(self),
&families,
&n_families);
result = rb_ary_new2(n_families);
for (i = 0; i < n_families; i++)
rb_ary_store(result, i, GOBJ2RVAL(families[i]));
g_free(families);
return result;
}
int unicodeGetFontList(char *str, int strLength) {
PangoFontMap *fontMap;
PangoFontFamily **fontFomilies;
int count, i;
str[0] = '\0';
if (cachedLayout == NULL) {
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
cairo_t *cr = cairo_create(surface);
cachedLayout = pango_cairo_create_layout(cr);
}
fontMap = pango_context_get_font_map(pango_layout_get_context(cachedLayout));
pango_font_map_list_families(fontMap, &fontFomilies, &count);
for (i = 0; i < count; i++) {
strncat(str, pango_font_family_get_name(fontFomilies[i]), strLength);
strncat(str, "\n", strLength);
}
g_free(fontFomilies);
return strlen(str);
}
/* This function creates an array of font definitions. Each entry corresponds to one of
the Graphviz PS fonts. The font definitions contain the generic font name and a list
of equivalent fonts that can be used in place of the PS font if the PS font is not
available on the system
*/
static availfont_t *gv_get_ps_fontlist(PangoFontMap * fontmap)
{
PangoFontFamily **families;
PangoFontFamily *family;
fontdef_t* gv_ps_fontdef;
int n_families;
int i, j, k, array_sz, availfaces;
availfont_t *gv_af_p, *gv_afs;
const char *name;
char *family_name;
/* Get a list of font families installed on the system */
pango_font_map_list_families(fontmap, &families, &n_families);
/* Setup a pointer to available font structs */
gv_af_p = N_NEW(GV_FONT_LIST_SIZE, availfont_t);
for (j = 0; j < GV_FONT_LIST_SIZE; j++) {
/* get the Graphviz PS font information and create the
available font definition structs */
gv_afs = gv_af_p+j;
gv_ps_fontdef = gv_ps_fontdefs+j;
gv_afs->gv_ps_fontname = gv_ps_fontdef->fontname;
family_name = NULL;
/* Search the installed system font families for the current
Graphvis PS font family name, i.e. AvantGarde */
for (i = 0; i < n_families; i++) {
family = families[i];
name = pango_font_family_get_name(family);
/* if a match is found get the installed font faces */
if (strcasecmp(gv_ps_fontdef->fontname, name) == 0) {
family_name = strdup(name);
availfaces = get_faces(family);
}
if (family_name)
break;
}
/* if a match is not found on the primary Graphviz font family,
search for a match on the equivalent font family names */
if (!family_name) {
array_sz = gv_ps_fontdef->eq_sz;
for (k = 0; k < array_sz; k++) {
for (i = 0; i < n_families; i++) {
family = families[i];
name = pango_font_family_get_name(family);
if (strcasecmp(gv_ps_fontdef->equiv[k], name) == 0) {
family_name = strdup(name);
availfaces = get_faces(family);
break;
}
}
if (family_name)
break;
}
}
/* if a match is not found on the equivalent font family names, search
for a match on the generic family name assigned to the Graphviz PS font */
if (!family_name) {
for (i = 0; i < n_families; i++) {
family = families[i];
name = pango_font_family_get_name(family);
if (strcasecmp(gv_ps_fontdef->generic_name, name) == 0) {
family_name = strdup(name);
availfaces = get_faces(family);
break;
}
}
}
/* if not match is found on the generic name, set the available font
name to NULL */
if (family_name && availfaces) {
gv_afs->fontname = family_name;
gv_afs->faces = availfaces;
} else {
gv_afs->fontname = NULL;
gv_afs->faces = 0;
}
}
g_free(families);
#ifdef DEBUG
display_available_fonts(gv_af_p);
#endif
/* Free the Graphviz PS font definitions */
return (gv_af_p);
}
weed_plant_t *weed_setup(weed_bootstrap_f weed_boot) {
weed_plant_t *plugin_info=weed_plugin_info_init(weed_boot,num_versions,api_versions);
if (plugin_info!=NULL) {
weed_plant_t *in_params[P_END+1],*gui;
weed_plant_t *filter_class;
PangoContext *ctx;
const char *modes[]= {"Spiral text","Spinning letters","Letter starfield","Word coalesce",NULL};
char *rfx_strings[]= {"special|fileread|0|"};
char *deftextfile;
int palette_list[2];
weed_plant_t *in_chantmpls[2];
weed_plant_t *out_chantmpls[2];
int flags,error;
if (is_big_endian())
palette_list[0]=WEED_PALETTE_ARGB32;
else
palette_list[0]=WEED_PALETTE_BGRA32;
palette_list[1]=WEED_PALETTE_END;
in_chantmpls[0]=weed_channel_template_init("in channel 0",0,palette_list);
in_chantmpls[1]=NULL;
out_chantmpls[0]=weed_channel_template_init("out channel 0",WEED_CHANNEL_CAN_DO_INPLACE,palette_list);
out_chantmpls[1]=NULL;
init_unal();
// this section contains code
// for configure fonts available
num_fonts_available = 0;
fonts_available = NULL;
ctx = gdk_pango_context_get();
if (ctx) {
PangoFontMap *pfm = pango_context_get_font_map(ctx);
if (pfm) {
int num = 0;
PangoFontFamily **pff = NULL;
pango_font_map_list_families(pfm, &pff, &num);
if (num > 0) {
// we should reserve num+1 for a final NULL pointer
fonts_available = (char **)weed_malloc((num+1)*sizeof(char *));
if (fonts_available) {
register int i;
num_fonts_available = num;
for (i = 0; i < num; ++i) {
fonts_available[i] = strdup(pango_font_family_get_name(pff[i]));
}
// don't forget this thing
fonts_available[num] = NULL;
}
}
g_free(pff);
}
g_object_unref(ctx);
}
deftextfile=g_build_filename(g_get_home_dir(), "livestext.txt", NULL);
in_params[P_TEXT]=weed_text_init("textfile","_Text file",deftextfile);
gui=weed_parameter_template_get_gui(in_params[P_TEXT]);
weed_set_int_value(gui,"maxchars",80); // for display only - fileread will override this
flags=0;
if (weed_plant_has_leaf(in_params[P_TEXT],"flags"))
flags=weed_get_int_value(in_params[P_TEXT],"flags",&error);
flags|=WEED_PARAMETER_REINIT_ON_VALUE_CHANGE;
weed_set_int_value(in_params[P_TEXT],"flags",flags);
in_params[P_MODE]=weed_string_list_init("mode","Effect _mode",0,modes);
flags=0;
if (weed_plant_has_leaf(in_params[P_MODE],"flags"))
flags=weed_get_int_value(in_params[P_MODE],"flags",&error);
flags|=WEED_PARAMETER_REINIT_ON_VALUE_CHANGE;
weed_set_int_value(in_params[P_MODE],"flags",flags);
in_params[P_END]=NULL;
g_free(deftextfile);
filter_class=weed_filter_class_init("puretext","Salsaman & Aleksej Penkov",1,0,&puretext_init,&puretext_process,NULL,
in_chantmpls,out_chantmpls,in_params,NULL);
gui=weed_filter_class_get_gui(filter_class);
weed_set_string_value(gui,"layout_scheme","RFX");
weed_set_string_value(gui,"rfx_delim","|");
weed_set_string_array(gui,"rfx_strings",1,rfx_strings);
weed_plugin_info_add_filter_class(plugin_info,filter_class);
weed_set_int_value(plugin_info,"version",package_version);
}
return plugin_info;
}
/*
* Do all the bar display and register the events
*/
void
gc_config_start ()
{
GcomprisProperties *properties = gc_prop_get();
gint y_start = 0;
gint x_start = 0;
gint x_text_start = 0;
gint y = 0;
GooCanvasItem *item;
/* Pause the board */
gc_board_pause(TRUE);
if(rootitem)
{
gc_config_stop();
return;
}
gc_bar_hide(TRUE);
rootitem = goo_canvas_group_new (goo_canvas_get_root_item(gc_get_canvas()),
NULL);
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#DIALOG",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
GooCanvasBounds bounds;
goo_canvas_item_get_bounds(item, &bounds);
x_start = bounds.x1;
y_start = bounds.y1;
y = bounds.y2 - 26;
goo_canvas_text_new (rootitem,
_("GCompris Configuration"),
(gdouble) BOARDWIDTH/2,
(gdouble) y_start + 40,
-1,
GTK_ANCHOR_CENTER,
"font", gc_skin_font_title,
"fill-color-rgba", gc_skin_color_title,
NULL);
pixmap_checked = "#CHECKED";
pixmap_unchecked = "#UNCHECKED";
pixmap_width = 30;
x_start += 60;
x_text_start = x_start + 80;
//--------------------------------------------------
// Locale
y_start += 105;
display_previous_next(x_start, y_start, "locale_previous", "locale_next");
y_flag_start = y_start - pixmap_width/2;
/* A repeat icon to reset the selection */
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#REPEAT",
NULL);
goo_canvas_item_get_bounds(item, &bounds);
double zoom = 0.50;
goo_canvas_item_scale(item, zoom, zoom);
goo_canvas_item_translate(item,
(-1 * bounds.x1 + x_start - 100) * zoom,
(-1 * bounds.y1 + y_start - 145) * zoom);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"locale_reset");
gc_item_focus_init(item, NULL);
/*
* The current locale is the one found in the config file
*/
current_locale = properties->locale;
set_locale_flag(current_locale);
item_locale_text = goo_canvas_text_new (rootitem,
gc_locale_get_name(current_locale),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Fullscreen / Window
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->fullscreen ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"fullscreen");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Fullscreen"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Rememberlevel
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->rememberlevel ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"rememberlevel");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Remember level for default user"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Music
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->music ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"music");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Music"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Effect
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->fx ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"effect");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Effect"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Zoom
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->zoom ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"zoom");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Zoom"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Timer
y_start += Y_GAP;
display_previous_next(x_start, y_start, "timer_previous", "timer_next");
item_timer_text = goo_canvas_text_new (rootitem,
gettext(timername[properties->timer]),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Font
y_start += Y_GAP;
{
int i;
PangoFontFamily ** families;
int n_families;
PangoFontMap * fontmap;
const gchar *current_familly_name = NULL;
fontmap = pango_cairo_font_map_get_default();
pango_font_map_list_families (fontmap, & families, & n_families);
for (i = 0; i < n_families; i++) {
PangoFontFamily * family = families[i];
const gchar * family_name;
family_name = pango_font_family_get_name (family);
/* Skip font to exclude */
guint j = 0;
gboolean exclude = FALSE;
while(excluded_fonts[j] != NULL) {
if( !g_ascii_strncasecmp(excluded_fonts[j], family_name,
strlen(excluded_fonts[j])) ) {
exclude = TRUE;
break;
}
j++;
}
if(exclude)
continue;
fontlist = g_list_insert_sorted (fontlist, (gpointer)family_name,
(GCompareFunc)strcmp);
if(!strcmp(properties->fontface, family_name))
current_familly_name = family_name;
}
g_free (families);
current_font_index = font_index = g_list_index(fontlist, current_familly_name);
display_previous_next(x_start, y_start, "font_previous", "font_next");
/* A repeat icon to reset the selection */
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#REPEAT",
NULL);
goo_canvas_item_get_bounds(item, &bounds);
double zoom = 0.50;
goo_canvas_item_scale(item, zoom, zoom);
goo_canvas_item_translate(item,
(-1 * bounds.x1 + x_start - 100) * zoom,
(-1 * bounds.y1 + y_start + 650) * zoom);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"fontface_reset");
gc_item_focus_init(item, NULL);
gchar *first_font_name = g_strdup_printf(_("Font: %s"), (char *)g_list_nth_data(fontlist, font_index));
item_font_text = goo_canvas_text_new (rootitem,
first_font_name,
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
}
// Difficulty Filter
y_start += Y_GAP;
stars_group_x = x_start + 45;
stars_group_y = y_start - 25;
gchar *text = g_strdup_printf("<i>%s</i>", gettext(filtername));
item_filter_text = goo_canvas_text_new (rootitem,
text,
x_text_start,
y_start,
400,
GTK_ANCHOR_WEST,
"use-markup", TRUE,
"font", gc_skin_font_content,
"fill-color-rgba", gc_skin_color_content,
NULL);
g_free(text);
// OK
gc_util_button_text_svg(rootitem,
BOARDWIDTH * 0.5,
y,
"#BUTTON_TEXT",
_("OK"),
(GCallback) item_event_ok,
"ok");
is_displayed = TRUE;
}
int
main (int argc,
char **argv)
{
PangoFontMap *fontmap;
PangoFontFamily **families;
int n_families;
int i, j, k;
#if !GLIB_CHECK_VERSION (2, 35, 3)
g_type_init();
#endif
g_set_prgname ("pango-list");
/* Use PangoCairo to get default fontmap so it works on every platform. */
fontmap = pango_cairo_font_map_get_default ();
pango_font_map_list_families (fontmap, &families, &n_families);
for (i = 0; i < n_families; i++)
{
PangoFontFace **faces;
int n_faces;
const char *family_name = pango_font_family_get_name (families[i]);
g_print ("%s\n", family_name);
pango_font_family_list_faces (families[i], &faces, &n_faces);
for (j = 0; j < n_faces; j++)
{
const char *face_name = pango_font_face_get_face_name (faces[j]);
gboolean is_synth = pango_font_face_is_synthesized (faces[j]);
const char *synth_str = is_synth ? "*" : "";
g_print (" %s%s\n", synth_str, face_name);
if (0)
{
int *sizes;
int n_sizes;
pango_font_face_list_sizes (faces[j], &sizes, &n_sizes);
if (n_sizes)
{
g_print (" {");
for (k = 0; k < n_sizes; k++)
{
if (k)
g_print (", ");
g_print ("%g", pango_units_to_double (sizes[k]));
}
g_print ("}\n");
}
g_free (sizes);
}
if (1)
{
PangoFontDescription *desc = pango_font_face_describe (faces[j]);
char *desc_str = pango_font_description_to_string (desc);
g_print (" \"%s\"\n", desc_str);
g_free (desc_str);
pango_font_description_free (desc);
}
}
g_free (faces);
}
g_free (families);
g_object_unref (fontmap);
return 0;
}
int main(void)
{
GtkWidget *mainwin;
GtkWidget *vbox;
GtkWidget *sizeSlider;
GtkWidget *sw;
GtkWidget *list;
GtkListStore *fontStore;
GtkTreeViewColumn *col;
GtkCellRenderer *r;
PangoFontMap *pcfm;
PangoFontFamily **fams;
int i, n;
gtk_init(NULL, NULL);
mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(mainwin, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(mainwin), 12);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add(GTK_CONTAINER(mainwin), vbox);
sizeSlider = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 4, 96, 1);
gtk_range_set_value(GTK_RANGE(sizeSlider), 10);
gtk_widget_set_vexpand(sizeSlider, FALSE);
gtk_container_add(GTK_CONTAINER(vbox), sizeSlider);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_widget_set_hexpand(sw, TRUE);
gtk_widget_set_vexpand(sw, TRUE);
gtk_container_add(GTK_CONTAINER(vbox), sw);
fontStore = gtk_list_store_new(3,
G_TYPE_STRING,
G_TYPE_STRING,
PANGO_TYPE_FONT_DESCRIPTION);
list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(fontStore));
r = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("Family", r,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), col);
r = gtk_cell_renderer_text_new();
g_object_bind_property(gtk_range_get_adjustment(GTK_RANGE(sizeSlider)), "value",
r, "size-points",
G_BINDING_SYNC_CREATE);
col = gtk_tree_view_column_new_with_attributes("Sample", r,
"text", 1,
"font-desc", 2,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), col);
gtk_container_add(GTK_CONTAINER(sw), list);
pcfm = pango_cairo_font_map_get_default();
pango_font_map_list_families(pcfm, &fams, &n);
for (i = 0; i < n; i++) {
PangoFontFace **faces;
int j, m;
pango_font_family_list_faces(fams[i], &faces, &m);
for (j = 0; j < m; j++) {
PangoFontDescription *desc;
GtkTreeIter iter;
desc = pango_font_face_describe(faces[j]);
if (pango_font_description_get_variant(desc) != PANGO_VARIANT_SMALL_CAPS) {
pango_font_description_free(desc);
continue;
}
gtk_list_store_append(fontStore, &iter);
gtk_list_store_set(fontStore, &iter,
0, pango_font_description_get_family(desc),
1, "The quick brown fox jumped over the lazy dog.",
2, desc,
-1);
}
g_free(faces);
}
g_free(fams);
gtk_widget_show_all(mainwin);
gtk_main();
return 0;
}
void font_factory::GetUIFamiliesAndStyles(FamilyToStylesMap *map)
{
g_assert(map);
if (map) {
// Gather the family names as listed by Pango
PangoFontFamily** families = NULL;
int numFamilies = 0;
pango_font_map_list_families(fontServer, &families, &numFamilies);
for (int currentFamily=0; currentFamily < numFamilies; currentFamily++) {
// Gather the styles for this family
PangoFontFace** faces = NULL;
int numFaces = 0;
pango_font_family_list_faces(families[currentFamily], &faces, &numFaces);
for (int currentFace=0; currentFace < numFaces; currentFace++) {
// If the face has a name, describe it, and then use the
// description to get the UI family and face strings
const gchar* displayName = pango_font_face_get_face_name(faces[currentFace]);
if (displayName == NULL) {
continue;
}
PangoFontDescription *faceDescr = pango_font_face_describe(faces[currentFace]);
if (faceDescr) {
Glib::ustring familyUIName = GetUIFamilyString(faceDescr);
Glib::ustring styleUIName = GetUIStyleString(faceDescr);
// Disable synthesized (faux) font faces except for CSS generic faces
if (pango_font_face_is_synthesized(faces[currentFace]) ) {
if( familyUIName.compare( "sans-serif" ) != 0 &&
familyUIName.compare( "serif" ) != 0 &&
familyUIName.compare( "monospace" ) != 0 &&
familyUIName.compare( "fantasy" ) != 0 &&
familyUIName.compare( "cursive" ) != 0 ) {
//std::cout << "faux: " << familyUIName << " | " << styleUIName << std::endl;
continue;
}
}
if (!familyUIName.empty() && !styleUIName.empty()) {
// Find the right place to put the style information, adding
// a map entry for the family name if it doesn't yet exist
FamilyToStylesMap::iterator iter = map->find(familyUIName);
// Insert new family
if (iter == map->end()) {
map->insert(std::make_pair(familyUIName, std::list<StyleNames>()));
}
// Insert into the style list and save the info in the reference maps
// only if the style does not yet exist
bool exists = false;
std::list<StyleNames> &styleList = (*map)[familyUIName];
for (std::list<StyleNames>::iterator it=styleList.begin();
it != styleList.end();
++it) {
if ( (*it).CssName == styleUIName) {
exists = true;
break;
}
}
if (!exists) {
styleList.push_back( StyleNames(styleUIName,displayName) );
// Add the string info needed in the reference maps
fontStringMap.insert(
std::make_pair(
Glib::ustring(familyUIName) + Glib::ustring(styleUIName),
ConstructFontSpecification(faceDescr)));
fontInstanceMap.insert(
std::make_pair(ConstructFontSpecification(faceDescr), faceDescr));
} else {
pango_font_description_free(faceDescr);
}
} else {
pango_font_description_free(faceDescr);
}
}
}
g_free(faces);
faces = 0;
}
g_free(families);
families = 0;
// Sort the style lists
for (FamilyToStylesMap::iterator iter = map->begin() ; iter != map->end(); ++iter) {
(*iter).second.sort(StyleNameCompareInternal);
}
}
}
