git.stevedylan.dev

merged dmenu & dinput (clunky interface) 7d5fe173

Connor Lane Smith · 2010-07-30 13:40 5 file(s) · +215 −440

Makefile +5 −10


include config.mk

SRC = dinput.c dmenu.c common.c
SRC = dmenu.c
OBJ = ${SRC:.c=.o}

all: options dinput dmenu

	@echo creating $@ from config.def.h
	@cp config.def.h $@

dinput: dinput.o common.o
	@echo CC -o $@
	@${CC} -o $@ $+ ${LDFLAGS}

dmenu: dmenu.o common.o
dmenu: ${OBJ}
	@echo CC -o $@
	@${CC} -o $@ $+ ${LDFLAGS}

clean:
	@echo cleaning
	@rm -f dinput dmenu ${OBJ} dmenu-${VERSION}.tar.gz
	@rm -f dmenu ${OBJ} dmenu-${VERSION}.tar.gz

dist: clean
	@echo creating dist tarball

install: all
	@echo installing executable file to ${DESTDIR}${PREFIX}/bin
	@mkdir -p ${DESTDIR}${PREFIX}/bin
	@cp -f dinput dmenu dmenu_path dmenu_run ${DESTDIR}${PREFIX}/bin
	@chmod 755 ${DESTDIR}${PREFIX}/bin/dinput
	@cp -f dmenu dmenu_path dmenu_run ${DESTDIR}${PREFIX}/bin
	@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu
	@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu_path
	@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu_run

uninstall:
	@echo removing executable file from ${DESTDIR}${PREFIX}/bin
	@rm -f ${DESTDIR}${PREFIX}/bin/dmenu ${DESTDIR}${PREFIX}/bin/dmenu_path
	@rm -f ${DESTDIR}${PREFIX}/bin/dinput ${DESTDIR}${PREFIX}/bin/dmenu_run
	@rm -f ${DESTDIR}${PREFIX}/bin/dmenu_run
	@echo removing manual page from ${DESTDIR}${MANPREFIX}/man1
	@rm -f ${DESTDIR}${MANPREFIX}/man1/dmenu.1


common.c (deleted) +0 −129

/* See LICENSE file for copyright and license details. */
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <X11/keysym.h>
#ifdef XINERAMA
#include <X11/extensions/Xinerama.h>
#endif
#include "dmenu.h"

/* variables */
char *prompt = NULL;
char text[4096] = "";
int promptw = 0;
int screen;
unsigned int numlockmask = 0;
unsigned int mw, mh;
unsigned long normcol[ColLast];
unsigned long selcol[ColLast];
Bool topbar = True;
DC dc;
Display *dpy;
Window win, root;

void
grabkeyboard(void) {
	unsigned int len;

	for(len = 1000; len; len--) {
		if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
		== GrabSuccess)
			return;
		usleep(1000);
	}
	exit(EXIT_FAILURE);
}

void
run(void) {
	XEvent ev;

	/* main event loop */
	XSync(dpy, False);
	while(!XNextEvent(dpy, &ev))
		switch(ev.type) {
		case KeyPress:
			kpress(&ev.xkey);
			break;
		case Expose:
			if(ev.xexpose.count == 0)
				drawbar();
			break;
		case VisibilityNotify:
			if(ev.xvisibility.state != VisibilityUnobscured)
				XRaiseWindow(dpy, win);
			break;
		}
	exit(EXIT_FAILURE);
}

void
setup(unsigned int lines) {
	int i, j, x, y;
#if XINERAMA
	int n;
	XineramaScreenInfo *info = NULL;
#endif
	XModifierKeymap *modmap;
	XSetWindowAttributes wa;

	/* init modifier map */
	modmap = XGetModifierMapping(dpy);
	for(i = 0; i < 8; i++)
		for(j = 0; j < modmap->max_keypermod; j++) {
			if(modmap->modifiermap[i * modmap->max_keypermod + j]
			== XKeysymToKeycode(dpy, XK_Num_Lock))
				numlockmask = (1 << i);
		}
	XFreeModifiermap(modmap);

	dc.dpy = dpy;
	normcol[ColBG] = getcolor(&dc, normbgcolor);
	normcol[ColFG] = getcolor(&dc, normfgcolor);
	selcol[ColBG] = getcolor(&dc, selbgcolor);
	selcol[ColFG] = getcolor(&dc, selfgcolor);
	initfont(&dc, font);

	/* input window */
	wa.override_redirect = True;
	wa.background_pixmap = ParentRelative;
	wa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;

	/* input window geometry */
	mh = (dc.font.height + 2) * (lines + 1);
#if XINERAMA
	if(XineramaIsActive(dpy) && (info = XineramaQueryScreens(dpy, &n))) {
		i = 0;
		if(n > 1) {
			int di;
			unsigned int dui;
			Window dummy;
			if(XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui))
				for(i = 0; i < n; i++)
					if(INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))
						break;
		}
		x = info[i].x_org;
		y = topbar ? info[i].y_org : info[i].y_org + info[i].height - mh;
		mw = info[i].width;
		XFree(info);
	}
	else
