moving software to separate submodules part 1

desktop/.dmenu/patch/center.c

@@ -0,0 +1,8 @@
+static int
+max_textw(void)
+{
+	int len = 0;
+	for (struct item *item = items; item && item->text; item++)
+		len = MAX(TEXTW(item->text), len);
+	return len;
+}

desktop/.dmenu/patch/dynamicoptions.c

@@ -0,0 +1,91 @@
+static void
+refreshoptions()
+{
+	int dynlen = strlen(dynamic);
+	char* cmd= malloc(dynlen + strlen(text) + 2);
+	if (cmd == NULL)
+		die("malloc:");
+	sprintf(cmd, "%s %s", dynamic, text);
+	FILE *stream = popen(cmd, "r");
+	if (!stream)
+		die("popen(%s):", cmd);
+	readstream(stream);
+	int pc = pclose(stream);
+	if (pc == -1)
+		die("pclose:");
+	free(cmd);
+	curr = sel = items;
+}
+
+static void
+readstream(FILE* stream)
+{
+	char buf[sizeof text], *p;
+	size_t i, imax = 0, size = 0;
+	unsigned int tmpmax = 0;
+
+	/* read each line from stdin and add it to the item list */
+	for (i = 0; fgets(buf, sizeof buf, stream); i++) {
+		if (i + 1 >= size / sizeof *items)
+			if (!(items = realloc(items, (size += BUFSIZ))))
+				die("cannot realloc %u bytes:", size);
+		if ((p = strchr(buf, '\n')))
+			*p = '\0';
+		if (!(items[i].text = strdup(buf)))
+			die("cannot strdup %u bytes:", strlen(buf) + 1);
+		#if SEPARATOR_PATCH
+		if (separator && (p = separator_greedy ?
+			strrchr(items[i].text, separator) : strchr(items[i].text, separator))) {
+			*p = '\0';
+			items[i].text_output = ++p;
+		} else {
+			items[i].text_output = items[i].text;
+		}
+		if (separator_reverse) {
+			p = items[i].text;
+			items[i].text = items[i].text_output;
+			items[i].text_output = p;
+		}
+		#elif TSV_PATCH
+		if ((p = strchr(buf, '\t')))
+			*p = '\0';
+		if (!(items[i].stext = strdup(buf)))
+			die("cannot strdup %u bytes:", strlen(buf) + 1);
+		#endif // TSV_PATCH
+		#if MULTI_SELECTION_PATCH
+		items[i].id = i;
+		#else
+		items[i].out = 0;
+		#endif // MULTI_SELECTION_PATCH
+		#if HIGHPRIORITY_PATCH
+		items[i].hp = arrayhas(hpitems, hplength, items[i].text);
+		#endif // HIGHPRIORITY_PATCH
+		#if PANGO_PATCH
+		drw_font_getexts(drw->font, buf, strlen(buf), &tmpmax, NULL, True);
+		#else
+		drw_font_getexts(drw->fonts, buf, strlen(buf), &tmpmax, NULL);
+		#endif // PANGO_PATCH
+		if (tmpmax > inputw) {
+			inputw = tmpmax;
+			imax = i;
+		}
+	}
+
+	/* If the command did not give any output at all, then do not clear the existing items */
+	if (!i)
+		return;
+
+	if (items)
+		items[i].text = NULL;
+	#if PANGO_PATCH
+	inputw = items ? TEXTWM(items[imax].text) : 0;
+	#else
+	inputw = items ? TEXTW(items[imax].text) : 0;
+	#endif // PANGO_PATCH
+	if (!dynamic || !*dynamic)
+		lines = MIN(lines, i);
+	else {
+		text[0] = '\0';
+		cursor = 0;
+	}
+}

desktop/.dmenu/patch/dynamicoptions.h

@@ -0,0 +1,2 @@
+static void refreshoptions();
+static void readstream(FILE* stream);

desktop/.dmenu/patch/fuzzyhighlight.c

