nixos-dotfiles

Diff

diff --cc config/dwm/.gitignore
index 0000000,0000000..72c4cc2
new file mode 100644
--- /dev/null
+++ b/config/dwm/.gitignore
@@@ -1,0 -1,0 +1,2 @@@
++dwm
++*.o
diff --cc config/dwm/LICENSE
index 0000000,995172f..995172f
mode 000000,100644..100644
--- a/config/dwm/LICENSE
+++ b/config/dwm/LICENSE
diff --cc config/dwm/Makefile
index 0000000,ffa69b4..ffa69b4
mode 000000,100644..100644
--- a/config/dwm/Makefile
+++ b/config/dwm/Makefile
diff --cc config/dwm/README.md
index 0000000,30bccc8..30bccc8
mode 000000,100644..100644
--- a/config/dwm/README.md
+++ b/config/dwm/README.md
diff --cc config/dwm/config.def.h
index 0000000,ec9eecc..ec9eecc
mode 000000,100644..100644
--- a/config/dwm/config.def.h
+++ b/config/dwm/config.def.h
diff --cc config/dwm/config.def.h.orig
index 0000000,fdad6a7..fdad6a7
mode 000000,100644..100644
--- a/config/dwm/config.def.h.orig
+++ b/config/dwm/config.def.h.orig
diff --cc config/dwm/config.def.h.rej
index 0000000,26f404b..26f404b
mode 000000,100644..100644
--- a/config/dwm/config.def.h.rej
+++ b/config/dwm/config.def.h.rej
diff --cc config/dwm/config.h
index 0000000,7416186..7416186
mode 000000,100644..100644
--- a/config/dwm/config.h
+++ b/config/dwm/config.h
diff --cc config/dwm/config.mk
index 0000000,8efca9a..8efca9a
mode 000000,100644..100644
--- a/config/dwm/config.mk
+++ b/config/dwm/config.mk
diff --cc config/dwm/drw.c
index 0000000,0000000..c41e6af
new file mode 100644
--- /dev/null
+++ b/config/dwm/drw.c
@@@ -1,0 -1,0 +1,448 @@@
++/* See LICENSE file for copyright and license details. */
++#include <stdio.h>
++#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
++
++static int
++utf8decode(const char *s_in, long *u, int *err)
++{
++	static const unsigned char lens[] = {
++		/* 0XXXX */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
++		/* 10XXX */ 0, 0, 0, 0, 0, 0, 0, 0,  /* invalid */
++		/* 110XX */ 2, 2, 2, 2,
++		/* 1110X */ 3, 3,
++		/* 11110 */ 4,
++		/* 11111 */ 0,  /* invalid */
++	};
++	static const unsigned char leading_mask[] = { 0x7F, 0x1F, 0x0F, 0x07 };
++	static const unsigned int overlong[] = { 0x0, 0x80, 0x0800, 0x10000 };
++
++	const unsigned char *s = (const unsigned char *)s_in;
++	int len = lens[*s >> 3];
++	*u = UTF_INVALID;
++	*err = 1;
++	if (len == 0)
++		return 1;
++
++	long cp = s[0] & leading_mask[len - 1];
++	for (int i = 1; i < len; ++i) {
++		if (s[i] == '\0' || (s[i] & 0xC0) != 0x80)
++			return i;
++		cp = (cp << 6) | (s[i] & 0x3F);
++	}
++	/* out of range, surrogate, overlong encoding */
++	if (cp > 0x10FFFF || (cp >> 11) == 0x1B || cp < overlong[len - 1])
++		return len;
++
++	*err = 0;
++	*u = cp;
++	return len;
++}
++
++Drw *
++drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
++{
++	Drw *drw = ecalloc(1, sizeof(Drw));
++
++	drw->dpy = dpy;
++	drw->screen = screen;
++	drw->root = root;
++	drw->w = w;
++	drw->h = h;
++	drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
++	drw->gc = XCreateGC(dpy, root, 0, NULL);
++	XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
++
++	return drw;
++}
++
++void
++drw_resize(Drw *drw, unsigned int w, unsigned int h)
++{
++	if (!drw)
++		return;
++
++	drw->w = w;
++	drw->h = h;
++	if (drw->drawable)
++		XFreePixmap(drw->dpy, drw->drawable);
++	drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
++}
++
++void
++drw_free(Drw *drw)
++{
++	XFreePixmap(drw->dpy, drw->drawable);
++	XFreeGC(drw->dpy, drw->gc);
++	drw_fontset_free(drw->fonts);
++	free(drw);
++}
++
++/* This function is an implementation detail. Library users should use
++ * drw_fontset_create instead.
++ */
++static Fnt *
++xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
++{
++	Fnt *font;
++	XftFont *xfont = NULL;
++	FcPattern *pattern = NULL;
++
++	if (fontname) {
++		/* Using the pattern found at font->xfont->pattern does not yield 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 (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
++			fprintf(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);
++			XftFontClose(drw->dpy, xfont);
++			return NULL;
++		}
++	} else if (fontpattern) {
++		if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
++			fprintf(stderr, "error, cannot load font from pattern.\n");
++			return NULL;
++		}
++	} else {
++		die("no font specified.");
++	}
++
++	font = ecalloc(1, sizeof(Fnt));
++	font->xfont = xfont;
++	font->pattern = pattern;
++	font->h = xfont->ascent + xfont->descent;
++	font->dpy = drw->dpy;
++
++	return font;
++}
++
++static void
++xfont_free(Fnt *font)
++{
++	if (!font)
++		return;
++	if (font->pattern)
++		FcPatternDestroy(font->pattern);
++	XftFontClose(font->dpy, font->xfont);
++	free(font);
++}
++
++Fnt*
++drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount)
++{
++	Fnt *cur, *ret = NULL;
++	size_t i;
++
++	if (!drw || !fonts)
++		return NULL;
++
++	for (i = 1; i <= fontcount; i++) {
++		if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
++			cur->next = ret;
++			ret = cur;
++		}
++	}
++	return (drw->fonts = ret);
++}
++
++void
++drw_fontset_free(Fnt *font)
++{
++	if (font) {
++		drw_fontset_free(font->next);
++		xfont_free(font);
++	}
++}
++
++void
++drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
++{
++	if (!drw || !dest || !clrname)
++		return;
++
++	if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
++	                       DefaultColormap(drw->dpy, drw->screen),
++	                       clrname, dest))
++		die("error, cannot allocate color '%s'", clrname);
++}
++
++/* Wrapper to create color schemes. The caller has to call free(3) on the
++ * returned color scheme when done using it. */
++Clr *
++drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
++{
++	size_t i;
++	Clr *ret;
++
++	/* need at least two colors for a scheme */
++	if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
++		return NULL;
++
++	for (i = 0; i < clrcount; i++)
++		drw_clr_create(drw, &ret[i], clrnames[i]);
++	return ret;
++}
++
++void
++drw_setfontset(Drw *drw, Fnt *set)
++{
++	if (drw)
++		drw->fonts = set;
++}
++
++void
++drw_setscheme(Drw *drw, Clr *scm)
++{
++	if (drw)
++		drw->scheme = scm;
++}
++
++void
++drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
++{
++	if (!drw || !drw->scheme)
++		return;
++	XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
++	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
++drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert)
++{
++	int ty, ellipsis_x = 0;
++	unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len, hash, h0, h1;
++	XftDraw *d = NULL;
++	Fnt *usedfont, *curfont, *nextfont;
++	int utf8strlen, utf8charlen, utf8err, render = x || y || w || h;
++	long utf8codepoint = 0;
++	const char *utf8str;
++	FcCharSet *fccharset;
++	FcPattern *fcpattern;
++	FcPattern *match;
++	XftResult result;
++	int charexists = 0, overflow = 0;
++	/* keep track of a couple codepoints for which we have no match. */
++	static unsigned int nomatches[128], ellipsis_width, invalid_width;
++	static const char invalid[] = "�";
++
++	if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts)
++		return 0;
++
++	if (!render) {
++		w = invert ? invert : ~invert;
++	} else {
++		XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
++		XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
++		if (w < lpad)
++			return x + w;
++		d = XftDrawCreate(drw->dpy, drw->drawable,
++		                  DefaultVisual(drw->dpy, drw->screen),
++		                  DefaultColormap(drw->dpy, drw->screen));
++		x += lpad;
++		w -= lpad;
++	}
++
++	usedfont = drw->fonts;
++	if (!ellipsis_width && render)
++		ellipsis_width = drw_fontset_getwidth(drw, "...");
++	if (!invalid_width && render)
++		invalid_width = drw_fontset_getwidth(drw, invalid);
++	while (1) {
++		ew = ellipsis_len = utf8err = utf8charlen = utf8strlen = 0;
++		utf8str = text;
++		nextfont = NULL;
++		while (*text) {
++			utf8charlen = utf8decode(text, &utf8codepoint, &utf8err);
++			for (curfont = drw->fonts; curfont; curfont = curfont->next) {
++				charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
++				if (charexists) {
++					drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL);
++					if (ew + ellipsis_width <= w) {
++						/* keep track where the ellipsis still fits */
++						ellipsis_x = x + ew;
++						ellipsis_w = w - ew;
++						ellipsis_len = utf8strlen;
++					}
++
++					if (ew + tmpw > w) {
++						overflow = 1;
++						/* called from drw_fontset_getwidth_clamp():
++						 * it wants the width AFTER the overflow
++						 */
++						if (!render)
++							x += tmpw;
++						else
++							utf8strlen = ellipsis_len;
++					} else if (curfont == usedfont) {
++						text += utf8charlen;
++						utf8strlen += utf8err ? 0 : utf8charlen;
++						ew += utf8err ? 0 : tmpw;
++					} else {
++						nextfont = curfont;
++					}
++					break;
++				}
++			}
++
++			if (overflow || !charexists || nextfont || utf8err)
++				break;
++			else
++				charexists = 0;
++		}
++
++		if (utf8strlen) {
++			if (render) {
++				ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
++				XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
++				                  usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen);
++			}
++			x += ew;
++			w -= ew;
++		}
++		if (utf8err && (!render || invalid_width < w)) {
++			if (render)
++				drw_text(drw, x, y, w, h, 0, invalid, invert);
++			x += invalid_width;
++			w -= invalid_width;
++		}
++		if (render && overflow)
++			drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert);
++
++		if (!*text || overflow) {
++			break;
++		} else if (nextfont) {
++			charexists = 0;
++			usedfont = nextfont;
++		} else {
++			/* Regardless of whether or not a fallback font is found, the
++			 * character must be drawn. */
++			charexists = 1;
++
++			hash = (unsigned int)utf8codepoint;
++			hash = ((hash >> 16) ^ hash) * 0x21F0AAAD;
++			hash = ((hash >> 15) ^ hash) * 0xD35A2D97;
++			h0 = ((hash >> 15) ^ hash) % LENGTH(nomatches);
++			h1 = (hash >> 17) % LENGTH(nomatches);
++			/* avoid expensive XftFontMatch call when we know we won't find a match */
++			if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint)
++				goto no_match;
++
++			fccharset = FcCharSetCreate();
++			FcCharSetAddChar(fccharset, utf8codepoint);
++
++			if (!drw->fonts->pattern) {
++				/* Refer to the comment in xfont_create for more information. */
++				die("the first font in the cache must be loaded from a font string.");
++			}
++
++			fcpattern = FcPatternDuplicate(drw->fonts->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) {
++				usedfont = xfont_create(drw, NULL, match);
++				if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
++					for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
++						; /* NOP */
++					curfont->next = usedfont;
++				} else {
++					xfont_free(usedfont);
++					nomatches[nomatches[h0] ? h1 : h0] = utf8codepoint;
++no_match:
++					usedfont = drw->fonts;
++				}
++			}
++		}
++	}
++	if (d)
++		XftDrawDestroy(d);
++
++	return x + (render ? w : 0);
++}
++
++void
++drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
++{
++	if (!drw)
++		return;
++
++	XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
++	XSync(drw->dpy, False);
++}
++
++unsigned int
++drw_fontset_getwidth(Drw *drw, const char *text)
++{
++	if (!drw || !drw->fonts || !text)
++		return 0;
++	return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
++}
++
++unsigned int
++drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
++{
++	unsigned int tmp = 0;
++	if (drw && drw->fonts && text && n)
++		tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n);
++	return MIN(n, tmp);
++}
++
++void
++drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
++{
++	XGlyphInfo ext;
++
++	if (!font || !text)
++		return;
++
++	XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
++	if (w)
++		*w = ext.xOff;
++	if (h)
++		*h = font->h;
++}
++
++Cur *
++drw_cur_create(Drw *drw, int shape)
++{
++	Cur *cur;
++
++	if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
++		return NULL;
++
++	cur->cursor = XCreateFontCursor(drw->dpy, shape);
++
++	return cur;
++}
++
++void
++drw_cur_free(Drw *drw, Cur *cursor)
++{
++	if (!cursor)
++		return;
++
++	XFreeCursor(drw->dpy, cursor->cursor);
++	free(cursor);
++}
diff --cc config/dwm/drw.h
index 0000000,6471431..6471431
mode 000000,100644..100644
--- a/config/dwm/drw.h
+++ b/config/dwm/drw.h
diff --cc config/dwm/dwm.1
index 0000000,7b6cadb..7b6cadb
mode 000000,100644..100644
--- a/config/dwm/dwm.1
+++ b/config/dwm/dwm.1
diff --cc config/dwm/dwm.c
index 0000000,ab2d072..ab2d072
mode 000000,100644..100644
--- a/config/dwm/dwm.c
+++ b/config/dwm/dwm.c
diff --cc config/dwm/dwm.c.orig
index 0000000,857fda1..857fda1
mode 000000,100644..100644
--- a/config/dwm/dwm.c.orig
+++ b/config/dwm/dwm.c.orig
diff --cc config/dwm/dwm.c.rej
index 0000000,d381116..d381116
mode 000000,100644..100644
--- a/config/dwm/dwm.c.rej
+++ b/config/dwm/dwm.c.rej
diff --cc config/dwm/dwm.png
index 0000000,b1f9ba7..b1f9ba7
mode 000000,100644..100644
Binary files differ
diff --cc config/dwm/fibonacci.c
index 0000000,fce0a57..fce0a57
mode 000000,100644..100644
--- a/config/dwm/fibonacci.c
+++ b/config/dwm/fibonacci.c
diff --cc config/dwm/patches/alwaysontop-6.2.diff
index 0000000,6a4f72e..6a4f72e
mode 000000,100644..100644
--- a/config/dwm/patches/alwaysontop-6.2.diff
+++ b/config/dwm/patches/alwaysontop-6.2.diff
diff --cc config/dwm/patches/dwm-attachaside-6.4.diff
index 0000000,17be6b5..17be6b5
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-attachaside-6.4.diff
+++ b/config/dwm/patches/dwm-attachaside-6.4.diff
diff --cc config/dwm/patches/dwm-barpadding-20211020-a786211.diff
index 0000000,7842181..7842181
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-barpadding-20211020-a786211.diff
+++ b/config/dwm/patches/dwm-barpadding-20211020-a786211.diff
diff --cc config/dwm/patches/dwm-barpadding-6.2.diff
index 0000000,4c26e46..4c26e46
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-barpadding-6.2.diff
+++ b/config/dwm/patches/dwm-barpadding-6.2.diff
diff --cc config/dwm/patches/dwm-fibonacci-5.8.2.diff
index 0000000,78664c8..78664c8
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-fibonacci-5.8.2.diff
+++ b/config/dwm/patches/dwm-fibonacci-5.8.2.diff
diff --cc config/dwm/patches/dwm-fullscreen-6.2.diff
index 0000000,36e3140..36e3140
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-fullscreen-6.2.diff
+++ b/config/dwm/patches/dwm-fullscreen-6.2.diff
diff --cc config/dwm/patches/dwm-hide_vacant_tags-6.4.diff
index 0000000,42d9c05..42d9c05
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-hide_vacant_tags-6.4.diff
+++ b/config/dwm/patches/dwm-hide_vacant_tags-6.4.diff
diff --cc config/dwm/patches/dwm-keychord-6.4.diff
index 0000000,96d6145..96d6145
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-keychord-6.4.diff
+++ b/config/dwm/patches/dwm-keychord-6.4.diff
diff --cc config/dwm/patches/dwm-notitle-6.2.diff
index 0000000,efd5ebc..efd5ebc
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-notitle-6.2.diff
+++ b/config/dwm/patches/dwm-notitle-6.2.diff
diff --cc config/dwm/patches/dwm-restartsig-20180523-6.2.diff
index 0000000,f1f8680..f1f8680
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-restartsig-20180523-6.2.diff
+++ b/config/dwm/patches/dwm-restartsig-20180523-6.2.diff
diff --cc config/dwm/patches/dwm-vanitygaps-6.2.diff
index 0000000,18cbd6d..18cbd6d
mode 000000,100644..100644
--- a/config/dwm/patches/dwm-vanitygaps-6.2.diff
+++ b/config/dwm/patches/dwm-vanitygaps-6.2.diff
diff --cc config/dwm/transient.c
index 0000000,040adb5..040adb5
mode 000000,100644..100644
--- a/config/dwm/transient.c
+++ b/config/dwm/transient.c
diff --cc config/dwm/util.c
index 0000000,0000000..8e26a51
new file mode 100644
--- /dev/null
+++ b/config/dwm/util.c
@@@ -1,0 -1,0 +1,37 @@@
++/* See LICENSE file for copyright and license details. */
++#include <errno.h>
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include "util.h"
++
++void
++die(const char *fmt, ...)
++{
++	va_list ap;
++	int saved_errno;
++
++	saved_errno = errno;
++
++	va_start(ap, fmt);
++	vfprintf(stderr, fmt, ap);
++	va_end(ap);
++
++	if (fmt[0] && fmt[strlen(fmt)-1] == ':')
++		fprintf(stderr, " %s", strerror(saved_errno));
++	fputc('\n', stderr);
++
++	exit(1);
++}
++
++void *
++ecalloc(size_t nmemb, size_t size)
++{
++	void *p;
++
++	if (!(p = calloc(nmemb, size)))
++		die("calloc:");
++	return p;
++}
diff --cc config/dwm/util.h
index 0000000,0000000..c0a50d4
new file mode 100644
--- /dev/null
+++ b/config/dwm/util.h
@@@ -1,0 -1,0 +1,9 @@@
++/* See LICENSE file for copyright and license details. */
++
++#define MAX(A, B)               ((A) > (B) ? (A) : (B))
++#define MIN(A, B)               ((A) < (B) ? (A) : (B))
++#define BETWEEN(X, A, B)        ((A) <= (X) && (X) <= (B))
++#define LENGTH(X)               (sizeof (X) / sizeof (X)[0])
++
++void die(const char *fmt, ...);
++void *ecalloc(size_t nmemb, size_t size);
diff --cc config/dwm/vanitygaps.c
index 0000000,e8b2ce8..e8b2ce8
mode 000000,100644..100644
--- a/config/dwm/vanitygaps.c
+++ b/config/dwm/vanitygaps.c