#endif
	{
		x = 0;
		y = topbar ? 0 : DisplayHeight(dpy, screen) - mh;
		mw = DisplayWidth(dpy, screen);
	}

	win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
			DefaultDepth(dpy, screen), CopyFromParent,
			DefaultVisual(dpy, screen),
			CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);

	setupdraw(&dc, win);
	if(prompt)
		promptw = MIN(textw(&dc, prompt), mw / 5);
	XMapRaised(dpy, win);
}

dinput.c (deleted) +0 −230

/* See LICENSE file for copyright and license details. */
#include <ctype.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/keysym.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "dmenu.h"

/* forward declarations */
static void cleanup(void);

/* variables */
static size_t cursor = 0;

void
cleanup(void) {
	cleanupdraw(&dc);
	XDestroyWindow(dpy, win);
	XUngrabKeyboard(dpy, CurrentTime);
	XCloseDisplay(dpy);
}

void
drawbar(void)
{
	dc.x = 0;
	dc.y = 0;
	dc.w = mw;
	dc.h = mh;
	drawbox(&dc, normcol);
	/* print prompt? */
	if(prompt) {
		dc.w = promptw;
		drawbox(&dc, selcol);
		drawtext(&dc, prompt, selcol);
		dc.x += dc.w;
	}
	dc.w = mw - dc.x;
	drawtext(&dc, text, normcol);
	drawline(&dc, textnw(&dc, text, cursor) + dc.font.height/2, 2, 1,
			dc.font.height-2, normcol);
	commitdraw(&dc, win);
}

void
kpress(XKeyEvent *e) {
	char buf[sizeof text];
	int num;
	unsigned int i, len;
	KeySym ksym;

	len = strlen(text);
	num = XLookupString(e, buf, sizeof buf, &ksym, NULL);
	if(ksym == XK_KP_Enter)
		ksym = XK_Return;
	else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
		ksym = (ksym - XK_KP_0) + XK_0;
	else if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
	|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
	|| IsPrivateKeypadKey(ksym))
		return;
	/* first check if a control mask is omitted */
	if(e->state & ControlMask) {
		switch(tolower(ksym)) {
		default:
			return;
		case XK_a:
			ksym = XK_Home;
			break;
		case XK_b:
			ksym = XK_Left;
			break;
		case XK_c:
			ksym = XK_Escape;
			break;
		case XK_e:
			ksym = XK_End;
			break;
		case XK_f:
			ksym = XK_Right;
			break;
		case XK_h:
			ksym = XK_BackSpace;
			break;
		case XK_j:
		case XK_m:
			ksym = XK_Return;
			break;
		case XK_k:
			text[cursor] = '\0';
			break;
		case XK_u:
			memmove(text, text + cursor, sizeof text - cursor + 1);
			cursor = 0;
			break;
		case XK_w:
			if(cursor > 0) {
				i = cursor;
				while(i-- > 0 && text[i] == ' ');
				while(i-- > 0 && text[i] != ' ');
				memmove(text + i + 1, text + cursor, sizeof text - cursor + 1);
				cursor = i + 1;
			}
			break;
		case XK_y:
			{
				FILE *fp;
				char *s;
				if(!(fp = popen("sselp", "r")))
					eprint("cannot popen sselp\n");
				s = fgets(buf, sizeof buf, fp);
				pclose(fp);
				if(s == NULL)
					return;
			}
			num = strlen(buf);
			if(num && buf[num-1] == '\n')
				buf[--num] = '\0';
			break;
		}
	}
	switch(ksym) {
	default:
		num = MIN(num, sizeof text - cursor);
		if(num && !iscntrl((int) buf[0])) {
			memmove(text + cursor + num, text + cursor, sizeof text - cursor - num);
			memcpy(text + cursor, buf, num);
			cursor += num;
		}
		break;
	case XK_BackSpace:
		if(cursor == 0)
			return;
		for(i = 1; cursor - i > 0 && !IS_UTF8_1ST_CHAR(text[cursor - i]); i++);
		memmove(text + cursor - i, text + cursor, sizeof text - cursor + i);
		cursor -= i;
		break;
	case XK_Delete:
		if(cursor == len)
			return;
		for(i = 1; cursor + i < len && !IS_UTF8_1ST_CHAR(text[cursor + i]); i++);
		memmove(text + cursor, text + cursor + i, sizeof text - cursor);
		break;
	case XK_End:
		cursor = len;
		break;
	case XK_Escape:
		exit(EXIT_FAILURE);
	case XK_Home:
		cursor = 0;
		break;
	case XK_Left:
		if(cursor == 0)
			return;
		while(cursor-- > 0 && !IS_UTF8_1ST_CHAR(text[cursor]));
		break;
	case XK_Return:
		fprintf(stdout, "%s", text);
		fflush(stdout);
		exit(EXIT_SUCCESS);
	case XK_Right:
		if(cursor == len)
			return;
		while(cursor++ < len && !IS_UTF8_1ST_CHAR(text[cursor]));
		break;
	}
	drawbar();
}