@@ -0,0 +1,57 @@
+static void
+#if EMOJI_HIGHLIGHT_PATCH
+drawhighlights(struct item *item, char *output, int x, int y, int maxw)
+#else
+drawhighlights(struct item *item, int x, int y, int maxw)
+#endif // EMOJI_HIGHLIGHT_PATCH
+{
+	int i, indent;
+	char *highlight;
+	char c;
+
+	#if EMOJI_HIGHLIGHT_PATCH
+	char *itemtext = output;
+	#elif TSV_PATCH && !SEPARATOR_PATCH
+	char *itemtext = item->stext;
+	#else
+	char *itemtext = item->text;
+	#endif // TSV_PATCH
+
+	if (!(strlen(itemtext) && strlen(text)))
+		return;
+
+	drw_setscheme(drw, scheme[item == sel
+	                   ? SchemeSelHighlight
+	                   : SchemeNormHighlight]);
+	for (i = 0, highlight = itemtext; *highlight && text[i];) {
+		#if FUZZYMATCH_PATCH
+		if (!fstrncmp(&(*highlight), &text[i], 1))
+		#else
+		if (*highlight == text[i])
+		#endif // FUZZYMATCH_PATCH
+		{
+			/* get indentation */
+			c = *highlight;
+			*highlight = '\0';
+			indent = TEXTW(itemtext) - lrpad;
+			*highlight = c;
+
+			/* highlight character */
+			c = highlight[1];
+			highlight[1] = '\0';
+			drw_text(
+				drw,
+				x + indent + (lrpad / 2),
+				y,
+				MIN(maxw - indent - lrpad, TEXTW(highlight) - lrpad),
+				bh, 0, highlight, 0
+				#if PANGO_PATCH
+				, True
+				#endif // PANGO_PATCH
+			);
+			highlight[1] = c;
+			i++;
+		}
+		highlight++;
+	}
+}

desktop/.dmenu/patch/fuzzymatch.c

@@ -0,0 +1,106 @@
+#include <math.h>
+
+int
+compare_distance(const void *a, const void *b)
+{
+	struct item *da = *(struct item **) a;
+	struct item *db = *(struct item **) b;
+
+	if (!db)
+		return 1;
+	if (!da)
+		return -1;
+
+	return da->distance == db->distance ? 0 : da->distance < db->distance ? -1 : 1;
+}
+
+void
+fuzzymatch(void)
+{
+	/* bang - we have so much memory */
+	struct item *it;
+	struct item **fuzzymatches = NULL;
+	char c;
+	int number_of_matches = 0, i, pidx, sidx, eidx;
+	int text_len = strlen(text), itext_len;
+	#if HIGHPRIORITY_PATCH
+	struct item *lhpprefix, *hpprefixend;
+	lhpprefix = hpprefixend = NULL;
+	#endif // HIGHPRIORITY_PATCH
+	matches = matchend = NULL;
+
+	/* walk through all items */
+	for (it = items; it && it->text; it++) {
+		if (text_len) {
+			itext_len = strlen(it->text);
+			pidx = 0; /* pointer */
+			sidx = eidx = -1; /* start of match, end of match */
+			/* walk through item text */
+			for (i = 0; i < itext_len && (c = it->text[i]); i++) {
+				/* fuzzy match pattern */
+				if (!fstrncmp(&text[pidx], &c, 1)) {
+					if (sidx == -1)
+						sidx = i;
+					pidx++;
+					if (pidx == text_len) {
+						eidx = i;
+						break;
+					}
+				}
+			}
+			/* build list of matches */
+			if (eidx != -1) {
+				/* compute distance */
+				/* add penalty if match starts late (log(sidx+2))
+				 * add penalty for long a match without many matching characters */
+				it->distance = log(sidx + 2) + (double)(eidx - sidx - text_len);
+				/* fprintf(stderr, "distance %s %f\n", it->text, it->distance); */
+				appenditem(it, &matches, &matchend);
+				number_of_matches++;
+			}
+		} else {
+			appenditem(it, &matches, &matchend);
+		}
+	}
+
+	if (number_of_matches) {
+		/* initialize array with matches */
+		if (!(fuzzymatches = realloc(fuzzymatches, number_of_matches * sizeof(struct item*))))
+			die("cannot realloc %u bytes:", number_of_matches * sizeof(struct item*));
+		for (i = 0, it = matches; it && i < number_of_matches; i++, it = it->right) {
+			fuzzymatches[i] = it;
+		}
+
+		#if NO_SORT_PATCH
+		if (sortmatches)
+		#endif // NO_SORT_PATCH
+		/* sort matches according to distance */
+		qsort(fuzzymatches, number_of_matches, sizeof(struct item*), compare_distance);
+		/* rebuild list of matches */
+		matches = matchend = NULL;
+		for (i = 0, it = fuzzymatches[i];  i < number_of_matches && it && \
+				it->text; i++, it = fuzzymatches[i]) {
+			#if HIGHPRIORITY_PATCH
+			#if NO_SORT_PATCH
+			if (sortmatches && it->hp)
+			#else
+			if (it->hp)
+			#endif // NO_SORT_PATCH
+				appenditem(it, &lhpprefix, &hpprefixend);
+			else
+				appenditem(it, &matches, &matchend);
+			#else
+			appenditem(it, &matches, &matchend);
+			#endif // HIGHPRIORITY_PATCH
+		}
+		free(fuzzymatches);
+	}
+	#if HIGHPRIORITY_PATCH
+	if (lhpprefix) {
+		hpprefixend->right = matches;
+		matches = lhpprefix;
+	}
+	#endif // HIGHPRIORITY_PATCH
+	curr = sel = matches;
+	calcoffsets();
+}

