franck.stauffer
/
dwm
1
0
Fork 0
Code Releases Activity

Personalize config.def.h and config.mk, add format target, format code

This commit is contained in:
Franck STAUFFER 2020-09-04 09:46:51 +02:00
parent 61bb8b2241
commit 100fed48d9
Signed by: franck.stauffer
GPG Key ID: AAF5A94045CEC261
7 changed files with 2388 additions and 1980 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -26,7 +26,7 @@ dwm: ${OBJ}
${CC} -o $@ ${OBJ} ${LDFLAGS} ${CC} -o $@ ${OBJ} ${LDFLAGS}
clean: clean:
rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz config.h
dist: clean dist: clean
mkdir -p dwm-${VERSION} mkdir -p dwm-${VERSION}
@ -36,6 +36,9 @@ dist: clean
gzip dwm-${VERSION}.tar gzip dwm-${VERSION}.tar
rm -rf dwm-${VERSION} rm -rf dwm-${VERSION}
format:
clang-format -i -style="{BasedOnStyle: mozilla, IndentWidth: 4}" *.c
install: all install: all
mkdir -p ${DESTDIR}${PREFIX}/bin mkdir -p ${DESTDIR}${PREFIX}/bin
cp -f dwm ${DESTDIR}${PREFIX}/bin cp -f dwm ${DESTDIR}${PREFIX}/bin

28
config.def.h
View File

@ -5,17 +5,15 @@ static const unsigned int borderpx = 1; /* border pixel of windows */
static const unsigned int snap = 32; /* snap pixel */ static const unsigned int snap = 32; /* snap pixel */
static const int showbar = 1; /* 0 means no bar */ static const int showbar = 1; /* 0 means no bar */
static const int topbar = 1; /* 0 means bottom bar */ static const int topbar = 1; /* 0 means bottom bar */
static const char *fonts[] = { "monospace:size=10" }; static const char *fonts[] = { "SauceCodePro Nerd Font Mono:size=10:antialias:true:autohint:true" };
static const char dmenufont[] = "monospace:size=10"; static const char dmenufont[] = "SauceCodePro Nerd Font Mono:size=10:antialias:true:autohint:true";
static const char col_gray1[] = "#222222"; static const char color_black[] = "#1D2021";
static const char col_gray2[] = "#444444"; static const char color_green[] = "#98971A";
static const char col_gray3[] = "#bbbbbb"; static const char color_red[] = "#CC241D";
static const char col_gray4[] = "#eeeeee";
static const char col_cyan[] = "#005577";
static const char *colors[][3] = { static const char *colors[][3] = {
/* fg bg border */ /* fg bg border */
[SchemeNorm] = { col_gray3, col_gray1, col_gray2 }, [SchemeNorm] = { color_red, color_black, color_red },
[SchemeSel] = { col_gray4, col_cyan, col_cyan }, [SchemeSel] = { color_black, color_red, color_green },
}; };
/* tagging */ /* tagging */
@ -40,7 +38,7 @@ static const Layout layouts[] = {
/* symbol arrange function */ /* symbol arrange function */
{ "[]=", tile }, /* first entry is default */ { "[]=", tile }, /* first entry is default */
{ "><>", NULL }, /* no layout function means floating behavior */ { "><>", NULL }, /* no layout function means floating behavior */
{ "[M]", monocle }, { "[ ]", monocle },
}; };
/* key definitions */ /* key definitions */
@ -56,13 +54,19 @@ 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", dmenufont, "-nb", col_gray1, "-nf", col_gray3, "-sb", col_cyan, "-sf", col_gray4, NULL }; static const char *dmenucmd[] = { "/usr/bin/dmenu_run", "-m", dmenumon, NULL };
static const char *termcmd[] = { "st", NULL }; static const char *termcmd[] = { "/usr/bin/xterm", NULL };
static const char *lockcmd[] = { "/usr/bin/xsecurelock", NULL };
static const char *mailcmd[] = { "/usr/bin/thunderbird", NULL };
static const char *webcmd[] = { "/usr/bin/chromium", NULL };
static Key keys[] = { static Key keys[] = {
/* modifier key function argument */ /* modifier key function argument */
{ MODKEY, XK_p, spawn, {.v = dmenucmd } }, { MODKEY, XK_p, spawn, {.v = dmenucmd } },
{ MODKEY|ShiftMask, XK_Return, spawn, {.v = termcmd } }, { MODKEY|ShiftMask, XK_Return, spawn, {.v = termcmd } },
{ MODKEY|ShiftMask, XK_l, spawn, {.v = lockcmd } },
{ MODKEY|ShiftMask, XK_m, spawn, {.v = mailcmd } },
{ MODKEY|ShiftMask, XK_w, spawn, {.v = webcmd } },
{ MODKEY, XK_b, togglebar, {0} }, { MODKEY, XK_b, togglebar, {0} },
{ MODKEY, XK_j, focusstack, {.i = +1 } }, { MODKEY, XK_j, focusstack, {.i = +1 } },
{ MODKEY, XK_k, focusstack, {.i = -1 } }, { MODKEY, XK_k, focusstack, {.i = -1 } },

11
config.mk
View File

@ -4,7 +4,7 @@ VERSION = 6.2
# Customize below to fit your system # Customize below to fit your system
# paths # paths
PREFIX = /usr/local PREFIX = /usr
MANPREFIX = ${PREFIX}/share/man MANPREFIX = ${PREFIX}/share/man
X11INC = /usr/X11R6/include X11INC = /usr/X11R6/include
@ -25,14 +25,13 @@ INCS = -I${X11INC} -I${FREETYPEINC}
LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS}
# flags # flags
CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_POSIX_C_SOURCE=200809L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS} CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_POSIX_C_SOURCE=200809L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS} -D_FORTIFY_SURCE=2
#CFLAGS = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS} CFLAGS = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Ofast -march=native -mtune=native -fstack-protector -fno-plt ${INCS} ${CPPFLAGS}
CFLAGS = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS} LDFLAGS = ${LIBS} -Wl,-O3,-z,now,-z,relro -s
LDFLAGS = ${LIBS}
# Solaris # Solaris
#CFLAGS = -fast ${INCS} -DVERSION=\"${VERSION}\" #CFLAGS = -fast ${INCS} -DVERSION=\"${VERSION}\"
#LDFLAGS = ${LIBS} #LDFLAGS = ${LIBS}
# compiler and linker # compiler and linker
CC = cc CC = clang