int
main(int argc, char *argv[]) {
	unsigned int i;

	/* command line args */
	progname = "dinput";
	for(i = 1; i < argc; i++)
		if(!strcmp(argv[i], "-i"))
			;  /* ignore flag */
		else if(!strcmp(argv[i], "-b"))
			topbar = False;
		else if(!strcmp(argv[i], "-l"))
			i++;  /* ignore flag */
		else if(!strcmp(argv[i], "-fn")) {
			if(++i < argc) font = argv[i];
		}
		else if(!strcmp(argv[i], "-nb")) {
			if(++i < argc) normbgcolor = argv[i];
		}
		else if(!strcmp(argv[i], "-nf")) {
			if(++i < argc) normfgcolor = argv[i];
		}
		else if(!strcmp(argv[i], "-p")) {
			if(++i < argc) prompt = argv[i];
		}
		else if(!strcmp(argv[i], "-sb")) {
			if(++i < argc) selbgcolor = argv[i];
		}
		else if(!strcmp(argv[i], "-sf")) {
			if(++i < argc) selfgcolor = argv[i];
		}
		else if(!strcmp(argv[i], "-v")) {
			printf("dinput-"VERSION", © 2006-2010 dmenu engineers, see LICENSE for details\n");
			exit(EXIT_SUCCESS);
		}
		else if(!*text) {
			strncpy(text, argv[i], sizeof text);
			cursor = strlen(text);
		}
		else {
			fputs("usage: dinput [-b] [-fn <font>] [-nb <color>] [-nf <color>]\n"
			      "              [-p <prompt>] [-sb <color>] [-sf <color>] [-v] [<text>]\n", stderr);
			exit(EXIT_FAILURE);
		}
	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
		fprintf(stderr, "dinput: warning: no locale support\n");
	if(!(dpy = XOpenDisplay(NULL)))
		eprint("cannot open display\n");
	if(atexit(&cleanup) != 0)
		eprint("cannot register cleanup\n");
	screen = DefaultScreen(dpy);
	root = RootWindow(dpy, screen);

	grabkeyboard();
	setup(0);
	run();
	return 0;
}

dmenu.c +210 −41

#include <X11/keysym.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "dmenu.h"
#ifdef XINERAMA
#include <X11/extensions/Xinerama.h>
#endif
#include <draw.h>
#include "config.h"

#define INRECT(x,y,rx,ry,rw,rh) ((rx) < (x) && (x) < (rx)+(rw) && (ry) < (y) && (y) < (ry)+(rh))
#define MIN(a,b)                ((a) < (b) ? (a) : (b))
#define MAX(a,b)                ((a) > (b) ? (a) : (b))
#define IS_UTF8_1ST_CHAR(c)     (((c) & 0xc0) == 0xc0 || ((c) & 0x80) == 0x00)

typedef struct Item Item;
struct Item {

	Item *left, *right; /* traverses items matching current search pattern */
};

/* forward declarations */
static void appenditem(Item *i, Item **list, Item **last);
static void calcoffsetsh(void);
static void calcoffsetsv(void);
static char *cistrstr(const char *s, const char *sub);
static void cleanup(void);
static void dinput(void);
static void drawitem(const char *s, unsigned long col[ColLast]);
static void drawmenu(void);
static void drawmenuh(void);
static void drawmenuv(void);
static void grabkeyboard(void);
static void keypress(XKeyEvent *e);
static void match(void);
static void readstdin(void);
static void run(void);
static void setup(void);

/* variables */
static char **argp = NULL;
static char *maxname = NULL;
static char *prompt;
static char text[4096];
static int promptw;
static int screen;
static size_t cur = 0;
static unsigned int cmdw = 0;
static unsigned int lines = 0;
static unsigned int numlockmask;
static unsigned int mw, mh;
static unsigned long normcol[ColLast];
static unsigned long selcol[ColLast];
static Bool topbar = True;
static DC dc;
static Display *dpy;
static Item *allitems = NULL;  /* first of all items */
static Item *item = NULL;      /* first of pattern matching items */
static Item *sel = NULL;
static Item *next = NULL;
static Item *prev = NULL;
static Item *curr = NULL;
static Window win, root;

static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
static char *(*fstrstr)(const char *, const char *) = strstr;
static void (*calcoffsets)(void) = calcoffsetsh;

}

