elal
/
ewm
mirror of https://github.com/E-Almqvist/ewm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add Xft and follback-fonts support to graphics lib

Browse Source
pull/1/head
Eric Pruitt 10 years ago committed by Anselm R Garbe
parent 35db6d8afc
commit 14343e69cc
6 changed files with 299 additions and 103 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 9
      config.def.h
  2. 4
      config.mk
  3. 349
      drw.c
  4. 19
      drw.h
  5. 20
      dwm.c
  6. 1
      util.h

9
config.def.h
Unescape View File

@ -1,7 +1,12 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
/* appearance */ /* 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 normbordercolor[] = "#444444";
static const char normbgcolor[] = "#222222"; static const char normbgcolor[] = "#222222";
static const char normfgcolor[] = "#bbbbbb"; static const char normfgcolor[] = "#bbbbbb";
@ -51,7 +56,7 @@ static const Layout layouts[] = {
/* commands */ /* commands */
static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */ 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 const char *termcmd[] = { "st", NULL };
static Key keys[] = { static Key keys[] = {

4
config.mk
Unescape View File

@ -15,8 +15,8 @@ XINERAMALIBS = -lXinerama
XINERAMAFLAGS = -DXINERAMA XINERAMAFLAGS = -DXINERAMA
# includes and libs # includes and libs
INCS = -I${X11INC} INCS = -I${X11INC} -I/usr/include/freetype2
LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} -lfontconfig -lXft
# flags # flags
CPPFLAGS = -D_BSD_SOURCE -D_POSIX_C_SOURCE=2 -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS} CPPFLAGS = -D_BSD_SOURCE -D_POSIX_C_SOURCE=2 -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS}

349
drw.c
Unescape View File