desktop/.dmenu/patch/fzfexpect.c

@@ -0,0 +1,39 @@
+static char *expected;
+#if MULTI_SELECTION_PATCH
+void
+expect(char *expect, XKeyEvent *ev)
+{
+	if (sel && expected && strstr(expected, expect)) {
+		if (expected && sel && !(ev->state & ShiftMask))
+			puts(expect);
+		for (int i = 0; i < selidsize; i++)
+			if (selid[i] != -1 && (!sel || sel->id != selid[i]))
+				puts(items[selid[i]].text);
+		if (sel && !(ev->state & ShiftMask)) {
+			puts(sel->text);
+		} else
+			puts(text);
+		cleanup();
+		exit(1);
+	} else if (!sel && expected && strstr(expected, expect)) {
+		puts(expect);
+		cleanup();
+		exit(1);
+	}
+}
+#else
+void
+expect(char *expect, XKeyEvent *ignored)
+{
+	if (sel && expected && strstr(expected, expect)) {
+		puts(expect);
+		puts(sel->text);
+		cleanup();
+		exit(1);
+	} else if (!sel && expected && strstr(expected, expect)){
+		puts(expect);
+		cleanup();
+		exit(1);
+	}
+}
+#endif // MULTI_SELECTION_PATCH

desktop/.dmenu/patch/fzfexpect.h

@@ -0,0 +1 @@
+static void expect(char *expect, XKeyEvent *ev);

desktop/.dmenu/patch/highlight.c

@@ -0,0 +1,51 @@
+static void
+#if EMOJI_HIGHLIGHT_PATCH
+drawhighlights(struct item *item, char *output, int x, int y, int maxw)
+#else
+drawhighlights(struct item *item, int x, int y, int maxw)
+#endif // EMOJI_HIGHLIGHT_PATCH
+{
+	char restorechar, tokens[sizeof text], *highlight,  *token;
+	int indentx, highlightlen;
+	#if EMOJI_HIGHLIGHT_PATCH
+	char *itemtext = output;
+	#elif TSV_PATCH && !SEPARATOR_PATCH
+	char *itemtext = item->stext;
+	#else
+	char *itemtext = item->text;
+	#endif // EMOJI_HIGHLIGHT_PATCH | TSV_PATCH
+
+	drw_setscheme(drw, scheme[item == sel ? SchemeSelHighlight : SchemeNormHighlight]);
+	strcpy(tokens, text);
+	for (token = strtok(tokens, " "); token; token = strtok(NULL, " ")) {
+		highlight = fstrstr(itemtext, token);
+		while (highlight) {
+			// Move item str end, calc width for highlight indent, & restore
+			highlightlen = highlight - itemtext;
+			restorechar = *highlight;
+			itemtext[highlightlen] = '\0';
+			indentx = TEXTW(itemtext);
+			itemtext[highlightlen] = restorechar;
+
+			// Move highlight str end, draw highlight, & restore
+			restorechar = highlight[strlen(token)];
+			highlight[strlen(token)] = '\0';
+			if (indentx - (lrpad / 2) - 1 < maxw)
+				drw_text(
+					drw,
+					x + indentx - (lrpad / 2) - 1,
+					y,
+					MIN(maxw - indentx, TEXTW(highlight) - lrpad),
+					bh, 0, highlight, 0
+					#if PANGO_PATCH
+					, True
+					#endif // PANGO_PATCH
+				);
+			highlight[strlen(token)] = restorechar;
+
+			if (strlen(highlight) - strlen(token) < strlen(token))
+				break;
+			highlight = fstrstr(highlight + strlen(token), token);
+		}
+	}
+}

desktop/.dmenu/patch/highpriority.c

@@ -0,0 +1,35 @@
+static char **hpitems = NULL;
+static int hplength = 0;
+
+static char **
+tokenize(char *source, const char *delim, int *llen)
+{
+	int listlength = 0, list_size = 0;
+	char **list = NULL, *token;
+
+	token = strtok(source, delim);
+	while (token) {
+		if (listlength + 1 >= list_size) {
+			if (!(list = realloc(list, (list_size += 8) * sizeof(*list))))
+				die("Unable to realloc %zu bytes\n", list_size * sizeof(*list));
+		}
+		if (!(list[listlength] = strdup(token)))
+			die("Unable to strdup %zu bytes\n", strlen(token) + 1);
+		token = strtok(NULL, delim);
+		listlength++;
+	}
+
+	*llen = listlength;
+	return list;
+}
+
+static int
+arrayhas(char **list, int length, char *item) {
+	for (int i = 0; i < length; i++) {
+		int len1 = strlen(list[i]);
+		int len2 = strlen(item);
+		if (fstrncmp(list[i], item, len1 > len2 ? len2 : len1) == 0)
+			return 1;
+	}
+	return 0;
+}