663
drw.c
View File

@ -1,436 +1,489 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#include <X11/Xft/Xft.h>
#include <X11/Xlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.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_INVALID 0xFFFD
#define UTF_SIZ 4 #define UTF_SIZ 4
static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0}; 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 unsigned char utfmask[UTF_SIZ + 1] = { 0xC0,
static const long utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000}; 0x80,
static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF}; 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 static long
utf8decodebyte(const char c, size_t *i) utf8decodebyte(const char c, size_t* i)
{ {
for (*i = 0; *i < (UTF_SIZ + 1); ++(*i)) for (*i = 0; *i < (UTF_SIZ + 1); ++(*i))
if (((unsigned char)c & utfmask[*i]) == utfbyte[*i]) if (((unsigned char)c & utfmask[*i]) == utfbyte[*i])
return (unsigned char)c & ~utfmask[*i]; return (unsigned char)c & ~utfmask[*i];
return 0; return 0;
} }
static size_t static size_t
utf8validate(long *u, size_t i) utf8validate(long* u, size_t i)
{ {
if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF)) if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
*u = UTF_INVALID; *u = UTF_INVALID;
for (i = 1; *u > utfmax[i]; ++i) for (i = 1; *u > utfmax[i]; ++i)
; ;
return i; return i;
} }
static size_t static size_t
utf8decode(const char *c, long *u, size_t clen) utf8decode(const char* c, long* u, size_t clen)
{ {
size_t i, j, len, type; size_t i, j, len, type;
long udecoded; long udecoded;
*u = UTF_INVALID; *u = UTF_INVALID;
if (!clen) if (!clen)
return 0; return 0;
udecoded = utf8decodebyte(c[0], &len); udecoded = utf8decodebyte(c[0], &len);
if (!BETWEEN(len, 1, UTF_SIZ)) if (!BETWEEN(len, 1, UTF_SIZ))
return 1; return 1;
for (i = 1, j = 1; i < clen && j < len; ++i, ++j) { for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type); udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
if (type) if (type)
return j; return j;
} }
if (j < len) if (j < len)
return 0; return 0;
*u = udecoded; *u = udecoded;
utf8validate(u, len); utf8validate(u, len);
return 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 = ecalloc(1, sizeof(Drw)); Drw* drw = ecalloc(1, sizeof(Drw));
drw->dpy = dpy; drw->dpy = dpy;
drw->screen = screen; drw->screen = screen;
drw->root = root; drw->root = root;
drw->w = w; drw->w = w;
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);
XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter); XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
return drw; return drw;
} }
void void
drw_resize(Drw *drw, unsigned int w, unsigned int h) drw_resize(Drw* drw, unsigned int w, unsigned int h)
{ {
if (!drw) if (!drw)
return; return;
drw->w = w; drw->w = w;
drw->h = h; drw->h = h;
if (drw->drawable) if (drw->drawable)
XFreePixmap(drw->dpy, drw->drawable); XFreePixmap(drw->dpy, drw->drawable);
drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen)); drw->drawable = XCreatePixmap(
drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
} }
void void
drw_free(Drw *drw) drw_free(Drw* drw)
{ {
XFreePixmap(drw->dpy, drw->drawable); XFreePixmap(drw->dpy, drw->drawable);
XFreeGC(drw->dpy, drw->gc); XFreeGC(drw->dpy, drw->gc);
drw_fontset_free(drw->fonts); drw_fontset_free(drw->fonts);
free(drw); free(drw);
} }
/* This function is an implementation detail. Library users should use /* This function is an implementation detail. Library users should use
* drw_fontset_create instead. * drw_fontset_create instead.
*/ */
static Fnt * static Fnt*
xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern) xfont_create(Drw* drw, const char* fontname, FcPattern* fontpattern)
{ {
Fnt *font; Fnt* font;
XftFont *xfont = NULL; XftFont* xfont = NULL;
FcPattern *pattern = NULL; FcPattern* pattern = NULL;
if (fontname) { if (fontname) {
/* Using the pattern found at font->xfont->pattern does not yield the /* Using the pattern found at font->xfont->pattern does not yield the
* same substitution results as using the pattern returned by * same substitution results as using the pattern returned by
* FcNameParse; using the latter results in the desired fallback * FcNameParse; using the latter results in the desired fallback
* behaviour whereas the former just results in missing-character * behaviour whereas the former just results in missing-character
* rectangles being drawn, at least with some fonts. */ * rectangles being drawn, at least with some fonts. */
if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) { if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname); fprintf(
return NULL; stderr, "error, cannot load font from name: '%s'\n", fontname);
} return NULL;
if (!(pattern = FcNameParse((FcChar8 *) fontname))) { }
fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname); if (!(pattern = FcNameParse((FcChar8*)fontname))) {
XftFontClose(drw->dpy, xfont); fprintf(stderr,
return NULL; "error, cannot parse font name to pattern: '%s'\n",
} fontname);
} else if (fontpattern) { XftFontClose(drw->dpy, xfont);
if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) { return NULL;
fprintf(stderr, "error, cannot load font from pattern.\n"); }
return NULL; } else if (fontpattern) {
} if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
} else { fprintf(stderr, "error, cannot load font from pattern.\n");
die("no font specified."); return NULL;
} }
} else {
die("no font specified.");
}
/* Do not allow using color fonts. This is a workaround for a BadLength /* Do not allow using color fonts. This is a workaround for a BadLength
* error from Xft with color glyphs. Modelled on the Xterm workaround. See * error from Xft with color glyphs. Modelled on the Xterm workaround. See
* https://bugzilla.redhat.com/show_bug.cgi?id=1498269 * https://bugzilla.redhat.com/show_bug.cgi?id=1498269
* https://lists.suckless.org/dev/1701/30932.html * https://lists.suckless.org/dev/1701/30932.html
* https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349 * https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349
* and lots more all over the internet. * and lots more all over the internet.
*/ */
FcBool iscol; FcBool iscol;
if(FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) { if (FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) ==
XftFontClose(drw->dpy, xfont); FcResultMatch &&
return NULL; iscol) {
} XftFontClose(drw->dpy, xfont);
return NULL;
}
font = ecalloc(1, sizeof(Fnt)); font = ecalloc(1, sizeof(Fnt));
font->xfont = xfont; font->xfont = xfont;
font->pattern = pattern; font->pattern = pattern;
font->h = xfont->ascent + xfont->descent; font->h = xfont->ascent + xfont->descent;
font->dpy = drw->dpy; font->dpy = drw->dpy;
return font; return font;
} }
static void static void
xfont_free(Fnt *font) xfont_free(Fnt* font)
{ {
if (!font) if (!font)
return; return;
if (font->pattern) if (font->pattern)
FcPatternDestroy(font->pattern); FcPatternDestroy(font->pattern);
XftFontClose(font->dpy, font->xfont); XftFontClose(font->dpy, font->xfont);
free(font); free(font);
} }
Fnt* Fnt*
drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount) drw_fontset_create(Drw* drw, const char* fonts[], size_t fontcount)
{ {
Fnt *cur, *ret = NULL; Fnt *cur, *ret = NULL;
size_t i; size_t i;
if (!drw || !fonts) if (!drw || !fonts)
return NULL; return NULL;
for (i = 1; i <= fontcount; i++) { for (i = 1; i <= fontcount; i++) {
if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) { if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
cur->next = ret; cur->next = ret;
ret = cur; ret = cur;
} }
} }
return (drw->fonts = ret); return (drw->fonts = ret);
} }
void void
drw_fontset_free(Fnt *font) drw_fontset_free(Fnt* font)
{ {
if (font) { if (font) {
drw_fontset_free(font->next); drw_fontset_free(font->next);
xfont_free(font); xfont_free(font);
} }
} }
void void
drw_clr_create(Drw *drw, Clr *dest, const char *clrname) drw_clr_create(Drw* drw, Clr* dest, const char* clrname)
{ {
if (!drw || !dest || !clrname) if (!drw || !dest || !clrname)
return; return;
if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen), if (!XftColorAllocName(drw->dpy,
DefaultColormap(drw->dpy, drw->screen), DefaultVisual(drw->dpy, drw->screen),
clrname, dest)) DefaultColormap(drw->dpy, drw->screen),
die("error, cannot allocate color '%s'", clrname); clrname,
dest))
die("error, cannot allocate color '%s'", clrname);
} }
/* Wrapper to create color schemes. The caller has to call free(3) on the /* Wrapper to create color schemes. The caller has to call free(3) on the
* returned color scheme when done using it. */ * returned color scheme when done using it. */
Clr * Clr*
drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount) drw_scm_create(Drw* drw, const char* clrnames[], size_t clrcount)
{ {
size_t i; size_t i;
Clr *ret; Clr* ret;
/* need at least two colors for a scheme */ /* need at least two colors for a scheme */
if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor)))) if (!drw || !clrnames || clrcount < 2 ||
return NULL; !(ret = ecalloc(clrcount, sizeof(XftColor))))
return NULL;
for (i = 0; i < clrcount; i++) for (i = 0; i < clrcount; i++)
drw_clr_create(drw, &ret[i], clrnames[i]); drw_clr_create(drw, &ret[i], clrnames[i]);
return ret; return ret;
} }
void void
drw_setfontset(Drw *drw, Fnt *set) drw_setfontset(Drw* drw, Fnt* set)
{ {
if (drw) if (drw)
drw->fonts = set; drw->fonts = set;
} }
void void
drw_setscheme(Drw *drw, Clr *scm) drw_setscheme(Drw* drw, Clr* scm)
{ {
if (drw) if (drw)
drw->scheme = scm; drw->scheme = scm;
} }
void void
drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert) drw_rect(Drw* drw,
int x,
int y,
unsigned int w,
unsigned int h,
int filled,
int invert)
{ {
if (!drw || !drw->scheme) if (!drw || !drw->scheme)
return; return;
XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel); XSetForeground(drw->dpy,
if (filled) drw->gc,
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); invert ? drw->scheme[ColBg].pixel
else : drw->scheme[ColFg].pixel);
XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1); if (filled)
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
else
XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
} }
int int
drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert) drw_text(Drw* drw,
int x,
int y,
unsigned int w,
unsigned int h,
unsigned int lpad,
const char* text,
int invert)
{ {
char buf[1024]; char buf[1024];
int ty; int ty;
unsigned int ew; unsigned int ew;
XftDraw *d = NULL; XftDraw* d = NULL;
Fnt *usedfont, *curfont, *nextfont; Fnt *usedfont, *curfont, *nextfont;
size_t i, len; size_t i, len;
int utf8strlen, utf8charlen, render = x || y || w || h; int utf8strlen, utf8charlen, render = x || y || w || h;
long utf8codepoint = 0; long utf8codepoint = 0;
const char *utf8str; const char* utf8str;
FcCharSet *fccharset; FcCharSet* fccharset;
FcPattern *fcpattern; FcPattern* fcpattern;
FcPattern *match; FcPattern* match;
XftResult result; XftResult result;
int charexists = 0; int charexists = 0;
if (!drw || (render && !drw->scheme) || !text || !drw->fonts) if (!drw || (render && !drw->scheme) || !text || !drw->fonts)
return 0; return 0;
if (!render) { if (!render) {
w = ~w; w = ~w;
} else { } else {
XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel); XSetForeground(
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
d = XftDrawCreate(drw->dpy, drw->drawable, XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
DefaultVisual(drw->dpy, drw->screen), d = XftDrawCreate(drw->dpy,
DefaultColormap(drw->dpy, drw->screen)); drw->drawable,
x += lpad; DefaultVisual(drw->dpy, drw->screen),
w -= lpad; DefaultColormap(drw->dpy, drw->screen));
} x += lpad;
w -= lpad;
}
usedfont = drw->fonts; usedfont = drw->fonts;
while (1) { while (1) {
utf8strlen = 0; utf8strlen = 0;
utf8str = text; utf8str = text;
nextfont = NULL; nextfont = NULL;
while (*text) { while (*text) {
utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ); utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ);
for (curfont = drw->fonts; curfont; curfont = curfont->next) { for (curfont = drw->fonts; curfont; curfont = curfont->next) {
charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint); charexists =
if (charexists) { charexists ||
if (curfont == usedfont) { XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
utf8strlen += utf8charlen; if (charexists) {
text += utf8charlen; if (curfont == usedfont) {
} else { utf8strlen += utf8charlen;
nextfont = curfont; text += utf8charlen;
} } else {
break; nextfont = curfont;
} }
} break;
}
}
if (!charexists || nextfont) if (!charexists || nextfont)
break; break;
else else
charexists = 0; charexists = 0;
} }
if (utf8strlen) { if (utf8strlen) {
drw_font_getexts(usedfont, utf8str, utf8strlen, &ew, NULL); drw_font_getexts(usedfont, utf8str, utf8strlen, &ew, NULL);
/* shorten text if necessary */ /* shorten text if necessary */
for (len = MIN(utf8strlen, sizeof(buf) - 1); len && ew > w; len--) for (len = MIN(utf8strlen, sizeof(buf) - 1); len && ew > w; len--)
drw_font_getexts(usedfont, utf8str, len, &ew, NULL); drw_font_getexts(usedfont, utf8str, len, &ew, NULL);
if (len) { if (len) {
memcpy(buf, utf8str, len); memcpy(buf, utf8str, len);
buf[len] = '\0'; buf[len] = '\0';
if (len < utf8strlen) if (len < utf8strlen)
for (i = len; i && i > len - 3; buf[--i] = '.') for (i = len; i && i > len - 3; buf[--i] = '.')
; /* NOP */ ; /* NOP */
if (render) { if (render) {
ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent; ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg], XftDrawStringUtf8(d,
usedfont->xfont, x, ty, (XftChar8 *)buf, len); &drw->scheme[invert ? ColBg : ColFg],
} usedfont->xfont,
x += ew; x,
w -= ew; ty,
} (XftChar8*)buf,
} len);
}
x += ew;
w -= ew;
}
}
if (!*text) { if (!*text) {
break; break;
} else if (nextfont) { } else if (nextfont) {
charexists = 0; charexists = 0;
usedfont = nextfont; usedfont = nextfont;
} else { } else {
/* Regardless of whether or not a fallback font is found, the /* Regardless of whether or not a fallback font is found, the
* character must be drawn. */ * character must be drawn. */
charexists = 1; charexists = 1;
fccharset = FcCharSetCreate(); fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, utf8codepoint); FcCharSetAddChar(fccharset, utf8codepoint);
if (!drw->fonts->pattern) { if (!drw->fonts->pattern) {
/* Refer to the comment in xfont_create for more information. */ /* Refer to the comment in xfont_create for more information. */
die("the first font in the cache must be loaded from a font string."); die("the first font in the cache must be loaded from a font "
} "string.");
}
fcpattern = FcPatternDuplicate(drw->fonts->pattern); fcpattern = FcPatternDuplicate(drw->fonts->pattern);
FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset); FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue); FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
FcPatternAddBool(fcpattern, FC_COLOR, FcFalse); FcPatternAddBool(fcpattern, FC_COLOR, FcFalse);
FcConfigSubstitute(NULL, fcpattern, FcMatchPattern); FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
FcDefaultSubstitute(fcpattern); FcDefaultSubstitute(fcpattern);
match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result); match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
FcCharSetDestroy(fccharset); FcCharSetDestroy(fccharset);
FcPatternDestroy(fcpattern); FcPatternDestroy(fcpattern);
if (match) { if (match) {
usedfont = xfont_create(drw, NULL, match); usedfont = xfont_create(drw, NULL, match);
if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) { if (usedfont &&
for (curfont = drw->fonts; curfont->next; curfont = curfont->next) XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
; /* NOP */ for (curfont = drw->fonts; curfont->next;
curfont->next = usedfont; curfont = curfont->next)
} else { ; /* NOP */
xfont_free(usedfont); curfont->next = usedfont;
usedfont = drw->fonts; } else {
} xfont_free(usedfont);
} usedfont = drw->fonts;
} }
} }
if (d) }
XftDrawDestroy(d); }
if (d)
XftDrawDestroy(d);
return x + (render ? w : 0); return x + (render ? w : 0);
} }
void void
drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) drw_map(Drw* drw, Window win, int x, int y, unsigned int w, unsigned int h)
{ {
if (!drw) if (!drw)
return; return;
XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y); XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
XSync(drw->dpy, False); XSync(drw->dpy, False);
} }
unsigned int unsigned int
drw_fontset_getwidth(Drw *drw, const char *text) drw_fontset_getwidth(Drw* drw, const char* text)
{ {
if (!drw || !drw->fonts || !text) if (!drw || !drw->fonts || !text)
return 0; return 0;
return drw_text(drw, 0, 0, 0, 0, 0, text, 0); return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
} }
void void
drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h) drw_font_getexts(Fnt* font,
const char* text,
unsigned int len,
unsigned int* w,
unsigned int* h)
{ {
XGlyphInfo ext; XGlyphInfo ext;
if (!font || !text) if (!font || !text)
return; return;
XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext); XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8*)text, len, &ext);
if (w) if (w)
*w = ext.xOff; *w = ext.xOff;
if (h) if (h)
*h = font->h; *h = font->h;
} }
Cur * Cur*
drw_cur_create(Drw *drw, int shape) drw_cur_create(Drw* drw, int shape)
{ {
Cur *cur; Cur* cur;
if (!drw || !(cur = ecalloc(1, sizeof(Cur)))) if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
return NULL; return NULL;
cur->cursor = XCreateFontCursor(drw->dpy, shape); cur->cursor = XCreateFontCursor(drw->dpy, shape);
return cur; return cur;
} }
void void
drw_cur_free(Drw *drw, Cur *cursor) drw_cur_free(Drw* drw, Cur* cursor)
{ {
if (!cursor) if (!cursor)
return; return;
XFreeCursor(drw->dpy, cursor->cursor); XFreeCursor(drw->dpy, cursor->cursor);
free(cursor); free(cursor);
} }