@ -3,10 +3,59 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/Xft/Xft.h>
#include "drw.h" #include "drw.h"
#include "util.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 *
drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h) { drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h) {
Drw *drw = (Drw *)calloc(1, sizeof(Drw)); 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->h = h;
drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen)); drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
drw->gc = XCreateGC(dpy, root, 0, NULL); drw->gc = XCreateGC(dpy, root, 0, NULL);
drw->fontcount = 0;
XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter); XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
return drw; return drw;
} }
@ -36,56 +86,88 @@ drw_resize(Drw *drw, unsigned int w, unsigned int h) {
void void
drw_free(Drw *drw) { 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); XFreePixmap(drw->dpy, drw->drawable);
XFreeGC(drw->dpy, drw->gc); XFreeGC(drw->dpy, drw->gc);
free(drw); free(drw);
} }
Fnt * /* This function is an implementation detail. Library users should use
drw_font_create(Display *dpy, const char *fontname) { * drw_font_create instead.
*/
static Fnt *
drw_font_xcreate(Drw *drw, const char *fontname, FcPattern *fontpattern) {
Fnt *font; Fnt *font;
char *def, **missing;
int n;
font = (Fnt *)calloc(1, sizeof(Fnt)); if (!(fontname || fontpattern))
if(!font) die("No font specified.\n");
if (!(font = (Fnt *)calloc(1, sizeof(Fnt))))
return NULL; return NULL;
font->set = XCreateFontSet(dpy, fontname, &missing, &n, &def);
if(missing) { if (fontname) {
while(n--) /* Using the pattern found at font->xfont->pattern does not yield same
fprintf(stderr, "drw: missing fontset: %s\n", missing[n]); * the same substitution results as using the pattern returned by
XFreeStringList(missing); * FcNameParse; using the latter results in the desired fallback
} * behaviour whereas the former just results in
if(font->set) { * missing-character-rectangles being drawn, at least with some fonts.
XFontStruct **xfonts; */
char **font_names; if (!(font->xfont = XftFontOpenName(drw->dpy, drw->screen, fontname)) ||
XExtentsOfFontSet(font->set); !(font->pattern = FcNameParse((FcChar8 *) fontname))) {
n = XFontsOfFontSet(font->set, &xfonts, &font_names); if (font->xfont) {
while(n--) { XftFontClose(drw->dpy, font->xfont);
font->ascent = MAX(font->ascent, (*xfonts)->ascent); font->xfont = NULL;
font->descent = MAX(font->descent,(*xfonts)->descent); }
xfonts++; fprintf(stderr, "error, cannot load font: '%s'\n", fontname);
}
} else if (fontpattern) {
if (!(font->xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
fprintf(stderr, "error, cannot load font pattern.\n");
} else {
font->pattern = NULL;
} }
} }
else {
if(!(font->xfont = XLoadQueryFont(dpy, fontname)) if (!font->xfont) {
&& !(font->xfont = XLoadQueryFont(dpy, "fixed"))) free(font);
die("error, cannot load font: '%s'\n", fontname); return NULL;
font->ascent = font->xfont->ascent;
font->descent = font->xfont->descent;
} }
font->ascent = font->xfont->ascent;
font->descent = font->xfont->descent;
font->h = font->ascent + font->descent; font->h = font->ascent + font->descent;
font->dpy = drw->dpy;
return font; return font;
} }
Fnt*
drw_font_create(Drw *drw, const char *fontname) {
return drw_font_xcreate(drw, fontname, NULL);
}
void
drw_load_fonts(Drw* drw, const char *fonts[], size_t fontcount) {
size_t i;
Fnt *font;
for (i = 0; i < fontcount; i++) {
if (drw->fontcount >= DRW_FONT_CACHE_SIZE) {
die("Font cache exhausted.\n");
} else if ((font = drw_font_xcreate(drw, fonts[i], NULL))) {
drw->fonts[drw->fontcount++] = font;
}
}
}
void void
drw_font_free(Display *dpy, Fnt *font) { drw_font_free(Fnt *font) {
if(!font) if(!font)
return; return;
if(font->set) if(font->pattern)
XFreeFontSet(dpy, font->set); FcPatternDestroy(font->pattern);
else XftFontClose(font->dpy, font->xfont);
XFreeFont(dpy, font->xfont);
free(font); free(font);
} }
@ -93,7 +175,7 @@ Clr *
drw_clr_create(Drw *drw, const char *clrname) { drw_clr_create(Drw *drw, const char *clrname) {
Clr *clr; Clr *clr;
Colormap cmap; Colormap cmap;
XColor color; Visual *vis;
if(!drw) if(!drw)
return NULL; return NULL;
@ -101,9 +183,10 @@ drw_clr_create(Drw *drw, const char *clrname) {
if(!clr) if(!clr)
return NULL; return NULL;
cmap = DefaultColormap(drw->dpy, drw->screen); 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'\n", clrname); die("error, cannot allocate color '%s'\n", clrname);
clr->rgb = color.pixel; clr->pix = clr->rgb.pixel;
return clr; return clr;
} }
@ -113,15 +196,9 @@ drw_clr_free(Clr *clr) {
free(clr); free(clr);
} }
void
drw_setfont(Drw *drw, Fnt *font) {
if(drw)
drw->font = font;
}
void void
drw_setscheme(Drw *drw, ClrScheme *scheme) { drw_setscheme(Drw *drw, ClrScheme *scheme) {
if(drw && scheme) if(drw && scheme)
drw->scheme = scheme; drw->scheme = scheme;
} }
@ -129,46 +206,160 @@ void
drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int empty, int invert) { drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int empty, int invert) {
int dx; int dx;
if(!drw || !drw->font || !drw->scheme) if(!drw || !drw->fontcount || !drw->scheme)
return; return;
XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->bg->rgb : drw->scheme->fg->rgb); XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->bg->pix : drw->scheme->fg->pix);
dx = (drw->font->ascent + drw->font->descent + 2) / 4; dx = (drw->fonts[0]->ascent + drw->fonts[0]->descent + 2) / 4;
if(filled) if(filled)
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx+1, dx+1); XFillRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx+1, dx+1);
else if(empty) else if(empty)
XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx, dx); 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) { drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text, int invert) {
char buf[256]; char buf[1024];
int i, tx, ty, th, len, olen; int tx, ty, th;
Extnts tex; 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) if (!(render = x || y || w || h)) {
return; w = ~w;
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) if (!drw || !drw->scheme) {
return; return 0;
olen = strlen(text); } else if (render) {
drw_font_getexts(drw->font, text, olen, &tex); XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme->fg->pix : drw->scheme->bg->pix);
th = drw->font->ascent + drw->font->descent; XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
ty = y + (h / 2) - (th / 2) + drw->font->ascent; }
tx = x + (h / 2);
/* shorten text if necessary */ if (!text || !drw->fontcount) {
for(len = MIN(olen, sizeof buf); len && (tex.w > w - tex.h || w < tex.h); len--) return 0;
drw_font_getexts(drw->font, text, len, &tex); } else if (render) {
if(!len) cmap = DefaultColormap(drw->dpy, drw->screen);
return; vis = DefaultVisual(drw->dpy, drw->screen);
memcpy(buf, text, len); d = XftDrawCreate(drw->dpy, drw->drawable, vis, cmap);
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); curfont = drw->fonts[0];
if(drw->font->set) while (1) {
XmbDrawString(drw->dpy, drw->drawable, drw->font->set, drw->gc, tx, ty, buf, len); utf8strlen = 0;
else utf8str = text;
XDrawString(drw->dpy, drw->drawable, drw->gc, tx, ty, buf, len); 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] = '\0';
if(len < utf8strlen)
for(i = len; i && i > len - 3; buf[--i] = '.');
if (render) {
th = curfont->ascent + curfont->descent;
ty = y + (h / 2) - (th / 2) + curfont->ascent;
tx = x + (h / 2);
XftDrawStringUtf8(d, invert ? &drw->scheme->bg->rgb : &drw->scheme->fg->rgb, curfont->xfont, tx, ty, (XftChar8 *)buf, len);
}
x += tex.w;
w -= tex.w;
}
}
if (!*text) {
break;
} else if (nextfont) {
charexists = 0;
curfont = nextfont;
} else {
/* Regardless of whether or not a fallback font is found, the
* character must be drawn.
*/
charexists = 1;
if (drw->fontcount >= DRW_FONT_CACHE_SIZE) {
continue;
}
fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, utf8codepoint);
if (!drw->fonts[0]->pattern) {
/* Refer to the comment in drw_font_xcreate for more
* information.
*/
die("The first font in the cache must be loaded from a font string.\n");
}
fcpattern = FcPatternDuplicate(drw->fonts[0]->pattern);
FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
FcDefaultSubstitute(fcpattern);
match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
FcCharSetDestroy(fccharset);
FcPatternDestroy(fcpattern);
if (match) {
curfont = drw_font_xcreate(drw, NULL, match);
if (curfont && XftCharExists(drw->dpy, curfont->xfont, utf8codepoint)) {
drw->fonts[drw->fontcount++] = curfont;
} else {
if (curfont) {
drw_font_free(curfont);
}
curfont = drw->fonts[0];
}
}
}
}
if (render) {
XftDrawDestroy(d);
}
return x;
} }
void void
@ -182,19 +373,13 @@ drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) {
void void
drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *tex) { drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *tex) {
XRectangle r; XGlyphInfo ext;
if(!font || !text) if(!font || !text)
return; return;
if(font->set) { XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
XmbTextExtents(font->set, text, len, NULL, &r); tex->h = font->h;
tex->w = r.width; tex->w = ext.xOff;
tex->h = r.height;
}
else {
tex->h = font->ascent + font->descent;
tex->w = XTextWidth(font->xfont, text, len);
}
} }
unsigned int unsigned int

