git.stevedylan.dev

efficiency tweaks 2b92c952

Connor Lane Smith · 2011-07-14 20:03 2 file(s) · +44 −60

dmenu.c +41 −57


static void appenditem(Item *item, Item **list, Item **last);
static void calcoffsets(void);
static char *cistrstr(const char *s, const char *sub);
static void drawmenu(void);
static char *fstrstr(const char *s, const char *sub);
static void grabkeyboard(void);
static void insert(const char *str, ssize_t n);
static void keypress(XKeyEvent *ev);

static Window win;

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

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

			topbar = False;
		else if(!strcmp(argv[i], "-f"))
			fast = True;
		else if(!strcmp(argv[i], "-i"))
		else if(!strcmp(argv[i], "-i")) {
			fstrncmp = strncasecmp;
			fstrstr = cistrstr;
		}
		else if(i+1 == argc)
			usage();
		/* double flags */

	setup();
	run();

	return EXIT_FAILURE;  /* should not reach */
	return EXIT_FAILURE; /* unreachable */
}

void

		*list = item;
	else
		(*last)->right = item;

	item->left = *last;
	item->right = NULL;
	*last = item;

			break;
}

char *
cistrstr(const char *s, const char *sub) {
	size_t len;

	for(len = strlen(sub); *s; s++)
		if(!strncasecmp(s, sub, len))
			return (char *)s;
	return NULL;
}

void
drawmenu(void) {
	int curpos;

	mapdc(dc, win, mw, mh);
}

char *
fstrstr(const char *s, const char *sub) {
	size_t len;

	for(len = strlen(sub); *s; s++)
		if(!fstrncmp(s, sub, len))
			return (char *)s;
	return NULL;
}