void
dinput(void) {
	cleanup();
	argp[0] = "dinput";
	argp[1] = text;
	execvp("dinput", argp);
	eprint("cannot exec dinput\n");
drawitem(const char *s, unsigned long col[ColLast]) {
	const char *p;
	unsigned int w = textnw(&dc, text, strlen(text));

	drawbox(&dc, col);
	drawtext(&dc, s, col);
	for(p = fstrstr(s, text); *text && (p = fstrstr(p, text)); p++)
		drawline(&dc, textnw(&dc, s, p-s) + dc.h/2 - 1, dc.h-2, w, 1, col);
}

void
drawbar(void) {
drawmenu(void) {
	dc.x = 0;
	dc.y = 0;
	dc.w = mw;

	if(cmdw && item && lines == 0)
		dc.w = cmdw;
	drawtext(&dc, text, normcol);
	drawline(&dc, textnw(&dc, text, cur) + dc.h/2 - 2, 2, 1, dc.h-4, normcol);
	if(lines > 0)
		drawmenuv();
	else if(curr)
		drawmenuh();
	commitdraw(&dc, win);
}

void
drawitem(const char *s, unsigned long col[ColLast]) {
	const char *p;
	unsigned int w = textnw(&dc, text, strlen(text));

	drawbox(&dc, col);
	drawtext(&dc, s, col);
	for(p = fstrstr(s, text); *text && (p = fstrstr(p, text)); p++)
		drawline(&dc, textnw(&dc, s, p-s) + dc.h/2 - 1, dc.h-2, w, 1, col);
}

void

}

void
kpress(XKeyEvent *e) {
grabkeyboard(void) {
	unsigned int n;

	for(n = 0; n < 1000; n++) {
		if(!XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime))
			return;
		usleep(1000);
	}
	exit(EXIT_FAILURE);
}

void
keypress(XKeyEvent *e) {
	char buf[sizeof text];
	int num;
	unsigned int i, len;

		case XK_m:
			ksym = XK_Return;
			break;
		case XK_k:
			text[cur] = '\0';
			break;
		case XK_n:
			ksym = XK_Down;
			break;

			ksym = XK_Up;
			break;
		case XK_u:
			text[0] = '\0';
			memmove(text, text + cur, sizeof text - cur + 1);
			cur = 0;
			match();
			break;
		case XK_w:
			if(len == 0)
			if(cur == 0)
				return;
			i = len;
			i = cur;
			while(i-- > 0 && text[i] == ' ');
			while(i-- > 0 && text[i] != ' ');
			text[++i] = '\0';
			memmove(text + i + 1, text + cur, sizeof text - cur + 1);
			cur = i + 1;
			match();
			break;
		case XK_y:
			{
				FILE *fp;
				char *s;
				if(!(fp = fopen("sselp", "r")))
					eprint("cannot popen sselp\n");
				s = fgets(buf, sizeof buf, fp);
				fclose(fp);
				if(!s)
					return;
			}
			num = strlen(buf);
			if(num && buf[num-1] == '\n')
				buf[--num] = '\0';
			break;
		}
	}
	switch(ksym) {
	default:
		num = MIN(num, sizeof text);
		if(num && !iscntrl((int) buf[0])) {
			memcpy(text + len, buf, num + 1);
			len += num;
			memmove(text + cur + num, text + cur, sizeof text - cur - num);
			memcpy(text + cur, buf, num);
			cur += num;
			match();
		}
		break;
	case XK_BackSpace:
		if(len == 0)
		if(cur == 0)
			return;
		for(i = 1; len - i > 0 && !IS_UTF8_1ST_CHAR(text[cur - i]); i++);
		memmove(text + cur - i, text + cur, sizeof text - cur + i);
		cur -= i;
		match();
		break;
	case XK_Delete:
		if(cur == len)
			return;
		for(i = 1; len - i > 0 && !IS_UTF8_1ST_CHAR(text[len - i]); i++);
		len -= i;
		text[len] = '\0';
		for(i = 1; cur + i < len && !IS_UTF8_1ST_CHAR(text[cur + i]); i++);
		memmove(text + cur, text + cur + i, sizeof text - cur);
		match();
		break;
	case XK_End:
		if(cur < len) {
			cur = len;
			break;
		}
		while(next) {
			sel = curr = next;
			calcoffsets();

	case XK_Escape:
		exit(EXIT_FAILURE);
	case XK_Home:
		if(sel == item) {
			cur = 0;
			break;
		}
		sel = curr = item;
		calcoffsets();
		break;
	case XK_Left:
		if(cur > 0 && (!sel || !sel->left || lines > 0)) {
			while(cur-- > 0 && !IS_UTF8_1ST_CHAR(text[cur]));
			break;
		}
		if(lines > 0)
			return;
	case XK_Up:
		if(!sel || !sel->left)
			return;

		calcoffsets();
		break;
	case XK_Return:
		if(e->state & ShiftMask)
			dinput();
		fprintf(stdout, "%s", sel ? sel->text : text);
		fprintf(stdout, "%s", ((e->state & ShiftMask) || sel) ? sel->text : text);
		fflush(stdout);
		exit(EXIT_SUCCESS);
	case XK_Right:
		if(cur < len) {
			while(cur++ < len && !IS_UTF8_1ST_CHAR(text[cur]));
			break;
		}
		if(lines > 0)
			return;
	case XK_Down:
		if(!sel || !sel->right)
			return;

		}
		break;
	case XK_Tab:
		if(sel)
			strncpy(text, sel->text, sizeof text);
		dinput();
		if(!sel)
			return;
		strncpy(text, sel->text, sizeof text);
		cur = strlen(text);
		match();
		break;
	}
	drawbar();
	drawmenu();
}

void

	}
}

void
run(void) {
	XEvent ev;

	XSync(dpy, False);
	while(!XNextEvent(dpy, &ev))
		switch(ev.type) {
		case Expose:
			if(ev.xexpose.count == 0)
				drawmenu();
			break;
		case KeyPress:
			keypress(&ev.xkey);
			break;
		case VisibilityNotify:
			if(ev.xvisibility.state != VisibilityUnobscured)
				XRaiseWindow(dpy, win);
			break;
		}
	exit(EXIT_FAILURE);
}