19
drw.h
Unescape View File

@ -1,7 +1,9 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#define DRW_FONT_CACHE_SIZE 32
typedef struct { typedef struct {
unsigned long rgb; unsigned long pix;
XftColor rgb;
} Clr; } Clr;
typedef struct { typedef struct {
@ -9,11 +11,12 @@ typedef struct {
} Cur; } Cur;
typedef struct { typedef struct {
Display *dpy;
int ascent; int ascent;
int descent; int descent;
unsigned int h; unsigned int h;
XFontSet set; XftFont *xfont;
XFontStruct *xfont; FcPattern *pattern;
} Fnt; } Fnt;
typedef struct { typedef struct {
@ -30,7 +33,8 @@ typedef struct {
Drawable drawable; Drawable drawable;
GC gc; GC gc;
ClrScheme *scheme; ClrScheme *scheme;
Fnt *font; size_t fontcount;
Fnt *fonts[DRW_FONT_CACHE_SIZE];
} Drw; } Drw;
typedef struct { typedef struct {
@ -44,8 +48,9 @@ void drw_resize(Drw *drw, unsigned int w, unsigned int h);
void drw_free(Drw *drw); void drw_free(Drw *drw);
/* Fnt abstraction */ /* Fnt abstraction */
Fnt *drw_font_create(Display *dpy, const char *fontname); Fnt *drw_font_create(Drw *drw, const char *fontname);
void drw_font_free(Display *dpy, Fnt *font); void drw_load_fonts(Drw* drw, const char *fonts[], size_t fontcount);
void drw_font_free(Fnt *font);
void drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *extnts); void drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *extnts);
unsigned int drw_font_getexts_width(Fnt *font, const char *text, unsigned int len); unsigned int drw_font_getexts_width(Fnt *font, const char *text, unsigned int len);
@ -63,7 +68,7 @@ void drw_setscheme(Drw *drw, ClrScheme *scheme);
/* Drawing functions */ /* Drawing functions */
void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int empty, int invert); void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int empty, int invert);
void drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text, int invert); int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text, int invert);
/* Map functions */ /* Map functions */
void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h); void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h);

20
dwm.c
Unescape View File