desktop/.dmenu/patch/highpriority.h

@@ -0,0 +1,2 @@
+static int arrayhas(char **list, int length, char *item);
+

desktop/.dmenu/patch/include.c

@@ -0,0 +1,38 @@
+#if CENTER_PATCH
+#include "center.c"
+#endif
+#if FUZZYHIGHLIGHT_PATCH
+#include "fuzzyhighlight.c"
+#elif HIGHLIGHT_PATCH
+#include "highlight.c"
+#endif
+#if FUZZYMATCH_PATCH
+#include "fuzzymatch.c"
+#endif
+#if FZFEXPECT_PATCH
+#include "fzfexpect.c"
+#endif
+#if HIGHPRIORITY_PATCH
+#include "highpriority.c"
+#endif
+#if DYNAMIC_OPTIONS_PATCH
+#include "dynamicoptions.c"
+#endif
+#if MULTI_SELECTION_PATCH
+#include "multiselect.c"
+#endif
+#if MOUSE_SUPPORT_PATCH
+#include "mousesupport.c"
+#endif
+#if NAVHISTORY_PATCH
+#include "navhistory.c"
+#endif
+#if NON_BLOCKING_STDIN_PATCH
+#include "nonblockingstdin.c"
+#endif
+#if NUMBERS_PATCH
+#include "numbers.c"
+#endif
+#if XRESOURCES_PATCH
+#include "xresources.c"
+#endif

desktop/.dmenu/patch/include.h

@@ -0,0 +1,15 @@
+#if DYNAMIC_OPTIONS_PATCH
+#include "dynamicoptions.h"
+#endif
+#if FZFEXPECT_PATCH
+#include "fzfexpect.h"
+#endif
+#if HIGHPRIORITY_PATCH
+#include "highpriority.h"
+#endif
+#if NON_BLOCKING_STDIN_PATCH
+#include "nonblockingstdin.h"
+#endif
+#if NUMBERS_PATCH
+#include "numbers.h"
+#endif

desktop/.dmenu/patch/mousesupport.c

@@ -0,0 +1,159 @@
+static void
+buttonpress(XEvent *e)
+{
+	struct item *item;
+	XButtonPressedEvent *ev = &e->xbutton;
+	int x = 0, y = 0, h = bh, w;
+
+	if (ev->window != win)
+		return;
+
+	/* right-click: exit */
+	if (ev->button == Button3)
+		exit(1);
+
+	if (prompt && *prompt)
+		x += promptw;
+
+	/* input field */
+	w = (lines > 0 || !matches) ? mw - x : inputw;
+
+	/* left-click on input: clear input,
+	 * NOTE: if there is no left-arrow the space for < is reserved so
+	 *       add that to the input width */
+	#if SYMBOLS_PATCH
+	if (ev->button == Button1 &&
+	   ((lines <= 0 && ev->x >= 0 && ev->x <= x + w +
+	   ((!prev || !curr->left) ? TEXTW(symbol_1) : 0)) ||
+	   (lines > 0 && ev->y >= y && ev->y <= y + h))) {
+		insert(NULL, -cursor);
+		drawmenu();
+		return;
+	}
+	#else
+	if (ev->button == Button1 &&
+	   ((lines <= 0 && ev->x >= 0 && ev->x <= x + w +
+	   ((!prev || !curr->left) ? TEXTW("<") : 0)) ||
+	   (lines > 0 && ev->y >= y && ev->y <= y + h))) {
+		insert(NULL, -cursor);
+		drawmenu();
+		return;
+	}
+	#endif // SYMBOLS_PATCH
+	/* middle-mouse click: paste selection */
+	if (ev->button == Button2) {
+		XConvertSelection(dpy, (ev->state & ShiftMask) ? clip : XA_PRIMARY,
+		                  utf8, utf8, win, CurrentTime);
+		drawmenu();
+		return;
+	}
+	/* scroll up */
+	if (ev->button == Button4 && prev) {
+		sel = curr = prev;
+		calcoffsets();
+		drawmenu();
+		return;
+	}
+	/* scroll down */
+	if (ev->button == Button5 && next) {
+		sel = curr = next;
+		calcoffsets();
+		drawmenu();
+		return;
+	}
+	if (ev->button != Button1)
+		return;
+	if (ev->state & ~ControlMask)
+		return;
+	if (lines > 0) {
+		/* vertical list: (ctrl)left-click on item */
+		w = mw - x;
+		for (item = curr; item != next; item = item->right) {
+			y += h;
+			if (ev->y >= y && ev->y <= (y + h)) {
+				#if !MULTI_SELECTION_PATCH
+				puts(item->text);
+				#endif // MULTI_SELECTION_PATCH
+				if (!(ev->state & ControlMask)) {
+					#if MULTI_SELECTION_PATCH
+					sel = item;
+					selsel();
+					printsel(ev->state);
+					#endif // MULTI_SELECTION_PATCH
+					exit(0);
+				}
+				sel = item;
+				if (sel) {
+					#if MULTI_SELECTION_PATCH
+					selsel();
+					#else
+					sel->out = 1;
+					#endif // MULTI_SELECTION_PATCH
+					drawmenu();
+				}
+				return;
+			}
+		}
+	} else if (matches) {
+		/* left-click on left arrow */
+		x += inputw;
+		#if SYMBOLS_PATCH
+		w = TEXTW(symbol_1);
+		#else
+		w = TEXTW("<");
+		#endif // SYMBOLS_PATCH
+		if (prev && curr->left) {
+			if (ev->x >= x && ev->x <= x + w) {
+				sel = curr = prev;
+				calcoffsets();
+				drawmenu();
+				return;
+			}
+		}
+		/* horizontal list: (ctrl)left-click on item */
+		for (item = curr; item != next; item = item->right) {
+			x += w;
+			#if SYMBOLS_PATCH
+			w = MIN(TEXTW(item->text), mw - x - TEXTW(symbol_2));
+			#else
+			w = MIN(TEXTW(item->text), mw - x - TEXTW(">"));
+			#endif // SYMBOLS_PATCH
+			if (ev->x >= x && ev->x <= x + w) {
+				#if !MULTI_SELECTION_PATCH
+				puts(item->text);
+				#endif // MULTI_SELECTION_PATCH
+				if (!(ev->state & ControlMask)) {
+					#if MULTI_SELECTION_PATCH
+					sel = item;
+					selsel();
+					printsel(ev->state);
+					#endif // MULTI_SELECTION_PATCH
+					exit(0);
+				}
+				sel = item;
+				if (sel) {
+					#if MULTI_SELECTION_PATCH
+					selsel();
+					#else
+					sel->out = 1;
+					#endif // MULTI_SELECTION_PATCH
+					drawmenu();
+				}
+				return;
+			}
+		}
+		/* left-click on right arrow */
+		#if SYMBOLS_PATCH
+		w = TEXTW(symbol_2);
+		#else
+		w = TEXTW(">");
+		#endif // SYMBOLS_PATCH
+		x = mw - w;
+		if (next && ev->x >= x && ev->x <= x + w) {
+			sel = curr = next;
+			calcoffsets();
+			drawmenu();
+			return;
+		}
+	}
+}

