commit 33b3bf5a197c9663b6041b54ebcbb49dd76d69fa
Author: Eric Pruitt <[email protected]>
Date: Sat Feb 28 20:59:10 2015 -0800
Added patch that adds Xft & fallback font support
diff --git a/dwm.suckless.org/patches/dwm-6.1-xft-with-fallback-font.diff
b/dwm.suckless.org/patches/dwm-6.1-xft-with-fallback-font.diff
new file mode 100644
index 0000000..0e90117
--- /dev/null
+++ b/dwm.suckless.org/patches/dwm-6.1-xft-with-fallback-font.diff
@@ -0,0 +1,657 @@
+Author: Eric Pruitt, https://github.com/ericpruitt/
+Description: Xft with fallback font support built on top of the Xft patch
+written by Quentin (http://lists.suckless.org/dev/1311/18279.html). The utf8*
+functions were written by Damian Okrasa for the MIT/X licensed
+(http://opensource.org/licenses/MIT) terminal emulator st
+(http://st.suckless.org/).
+
+With this patch, the "font" variable in config.h is superseded by the "fonts"
+variable which is a priority-ordered list of fonts that should be used to
+render text. Here's an example "fonts" definition:
+
+ static const char *fonts[] = {
+ "Sans:size=10.5",
+ "VL Gothic:size=10.5",
+ "WenQuanYi Micro Hei:size=10.5",
+ };
+
+At least one font must be specified, and a maximum of DRW_FONT_CACHE_SIZE fonts
+can be used.
+
+diff --git a/config.def.h b/config.def.h
+index 875885b..eaae8f3 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -1,7 +1,12 @@
+ /* See LICENSE file for copyright and license details. */
+
+ /* appearance */
+-static const char font[] =
"-*-terminus-medium-r-*-*-16-*-*-*-*-*-*-*";
++static const char *fonts[] = {
++ "Sans:size=10.5",
++ "VL Gothic:size=10.5",
++ "WenQuanYi Micro Hei:size=10.5",
++};
++static const char dmenufont[] = "-*-terminus-medium-r-*-*-16-*-*-*-*-*-*-*";
+ static const char normbordercolor[] = "#444444";
+ static const char normbgcolor[] = "#222222";
+ static const char normfgcolor[] = "#bbbbbb";
+@@ -51,7 +56,7 @@ static const Layout layouts[] = {
+
+ /* commands */
+ static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in
spawn() */
+-static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", font,
"-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf", selfgcolor,
NULL };
++static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn",
dmenufont, "-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf",
selfgcolor, NULL };
+ static const char *termcmd[] = { "st", NULL };
+
+ static Key keys[] = {
+diff --git a/config.mk b/config.mk
+index bc3d80e..50b2175 100644
+--- a/config.mk
++++ b/config.mk
+@@ -11,12 +11,12 @@ X11INC = /usr/X11R6/include
+ X11LIB = /usr/X11R6/lib
+
+ # Xinerama, comment if you don't want it
+-XINERAMALIBS = -lXinerama
+-XINERAMAFLAGS = -DXINERAMA
++#XINERAMALIBS = -lXinerama
++#XINERAMAFLAGS = -DXINERAMA
+
+ # includes and libs
+-INCS = -I${X11INC}
+-LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS}
++INCS = -I${X11INC} -I/usr/include/freetype2
++LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} -lfontconfig -lXft
+
+ # flags
+ CPPFLAGS = -D_BSD_SOURCE -D_POSIX_C_SOURCE=2 -DVERSION=\"${VERSION}\"
${XINERAMAFLAGS}
+diff --git a/drw.c b/drw.c
+index b130405..36cf992 100644
+--- a/drw.c
++++ b/drw.c
+@@ -3,10 +3,59 @@
+ #include <stdlib.h>
+ #include <string.h>
+ #include <X11/Xlib.h>
++#include <X11/Xft/Xft.h>
+
+ #include "drw.h"
+ #include "util.h"
+
++#define UTF_INVALID 0xFFFD
++#define UTF_SIZ 4
++
++static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0,
0xF0};
++static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0,
0xF8};
++static const long utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800,
0x10000};
++static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF,
0x10FFFF};
++
++static long
++utf8decodebyte(const char c, size_t *i) {
++ for(*i = 0; *i < (UTF_SIZ + 1); ++(*i))
++ if(((unsigned char)c & utfmask[*i]) == utfbyte[*i])
++ return (unsigned char)c & ~utfmask[*i];
++ return 0;
++}
++
++static size_t
++utf8validate(long *u, size_t i) {
++ if(!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
++ *u = UTF_INVALID;
++ for(i = 1; *u > utfmax[i]; ++i)
++ ;
++ return i;
++}
++
++static size_t
++utf8decode(const char *c, long *u, size_t clen) {
++ size_t i, j, len, type;
++ long udecoded;
++
++ *u = UTF_INVALID;
++ if(!clen)
++ return 0;
++ udecoded = utf8decodebyte(c[0], &len);
++ if(!BETWEEN(len, 1, UTF_SIZ))
++ return 1;
++ for(i = 1, j = 1; i < clen && j < len; ++i, ++j) {
++ udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
++ if(type != 0)
++ return j;
++ }
++ if(j < len)
++ return 0;
++ *u = udecoded;
++ utf8validate(u, len);
++ return len;
++}
++
+ Drw *
+ drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned
int h) {
+ Drw *drw = (Drw *)calloc(1, sizeof(Drw));
+@@ -19,6 +68,7 @@ drw_create(Display *dpy, int screen, Window root, unsigned
int w, unsigned int h
+ drw->h = h;
+ drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy,
screen));
+ drw->gc = XCreateGC(dpy, root, 0, NULL);
++ drw->fontcount = 0;
+ XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
+ return drw;
+ }
+@@ -36,56 +86,79 @@ drw_resize(Drw *drw, unsigned int w, unsigned int h) {
+
+ void
+ drw_free(Drw *drw) {
++ size_t i;
++ for (i = 0; i < drw->fontcount; i++) {
++ drw_font_free(drw->fonts[i]);
++ }
+ XFreePixmap(drw->dpy, drw->drawable);
+ XFreeGC(drw->dpy, drw->gc);
+ free(drw);
+ }
+
+ Fnt *
+-drw_font_create(Display *dpy, const char *fontname) {
++drw_font_create(Drw *drw, const char *fontname, FcPattern *fontpattern) {
+ Fnt *font;
+- char *def, **missing;
+- int n;
+
+- font = (Fnt *)calloc(1, sizeof(Fnt));
+- if(!font)
++ if (!(fontname || fontpattern))
++ die("No font specified.
");
++
++ if (!(font = (Fnt *)calloc(1, sizeof(Fnt))))
+ return NULL;
+- font->set = XCreateFontSet(dpy, fontname, &missing, &n, &def);
+- if(missing) {
+- while(n--)
+- fprintf(stderr, "drw: missing fontset: %s
", missing[n]);
+- XFreeStringList(missing);
+- }
+- if(font->set) {
+- XFontStruct **xfonts;
+- char **font_names;
+- XExtentsOfFontSet(font->set);
+- n = XFontsOfFontSet(font->set, &xfonts, &font_names);
+- while(n--) {
+- font->ascent = MAX(font->ascent, (*xfonts)->ascent);
+- font->descent = MAX(font->descent,(*xfonts)->descent);
+- xfonts++;
++
++ if (fontname) {
++ // Using the pattern found at font->xfont->pattern does not
yield same
++ // the same substitution results as using the pattern returned
by
++ // FcNameParse; using the latter results in the desired fallback
++ // behaviour whereas the former just results in
++ // missing-character-rectangles being drawn, at least with some
fonts.
++ if (!(font->xfont = XftFontOpenName(drw->dpy, drw->screen,
fontname)) ||
++ !(font->pattern = FcNameParse((FcChar8 *) fontname))) {
++ if (font->xfont)
++ XftFontClose(font->dpy, font->xfont);
++ fprintf(stderr, "error, cannot load font: '%s'
", fontname);
++ }
++ } else if (fontpattern) {
++ if (!(font->xfont = XftFontOpenPattern(drw->dpy, fontpattern)))
{
++ fprintf(stderr, "error, cannot load font pattern.
");
++ } else {
++ font->pattern = NULL;
+ }
+ }
+- else {
+- if(!(font->xfont = XLoadQueryFont(dpy, fontname))
+- && !(font->xfont = XLoadQueryFont(dpy, "fixed")))
+- die("error, cannot load font: '%s'
", fontname);
+- font->ascent = font->xfont->ascent;
+- font->descent = font->xfont->descent;
++
++ if (!font->xfont) {
++ free(font);
++ return NULL;
+ }
++
++ font->ascent = font->xfont->ascent;
++ font->descent = font->xfont->descent;
+ font->h = font->ascent + font->descent;
++ font->dpy = drw->dpy;
+ return font;
+ }
+
+ void
+-drw_font_free(Display *dpy, Fnt *font) {
++drw_load_fonts(Drw* drw, const char *fonts[], size_t fontcount) {
++ size_t i;
++ Fnt *font;
++ for (i = 0; i < fontcount && drw->fontcount < DRW_FONT_CACHE_SIZE; i++)
{
++ if ((font = drw_font_create(drw, fonts[i], NULL))) {
++ drw->fonts[drw->fontcount++] = font;
++ }
++ }
++
++ if (i != fontcount) {
++ die("Font cache exhausted.
");
++ }
++}
++
++void
++drw_font_free(Fnt *font) {
+ if(!font)
+ return;
+- if(font->set)
+- XFreeFontSet(dpy, font->set);
+- else
+- XFreeFont(dpy, font->xfont);
++ if(font->pattern)
++ FcPatternDestroy(font->pattern);
++ XftFontClose(font->dpy, font->xfont);
+ free(font);
+ }
+
+@@ -93,7 +166,7 @@ Clr *
+ drw_clr_create(Drw *drw, const char *clrname) {
+ Clr *clr;
+ Colormap cmap;
+- XColor color;
++ Visual *vis;
+
+ if(!drw)
+ return NULL;
+@@ -101,9 +174,10 @@ drw_clr_create(Drw *drw, const char *clrname) {
+ if(!clr)
+ return NULL;
+ cmap = DefaultColormap(drw->dpy, drw->screen);
+- if(!XAllocNamedColor(drw->dpy, cmap, clrname, &color, &color))
++ vis = DefaultVisual(drw->dpy, drw->screen);
++ if(!XftColorAllocName(drw->dpy, vis, cmap, clrname, &clr->rgb))
+ die("error, cannot allocate color '%s'
", clrname);
+- clr->rgb = color.pixel;
++ clr->pix = clr->rgb.pixel;
+ return clr;
+ }
+
+@@ -114,14 +188,8 @@ drw_clr_free(Clr *clr) {
+ }
+
+ void
+-drw_setfont(Drw *drw, Fnt *font) {
+- if(drw)
+- drw->font = font;
+-}
+-
+-void
+ drw_setscheme(Drw *drw, ClrScheme *scheme) {
+- if(drw && scheme)
++ if(drw && scheme)
+ drw->scheme = scheme;
+ }
+
+@@ -129,46 +197,158 @@ void
+ drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled,
int empty, int invert) {
+ int dx;
+
+- if(!drw || !drw->font || !drw->scheme)
++ if(!drw || !drw->fontcount || !drw->scheme)
+ return;
+- XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->bg->rgb :
drw->scheme->fg->rgb);
+- dx = (drw->font->ascent + drw->font->descent + 2) / 4;
++ XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->bg->pix :
drw->scheme->fg->pix);
++ dx = (drw->fonts[0]->ascent + drw->fonts[0]->descent + 2) / 4;
+ if(filled)
+ XFillRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1,
dx+1, dx+1);
+ else if(empty)
+ XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx,
dx);
+ }
+
+-void
++int
+ drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char
*text, int invert) {
+- char buf[256];
+- int i, tx, ty, th, len, olen;
++ char buf[1024];
++ int tx, ty, th;
+ Extnts tex;
++ Colormap cmap;
++ Visual *vis;
++ XftDraw *d;
++ Fnt *curfont, *nextfont;
++ size_t i, len;
++ int utf8strlen, utf8charlen, render;
++ long utf8codepoint = 0;
++ const char *utf8str;
++ FcCharSet *fccharset;
++ FcPattern *fcpattern;
++ FcPattern *match;
++ XftResult result;
++ int charexists = 0;
+
+- if(!drw || !drw->scheme)
+- return;
+- XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->fg->rgb :
drw->scheme->bg->rgb);
+- XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+- if(!text || !drw->font)
+- return;
+- olen = strlen(text);
+- drw_font_getexts(drw->font, text, olen, &tex);
+- th = drw->font->ascent + drw->font->descent;
+- ty = y + (h / 2) - (th / 2) + drw->font->ascent;
+- tx = x + (h / 2);
+- /* shorten text if necessary */
+- for(len = MIN(olen, sizeof buf); len && (tex.w > w - tex.h || w <
tex.h); len--)
+- drw_font_getexts(drw->font, text, len, &tex);
+- if(!len)
+- return;
+- memcpy(buf, text, len);
+- if(len < olen)
+- for(i = len; i && i > len - 3; buf[--i] = '.');
+- XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->bg->rgb :
drw->scheme->fg->rgb);
+- if(drw->font->set)
+- XmbDrawString(drw->dpy, drw->drawable, drw->font->set, drw->gc,
tx, ty, buf, len);
+- else
+- XDrawString(drw->dpy, drw->drawable, drw->gc, tx, ty, buf, len);
++ if (!(render = x || y || w || h)) {
++ w = ~w;
++ }
++
++ if (!drw || !drw->scheme) {
++ return 0;
++ } else if (render) {
++ XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->fg->pix
: drw->scheme->bg->pix);
++ XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
++ }
++
++ if (!text || !drw->fontcount) {
++ return 0;
++ } else if (render) {
++ cmap = DefaultColormap(drw->dpy, drw->screen);
++ vis = DefaultVisual(drw->dpy, drw->screen);
++ d = XftDrawCreate(drw->dpy, drw->drawable, vis, cmap);
++ }
++
++ curfont = drw->fonts[0];
++ while (1) {
++ utf8strlen = 0;
++ utf8str = text;
++ nextfont = NULL;
++ while (*text) {
++ utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ);
++ for (i = 0; i < drw->fontcount; i++) {
++ charexists = charexists ||
XftCharExists(drw->dpy, drw->fonts[i]->xfont, utf8codepoint);
++ if (charexists) {
++ if (drw->fonts[i] == curfont) {
++ utf8strlen += utf8charlen;
++ text += utf8charlen;
++ } else {
++ nextfont = drw->fonts[i];
++ }
++ break;
++ }
++ }
++
++ if (!charexists || (nextfont && nextfont != curfont)) {
++ break;
++ } else {
++ charexists = 0;
++ }
++ }
++
++ if (utf8strlen) {
++ drw_font_getexts(curfont, utf8str, utf8strlen, &tex);
++ /* shorten text if necessary */
++ for(len = MIN(utf8strlen, (sizeof buf) - 1); len &&
(tex.w > w - drw->fonts[0]->h || w < drw->fonts[0]->h); len--)
++ drw_font_getexts(curfont, utf8str, len, &tex);
++
++ if (len) {
++ memcpy(buf, utf8str, len);
++ buf[len] = '