void
setup(void) {
	int i, j, x, y;
#if XINERAMA
	int n;
	XineramaScreenInfo *info = NULL;
#endif
	XModifierKeymap *modmap;
	XSetWindowAttributes wa;

	/* init modifier map */
	modmap = XGetModifierMapping(dpy);
	for(i = 0; i < 8; i++)
		for(j = 0; j < modmap->max_keypermod; j++) {
			if(modmap->modifiermap[i * modmap->max_keypermod + j]
			== XKeysymToKeycode(dpy, XK_Num_Lock))
				numlockmask = (1 << i);
		}
	XFreeModifiermap(modmap);

	dc.dpy = dpy;
	normcol[ColBG] = getcolor(&dc, normbgcolor);
	normcol[ColFG] = getcolor(&dc, normfgcolor);
	selcol[ColBG] = getcolor(&dc, selbgcolor);
	selcol[ColFG] = getcolor(&dc, selfgcolor);
	initfont(&dc, font);

	/* input window */
	wa.override_redirect = True;
	wa.background_pixmap = ParentRelative;
	wa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;

	/* input window geometry */
	mh = (dc.font.height + 2) * (lines + 1);
#if XINERAMA
	if(XineramaIsActive(dpy) && (info = XineramaQueryScreens(dpy, &n))) {
		i = 0;
		if(n > 1) {
			int di;
			unsigned int dui;
			Window dummy;
			if(XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui))
				for(i = 0; i < n; i++)
					if(INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))
						break;
		}
		x = info[i].x_org;
		y = topbar ? info[i].y_org : info[i].y_org + info[i].height - mh;
		mw = info[i].width;
		XFree(info);
	}
	else
#endif
	{
		x = 0;
		y = topbar ? 0 : DisplayHeight(dpy, screen) - mh;
		mw = DisplayWidth(dpy, screen);
	}

	win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
			DefaultDepth(dpy, screen), CopyFromParent,
			DefaultVisual(dpy, screen),
			CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);

	setupdraw(&dc, win);
	if(prompt)
		promptw = MIN(textw(&dc, prompt), mw / 5);
	XMapRaised(dpy, win);
}