3562
dwm.c
View File

File diff suppressed because it is too large Load Diff

64
transient.c
View File

@ -1,42 +1,44 @@
/* cc transient.c -o transient -lX11 */ /* cc transient.c -o transient -lX11 */
#include <stdlib.h>
#include <unistd.h>
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/Xutil.h> #include <X11/Xutil.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) { int
Display *d; main(void)
Window r, f, t = None; {
XSizeHints h; Display* d;
XEvent e; Window r, f, t = None;
XSizeHints h;
XEvent e;
d = XOpenDisplay(NULL); d = XOpenDisplay(NULL);
if (!d) if (!d)
exit(1); exit(1);
r = DefaultRootWindow(d); r = DefaultRootWindow(d);
f = XCreateSimpleWindow(d, r, 100, 100, 400, 400, 0, 0, 0); f = XCreateSimpleWindow(d, r, 100, 100, 400, 400, 0, 0, 0);
h.min_width = h.max_width = h.min_height = h.max_height = 400; h.min_width = h.max_width = h.min_height = h.max_height = 400;
h.flags = PMinSize | PMaxSize; h.flags = PMinSize | PMaxSize;
XSetWMNormalHints(d, f, &h); XSetWMNormalHints(d, f, &h);
XStoreName(d, f, "floating"); XStoreName(d, f, "floating");
XMapWindow(d, f); XMapWindow(d, f);
XSelectInput(d, f, ExposureMask); XSelectInput(d, f, ExposureMask);
while (1) { while (1) {
XNextEvent(d, &e); XNextEvent(d, &e);
if (t == None) { if (t == None) {
sleep(5); sleep(5);
t = XCreateSimpleWindow(d, r, 50, 50, 100, 100, 0, 0, 0); t = XCreateSimpleWindow(d, r, 50, 50, 100, 100, 0, 0, 0);
XSetTransientForHint(d, t, f); XSetTransientForHint(d, t, f);
XStoreName(d, t, "transient"); XStoreName(d, t, "transient");
XMapWindow(d, t); XMapWindow(d, t);
XSelectInput(d, t, ExposureMask); XSelectInput(d, t, ExposureMask);
} }
} }
XCloseDisplay(d); XCloseDisplay(d);
exit(0); exit(0);
} }

35
util.c
View File

@ -6,30 +6,31 @@
#include "util.h" #include "util.h"
void * void*
ecalloc(size_t nmemb, size_t size) ecalloc(size_t nmemb, size_t size)
{ {
void *p; void* p;
if (!(p = calloc(nmemb, size))) if (!(p = calloc(nmemb, size)))
die("calloc:"); die("calloc:");
return p; return p;
} }
void void
die(const char *fmt, ...) { die(const char* fmt, ...)
va_list ap; {
va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
vfprintf(stderr, fmt, ap); vfprintf(stderr, fmt, ap);
va_end(ap); va_end(ap);
if (fmt[0] && fmt[strlen(fmt)-1] == ':') { if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
fputc(' ', stderr); fputc(' ', stderr);
perror(NULL); perror(NULL);
} else { } else {
fputc('\n', stderr); fputc('\n', stderr);
} }
exit(1); exit(1);
} }