void
grabkeyboard(void) {
	int i;


		XConvertCase(ksym, &lower, &upper);
		switch(lower) {
		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_d:
			ksym = XK_Delete;
			break;
		case XK_e:
			ksym = XK_End;
			break;
		case XK_f:
			ksym = XK_Right;
			break;
		case XK_h:
			ksym = XK_BackSpace;
			break;
		case XK_i:
			ksym = XK_Tab;
			break;
		case XK_j:
		case XK_m:
			ksym = XK_Return;
			break;
		case XK_k:  /* delete right */
		case XK_a: ksym = XK_Home;      break;
		case XK_b: ksym = XK_Left;      break;
		case XK_c: ksym = XK_Escape;    break;
		case XK_d: ksym = XK_Delete;    break;
		case XK_e: ksym = XK_End;       break;
		case XK_f: ksym = XK_Right;     break;
		case XK_h: ksym = XK_BackSpace; break;
		case XK_i: ksym = XK_Tab;       break;
		case XK_j: ksym = XK_Return;    break;
		case XK_m: ksym = XK_Return;    break;
		case XK_n: ksym = XK_Up;        break;
		case XK_p: ksym = XK_Down;      break;

		case XK_k: /* delete right */
			text[cursor] = '\0';
			match(False);
			break;
		case XK_n:
			ksym = XK_Next;
			break;
		case XK_p:
			ksym = XK_Prior;
			break;
		case XK_u:  /* delete left */
		case XK_u: /* delete left */
			insert(NULL, 0 - cursor);
			break;
		case XK_w:  /* delete word */
		case XK_w: /* delete word */
			while(cursor > 0 && text[nextrune(-1)] == ' ')
				insert(NULL, nextrune(-1) - cursor);
			while(cursor > 0 && text[nextrune(-1)] != ' ')
				insert(NULL, nextrune(-1) - cursor);
			break;
		case XK_y:  /* paste selection */
		case XK_y: /* paste selection */
			XConvertSelection(dc->dpy, XA_PRIMARY, utf8, utf8, win, CurrentTime);
			return;
		default:
			return;
		}
	}

			return;
		cursor = nextrune(+1);
	case XK_BackSpace:
		if(cursor > 0)
			insert(NULL, nextrune(-1) - cursor);
		if(cursor == 0)
			return;
		insert(NULL, nextrune(-1) - cursor);
		break;
	case XK_End:
		if(text[cursor] != '\0') {

		break;
	case XK_Return:
	case XK_KP_Enter:
		fputs((sel && !(ev->state & ShiftMask)) ? sel->text : text, stdout);
		puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
		exit(EXIT_SUCCESS);
	case XK_Right:
		if(text[cursor] != '\0') {

		switch(ev.type) {
		case Expose:
			if(ev.xexpose.count == 0)
				drawmenu();
				mapdc(dc, win, mw, mh);
			break;
		case KeyPress:
			keypress(&ev.xkey);

draw.c +3 −3

	DC *dc;

	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
		fprintf(stderr, "no locale support\n");
		fputs("no locale support\n", stderr);
	if(!(dc = calloc(1, sizeof *dc)))
		eprintf("cannot malloc %u bytes:", sizeof *dc);
	if(!(dc->dpy = XOpenDisplay(NULL)))

	if(dc->canvas)
		XFreePixmap(dc->dpy, dc->canvas);

	dc->w = w;
	dc->h = h;
	dc->canvas = XCreatePixmap(dc->dpy, DefaultRootWindow(dc->dpy), w, h,
	                           DefaultDepth(dc->dpy, DefaultScreen(dc->dpy)));
	dc->w = w;
	dc->h = h;
}

int

25	25
26	26		static void appenditem(Item item, Item list, Item *last);
27	27		static void calcoffsets(void);
	28	+	static char cistrstr(const char s, const char *sub);
28	29		static void drawmenu(void);
29		-	static char fstrstr(const char s, const char *sub);
30	30		static void grabkeyboard(void);
31	31		static void insert(const char *str, ssize_t n);
32	32		static void keypress(XKeyEvent *ev);

60	60		static Window win;
61	61
62	62		static int (fstrncmp)(const char , const char *, size_t) = strncmp;
	63	+	static char (fstrstr)(const char , const char ) = strstr;
63	64
64	65		int
65	66		main(int argc, char *argv[]) {

76	77		topbar = False;
77	78		else if(!strcmp(argv[i], "-f"))
78	79		fast = True;
79		-	else if(!strcmp(argv[i], "-i"))
	80	+	else if(!strcmp(argv[i], "-i")) {
80	81		fstrncmp = strncasecmp;
	82	+	fstrstr = cistrstr;
	83	+	}
81	84		else if(i+1 == argc)
82	85		usage();
83	86		/* double flags */

112	115		setup();
113	116		run();
114	117
115		-	return EXIT_FAILURE; /* should not reach */
	118	+	return EXIT_FAILURE; /* unreachable */
116	119		}
117	120
118	121		void

121	124		*list = item;
122	125		else
123	126		(*last)->right = item;
	127	+
124	128		item->left = *last;
125	129		item->right = NULL;
126	130		*last = item;

143	147		break;
144	148		}
145	149
	150	+	char *
	151	+	cistrstr(const char s, const char sub) {
	152	+	size_t len;
	153	+
	154	+	for(len = strlen(sub); *s; s++)
	155	+	if(!strncasecmp(s, sub, len))
	156	+	return (char *)s;
	157	+	return NULL;
	158	+	}
	159	+
146	160		void
147	161		drawmenu(void) {
148	162		int curpos;

188	202		mapdc(dc, win, mw, mh);
189	203		}
190	204
191		-	char *
192		-	fstrstr(const char s, const char sub) {
193		-	size_t len;
194		-
195		-	for(len = strlen(sub); *s; s++)
196		-	if(!fstrncmp(s, sub, len))
197		-	return (char *)s;
198		-	return NULL;
199		-	}
200		-
201	205		void
202	206		grabkeyboard(void) {
203	207		int i;

233	237
234	238		XConvertCase(ksym, &lower, &upper);
235	239		switch(lower) {
236		-	default:
237		-	return;
238		-	case XK_a:
239		-	ksym = XK_Home;
240		-	break;
241		-	case XK_b:
242		-	ksym = XK_Left;
243		-	break;
244		-	case XK_c:
245		-	ksym = XK_Escape;
246		-	break;
247		-	case XK_d:
248		-	ksym = XK_Delete;
249		-	break;
250		-	case XK_e:
251		-	ksym = XK_End;
252		-	break;
253		-	case XK_f:
254		-	ksym = XK_Right;
255		-	break;
256		-	case XK_h:
257		-	ksym = XK_BackSpace;
258		-	break;
259		-	case XK_i:
260		-	ksym = XK_Tab;
261		-	break;
262		-	case XK_j:
263		-	case XK_m:
264		-	ksym = XK_Return;
265		-	break;
266		-	case XK_k: /* delete right */
	240	+	case XK_a: ksym = XK_Home; break;
	241	+	case XK_b: ksym = XK_Left; break;
	242	+	case XK_c: ksym = XK_Escape; break;
	243	+	case XK_d: ksym = XK_Delete; break;
	244	+	case XK_e: ksym = XK_End; break;
	245	+	case XK_f: ksym = XK_Right; break;
	246	+	case XK_h: ksym = XK_BackSpace; break;
	247	+	case XK_i: ksym = XK_Tab; break;
	248	+	case XK_j: ksym = XK_Return; break;
	249	+	case XK_m: ksym = XK_Return; break;
	250	+	case XK_n: ksym = XK_Up; break;
	251	+	case XK_p: ksym = XK_Down; break;
	252	+
	253	+	case XK_k: /* delete right */
267	254		text[cursor] = '\0';
268	255		match(False);
269	256		break;
270		-	case XK_n:
271		-	ksym = XK_Next;
272		-	break;
273		-	case XK_p:
274		-	ksym = XK_Prior;
275		-	break;
276		-	case XK_u: /* delete left */
	257	+	case XK_u: /* delete left */
277	258		insert(NULL, 0 - cursor);
278	259		break;
279		-	case XK_w: /* delete word */
	260	+	case XK_w: /* delete word */
280	261		while(cursor > 0 && text[nextrune(-1)] == ' ')
281	262		insert(NULL, nextrune(-1) - cursor);
282	263		while(cursor > 0 && text[nextrune(-1)] != ' ')
283	264		insert(NULL, nextrune(-1) - cursor);
284	265		break;
285		-	case XK_y: /* paste selection */
	266	+	case XK_y: /* paste selection */
286	267		XConvertSelection(dc->dpy, XA_PRIMARY, utf8, utf8, win, CurrentTime);
	268	+	return;
	269	+	default:
287	270		return;
288	271		}
289	272		}

297	280		return;
298	281		cursor = nextrune(+1);
299	282		case XK_BackSpace:
300		-	if(cursor > 0)
301		-	insert(NULL, nextrune(-1) - cursor);
	283	+	if(cursor == 0)
	284	+	return;
	285	+	insert(NULL, nextrune(-1) - cursor);
302	286		break;
303	287		case XK_End:
304	288		if(text[cursor] != '\0') {

351	335		break;
352	336		case XK_Return:
353	337		case XK_KP_Enter:
354		-	fputs((sel && !(ev->state & ShiftMask)) ? sel->text : text, stdout);
	338	+	puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
355	339		exit(EXIT_SUCCESS);
356	340		case XK_Right:
357	341		if(text[cursor] != '\0') {

468	452		switch(ev.type) {
469	453		case Expose:
470	454		if(ev.xexpose.count == 0)
471		-	drawmenu();
	455	+	mapdc(dc, win, mw, mh);
472	456		break;
473	457		case KeyPress:
474	458		keypress(&ev.xkey);

96	96		DC *dc;
97	97
98	98		if(!setlocale(LC_CTYPE, "") \|\| !XSupportsLocale())
99		-	fprintf(stderr, "no locale support\n");
	99	+	fputs("no locale support\n", stderr);
100	100		if(!(dc = calloc(1, sizeof *dc)))
101	101		eprintf("cannot malloc %u bytes:", sizeof *dc);
102	102		if(!(dc->dpy = XOpenDisplay(NULL)))

153	153		if(dc->canvas)
154	154		XFreePixmap(dc->dpy, dc->canvas);
155	155
	156	+	dc->w = w;
	157	+	dc->h = h;
156	158		dc->canvas = XCreatePixmap(dc->dpy, DefaultRootWindow(dc->dpy), w, h,
157	159		DefaultDepth(dc->dpy, DefaultScreen(dc->dpy)));
158		-	dc->w = w;
159		-	dc->h = h;
160	160		}
161	161
162	162		int