int
main(int argc, char *argv[]) {
	unsigned int i;


	readstdin();
	grabkeyboard();
	setup(lines);
	setup();
	if(maxname)
		cmdw = MIN(textw(&dc, maxname), mw / 3);
	match();

dmenu.h (deleted) +0 −30

#include <X11/Xlib.h>
#include <draw.h>
#include "config.h"

/* macros */
#define INRECT(X,Y,RX,RY,RW,RH) ((X) >= (RX) && (X) < (RX) + (RW) && (Y) >= (RY) && (Y) < (RY) + (RH))
#define MIN(a, b)               ((a) < (b) ? (a) : (b))
#define MAX(a, b)               ((a) > (b) ? (a) : (b))
#define IS_UTF8_1ST_CHAR(c)     ((((c) & 0xc0) == 0xc0) || !((c) & 0x80))

/* forward declarations */
void drawbar(void);
void grabkeyboard(void);
void kpress(XKeyEvent *e);
void run(void);
void setup(unsigned int lines);

/* variables */
extern char *prompt;
extern char text[4096];
extern int promptw;
extern int screen;
extern unsigned int numlockmask;
extern unsigned int mw, mh;
extern unsigned long normcol[ColLast];
extern unsigned long selcol[ColLast];
extern Bool topbar;
extern DC dc;
extern Display *dpy;
extern Window win, root;

3	3
4	4		include config.mk
5	5
6		-	SRC = dinput.c dmenu.c common.c
	6	+	SRC = dmenu.c
7	7		OBJ = ${SRC:.c=.o}
8	8
9	9		all: options dinput dmenu

24	24		@echo creating $@ from config.def.h
25	25		@cp config.def.h $@
26	26
27		-	dinput: dinput.o common.o
28		-	@echo CC -o $@
29		-	@${CC} -o $@ $+ ${LDFLAGS}
30		-
31		-	dmenu: dmenu.o common.o
	27	+	dmenu: ${OBJ}
32	28		@echo CC -o $@
33	29		@${CC} -o $@ $+ ${LDFLAGS}
34	30
35	31		clean:
36	32		@echo cleaning
37		-	@rm -f dinput dmenu ${OBJ} dmenu-${VERSION}.tar.gz
	33	+	@rm -f dmenu ${OBJ} dmenu-${VERSION}.tar.gz
38	34
39	35		dist: clean
40	36		@echo creating dist tarball

47	43		install: all
48	44		@echo installing executable file to ${DESTDIR}${PREFIX}/bin
49	45		@mkdir -p ${DESTDIR}${PREFIX}/bin
50		-	@cp -f dinput dmenu dmenu_path dmenu_run ${DESTDIR}${PREFIX}/bin
51		-	@chmod 755 ${DESTDIR}${PREFIX}/bin/dinput
	46	+	@cp -f dmenu dmenu_path dmenu_run ${DESTDIR}${PREFIX}/bin
52	47		@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu
53	48		@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu_path
54	49		@chmod 755 ${DESTDIR}${PREFIX}/bin/dmenu_run

60	55		uninstall:
61	56		@echo removing executable file from ${DESTDIR}${PREFIX}/bin
62	57		@rm -f ${DESTDIR}${PREFIX}/bin/dmenu ${DESTDIR}${PREFIX}/bin/dmenu_path
63		-	@rm -f ${DESTDIR}${PREFIX}/bin/dinput ${DESTDIR}${PREFIX}/bin/dmenu_run
	58	+	@rm -f ${DESTDIR}${PREFIX}/bin/dmenu_run
64	59		@echo removing manual page from ${DESTDIR}${MANPREFIX}/man1
65	60		@rm -f ${DESTDIR}${MANPREFIX}/man1/dmenu.1
66	61

1	-	/* See LICENSE file for copyright and license details. */
2	-	#include <stdlib.h>
3	-	#include <string.h>
4	-	#include <unistd.h>
5	-	#include <X11/keysym.h>
6	-	#ifdef XINERAMA
7	-	#include <X11/extensions/Xinerama.h>
8	-	#endif
9	-	#include "dmenu.h"
10	-
11	-	/* variables */
12	-	char *prompt = NULL;
13	-	char text[4096] = "";
14	-	int promptw = 0;
15	-	int screen;
16	-	unsigned int numlockmask = 0;
17	-	unsigned int mw, mh;
18	-	unsigned long normcol[ColLast];
19	-	unsigned long selcol[ColLast];
20	-	Bool topbar = True;
21	-	DC dc;
22	-	Display *dpy;
23	-	Window win, root;
24	-
25	-	void
26	-	grabkeyboard(void) {
27	-	unsigned int len;
28	-
29	-	for(len = 1000; len; len--) {
30	-	if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
31	-	== GrabSuccess)
32	-	return;
33	-	usleep(1000);
34	-	}
35	-	exit(EXIT_FAILURE);
36	-	}
37	-
38	-	void
39	-	run(void) {
40	-	XEvent ev;
41	-
42	-	/* main event loop */
43	-	XSync(dpy, False);
44	-	while(!XNextEvent(dpy, &ev))
45	-	switch(ev.type) {
46	-	case KeyPress:
47	-	kpress(&ev.xkey);
48	-	break;
49	-	case Expose:
50	-	if(ev.xexpose.count == 0)
51	-	drawbar();
52	-	break;
53	-	case VisibilityNotify:
54	-	if(ev.xvisibility.state != VisibilityUnobscured)
55	-	XRaiseWindow(dpy, win);
56	-	break;
57	-	}
58	-	exit(EXIT_FAILURE);
59	-	}
60	-
61	-	void
62	-	setup(unsigned int lines) {
63	-	int i, j, x, y;
64	-	#if XINERAMA
65	-	int n;
66	-	XineramaScreenInfo *info = NULL;
67	-	#endif
68	-	XModifierKeymap *modmap;
69	-	XSetWindowAttributes wa;
70	-
71	-	/* init modifier map */
72	-	modmap = XGetModifierMapping(dpy);
73	-	for(i = 0; i < 8; i++)
74	-	for(j = 0; j < modmap->max_keypermod; j++) {
75	-	if(modmap->modifiermap[i * modmap->max_keypermod + j]
76	-	== XKeysymToKeycode(dpy, XK_Num_Lock))
77	-	numlockmask = (1 << i);
78	-	}
79	-	XFreeModifiermap(modmap);
80	-
81	-	dc.dpy = dpy;
82	-	normcol[ColBG] = getcolor(&dc, normbgcolor);
83	-	normcol[ColFG] = getcolor(&dc, normfgcolor);
84	-	selcol[ColBG] = getcolor(&dc, selbgcolor);
85	-	selcol[ColFG] = getcolor(&dc, selfgcolor);
86	-	initfont(&dc, font);
87	-
88	-	/* input window */
89	-	wa.override_redirect = True;
90	-	wa.background_pixmap = ParentRelative;
91	-	wa.event_mask = ExposureMask \| KeyPressMask \| VisibilityChangeMask;
92	-
93	-	/* input window geometry */
94	-	mh = (dc.font.height + 2) * (lines + 1);
95	-	#if XINERAMA
96	-	if(XineramaIsActive(dpy) && (info = XineramaQueryScreens(dpy, &n))) {
97	-	i = 0;
98	-	if(n > 1) {
99	-	int di;
100	-	unsigned int dui;
101	-	Window dummy;
102	-	if(XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui))
103	-	for(i = 0; i < n; i++)
104	-	if(INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))
105	-	break;
106	-	}
107	-	x = info[i].x_org;
108	-	y = topbar ? info[i].y_org : info[i].y_org + info[i].height - mh;
109	-	mw = info[i].width;
110	-	XFree(info);
111	-	}
112	-	else
113	-	#endif
114	-	{
115	-	x = 0;
116	-	y = topbar ? 0 : DisplayHeight(dpy, screen) - mh;
117	-	mw = DisplayWidth(dpy, screen);
118	-	}
119	-
120	-	win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
121	-	DefaultDepth(dpy, screen), CopyFromParent,
122	-	DefaultVisual(dpy, screen),
123	-	CWOverrideRedirect \| CWBackPixmap \| CWEventMask, &wa);
124	-
125	-	setupdraw(&dc, win);
126	-	if(prompt)
127	-	promptw = MIN(textw(&dc, prompt), mw / 5);
128	-	XMapRaised(dpy, win);
129	-	}