desktop/.dmenu/patch/multiselect.c

@@ -0,0 +1,53 @@
+static int
+issel(size_t id)
+{
+	for (int i = 0;i < selidsize;i++)
+		if (selid[i] == id)
+			return 1;
+	return 0;
+}
+
+static void
+printsel(unsigned int state)
+{
+	for (int i = 0;i < selidsize;i++)
+		if (selid[i] != -1 && (!sel || sel->id != selid[i])) {
+			#if PRINTINDEX_PATCH
+			if (print_index)
+				printf("%d\n", selid[i]);
+			else
+			#endif // PRINTINDEX_PATCH
+			puts(items[selid[i]].text);
+		}
+	if (sel && !(state & ShiftMask)) {
+		#if PRINTINDEX_PATCH
+		if (print_index)
+			printf("%d\n", sel->index);
+		else
+		#endif // PRINTINDEX_PATCH
+		puts(sel->text);
+	} else
+		puts(text);
+
+}
+
+static void
+selsel()
+{
+	if (!sel)
+		return;
+	if (issel(sel->id)) {
+		for (int i = 0; i < selidsize; i++)
+			if (selid[i] == sel->id)
+				selid[i] = -1;
+	} else {
+		for (int i = 0; i < selidsize; i++)
+			if (selid[i] == -1) {
+				selid[i] = sel->id;
+				return;
+			}
+		selidsize++;
+		selid = realloc(selid, (selidsize + 1) * sizeof(int));
+		selid[selidsize - 1] = sel->id;
+	}
+}

desktop/.dmenu/patch/navhistory.c

