X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=render%2Ffont.c;h=cde0d0309bf92a01f6d3c45255df8a427f03360d;hb=fa0ae17adbc8f73b707c33836d37841e81b9303a;hp=6ddd3b894e1f29575b1bc42303daa791e8e9c053;hpb=2fb7b70ccbba394e2bfff3b4f67fa4e5ea456981;p=chaz%2Fopenbox diff --git a/render/font.c b/render/font.c index 6ddd3b89..cde0d030 100644 --- a/render/font.c +++ b/render/font.c @@ -1,7 +1,8 @@ /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- font.c for the Openbox window manager - Copyright (c) 2003 Ben Jansens + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2007 Dana Jansens Copyright (c) 2003 Derek Foreman This program is free software; you can redistribute it and/or modify @@ -22,229 +23,175 @@ #include "mask.h" #include "theme.h" #include "geom.h" +#include "instance.h" #include "gettext.h" -#include #include #include #include +#include -#define ELIPSES "..." -#define ELIPSES_LENGTH(font) \ - (font->elipses_length + (font->shadow ? font->offset : 0)) - -#define OB_SHADOW "shadow" -#define OB_SHADOW_OFFSET "shadowoffset" -#define OB_SHADOW_ALPHA "shadowtint" - -FcObjectType objs[] = { - { OB_SHADOW, FcTypeBool }, - { OB_SHADOW_OFFSET, FcTypeInteger }, - { OB_SHADOW_ALPHA, FcTypeInteger } -}; - -static PangoContext *context; -static gboolean started = FALSE; - -static void font_startup(void) +static void measure_font(const RrInstance *inst, RrFont *f) { - if (!XftInit(0)) { - g_warning(_("Couldn't initialize Xft.")); - exit(EXIT_FAILURE); - } + PangoFontMetrics *metrics; + static PangoLanguage *lang = NULL; -#ifdef USE_PANGO - g_type_init(); - /* these will never be freed, but we will need them until we shut down anyway */ - context = pango_xft_get_context(RrDisplay(NULL), RrScreen(NULL)); -#endif /* USE_PANGO */ - /* Here we are teaching xft about the shadow, shadowoffset & shadowtint */ - FcNameRegisterObjectTypes(objs, (sizeof(objs) / sizeof(objs[0]))); -} + if (lang == NULL) { +#if PANGO_VERSION_MAJOR > 1 || \ + (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16) + lang = pango_language_get_default(); +#else + gchar *locale, *p; + /* get the default language from the locale + (based on gtk_get_default_language in gtkmain.c) */ + locale = g_strdup(setlocale(LC_CTYPE, NULL)); + if ((p = strchr(locale, '.'))) *p = '\0'; /* strip off the . */ + if ((p = strchr(locale, '@'))) *p = '\0'; /* strip off the @ */ + lang = pango_language_from_string(locale); + g_free(locale); +#endif + } -static void measure_font(RrFont *f) -{ - /* xOff, yOff is the normal spacing to the next glyph. */ - XGlyphInfo info; + /* measure the ascent and descent */ + metrics = pango_context_get_metrics(inst->pango, f->font_desc, lang); + f->ascent = pango_font_metrics_get_ascent(metrics); + f->descent = pango_font_metrics_get_descent(metrics); + pango_font_metrics_unref(metrics); - /* measure an elipses */ - XftTextExtentsUtf8(RrDisplay(f->inst), f->xftfont, - (FcChar8*)ELIPSES, strlen(ELIPSES), &info); - f->elipses_length = (signed) info.xOff; } -static RrFont *openfont(const RrInstance *inst, gchar *fontstring) +RrFont *RrFontOpen(const RrInstance *inst, const gchar *name, gint size, + RrFontWeight weight, RrFontSlant slant) { - /* This function is called for each font in the theme file. */ - /* It returns a pointer to a RrFont struct after filling it. */ RrFont *out; - FcPattern *pat, *match; - XftFont *font; - FcResult res; - gint tint; -#ifdef USE_PANGO - guchar *tmp_string = NULL; - gint tmp_int; -#endif /* USE_PANGO */ - - if (!(pat = XftNameParse(fontstring))) - return NULL; - - match = XftFontMatch(RrDisplay(inst), RrScreen(inst), pat, &res); - FcPatternDestroy(pat); - if (!match) - return NULL; + PangoWeight pweight; + PangoStyle pstyle; + PangoAttrList *attrlist; out = g_new(RrFont, 1); out->inst = inst; -#ifdef USE_PANGO - /* printf("\n\n%s\n\n",fontstring); - FcPatternPrint(match); */ - - out->pango_font_description = pango_font_description_new(); - - if (FcPatternGetString(match, "family", 0, &tmp_string) != FcResultTypeMismatch) { - pango_font_description_set_family(out->pango_font_description, (gchar *)tmp_string); - tmp_string = NULL; - } - if (FcPatternGetString(match, "style", 0, &tmp_string) != FcResultTypeMismatch) { - /* Bold ? */ - if (!strcasecmp("bold", (gchar *)tmp_string)) { - pango_font_description_set_weight(out->pango_font_description, PANGO_WEIGHT_BOLD); - } - /* Italic ? */ - else if (!strcasecmp("italic", (gchar *)tmp_string)) { - pango_font_description_set_style(out->pango_font_description, PANGO_STYLE_ITALIC); - } - tmp_string = NULL; + out->ref = 1; + out->font_desc = pango_font_description_new(); + out->layout = pango_layout_new(inst->pango); + out->shortcut_underline = pango_attr_underline_new(PANGO_UNDERLINE_LOW); + out->shortcut_underline->start_index = 0; + out->shortcut_underline->end_index = 0; + + attrlist = pango_attr_list_new(); + /* shortcut_underline is owned by the attrlist */ + pango_attr_list_insert(attrlist, out->shortcut_underline); + /* the attributes are owned by the layout */ + pango_layout_set_attributes(out->layout, attrlist); + pango_attr_list_unref(attrlist); + + switch (weight) { + case RR_FONTWEIGHT_LIGHT: pweight = PANGO_WEIGHT_LIGHT; break; + case RR_FONTWEIGHT_NORMAL: pweight = PANGO_WEIGHT_NORMAL; break; + case RR_FONTWEIGHT_SEMIBOLD: pweight = PANGO_WEIGHT_SEMIBOLD; break; + case RR_FONTWEIGHT_BOLD: pweight = PANGO_WEIGHT_BOLD; break; + case RR_FONTWEIGHT_ULTRABOLD: pweight = PANGO_WEIGHT_ULTRABOLD; break; + default: g_assert_not_reached(); } - if (FcPatternGetInteger(match, "pixelsize", 0, &tmp_int) != FcResultTypeMismatch) { - /* TODO: is PANGO_SCALE correct ?? */ - pango_font_description_set_size(out->pango_font_description, tmp_int*PANGO_SCALE); + switch (slant) { + case RR_FONTSLANT_NORMAL: pstyle = PANGO_STYLE_NORMAL; break; + case RR_FONTSLANT_ITALIC: pstyle = PANGO_STYLE_ITALIC; break; + case RR_FONTSLANT_OBLIQUE: pstyle = PANGO_STYLE_OBLIQUE; break; + default: g_assert_not_reached(); } - PangoLanguage *ln; - PangoFontMetrics *metrics = pango_context_get_metrics(context, out->pango_font_description, ln = pango_language_from_string("en_US")); - out->pango_ascent = pango_font_metrics_get_ascent(metrics); - out->pango_descent = pango_font_metrics_get_descent(metrics); - pango_font_metrics_unref(metrics); -#endif /* USE_PANGO */ - - if (FcPatternGetBool(match, OB_SHADOW, 0, &out->shadow) != FcResultMatch) - out->shadow = FALSE; - - if (FcPatternGetInteger(match, OB_SHADOW_OFFSET, 0, &out->offset) != - FcResultMatch) - out->offset = 1; - - if (FcPatternGetInteger(match, OB_SHADOW_ALPHA, 0, &tint) != FcResultMatch) - tint = 25; - if (tint > 100) tint = 100; - else if (tint < -100) tint = -100; - out->tint = tint; - - font = XftFontOpenPattern(RrDisplay(inst), match); - if (!font) { - FcPatternDestroy(match); - g_free(out); - return NULL; - } else - out->xftfont = font; - -#ifdef USE_PANGO - /* FcPatternDestroy(match); */ -#endif /* USE_PANGO */ - measure_font(out); + /* setup the font */ + pango_font_description_set_family(out->font_desc, name); + pango_font_description_set_weight(out->font_desc, pweight); + pango_font_description_set_style(out->font_desc, pstyle); + pango_font_description_set_size(out->font_desc, size * PANGO_SCALE); + + /* setup the layout */ + pango_layout_set_font_description(out->layout, out->font_desc); + pango_layout_set_wrap(out->layout, PANGO_WRAP_WORD_CHAR); + + /* get the ascent and descent */ + measure_font(inst, out); return out; } -RrFont *RrFontOpen(const RrInstance *inst, gchar *fontstring) +RrFont *RrFontOpenDefault(const RrInstance *inst) { - RrFont *out; - - if (!started) { - font_startup(); - started = TRUE; - } - - if ((out = openfont(inst, fontstring))) - return out; - g_warning(_("Unable to load font: %s\n"), fontstring); - g_warning(_("Trying fallback font: %s\n"), "sans"); - - if ((out = openfont(inst, "sans"))) - return out; - g_warning(_("Unable to load font: %s\n"), "sans"); + return RrFontOpen(inst, RrDefaultFontFamily, RrDefaultFontSize, + RrDefaultFontWeight, RrDefaultFontSlant); +} - return NULL; +void RrFontRef(RrFont *f) +{ + ++f->ref; } void RrFontClose(RrFont *f) { if (f) { - XftFontClose(RrDisplay(f->inst), f->xftfont); - g_free(f); + if (--f->ref < 1) { + g_object_unref(f->layout); + pango_font_description_free(f->font_desc); + g_free(f); + } } -#ifdef USE_PANGO - pango_font_description_free(f->pango_font_description); -#endif } static void font_measure_full(const RrFont *f, const gchar *str, - gint *x, gint *y) + gint *x, gint *y, gint shadow_x, gint shadow_y, + gboolean flow, gint maxwidth) { -#ifdef USE_PANGO - PangoLayout *pl; PangoRectangle rect; - pl = pango_layout_new (context); - pango_layout_set_text(pl, str, -1); - pango_layout_set_font_description(pl, f->pango_font_description); - pango_layout_set_single_paragraph_mode(pl, TRUE); - pango_layout_get_pixel_extents(pl, NULL, &rect); - *x = rect.width + (f->shadow ? ABS(f->offset) : 0); - *y = rect.height + (f->shadow ? ABS(f->offset) : 0); - g_object_unref(pl); - -#else - XGlyphInfo info; - XftTextExtentsUtf8(RrDisplay(f->inst), f->xftfont, - (const FcChar8*)str, strlen(str), &info); + pango_layout_set_text(f->layout, str, -1); + if (flow) { + pango_layout_set_single_paragraph_mode(f->layout, FALSE); + pango_layout_set_width(f->layout, maxwidth * PANGO_SCALE); + pango_layout_set_ellipsize(f->layout, PANGO_ELLIPSIZE_NONE); + } + else { + /* single line mode */ + pango_layout_set_single_paragraph_mode(f->layout, TRUE); + pango_layout_set_width(f->layout, -1); + pango_layout_set_ellipsize(f->layout, PANGO_ELLIPSIZE_MIDDLE); + } - *x = (signed) info.xOff + (f->shadow ? ABS(f->offset) : 0); - *y = info.height + (f->shadow ? ABS(f->offset) : 0); -#endif /* USE_PANGO */ + /* pango_layout_get_pixel_extents lies! this is the right way to get the + size of the text's area */ + pango_layout_get_extents(f->layout, NULL, &rect); +#if PANGO_VERSION_MAJOR > 1 || \ + (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16) + /* pass the logical rect as the ink rect, this is on purpose so we get the + full area for the text */ + pango_extents_to_pixels(&rect, NULL); +#else + rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE; + rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE; +#endif + *x = rect.width + ABS(shadow_x) + 4 /* we put a 2 px edge on each side */; + *y = rect.height + ABS(shadow_y); } -RrSize *RrFontMeasureString(const RrFont *f, const gchar *str) +RrSize *RrFontMeasureString(const RrFont *f, const gchar *str, + gint shadow_x, gint shadow_y, + gboolean flow, gint maxwidth) { RrSize *size; + + g_assert(!flow || maxwidth > 0); + size = g_new(RrSize, 1); - font_measure_full (f, str, &size->width, &size->height); + font_measure_full(f, str, &size->width, &size->height, shadow_x, shadow_y, + flow, maxwidth); return size; } -gint RrFontHeight(const RrFont *f) +gint RrFontHeight(const RrFont *f, gint shadow_y) { -#ifdef USE_PANGO - return (f->pango_ascent - + f->pango_descent - ) / PANGO_SCALE + - (f->shadow ? f->offset : 0); -#else - return f->xftfont->ascent + f->xftfont->descent + - (f->shadow ? f->offset : 0); -#endif + return (f->ascent + f->descent) / PANGO_SCALE + ABS(shadow_y); } -gint RrFontMaxCharWidth(const RrFont *f) -{ - return (signed) f->xftfont->max_advance_width; -} - -#ifdef USE_PANGO static inline int font_calculate_baseline(RrFont *f, gint height) { /* For my own reference: @@ -260,83 +207,74 @@ static inline int font_calculate_baseline(RrFont *f, gint height) * ^space/2 | * V_________v */ - int asc = f->pango_ascent; - int ascdesc = asc + f->pango_descent; - int space = height * PANGO_SCALE - ascdesc; - int baseline = space / 2 + asc; - return baseline / PANGO_SCALE; + return (((height * PANGO_SCALE) /* height of the space in pango units */ + - (f->ascent + f->descent)) /* minus space taken up by text */ + / 2 /* divided by two -> half of the empty space (this is the top + of the text) */ + + f->ascent) /* now move down to the baseline */ + / PANGO_SCALE; /* back to pixels */ } -#endif void RrFontDraw(XftDraw *d, RrTextureText *t, RrRect *area) { - gint x,y,w,h; + gint x,y,w; XftColor c; - GString *text; - gint mw, mh; -#ifndef USE_PANGO - size_t l; - gboolean shortened = FALSE; -#else - PangoLayout *pl; + gint mw; PangoRectangle rect; + PangoAttrList *attrlist; + PangoEllipsizeMode ell; - pl = pango_layout_new (context); -#endif /* USE_PANGO */ + g_assert(!t->flow || t->maxwidth > 0); + + y = area->y; + if (!t->flow) + /* center the text vertically + We do this centering based on the 'baseline' since different fonts + have different top edges. It looks bad when the whole string is + moved when 1 character from a non-default language is included in + the string */ + y += font_calculate_baseline(t->font, area->height); - /* center vertically - * for xft we pass the top edge of the text for positioning... */ -#ifndef USE_PANGO - y = area->y + - (area->height - RrFontHeight(t->font)) / 2; -#else - /* but for pango we pass the baseline, since different fonts have - * different top edges. It looks stupid when the baseline of "normal" - * text jumps up and down when a "strange" character is just added - * to the end of the text */ - y = area->y + - font_calculate_baseline(t->font, area->height); -#endif /* the +2 and -4 leave a small blank edge on the sides */ x = area->x + 2; - w = area->width - 4; - h = area->height; - - text = g_string_new(t->string); -#ifndef USE_PANGO - l = g_utf8_strlen(text->str, -1); - font_measure_full(t->font, text->str, &mw, &mh); - while (l && mw > area->width) { - shortened = TRUE; - /* remove a character from the middle */ - text = g_string_erase(text, l-- / 2, 1); - /* if the elipses are too large, don't show them at all */ - if (ELIPSES_LENGTH(t->font) > area->width) - shortened = FALSE; - font_measure_full(t->font, text->str, &mw, &mh); - mw += ELIPSES_LENGTH(t->font); - } - if (shortened) { - text = g_string_insert(text, (l + 1) / 2, ELIPSES); - l += 3; + w = area->width; + if (t->flow) w = MAX(w, t->maxwidth); + w -= 4; + /* h = area->height; */ + + if (t->flow) + ell = PANGO_ELLIPSIZE_NONE; + else { + switch (t->ellipsize) { + case RR_ELLIPSIZE_NONE: + ell = PANGO_ELLIPSIZE_NONE; + break; + case RR_ELLIPSIZE_START: + ell = PANGO_ELLIPSIZE_START; + break; + case RR_ELLIPSIZE_MIDDLE: + ell = PANGO_ELLIPSIZE_MIDDLE; + break; + case RR_ELLIPSIZE_END: + ell = PANGO_ELLIPSIZE_END; + break; + default: + g_assert_not_reached(); + } } - if (!l) return; - l = strlen(text->str); /* number of bytes */ + pango_layout_set_text(t->font->layout, t->string, -1); + pango_layout_set_width(t->font->layout, w * PANGO_SCALE); + pango_layout_set_ellipsize(t->font->layout, ell); + pango_layout_set_single_paragraph_mode(t->font->layout, !t->flow); -#else - pango_layout_set_text(pl, text->str, -1); - pango_layout_set_font_description(pl, t->font->pango_font_description); - pango_layout_set_single_paragraph_mode(pl, TRUE); - pango_layout_set_width(pl, w * PANGO_SCALE); - pango_layout_set_ellipsize(pl, PANGO_ELLIPSIZE_MIDDLE); - /* This doesn't work with layout_line() of course */ -/* pango_layout_set_alignment(pl, (PangoAlignment)(t->justify)); */ - pango_layout_get_pixel_extents(pl, NULL, &rect); - mw = rect.width; + /* * * end of setting up the layout * * */ -#endif /* USE_PANGO */ + pango_layout_get_pixel_extents(t->font->layout, NULL, &rect); + mw = rect.width; + /* pango_layout_set_alignment doesn't work with + pango_xft_render_layout_line */ switch (t->justify) { case RR_JUSTIFY_LEFT: break; @@ -348,54 +286,95 @@ void RrFontDraw(XftDraw *d, RrTextureText *t, RrRect *area) break; } - if (t->font->shadow) { - if (t->font->tint >= 0) { - c.color.red = 0; - c.color.green = 0; - c.color.blue = 0; - c.color.alpha = 0xffff * t->font->tint / 100; - c.pixel = BlackPixel(RrDisplay(t->font->inst), - RrScreen(t->font->inst)); - } else { - c.color.red = 0xffff; - c.color.green = 0xffff; - c.color.blue = 0xffff; - c.color.alpha = 0xffff * -t->font->tint / 100; - c.pixel = WhitePixel(RrDisplay(t->font->inst), - RrScreen(t->font->inst)); - } -#ifndef USE_PANGO - XftDrawStringUtf8(d, &c, t->font->xftfont, x + t->font->offset, - t->font->xftfont->ascent + y + t->font->offset, - (FcChar8*)text->str, l); -#else /* USE_PANGO */ + if (t->shadow_offset_x || t->shadow_offset_y) { + /* From nvidia's readme (chapter 23): + + When rendering to a 32-bit window, keep in mind that the X RENDER + extension, used by most composite managers, expects "premultiplied + alpha" colors. This means that if your color has components (r,g,b) + and alpha value a, then you must render (a*r, a*g, a*b, a) into the + target window. + */ + c.color.red = (t->shadow_color->r | t->shadow_color->r << 8) * + t->shadow_alpha / 255; + c.color.green = (t->shadow_color->g | t->shadow_color->g << 8) * + t->shadow_alpha / 255; + c.color.blue = (t->shadow_color->b | t->shadow_color->b << 8) * + t->shadow_alpha / 255; + c.color.alpha = 0xffff * t->shadow_alpha / 255; + c.pixel = t->shadow_color->pixel; + /* see below... */ - pango_xft_render_layout_line(d, &c, pango_layout_get_line(pl, 0), - (x + t->font->offset) * PANGO_SCALE, - (y + t->font->offset) * PANGO_SCALE); -#endif /* USE_PANGO */ + if (!t->flow) { + pango_xft_render_layout_line + (d, &c, +#if PANGO_VERSION_MAJOR > 1 || \ + (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16) + pango_layout_get_line_readonly(t->font->layout, 0), +#else + pango_layout_get_line(t->font->layout, 0), +#endif + (x + t->shadow_offset_x) * PANGO_SCALE, + (y + t->shadow_offset_y) * PANGO_SCALE); + } + else { + pango_xft_render_layout(d, &c, t->font->layout, + (x + t->shadow_offset_x) * PANGO_SCALE, + (y + t->shadow_offset_y) * PANGO_SCALE); + } } + c.color.red = t->color->r | t->color->r << 8; c.color.green = t->color->g | t->color->g << 8; c.color.blue = t->color->b | t->color->b << 8; c.color.alpha = 0xff | 0xff << 8; /* fully opaque text */ c.pixel = t->color->pixel; -#ifndef USE_PANGO - XftDrawStringUtf8(d, &c, t->font->xftfont, x, - t->font->xftfont->ascent + y, - (FcChar8*)text->str, l); -#else /* USE_PANGO */ - /* This looks retarded, but layout_line() bases y on the baseline, while - * layout() bases y on the top of the ink layout shit ass fucking crap. - * We want the baseline to always be in the same place, thusly, we use - * layout_line() - * The actual line doesn't need to be freed */ - pango_xft_render_layout_line(d, &c, pango_layout_get_line(pl, 0), - x * PANGO_SCALE, y * PANGO_SCALE); - g_object_unref(pl); + if (t->shortcut) { + const gchar *s = t->string + t->shortcut_pos; + + t->font->shortcut_underline->start_index = t->shortcut_pos; + t->font->shortcut_underline->end_index = t->shortcut_pos + + (g_utf8_next_char(s) - s); + + /* the attributes are owned by the layout. + re-add the attributes to the layout after changing the + start and end index */ + attrlist = pango_layout_get_attributes(t->font->layout); + pango_attr_list_ref(attrlist); + pango_layout_set_attributes(t->font->layout, attrlist); + pango_attr_list_unref(attrlist); + } + + /* layout_line() uses y to specify the baseline + The line doesn't need to be freed, it's a part of the layout */ + if (!t->flow) { + pango_xft_render_layout_line + (d, &c, +#if PANGO_VERSION_MAJOR > 1 || \ + (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 16) + pango_layout_get_line_readonly(t->font->layout, 0), +#else + pango_layout_get_line(t->font->layout, 0), #endif + x * PANGO_SCALE, + y * PANGO_SCALE); + } + else { + pango_xft_render_layout(d, &c, t->font->layout, + x * PANGO_SCALE, + y * PANGO_SCALE); + } - g_string_free(text, TRUE); - return; + if (t->shortcut) { + t->font->shortcut_underline->start_index = 0; + t->font->shortcut_underline->end_index = 0; + /* the attributes are owned by the layout. + re-add the attributes to the layout after changing the + start and end index */ + attrlist = pango_layout_get_attributes(t->font->layout); + pango_attr_list_ref(attrlist); + pango_layout_set_attributes(t->font->layout, attrlist); + pango_attr_list_unref(attrlist); + } }