1	-	/* See LICENSE file for copyright and license details. */
2	-	#include <ctype.h>
3	-	#include <locale.h>
4	-	#include <stdio.h>
5	-	#include <stdlib.h>
6	-	#include <string.h>
7	-	#include <X11/keysym.h>
8	-	#include <X11/Xlib.h>
9	-	#include <X11/Xutil.h>
10	-	#include "dmenu.h"
11	-
12	-	/* forward declarations */
13	-	static void cleanup(void);
14	-
15	-	/* variables */
16	-	static size_t cursor = 0;
17	-
18	-	void
19	-	cleanup(void) {
20	-	cleanupdraw(&dc);
21	-	XDestroyWindow(dpy, win);
22	-	XUngrabKeyboard(dpy, CurrentTime);
23	-	XCloseDisplay(dpy);
24	-	}
25	-
26	-	void
27	-	drawbar(void)
28	-	{
29	-	dc.x = 0;
30	-	dc.y = 0;
31	-	dc.w = mw;
32	-	dc.h = mh;
33	-	drawbox(&dc, normcol);
34	-	/* print prompt? */
35	-	if(prompt) {
36	-	dc.w = promptw;
37	-	drawbox(&dc, selcol);
38	-	drawtext(&dc, prompt, selcol);
39	-	dc.x += dc.w;
40	-	}
41	-	dc.w = mw - dc.x;
42	-	drawtext(&dc, text, normcol);
43	-	drawline(&dc, textnw(&dc, text, cursor) + dc.font.height/2, 2, 1,
44	-	dc.font.height-2, normcol);
45	-	commitdraw(&dc, win);
46	-	}
47	-
48	-	void
49	-	kpress(XKeyEvent *e) {
50	-	char buf[sizeof text];
51	-	int num;
52	-	unsigned int i, len;
53	-	KeySym ksym;
54	-
55	-	len = strlen(text);
56	-	num = XLookupString(e, buf, sizeof buf, &ksym, NULL);
57	-	if(ksym == XK_KP_Enter)
58	-	ksym = XK_Return;
59	-	else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
60	-	ksym = (ksym - XK_KP_0) + XK_0;
61	-	else if(IsFunctionKey(ksym) \|\| IsKeypadKey(ksym)
62	-	\|\| IsMiscFunctionKey(ksym) \|\| IsPFKey(ksym)
63	-	\|\| IsPrivateKeypadKey(ksym))
64	-	return;
65	-	/* first check if a control mask is omitted */
66	-	if(e->state & ControlMask) {
67	-	switch(tolower(ksym)) {
68	-	default:
69	-	return;
70	-	case XK_a:
71	-	ksym = XK_Home;
72	-	break;
73	-	case XK_b:
74	-	ksym = XK_Left;
75	-	break;
76	-	case XK_c:
77	-	ksym = XK_Escape;
78	-	break;
79	-	case XK_e:
80	-	ksym = XK_End;
81	-	break;
82	-	case XK_f:
83	-	ksym = XK_Right;
84	-	break;
85	-	case XK_h:
86	-	ksym = XK_BackSpace;
87	-	break;
88	-	case XK_j:
89	-	case XK_m:
90	-	ksym = XK_Return;
91	-	break;
92	-	case XK_k:
93	-	text[cursor] = '\0';
94	-	break;
95	-	case XK_u:
96	-	memmove(text, text + cursor, sizeof text - cursor + 1);
97	-	cursor = 0;
98	-	break;
99	-	case XK_w:
100	-	if(cursor > 0) {
101	-	i = cursor;
102	-	while(i-- > 0 && text[i] == ' ');
103	-	while(i-- > 0 && text[i] != ' ');
104	-	memmove(text + i + 1, text + cursor, sizeof text - cursor + 1);
105	-	cursor = i + 1;
106	-	}
107	-	break;
108	-	case XK_y:
109	-	{
110	-	FILE *fp;
111	-	char *s;
112	-	if(!(fp = popen("sselp", "r")))
113	-	eprint("cannot popen sselp\n");
114	-	s = fgets(buf, sizeof buf, fp);
115	-	pclose(fp);
116	-	if(s == NULL)
117	-	return;
118	-	}
119	-	num = strlen(buf);
120	-	if(num && buf[num-1] == '\n')
121	-	buf[--num] = '\0';
122	-	break;
123	-	}
124	-	}
125	-	switch(ksym) {
126	-	default:
127	-	num = MIN(num, sizeof text - cursor);
128	-	if(num && !iscntrl((int) buf[0])) {
129	-	memmove(text + cursor + num, text + cursor, sizeof text - cursor - num);
130	-	memcpy(text + cursor, buf, num);
131	-	cursor += num;
132	-	}
133	-	break;
134	-	case XK_BackSpace:
135	-	if(cursor == 0)
136	-	return;
137	-	for(i = 1; cursor - i > 0 && !IS_UTF8_1ST_CHAR(text[cursor - i]); i++);
138	-	memmove(text + cursor - i, text + cursor, sizeof text - cursor + i);
139	-	cursor -= i;
140	-	break;
141	-	case XK_Delete:
142	-	if(cursor == len)
143	-	return;
144	-	for(i = 1; cursor + i < len && !IS_UTF8_1ST_CHAR(text[cursor + i]); i++);
145	-	memmove(text + cursor, text + cursor + i, sizeof text - cursor);
146	-	break;
147	-	case XK_End:
148	-	cursor = len;
149	-	break;
150	-	case XK_Escape:
151	-	exit(EXIT_FAILURE);
152	-	case XK_Home:
153	-	cursor = 0;
154	-	break;
155	-	case XK_Left:
156	-	if(cursor == 0)
157	-	return;
158	-	while(cursor-- > 0 && !IS_UTF8_1ST_CHAR(text[cursor]));
159	-	break;
160	-	case XK_Return:
161	-	fprintf(stdout, "%s", text);
162	-	fflush(stdout);
163	-	exit(EXIT_SUCCESS);
164	-	case XK_Right:
165	-	if(cursor == len)
166	-	return;
167	-	while(cursor++ < len && !IS_UTF8_1ST_CHAR(text[cursor]));
168	-	break;
169	-	}
170	-	drawbar();
171	-	}
172	-
173	-	int
174	-	main(int argc, char *argv[]) {
175	-	unsigned int i;
176	-
177	-	/* command line args */
178	-	progname = "dinput";
179	-	for(i = 1; i < argc; i++)
180	-	if(!strcmp(argv[i], "-i"))
181	-	; /* ignore flag */
182	-	else if(!strcmp(argv[i], "-b"))
183	-	topbar = False;
184	-	else if(!strcmp(argv[i], "-l"))
185	-	i++; /* ignore flag */
186	-	else if(!strcmp(argv[i], "-fn")) {
187	-	if(++i < argc) font = argv[i];
188	-	}
189	-	else if(!strcmp(argv[i], "-nb")) {
190	-	if(++i < argc) normbgcolor = argv[i];
191	-	}
192	-	else if(!strcmp(argv[i], "-nf")) {
193	-	if(++i < argc) normfgcolor = argv[i];
194	-	}
195	-	else if(!strcmp(argv[i], "-p")) {
196	-	if(++i < argc) prompt = argv[i];
197	-	}
198	-	else if(!strcmp(argv[i], "-sb")) {
199	-	if(++i < argc) selbgcolor = argv[i];
200	-	}
201	-	else if(!strcmp(argv[i], "-sf")) {
202	-	if(++i < argc) selfgcolor = argv[i];
203	-	}
204	-	else if(!strcmp(argv[i], "-v")) {
205	-	printf("dinput-"VERSION", © 2006-2010 dmenu engineers, see LICENSE for details\n");
206	-	exit(EXIT_SUCCESS);
207	-	}
208	-	else if(!*text) {
209	-	strncpy(text, argv[i], sizeof text);
210	-	cursor = strlen(text);
211	-	}
212	-	else {
213	-	fputs("usage: dinput [-b] [-fn <font>] [-nb <color>] [-nf <color>]\n"
214	-	" [-p <prompt>] [-sb <color>] [-sf <color>] [-v] [<text>]\n", stderr);
215	-	exit(EXIT_FAILURE);
216	-	}
217	-	if(!setlocale(LC_CTYPE, "") \|\| !XSupportsLocale())
218	-	fprintf(stderr, "dinput: warning: no locale support\n");
219	-	if(!(dpy = XOpenDisplay(NULL)))
220	-	eprint("cannot open display\n");
221	-	if(atexit(&cleanup) != 0)
222	-	eprint("cannot register cleanup\n");
223	-	screen = DefaultScreen(dpy);
224	-	root = RootWindow(dpy, screen);
225	-
226	-	grabkeyboard();
227	-	setup(0);
228	-	run();
229	-	return 0;
230	-	}