@@ -0,0 +1,126 @@
+static char *histfile;
+static char **history;
+static size_t histsz, histpos;
+
+static void
+loadhistory(void)
+{
+	FILE *fp = NULL;
+	static size_t cap = 0;
+	size_t llen;
+	char *line;
+
+	if (!histfile) {
+		return;
+	}
+
+	fp = fopen(histfile, "r");
+	if (!fp) {
+		return;
+	}
+
+	for (;;) {
+		line = NULL;
+		llen = 0;
+		if (-1 == getline(&line, &llen, fp)) {
+			if (ferror(fp)) {
+				die("failed to read history");
+			}
+			free(line);
+			break;
+		}
+
+		if (cap == histsz) {
+			cap += 64 * sizeof(char*);
+			history = realloc(history, cap);
+			if (!history) {
+				die("failed to realloc memory");
+			}
+		}
+		strtok(line, "\n");
+		history[histsz] = line;
+		histsz++;
+	}
+	histpos = histsz;
+
+	if (fclose(fp)) {
+		die("failed to close file %s", histfile);
+	}
+}
+
+static void
+navhistory(int dir)
+{
+	static char def[BUFSIZ];
+	char *p = NULL;
+	size_t len = 0;
+
+	if (!history || histpos + 1 == 0)
+		return;
+
+	if (histsz == histpos) {
+		strncpy(def, text, sizeof(def));
+	}
+
+	switch(dir) {
+	case 1:
+		if (histpos < histsz - 1) {
+			p = history[++histpos];
+		} else if (histpos == histsz - 1) {
+			p = def;
+			histpos++;
+		}
+		break;
+	case -1:
+		if (histpos > 0) {
+			p = history[--histpos];
+		}
+		break;
+	}
+	if (p == NULL) {
+		return;
+	}
+
+	len = MIN(strlen(p), BUFSIZ - 1);
+	strncpy(text, p, len);
+	text[len] = '\0';
+	cursor = len;
+	match();
+}
+
+static void
+savehistory(char *input)
+{
+	unsigned int i;
+	FILE *fp;
+
+	if (!histfile ||
+	    0 == maxhist ||
+	    0 == strlen(input)) {
+		goto out;
+	}
+
+	fp = fopen(histfile, "w");
+	if (!fp) {
+		die("failed to open %s", histfile);
+	}
+	for (i = histsz < maxhist ? 0 : histsz - maxhist; i < histsz; i++) {
+		if (0 >= fprintf(fp, "%s\n", history[i])) {
+			die("failed to write to %s", histfile);
+		}
+	}
+	if (histsz == 0 || !histnodup || (histsz > 0 && strcmp(input, history[histsz-1]) != 0)) { /* TODO */
+		if (0 >= fputs(input, fp)) {
+			die("failed to write to %s", histfile);
+		}
+	}
+	if (fclose(fp)) {
+		die("failed to close file %s", histfile);
+	}
+
+out:
+	for (i = 0; i < histsz; i++) {
+		free(history[i]);
+	}
+	free(history);
+}

desktop/.dmenu/patch/nonblockingstdin.c

@@ -0,0 +1,68 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/select.h>
+
+static void
+readstdin(void)
+{
+	static size_t max = 0;
+	static struct item **end = &items;
+
+	char buf[sizeof text], *p, *maxstr;
+	struct item *item;
+
+	#if PASSWORD_PATCH
+	if (passwd) {
+		inputw = lines = 0;
+		return;
+	}
+	#endif // PASSWORD_PATCH
+
+	/* read each line from stdin and add it to the item list */
+	while (fgets(buf, sizeof buf, stdin)) {
+		if (!(item = malloc(sizeof *item)))
+			die("cannot malloc %u bytes:", sizeof *item);
+		if ((p = strchr(buf, '\n')))
+			*p = '\0';
+		if (!(item->text = strdup(buf)))
+			die("cannot strdup %u bytes:", strlen(buf)+1);
+		if (strlen(item->text) > max) {
+			max = strlen(maxstr = item->text);
+			#if PANGO_PATCH
+			inputw = maxstr ? TEXTWM(maxstr) : 0;
+			#else
+			inputw = maxstr ? TEXTW(maxstr) : 0;
+			#endif // PANGO_PATCH
+		}
+		*end = item;
+		end = &item->next;
+		item->next = NULL;
+		item->out = 0;
+	}
+	match();
+	drawmenu();
+}
+
+static void
+run(void)
+{
+	fd_set fds;
+	int flags, xfd = XConnectionNumber(dpy);
+
+	if ((flags = fcntl(0, F_GETFL)) == -1)
+		die("cannot get stdin control flags:");
+	if (fcntl(0, F_SETFL, flags | O_NONBLOCK) == -1)
+		die("cannot set stdin control flags:");
+	for (;;) {
+		FD_ZERO(&fds);
+		FD_SET(xfd, &fds);
+		if (!feof(stdin))
+			FD_SET(0, &fds);
+		if (select(xfd + 1, &fds, NULL, NULL, NULL) == -1)
+			die("cannot multiplex input:");
+		if (FD_ISSET(xfd, &fds))
+			readevent();
+		if (FD_ISSET(0, &fds))
+			readstdin();
+	}
+}

desktop/.dmenu/patch/nonblockingstdin.h

@@ -0,0 +1 @@
+static void readevent();

desktop/.dmenu/patch/numbers.c