@ -39,6 +39,7 @@
#ifdef XINERAMA #ifdef XINERAMA
#include <X11/extensions/Xinerama.h> #include <X11/extensions/Xinerama.h>
#endif /* XINERAMA */ #endif /* XINERAMA */
#include <X11/Xft/Xft.h>
#include "drw.h" #include "drw.h"
#include "util.h" #include "util.h"
@ -54,7 +55,7 @@
#define WIDTH(X) ((X)->w + 2 * (X)->bw) #define WIDTH(X) ((X)->w + 2 * (X)->bw)
#define HEIGHT(X) ((X)->h + 2 * (X)->bw) #define HEIGHT(X) ((X)->h + 2 * (X)->bw)
#define TAGMASK ((1 << LENGTH(tags)) - 1) #define TAGMASK ((1 << LENGTH(tags)) - 1)
#define TEXTW(X) (drw_font_getexts_width(drw->font, X, strlen(X)) + drw->font->h) #define TEXTW(X) (drw_text(drw, 0, 0, 0, 0, (X), 0) + drw->fonts[0]->h)
/* enums */ /* enums */
enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */ enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
@ -263,7 +264,6 @@ static Cur *cursor[CurLast];
static ClrScheme scheme[SchemeLast]; static ClrScheme scheme[SchemeLast];
static Display *dpy; static Display *dpy;
static Drw *drw; static Drw *drw;
static Fnt *fnt;
static Monitor *mons, *selmon; static Monitor *mons, *selmon;
static Window root; static Window root;
@ -474,7 +474,6 @@ cleanup(void) {
drw_cur_free(drw, cursor[CurNormal]); drw_cur_free(drw, cursor[CurNormal]);
drw_cur_free(drw, cursor[CurResize]); drw_cur_free(drw, cursor[CurResize]);
drw_cur_free(drw, cursor[CurMove]); drw_cur_free(drw, cursor[CurMove]);
drw_font_free(dpy, fnt);
drw_clr_free(scheme[SchemeNorm].border); drw_clr_free(scheme[SchemeNorm].border);
drw_clr_free(scheme[SchemeNorm].bg); drw_clr_free(scheme[SchemeNorm].bg);
drw_clr_free(scheme[SchemeNorm].fg); drw_clr_free(scheme[SchemeNorm].fg);
@ -792,7 +791,7 @@ focus(Client *c) {
detachstack(c); detachstack(c);
attachstack(c); attachstack(c);
grabbuttons(c, True); grabbuttons(c, True);
XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->rgb); XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->pix);
setfocus(c); setfocus(c);
} }
else { else {
@ -1040,7 +1039,7 @@ manage(Window w, XWindowAttributes *wa) {
wc.border_width = c->bw; wc.border_width = c->bw;
XConfigureWindow(dpy, w, CWBorderWidth, &wc); XConfigureWindow(dpy, w, CWBorderWidth, &wc);
XSetWindowBorder(dpy, w, scheme[SchemeNorm].border->rgb); XSetWindowBorder(dpy, w, scheme[SchemeNorm].border->pix);
configure(c); /* propagates border_width, if size doesn't change */ configure(c); /* propagates border_width, if size doesn't change */
updatewindowtype(c); updatewindowtype(c);
updatesizehints(c); updatesizehints(c);
@ -1505,13 +1504,14 @@ setup(void) {
/* init screen */ /* init screen */
screen = DefaultScreen(dpy); screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
fnt = drw_font_create(dpy, font);
sw = DisplayWidth(dpy, screen); sw = DisplayWidth(dpy, screen);
sh = DisplayHeight(dpy, screen); sh = DisplayHeight(dpy, screen);
bh = fnt->h + 2; root = RootWindow(dpy, screen);
drw = drw_create(dpy, screen, root, sw, sh); drw = drw_create(dpy, screen, root, sw, sh);
drw_setfont(drw, fnt); drw_load_fonts(drw, fonts, LENGTH(fonts));
if (!drw->fontcount)
die("No fonts could be loaded.\n");
bh = drw->fonts[0]->h + 2;
updategeom(); updategeom();
/* init atoms */ /* init atoms */
wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False); wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
@ -1685,7 +1685,7 @@ unfocus(Client *c, Bool setfocus) {
if(!c) if(!c)
return; return;
grabbuttons(c, False); grabbuttons(c, False);
XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->rgb); XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->pix);
if(setfocus) { if(setfocus) {
XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
XDeleteProperty(dpy, root, netatom[NetActiveWindow]); XDeleteProperty(dpy, root, netatom[NetActiveWindow]);

1
util.h
Unescape View File

@ -2,5 +2,6 @@
#define MAX(A, B) ((A) > (B) ? (A) : (B)) #define MAX(A, B) ((A) > (B) ? (A) : (B))
#define MIN(A, B) ((A) < (B) ? (A) : (B)) #define MIN(A, B) ((A) < (B) ? (A) : (B))
#define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B))
void die(const char *errstr, ...); void die(const char *errstr, ...);

Write Preview
Loading…
Cancel
Save