1	-	#include <X11/Xlib.h>
2	-	#include <draw.h>
3	-	#include "config.h"
4	-
5	-	/* macros */
6	-	#define INRECT(X,Y,RX,RY,RW,RH) ((X) >= (RX) && (X) < (RX) + (RW) && (Y) >= (RY) && (Y) < (RY) + (RH))
7	-	#define MIN(a, b) ((a) < (b) ? (a) : (b))
8	-	#define MAX(a, b) ((a) > (b) ? (a) : (b))
9	-	#define IS_UTF8_1ST_CHAR(c) ((((c) & 0xc0) == 0xc0) \|\| !((c) & 0x80))
10	-
11	-	/* forward declarations */
12	-	void drawbar(void);
13	-	void grabkeyboard(void);
14	-	void kpress(XKeyEvent *e);
15	-	void run(void);
16	-	void setup(unsigned int lines);
17	-
18	-	/* variables */
19	-	extern char *prompt;
20	-	extern char text[4096];
21	-	extern int promptw;
22	-	extern int screen;
23	-	extern unsigned int numlockmask;
24	-	extern unsigned int mw, mh;
25	-	extern unsigned long normcol[ColLast];
26	-	extern unsigned long selcol[ColLast];
27	-	extern Bool topbar;
28	-	extern DC dc;
29	-	extern Display *dpy;
30	-	extern Window win, root;