@@ -0,0 +1,16 @@
+static char numbers[NUMBERSBUFSIZE] = "";
+
+static void
+recalculatenumbers()
+{
+	unsigned int numer = 0, denom = 0;
+	struct item *item;
+	if (matchend) {
+		numer++;
+		for (item = matchend; item && item->left; item = item->left)
+			numer++;
+	}
+	for (item = items; item && item->text; item++)
+		denom++;
+	snprintf(numbers, NUMBERSBUFSIZE, "%d/%d", numer, denom);
+}

desktop/.dmenu/patch/numbers.h

@@ -0,0 +1,4 @@
+#define NUMBERSMAXDIGITS      100
+#define NUMBERSBUFSIZE        (NUMBERSMAXDIGITS * 2) + 1
+
+static void recalculatenumbers();

desktop/.dmenu/patch/scroll.c

@@ -0,0 +1,168 @@
+int
+utf8nextchar(const char *str, int len, int i, int inc)
+{
+	int n;
+
+	for (n = i + inc; n + inc >= 0 && n + inc <= len
+	  && (str[n] & 0xc0) == 0x80; n += inc)
+		;
+	return n;
+}
+
+int
+drw_text_align(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text, int textlen, int align)
+{
+	int ty;
+	unsigned int ew;
+	XftDraw *d = NULL;
+	Fnt *usedfont, *curfont, *nextfont;
+	size_t len;
+	int utf8strlen, utf8charlen, render = x || y || w || h;
+	long utf8codepoint = 0;
+	const char *utf8str;
+	FcCharSet *fccharset;
+	FcPattern *fcpattern;
+	FcPattern *match;
+	XftResult result;
+	int charexists = 0;
+	int i, n;
+
+	if (!drw || (render && !drw->scheme) || !text || !drw->fonts || textlen <= 0
+	  || (align != AlignL && align != AlignR))
+		return 0;
+
+	if (!render) {
+		w = ~w;
+	} else {
+		XSetForeground(drw->dpy, drw->gc, drw->scheme[ColBg].pixel);
+		XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
+		d = XftDrawCreate(drw->dpy, drw->drawable,
+		                  DefaultVisual(drw->dpy, drw->screen),
+		                  DefaultColormap(drw->dpy, drw->screen));
+	}
+
+	usedfont = drw->fonts;
+	i = align == AlignL ? 0 : textlen;
+	x = align == AlignL ? x : x + w;
+	while (1) {
+		utf8strlen = 0;
+		nextfont = NULL;
+		/* if (align == AlignL) */
+		utf8str = text + i;
+
+		while ((align == AlignL && i < textlen) || (align == AlignR && i > 0)) {
+			if (align == AlignL) {
+				utf8charlen = utf8decode(text + i, &utf8codepoint, MIN(textlen - i, UTF_SIZ));
+				if (!utf8charlen) {
+					textlen = i;
+					break;
+				}
+			} else {
+				n = utf8nextchar(text, textlen, i, -1);
+				utf8charlen = utf8decode(text + n, &utf8codepoint, MIN(textlen - n, UTF_SIZ));
+				if (!utf8charlen) {
+					textlen -= i;
+					text += i;
+					i = 0;
+					break;
+				}
+			}
+			for (curfont = drw->fonts; curfont; curfont = curfont->next) {
+				charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
+				if (charexists) {
+					if (curfont == usedfont) {
+						utf8strlen += utf8charlen;
+						i += align == AlignL ? utf8charlen : -utf8charlen;
+					} else {
+						nextfont = curfont;
+					}
+					break;
+				}
+			}
+
+			if (!charexists || nextfont)
+				break;
+			else
+				charexists = 0;
+		}
+
+		if (align == AlignR)
+			utf8str = text + i;
+
+		if (utf8strlen) {
+			drw_font_getexts(usedfont, utf8str, utf8strlen, &ew, NULL);
+			/* shorten text if necessary */
+			if (align == AlignL) {
+				for (len = utf8strlen; len && ew > w; ) {
+					len = utf8nextchar(utf8str, len, len, -1);
+					drw_font_getexts(usedfont, utf8str, len, &ew, NULL);
+				}
+			} else {
+				for (len = utf8strlen; len && ew > w; ) {
+					n = utf8nextchar(utf8str, len, 0, +1);
+					utf8str += n;
+					len -= n;
+					drw_font_getexts(usedfont, utf8str, len, &ew, NULL);
+				}
+			}
+
+			if (len) {
+				if (render) {
+					ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
+					XftDrawStringUtf8(d, &drw->scheme[ColFg],
+					                  usedfont->xfont, align == AlignL ? x : x - ew, ty, (XftChar8 *)utf8str, len);
+				}
+				x += align == AlignL ? ew : -ew;
+				w -= ew;
+			}
+			if (len < utf8strlen)
+				break;
+		}
+
+		if ((align == AlignR && i <= 0) || (align == AlignL && i >= textlen)) {
+			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;
+
+			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);
+					usedfont = drw->fonts;
+				}
+			}
+		}
+	}
+	if (d)
+		XftDrawDestroy(d);
+
+	return x;
+}

