static gboolean
font_description_style_equal (const PangoFontDescription *a,
const PangoFontDescription *b)
{
return (pango_font_description_get_weight (a) == pango_font_description_get_weight (b) &&
pango_font_description_get_style (a) == pango_font_description_get_style (b) &&
pango_font_description_get_stretch (a) == pango_font_description_get_stretch (b) &&
pango_font_description_get_variant (a) == pango_font_description_get_variant (b));
}
bool font_descr_equal::operator()( PangoFontDescription *const&a, PangoFontDescription *const &b) const {
//if ( pango_font_description_equal(a,b) ) return true;
char const *fa = sp_font_description_get_family(a);
char const *fb = sp_font_description_get_family(b);
if ( ( fa && fb == NULL ) || ( fb && fa == NULL ) ) return false;
if ( fa && fb && strcmp(fa,fb) != 0 ) return false;
if ( pango_font_description_get_style(a) != pango_font_description_get_style(b) ) return false;
if ( pango_font_description_get_variant(a) != pango_font_description_get_variant(b) ) return false;
if ( pango_font_description_get_weight(a) != pango_font_description_get_weight(b) ) return false;
if ( pango_font_description_get_stretch(a) != pango_font_description_get_stretch(b) ) return false;
return true;
}
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;
}
JNIEXPORT jint JNICALL
Java_org_gnome_pango_PangoFontDescription_pango_1font_1description_1get_1variant
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
PangoVariant result;
jint _result;
PangoFontDescription* self;
// convert parameter self
self = (PangoFontDescription*) _self;
// call function
result = pango_font_description_get_variant(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;
}
// Calculate a Style "value" based on CSS values for ordering styles.
static int StyleNameValue( const Glib::ustring &style )
{
PangoFontDescription *pfd = pango_font_description_from_string ( style.c_str() );
int value =
pango_font_description_get_weight ( pfd ) * 1000000 +
pango_font_description_get_style ( pfd ) * 10000 +
pango_font_description_get_stretch( pfd ) * 100 +
pango_font_description_get_variant( pfd );
pango_font_description_free ( pfd );
return value;
}
// need to avoid using the size field
size_t font_descr_hash::operator()( PangoFontDescription *const &x) const {
int h = 0;
char const *theF = sp_font_description_get_family(x);
h += (theF)?g_str_hash(theF):0;
h *= 1128467;
h += (int)pango_font_description_get_style(x);
h *= 1128467;
h += (int)pango_font_description_get_variant(x);
h *= 1128467;
h += (int)pango_font_description_get_weight(x);
h *= 1128467;
h += (int)pango_font_description_get_stretch(x);
return h;
}
void
set_style (GtkWidget *entry, gpointer data)
{
char *str = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
PangoFontDescription *tmp_desc;
tmp_desc = pango_font_description_from_string (str);
pango_font_description_set_style(font_description, pango_font_description_get_style(tmp_desc));
pango_font_description_set_variant(font_description, pango_font_description_get_variant(tmp_desc));
pango_font_description_set_weight(font_description, pango_font_description_get_weight(tmp_desc));
pango_font_description_set_stretch(font_description, pango_font_description_get_stretch(tmp_desc));
pango_font_description_free (tmp_desc);
g_free (str);
reload_font ();
}
PP_Bool
ppb_browser_font_trusted_describe(PP_Resource font,
struct PP_BrowserFont_Trusted_Description *description,
struct PP_BrowserFont_Trusted_Metrics *metrics)
{
struct pp_browser_font_s *bf = pp_resource_acquire(font, PP_RESOURCE_BROWSER_FONT);
if (!bf)
return PP_FALSE;
memset(description, 0, sizeof(*description));
memset(metrics, 0, sizeof(*metrics));
const char *s_family = pango_font_description_get_family(bf->font_desc);
description->face = PP_MakeString(s_family);
description->family = bf->family >= 0 ? bf->family : 0;
description->size = pango_font_description_get_size(bf->font_desc) / PANGO_SCALE;
description->weight = pango_font_description_get_weight(bf->font_desc)/100 - 1;
description->italic = (pango_font_description_get_style(bf->font_desc) != PANGO_STYLE_NORMAL);
description->small_caps =
(pango_font_description_get_variant(bf->font_desc) == PANGO_VARIANT_SMALL_CAPS);
description->letter_spacing = bf->letter_spacing;
description->word_spacing = bf->word_spacing;
PangoFontMetrics *m = pango_font_get_metrics(bf->font, NULL);
// TODO: use fontconfig-specific structures in pango to determine height and x-height
metrics->ascent = pango_font_metrics_get_ascent(m) / PANGO_SCALE;
metrics->descent = pango_font_metrics_get_descent(m) / PANGO_SCALE;
metrics->height = (pango_font_metrics_get_ascent(m) +
pango_font_metrics_get_descent(m)) / PANGO_SCALE;
metrics->line_spacing = 1; // TODO: get actual line spacing
metrics->x_height = metrics->height; // TODO: find out actual x-height
pango_font_metrics_unref(m);
pp_resource_release(font);
return PP_TRUE;
}
/**
* This function is orignally written in gtk/gtkfontbutton.c of gtk+ project.
*/
gchar *
pango_font_description_to_css (PangoFontDescription *desc)
{
GString *s;
PangoFontMask set;
s = g_string_new ("{ ");
set = pango_font_description_get_set_fields (desc);
if (set & PANGO_FONT_MASK_FAMILY)
{
g_string_append (s, "font-family: ");
g_string_append (s, pango_font_description_get_family (desc));
g_string_append (s, "; ");
}
if (set & PANGO_FONT_MASK_STYLE)
{
switch (pango_font_description_get_style (desc))
{
case PANGO_STYLE_NORMAL:
g_string_append (s, "font-style: normal; ");
break;
case PANGO_STYLE_OBLIQUE:
g_string_append (s, "font-style: oblique; ");
break;
case PANGO_STYLE_ITALIC:
g_string_append (s, "font-style: italic; ");
break;
}
}
if (set & PANGO_FONT_MASK_VARIANT)
{
switch (pango_font_description_get_variant (desc))
{
case PANGO_VARIANT_NORMAL:
g_string_append (s, "font-variant: normal; ");
break;
case PANGO_VARIANT_SMALL_CAPS:
g_string_append (s, "font-variant: small-caps; ");
break;
}
}
if (set & PANGO_FONT_MASK_WEIGHT)
{
switch (pango_font_description_get_weight (desc))
{
case PANGO_WEIGHT_THIN:
g_string_append (s, "font-weight: 100; ");
break;
case PANGO_WEIGHT_ULTRALIGHT:
g_string_append (s, "font-weight: 200; ");
break;
case PANGO_WEIGHT_LIGHT:
case PANGO_WEIGHT_SEMILIGHT:
g_string_append (s, "font-weight: 300; ");
break;
case PANGO_WEIGHT_BOOK:
case PANGO_WEIGHT_NORMAL:
g_string_append (s, "font-weight: 400; ");
break;
case PANGO_WEIGHT_MEDIUM:
g_string_append (s, "font-weight: 500; ");
break;
case PANGO_WEIGHT_SEMIBOLD:
g_string_append (s, "font-weight: 600; ");
break;
case PANGO_WEIGHT_BOLD:
g_string_append (s, "font-weight: 700; ");
break;
case PANGO_WEIGHT_ULTRABOLD:
g_string_append (s, "font-weight: 800; ");
break;
case PANGO_WEIGHT_HEAVY:
case PANGO_WEIGHT_ULTRAHEAVY:
g_string_append (s, "font-weight: 900; ");
break;
}
}
if (set & PANGO_FONT_MASK_STRETCH)
{
switch (pango_font_description_get_stretch (desc))
{
case PANGO_STRETCH_ULTRA_CONDENSED:
g_string_append (s, "font-stretch: ultra-condensed; ");
break;
case PANGO_STRETCH_EXTRA_CONDENSED:
g_string_append (s, "font-stretch: extra-condensed; ");
break;
case PANGO_STRETCH_CONDENSED:
g_string_append (s, "font-stretch: condensed; ");
break;
case PANGO_STRETCH_SEMI_CONDENSED:
g_string_append (s, "font-stretch: semi-condensed; ");
break;
case PANGO_STRETCH_NORMAL:
g_string_append (s, "font-stretch: normal; ");
break;
case PANGO_STRETCH_SEMI_EXPANDED:
g_string_append (s, "font-stretch: semi-expanded; ");
break;
case PANGO_STRETCH_EXPANDED:
g_string_append (s, "font-stretch: expanded; ");
break;
case PANGO_STRETCH_EXTRA_EXPANDED:
g_string_append (s, "font-stretch: extra-expanded; ");
break;
case PANGO_STRETCH_ULTRA_EXPANDED:
g_string_append (s, "font-stretch: ultra-expanded; ");
break;
}
}
if (set & PANGO_FONT_MASK_SIZE)
{
g_string_append_printf (s, "font-size: %dpt", pango_font_description_get_size (desc) / PANGO_SCALE);
}
g_string_append (s, "}");
return g_string_free (s, FALSE);
}
/*
* This function is used by gail_text_cell_get_offset_at_point()
* and gail_text_cell_get_character_extents(). There is no
* cached PangoLayout for gailtextcell so we must create a temporary
* one using this function.
*/
static PangoLayout*
create_pango_layout(GtkCellRendererText *gtk_renderer,
GtkWidget *widget)
{
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
PangoFontMask mask;
layout = gtk_widget_create_pango_layout (widget, gtk_renderer->text);
if (gtk_renderer->extra_attrs)
attr_list = pango_attr_list_copy (gtk_renderer->extra_attrs);
else
attr_list = pango_attr_list_new ();
if (gtk_renderer->foreground_set)
{
PangoColor color;
color = gtk_renderer->foreground;
add_attr (attr_list, pango_attr_foreground_new (color.red,
color.green, color.blue));
}
if (gtk_renderer->strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (gtk_renderer->strikethrough));
mask = pango_font_description_get_set_fields (gtk_renderer->font);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (gtk_renderer->font)));
if (gtk_renderer->scale_set &&
gtk_renderer->font_scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (gtk_renderer->font_scale));
if (gtk_renderer->underline_set)
uline = gtk_renderer->underline_style;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (gtk_renderer->underline_style));
if (gtk_renderer->rise_set)
add_attr (attr_list, pango_attr_rise_new (gtk_renderer->rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
return layout;
}
gchar *
gb_pango_font_description_to_css (const PangoFontDescription *font_desc)
{
PangoFontMask mask;
GString *str;
#define ADD_KEYVAL(key,fmt) \
g_string_append(str,key":"fmt";")
#define ADD_KEYVAL_PRINTF(key,fmt,...) \
g_string_append_printf(str,key":"fmt";", __VA_ARGS__)
g_return_val_if_fail (font_desc, NULL);
str = g_string_new (NULL);
mask = pango_font_description_get_set_fields (font_desc);
if ((mask & PANGO_FONT_MASK_FAMILY) != 0)
{
const gchar *family;
family = pango_font_description_get_family (font_desc);
ADD_KEYVAL_PRINTF (FONT_FAMILY, "\"%s\"", family);
}
if ((mask & PANGO_FONT_MASK_STYLE) != 0)
{
PangoVariant variant;
variant = pango_font_description_get_variant (font_desc);
switch (variant)
{
case PANGO_VARIANT_NORMAL:
ADD_KEYVAL (FONT_VARIANT, "normal");
break;
case PANGO_VARIANT_SMALL_CAPS:
ADD_KEYVAL (FONT_VARIANT, "small-caps");
break;
default:
break;
}
}
if ((mask & PANGO_FONT_MASK_WEIGHT))
{
gint weight;
weight = pango_font_description_get_weight (font_desc);
ADD_KEYVAL_PRINTF ("font-weight", "%d", weight);
}
if ((mask & PANGO_FONT_MASK_STRETCH))
{
switch (pango_font_description_get_stretch (font_desc))
{
case PANGO_STRETCH_ULTRA_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "untra-condensed");
break;
case PANGO_STRETCH_EXTRA_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "extra-condensed");
break;
case PANGO_STRETCH_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "condensed");
break;
case PANGO_STRETCH_SEMI_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "semi-condensed");
break;
case PANGO_STRETCH_NORMAL:
ADD_KEYVAL (FONT_STRETCH, "normal");
break;
case PANGO_STRETCH_SEMI_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "semi-expanded");
break;
case PANGO_STRETCH_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "expanded");
break;
case PANGO_STRETCH_EXTRA_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "extra-expanded");
break;
case PANGO_STRETCH_ULTRA_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "untra-expanded");
break;
default:
break;
}
}
if ((mask & PANGO_FONT_MASK_SIZE))
{
gint font_size;
font_size = pango_font_description_get_size (font_desc) / PANGO_SCALE;
ADD_KEYVAL_PRINTF ("font-size", "%dpx", font_size);
}
return g_string_free (str, FALSE);
#undef ADD_KEYVAL
#undef ADD_KEYVAL_PRINTF
}
/**
* gail_misc_get_default_attributes:
* @attrib_set: The #AtkAttributeSet to add the attribute to
* @layout: The PangoLayout from which the attributes will be obtained
* @widget: The GtkWidget for which the default attributes are required.
*
* Adds the default attributes to the specified attribute set.
*
* Returns: A pointer to the #AtkAttributeSet.
**/
AtkAttributeSet*
gail_misc_get_default_attributes (AtkAttributeSet *attrib_set,
PangoLayout *layout,
GtkWidget *widget)
{
PangoContext *context;
GtkStyleContext *style_context;
gint int_value;
PangoWrapMode mode;
GdkRGBA color;
gchar *value;
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_DIRECTION,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION,
gtk_widget_get_direction (widget))));
context = pango_layout_get_context (layout);
if (context)
{
PangoLanguage* language;
PangoFontDescription* font;
language = pango_context_get_language (context);
if (language)
{
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_LANGUAGE,
g_strdup (pango_language_to_string (language)));
}
font = pango_context_get_font_description (context);
if (font)
{
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_STYLE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STYLE,
pango_font_description_get_style (font))));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_VARIANT,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_VARIANT,
pango_font_description_get_variant (font))));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_STRETCH,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRETCH,
pango_font_description_get_stretch (font))));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_FAMILY_NAME,
g_strdup (pango_font_description_get_family (font)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_WEIGHT,
g_strdup_printf ("%d",
pango_font_description_get_weight (font)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_SIZE,
g_strdup_printf ("%i",
pango_font_description_get_size (font) / PANGO_SCALE));
}
}
if (pango_layout_get_justify (layout))
{
int_value = 3;
}
else
{
PangoAlignment align;
align = pango_layout_get_alignment (layout);
if (align == PANGO_ALIGN_LEFT)
int_value = 0;
else if (align == PANGO_ALIGN_CENTER)
int_value = 2;
else /* if (align == PANGO_ALIGN_RIGHT) */
int_value = 1;
}
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_JUSTIFICATION,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_JUSTIFICATION,
int_value)));
mode = pango_layout_get_wrap (layout);
if (mode == PANGO_WRAP_WORD)
int_value = 2;
else /* if (mode == PANGO_WRAP_CHAR) */
int_value = 1;
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_WRAP_MODE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_WRAP_MODE,
int_value)));
style_context = gtk_widget_get_style_context (widget);
gtk_style_context_get_background_color (style_context, 0, &color);
value = g_strdup_printf ("%u,%u,%u",
(guint) ceil (color.red * 65536 - color.red),
(guint) ceil (color.green * 65536 - color.green),
(guint) ceil (color.blue * 65536 - color.blue));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_BG_COLOR,
value);
gtk_style_context_get_color (style_context, 0, &color);
value = g_strdup_printf ("%u,%u,%u",
(guint) ceil (color.red * 65536 - color.red),
(guint) ceil (color.green * 65536 - color.green),
(guint) ceil (color.blue * 65536 - color.blue));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_FG_COLOR,
value);
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_FG_STIPPLE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_FG_STIPPLE,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_BG_STIPPLE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_BG_STIPPLE,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_STRIKETHROUGH,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_STRIKETHROUGH,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_UNDERLINE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_UNDERLINE,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_RISE,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_SCALE,
g_strdup_printf ("%g", 1.0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_BG_FULL_HEIGHT,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_PIXELS_BELOW_LINES,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_PIXELS_ABOVE_LINES,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_EDITABLE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_EDITABLE,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_INVISIBLE,
g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_INVISIBLE,
0)));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_INDENT,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_RIGHT_MARGIN,
g_strdup_printf ("%i", 0));
attrib_set = gail_misc_add_attribute (attrib_set,
ATK_TEXT_ATTR_LEFT_MARGIN,
g_strdup_printf ("%i", 0));
return attrib_set;
}
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;
}
unsigned int font_instance::Attribute(const gchar *key, gchar *str, unsigned int size)
{
if ( descr == NULL ) {
if ( size > 0 ) {
str[0]=0;
}
return 0;
}
char* res=NULL;
bool free_res=false;
if ( strcmp(key,"name") == 0 ) {
PangoFontDescription* td=pango_font_description_copy(descr);
pango_font_description_unset_fields (td, PANGO_FONT_MASK_SIZE);
res=pango_font_description_to_string (td);
pango_font_description_free(td);
free_res=true;
} else if ( strcmp(key,"psname") == 0 ) {
#ifndef USE_PANGO_WIN32
res = (char *) FT_Get_Postscript_Name (theFace); // that's the main method, seems to always work
#endif
free_res=false;
if (res == NULL) { // a very limited workaround, only bold, italic, and oblique will work
PangoStyle style=pango_font_description_get_style(descr);
bool i = (style == PANGO_STYLE_ITALIC);
bool o = (style == PANGO_STYLE_OBLIQUE);
PangoWeight weight=pango_font_description_get_weight(descr);
bool b = (weight >= PANGO_WEIGHT_BOLD);
res = g_strdup_printf ("%s%s%s%s",
pango_font_description_get_family(descr),
(b || i || o) ? "-" : "",
(b) ? "Bold" : "",
(i) ? "Italic" : ((o) ? "Oblique" : "") );
free_res = true;
}
} else if ( strcmp(key,"family") == 0 ) {
res=(char*)pango_font_description_get_family(descr);
free_res=false;
} else if ( strcmp(key,"style") == 0 ) {
PangoStyle v=pango_font_description_get_style(descr);
if ( v == PANGO_STYLE_ITALIC ) {
res=(char*)"italic";
} else if ( v == PANGO_STYLE_OBLIQUE ) {
res=(char*)"oblique";
} else {
res=(char*)"normal";
}
free_res=false;
} else if ( strcmp(key,"weight") == 0 ) {
PangoWeight v=pango_font_description_get_weight(descr);
if ( v <= PANGO_WEIGHT_THIN ) {
res=(char*)"100";
} else if ( v <= PANGO_WEIGHT_ULTRALIGHT ) {
res=(char*)"200";
} else if ( v <= PANGO_WEIGHT_LIGHT ) {
res=(char*)"300";
} else if ( v <= PANGO_WEIGHT_BOOK ) {
res=(char*)"380";
} else if ( v <= PANGO_WEIGHT_NORMAL ) {
res=(char*)"normal";
} else if ( v <= PANGO_WEIGHT_MEDIUM ) {
res=(char*)"500";
} else if ( v <= PANGO_WEIGHT_SEMIBOLD ) {
res=(char*)"600";
} else if ( v <= PANGO_WEIGHT_BOLD ) {
res=(char*)"bold";
} else if ( v <= PANGO_WEIGHT_ULTRABOLD ) {
res=(char*)"800";
} else { // HEAVY NB: Pango defines ULTRAHEAVY = 1000 but not CSS2
res=(char*)"900";
}
free_res=false;
} else if ( strcmp(key,"stretch") == 0 ) {
PangoStretch v=pango_font_description_get_stretch(descr);
if ( v <= PANGO_STRETCH_EXTRA_CONDENSED ) {
res=(char*)"extra-condensed";
} else if ( v <= PANGO_STRETCH_CONDENSED ) {
res=(char*)"condensed";
} else if ( v <= PANGO_STRETCH_SEMI_CONDENSED ) {
res=(char*)"semi-condensed";
} else if ( v <= PANGO_STRETCH_NORMAL ) {
res=(char*)"normal";
} else if ( v <= PANGO_STRETCH_SEMI_EXPANDED ) {
res=(char*)"semi-expanded";
} else if ( v <= PANGO_STRETCH_EXPANDED ) {
res=(char*)"expanded";
} else {
res=(char*)"extra-expanded";
}
free_res=false;
} else if ( strcmp(key,"variant") == 0 ) {
PangoVariant v=pango_font_description_get_variant(descr);
if ( v == PANGO_VARIANT_SMALL_CAPS ) {
res=(char*)"small-caps";
} else {
res=(char*)"normal";
}
free_res=false;
} else {
res = NULL;
free_res=false;
}
if ( res == NULL ) {
if ( size > 0 ) {
str[0] = 0;
}
return 0;
}
if (res) {
unsigned int len=strlen(res);
unsigned int rlen=(size-1<len)?size-1:len;
if ( str ) {
if ( rlen > 0 ) {
memcpy(str, res, rlen);
}
if ( size > 0 ) {
str[rlen] = 0;
}
}
if (free_res) {
g_free(res);
res = 0;
}
return len;
}
return 0;
}
/* This function is used by gtk_text_cell_accessible_get_offset_at_point()
* and gtk_text_cell_accessible_get_character_extents(). There is no
* cached PangoLayout so we must create a temporary one using this function.
*/
static PangoLayout *
create_pango_layout (GtkTextCellAccessible *text)
{
GdkRGBA *foreground_rgba;
PangoAttrList *attr_list, *attributes;
PangoLayout *layout;
PangoUnderline uline, underline;
PangoFontMask mask;
PangoFontDescription *font_desc;
gboolean foreground_set, strikethrough_set, strikethrough;
gboolean scale_set, underline_set, rise_set;
gchar *renderer_text;
gdouble scale;
gint rise;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
g_object_get (gtk_renderer,
"text", &renderer_text,
"attributes", &attributes,
"foreground-set", &foreground_set,
"foreground-rgba", &foreground_rgba,
"strikethrough-set", &strikethrough_set,
"strikethrough", &strikethrough,
"font-desc", &font_desc,
"scale-set", &scale_set,
"scale", &scale,
"underline-set", &underline_set,
"underline", &underline,
"rise-set", &rise_set,
"rise", &rise,
NULL);
layout = gtk_widget_create_pango_layout (get_widget (text), renderer_text);
if (attributes)
attr_list = pango_attr_list_copy (attributes);
else
attr_list = pango_attr_list_new ();
if (foreground_set)
{
add_attr (attr_list, pango_attr_foreground_new (foreground_rgba->red * 65535,
foreground_rgba->green * 65535,
foreground_rgba->blue * 65535));
}
if (strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (strikethrough));
mask = pango_font_description_get_set_fields (font_desc);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (font_desc)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (font_desc)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (font_desc)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (font_desc)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (font_desc)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (font_desc)));
if (scale_set && scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (scale));
if (underline_set)
uline = underline;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (underline));
if (rise_set)
add_attr (attr_list, pango_attr_rise_new (rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
pango_font_description_free (font_desc);
pango_attr_list_unref (attributes);
g_free (renderer_text);
gdk_rgba_free (foreground_rgba);
return layout;
}
gchar *
ide_pango_font_description_to_css (const PangoFontDescription *font_desc)
{
PangoFontMask mask;
GString *str;
#define ADD_KEYVAL(key,fmt) \
g_string_append(str,key":"fmt";")
#define ADD_KEYVAL_PRINTF(key,fmt,...) \
g_string_append_printf(str,key":"fmt";", __VA_ARGS__)
g_return_val_if_fail (font_desc, NULL);
str = g_string_new (NULL);
mask = pango_font_description_get_set_fields (font_desc);
if ((mask & PANGO_FONT_MASK_FAMILY) != 0)
{
const gchar *family;
family = pango_font_description_get_family (font_desc);
ADD_KEYVAL_PRINTF (FONT_FAMILY, "\"%s\"", family);
}
if ((mask & PANGO_FONT_MASK_STYLE) != 0)
{
PangoVariant variant;
variant = pango_font_description_get_variant (font_desc);
switch (variant)
{
case PANGO_VARIANT_NORMAL:
ADD_KEYVAL (FONT_VARIANT, "normal");
break;
case PANGO_VARIANT_SMALL_CAPS:
ADD_KEYVAL (FONT_VARIANT, "small-caps");
break;
default:
break;
}
}
if ((mask & PANGO_FONT_MASK_WEIGHT))
{
gint weight;
weight = pango_font_description_get_weight (font_desc);
/*
* WORKAROUND:
*
* font-weight with numbers does not appear to be working as expected
* right now. So for the common (bold/normal), let's just use the string
* and let gtk warn for the other values, which shouldn't really be
* used for this.
*/
switch (weight)
{
case PANGO_WEIGHT_SEMILIGHT:
/*
* 350 is not actually a valid css font-weight, so we will just round
* up to 400.
*/
case PANGO_WEIGHT_NORMAL:
ADD_KEYVAL (FONT_WEIGHT, "normal");
break;
case PANGO_WEIGHT_BOLD:
ADD_KEYVAL (FONT_WEIGHT, "bold");
break;
case PANGO_WEIGHT_THIN:
case PANGO_WEIGHT_ULTRALIGHT:
case PANGO_WEIGHT_LIGHT:
case PANGO_WEIGHT_BOOK:
case PANGO_WEIGHT_MEDIUM:
case PANGO_WEIGHT_SEMIBOLD:
case PANGO_WEIGHT_ULTRABOLD:
case PANGO_WEIGHT_HEAVY:
case PANGO_WEIGHT_ULTRAHEAVY:
default:
/* round to nearest hundred */
weight = round (weight / 100.0) * 100;
ADD_KEYVAL_PRINTF ("font-weight", "%d", weight);
break;
}
}
#ifndef GDK_WINDOWING_QUARTZ
/*
* We seem to get "Condensed" for fonts on the Quartz backend,
* which is rather annoying as it results in us always hitting
* fallback (stretch) paths. So let's cheat and just disable
* stretch support for now on Quartz.
*/
if ((mask & PANGO_FONT_MASK_STRETCH))
{
switch (pango_font_description_get_stretch (font_desc))
{
case PANGO_STRETCH_ULTRA_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "untra-condensed");
break;
case PANGO_STRETCH_EXTRA_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "extra-condensed");
break;
case PANGO_STRETCH_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "condensed");
break;
case PANGO_STRETCH_SEMI_CONDENSED:
ADD_KEYVAL (FONT_STRETCH, "semi-condensed");
break;
case PANGO_STRETCH_NORMAL:
ADD_KEYVAL (FONT_STRETCH, "normal");
break;
case PANGO_STRETCH_SEMI_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "semi-expanded");
break;
case PANGO_STRETCH_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "expanded");
break;
case PANGO_STRETCH_EXTRA_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "extra-expanded");
break;
case PANGO_STRETCH_ULTRA_EXPANDED:
ADD_KEYVAL (FONT_STRETCH, "untra-expanded");
break;
default:
break;
}
}
#endif
if ((mask & PANGO_FONT_MASK_SIZE))
{
gint font_size;
font_size = pango_font_description_get_size (font_desc) / PANGO_SCALE;
ADD_KEYVAL_PRINTF ("font-size", "%dpx", font_size);
}
return g_string_free (str, FALSE);
#undef ADD_KEYVAL
#undef ADD_KEYVAL_PRINTF
}