desktop/.dmenu/patch/scroll.h

@@ -0,0 +1,3 @@
+enum { AlignL, AlignR };
+
+int drw_text_align(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text, int textlen, int align);

desktop/.dmenu/patch/xresources.c

@@ -0,0 +1,90 @@
+#include <X11/Xresource.h>
+
+void
+readxresources(void)
+{
+	XrmInitialize();
+
+	char* xrm;
+	if ((xrm = XResourceManagerString(drw->dpy))) {
+		char *type;
+		XrmDatabase xdb = XrmGetStringDatabase(xrm);
+		XrmValue xval;
+
+		if (XrmGetResource(xdb, "dmenu.font", "*", &type, &xval))
+			#if PANGO_PATCH
+			strcpy(font, xval.addr);
+			#else
+			fonts[0] = strdup(xval.addr);
+			#endif // PANGO_PATCH
+		#if !PANGO_PATCH
+		else
+			fonts[0] = strdup(fonts[0]);
+		#endif // PANGO_PATCH
+		if (XrmGetResource(xdb, "dmenu.background", "*", &type, &xval))
+			colors[SchemeNorm][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.foreground", "*", &type, &xval))
+			colors[SchemeNorm][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.selbackground", "*", &type, &xval))
+			colors[SchemeSel][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.selforeground", "*", &type, &xval))
+			colors[SchemeSel][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.outbackground", "*", &type, &xval))
+			colors[SchemeOut][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.outforeground", "*", &type, &xval))
+			colors[SchemeOut][ColFg] = strdup(xval.addr);
+		#if MORECOLOR_PATCH
+		if (XrmGetResource(xdb, "dmenu.midbackground", "*", &type, &xval))
+			colors[SchemeMid][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.midforeground", "*", &type, &xval))
+			colors[SchemeMid][ColFg] = strdup(xval.addr);
+		#endif // MORECOLOR_PATCH
+		#if BORDER_PATCH
+		if (XrmGetResource(xdb, "dmenu.bordercolor", "*", &type, &xval))
+			colors[SchemeBorder][ColBg] = strdup(xval.addr);
+		#endif // BORDER_PATCH
+		#if HIGHLIGHT_PATCH || FUZZYHIGHLIGHT_PATCH
+		if (XrmGetResource(xdb, "dmenu.selhlbackground", "*", &type, &xval))
+			colors[SchemeSelHighlight][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.selhlforeground", "*", &type, &xval))
+			colors[SchemeSelHighlight][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.hlbackground", "*", &type, &xval))
+			colors[SchemeNormHighlight][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.hlforeground", "*", &type, &xval))
+			colors[SchemeNormHighlight][ColFg] = strdup(xval.addr);
+		#endif // HIGHLIGHT_PATCH | FUZZYHIGHLIGHT_PATCH
+		#if HIGHPRIORITY_PATCH
+		if (XrmGetResource(xdb, "dmenu.hpbackground", "*", &type, &xval))
+			colors[SchemeHp][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.hpforeground", "*", &type, &xval))
+			colors[SchemeHp][ColFg] = strdup(xval.addr);
+		#endif // HIGHPRIORITY_PATCH
+		#if EMOJI_HIGHLIGHT_PATCH
+		if (XrmGetResource(xdb, "dmenu.hoverbackground", "*", &type, &xval))
+			colors[SchemeHover][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.hoverforeground", "*", &type, &xval))
+			colors[SchemeHover][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.greenbackground", "*", &type, &xval))
+			colors[SchemeGreen][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.greenforeground", "*", &type, &xval))
+			colors[SchemeGreen][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.yellowbackground", "*", &type, &xval))
+			colors[SchemeYellow][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.yellowforeground", "*", &type, &xval))
+			colors[SchemeYellow][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.bluebackground", "*", &type, &xval))
+			colors[SchemeBlue][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.blueforeground", "*", &type, &xval))
+			colors[SchemeBlue][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.purplebackground", "*", &type, &xval))
+			colors[SchemePurple][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.purpleforeground", "*", &type, &xval))
+			colors[SchemePurple][ColFg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.redbackground", "*", &type, &xval))
+			colors[SchemeRed][ColBg] = strdup(xval.addr);
+		if (XrmGetResource(xdb, "dmenu.redforeground", "*", &type, &xval))
+			colors[SchemeRed][ColFg] = strdup(xval.addr);
+		#endif // EMOJI_HIGHLIGHT_PATCH
+		XrmDestroyDatabase(xdb);
+	}
+}