rinri
/
dmenu-rinri
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
My dmenu build
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
218 Commits
1 Branch
1.2 MiB
 
 
 
 
 
 
Tree: d094ebea96
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd094ebea96'
${ noResults }
dmenu-rinri/dmenu.c

713 lines
15 KiB
Raw Blame History 

  1. /* See LICENSE file for copyright and license details. */

  2. #include <ctype.h>

  3. #include <locale.h>

  4. #include <stdarg.h>

  5. #include <stdlib.h>

  6. #include <stdio.h>

  7. #include <string.h>

  8. #include <unistd.h>

  9. #include <X11/Xlib.h>

  10. #include <X11/Xutil.h>

  11. #include <X11/keysym.h>

  12. 

  13. /* macros */

  14. #define CLEANMASK(mask) (mask & ~(numlockmask | LockMask))

  15. 

  16. /* enums */

  17. enum { ColFG, ColBG, ColLast };

  18. 

  19. /* typedefs */

  20. typedef struct {

  21. 	int x, y, w, h;

  22. 	unsigned long norm[ColLast];

  23. 	unsigned long sel[ColLast];

  24. 	Drawable drawable;

  25. 	GC gc;

  26. 	struct {

  27. 		XFontStruct *xfont;

  28. 		XFontSet set;

  29. 		int ascent;

  30. 		int descent;

  31. 		int height;

  32. 	} font;

  33. } DC; /* draw context */

  34. 

  35. typedef struct Item Item;

  36. struct Item {

  37. 	Item *next;		/* traverses all items */

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

  39. 	char *text;

  40. };

  41. 

  42. /* forward declarations */

  43. void calcoffsets(void);

  44. void cleanup(void);

  45. void drawmenu(void);

  46. void drawtext(const char *text, unsigned long col[ColLast]);

  47. void *emalloc(unsigned int size);

  48. void eprint(const char *errstr, ...);

  49. char *estrdup(const char *str);

  50. unsigned long getcolor(const char *colstr);

  51. Bool grabkeyboard(void);

  52. void initfont(const char *fontstr);

  53. void kpress(XKeyEvent * e);

  54. void match(char *pattern);

  55. void readstdin(void);

  56. void run(void);

  57. void setup(Bool bottom);

  58. int strido(const char *text, const char *pattern);

  59. unsigned int textnw(const char *text, unsigned int len);

  60. unsigned int textw(const char *text);

  61. 

  62. #include "config.h"

  63. 

  64. /* variables */

  65. char *font = FONT;

  66. char *maxname = NULL;

  67. char *normbg = NORMBGCOLOR;

  68. char *normfg = NORMFGCOLOR;

  69. char *prompt = NULL;

  70. char *selbg = SELBGCOLOR;

  71. char *selfg = SELFGCOLOR;

  72. char text[4096];

  73. int screen;

  74. int ret = 0;

  75. unsigned int cmdw = 0;

  76. unsigned int mw, mh;

  77. unsigned int promptw = 0;

  78. unsigned int nitem = 0;

  79. unsigned int numlockmask = 0;

  80. Bool running = True;

  81. Display *dpy;

  82. DC dc = {0};

  83. Item *allitems = NULL;	/* first of all items */

  84. Item *item = NULL;	/* first of pattern matching items */

  85. Item *sel = NULL;

  86. Item *next = NULL;

  87. Item *prev = NULL;

  88. Item *curr = NULL;

  89. Window root, win;

  90. 

  91. void

  92. calcoffsets(void) {

  93. 	unsigned int tw, w;

  94. 

  95. 	if(!curr)

  96. 		return;

  97. 	w = promptw + cmdw + 2 * SPACE;

  98. 	for(next = curr; next; next=next->right) {

  99. 		tw = textw(next->text);

  100. 		if(tw > mw / 3)

  101. 			tw = mw / 3;

  102. 		w += tw;

  103. 		if(w > mw)

  104. 			break;

  105. 	}

  106. 	w = promptw + cmdw + 2 * SPACE;

  107. 	for(prev = curr; prev && prev->left; prev=prev->left) {

  108. 		tw = textw(prev->left->text);

  109. 		if(tw > mw / 3)

  110. 			tw = mw / 3;

  111. 		w += tw;

  112. 		if(w > mw)

  113. 			break;

  114. 	}

  115. }

  116. 

  117. void

  118. cleanup(void) {

  119. 	Item *itm;

  120. 

  121. 	while(allitems) {

  122. 		itm = allitems->next;

  123. 		free(allitems->text);

  124. 		free(allitems);

  125. 		allitems = itm;

  126. 	}

  127. 	if(dc.font.set)

  128. 		XFreeFontSet(dpy, dc.font.set);

  129. 	else

  130. 		XFreeFont(dpy, dc.font.xfont);

  131. 	XFreePixmap(dpy, dc.drawable);

  132. 	XFreeGC(dpy, dc.gc);

  133. 	XDestroyWindow(dpy, win);

  134. 	XUngrabKeyboard(dpy, CurrentTime);

  135. }

  136. 

  137. void

  138. drawmenu(void) {

  139. 	Item *i;

  140. 

  141. 	dc.x = 0;

  142. 	dc.y = 0;

  143. 	dc.w = mw;

  144. 	dc.h = mh;

  145. 	drawtext(NULL, dc.norm);

  146. 	/* print prompt? */

  147. 	if(promptw) {

  148. 		dc.w = promptw;

  149. 		drawtext(prompt, dc.sel);

  150. 	}

  151. 	dc.x += promptw;

  152. 	dc.w = mw - promptw;

  153. 	/* print command */

  154. 	if(cmdw && item)

  155. 		dc.w = cmdw;

  156. 	drawtext(text[0] ? text : NULL, dc.norm);

  157. 	dc.x += cmdw;

  158. 	if(curr) {

  159. 		dc.w = SPACE;

  160. 		drawtext((curr && curr->left) ? "<" : NULL, dc.norm);

  161. 		dc.x += dc.w;

  162. 		/* determine maximum items */

  163. 		for(i = curr; i != next; i=i->right) {

  164. 			dc.w = textw(i->text);

  165. 			if(dc.w > mw / 3)

  166. 				dc.w = mw / 3;

  167. 			drawtext(i->text, (sel == i) ? dc.sel : dc.norm);

  168. 			dc.x += dc.w;

  169. 		}

  170. 		dc.x = mw - SPACE;

  171. 		dc.w = SPACE;

  172. 		drawtext(next ? ">" : NULL, dc.norm);

  173. 	}

  174. 	XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, mw, mh, 0, 0);

  175. 	XFlush(dpy);

  176. }

  177. 

  178. void

  179. drawtext(const char *text, unsigned long col[ColLast]) {

  180. 	int x, y, w, h;

  181. 	static char buf[256];

  182. 	unsigned int len, olen;

  183. 	XRectangle r = { dc.x, dc.y, dc.w, dc.h };

  184. 

  185. 	XSetForeground(dpy, dc.gc, col[ColBG]);

  186. 	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);

  187. 	if(!text)

  188. 		return;

  189. 	w = 0;

  190. 	olen = len = strlen(text);

  191. 	if(len >= sizeof buf)

  192. 		len = sizeof buf - 1;

  193. 	memcpy(buf, text, len);

  194. 	buf[len] = 0;

  195. 	h = dc.font.ascent + dc.font.descent;

  196. 	y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;

  197. 	x = dc.x + (h / 2);

  198. 	/* shorten text if necessary */

  199. 	while(len && (w = textnw(buf, len)) > dc.w - h)

  200. 		buf[--len] = 0;

  201. 	if(len < olen) {

  202. 		if(len > 1)

  203. 			buf[len - 1] = '.';

  204. 		if(len > 2)

  205. 			buf[len - 2] = '.';

  206. 		if(len > 3)

  207. 			buf[len - 3] = '.';

  208. 	}

  209. 	if(w > dc.w)

  210. 		return; /* too long */

  211. 	XSetForeground(dpy, dc.gc, col[ColFG]);

  212. 	if(dc.font.set)

  213. 		XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);

  214. 	else

  215. 		XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);

  216. }

  217. 

  218. void *

  219. emalloc(unsigned int size) {

  220. 	void *res = malloc(size);

  221. 

  222. 	if(!res)

  223. 		eprint("fatal: could not malloc() %u bytes\n", size);

  224. 	return res;

  225. }

  226. 

  227. void

  228. eprint(const char *errstr, ...) {

  229. 	va_list ap;

  230. 

  231. 	va_start(ap, errstr);

  232. 	vfprintf(stderr, errstr, ap);

  233. 	va_end(ap);

  234. 	exit(EXIT_FAILURE);

  235. }

  236. 

  237. char *

  238. estrdup(const char *str) {

  239. 	void *res = strdup(str);

  240. 

  241. 	if(!res)

  242. 		eprint("fatal: could not malloc() %u bytes\n", strlen(str));

  243. 	return res;

  244. }

  245. 

  246. unsigned long

  247. getcolor(const char *colstr) {

  248. 	Colormap cmap = DefaultColormap(dpy, screen);

  249. 	XColor color;

  250. 

  251. 	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))

  252. 		eprint("error, cannot allocate color '%s'\n", colstr);

  253. 	return color.pixel;

  254. }

  255. 

  256. Bool

  257. grabkeyboard(void) {

  258. 	unsigned int len;

  259. 

  260. 	for(len = 1000; len; len--) {

  261. 		if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)

  262. 			== GrabSuccess)

  263. 			break;

  264. 		usleep(1000);

  265. 	}

  266. 	return len > 0;

  267. }

  268. 

  269. void

  270. initfont(const char *fontstr) {

  271. 	char *def, **missing;

  272. 	int i, n;

  273. 

  274. 	if(!fontstr || fontstr[0] == '\0')

  275. 		eprint("error, cannot load font: '%s'\n", fontstr);

  276. 	missing = NULL;

  277. 	if(dc.font.set)

  278. 		XFreeFontSet(dpy, dc.font.set);

  279. 	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);

  280. 	if(missing)

  281. 		XFreeStringList(missing);

  282. 	if(dc.font.set) {

  283. 		XFontSetExtents *font_extents;

  284. 		XFontStruct **xfonts;

  285. 		char **font_names;

  286. 		dc.font.ascent = dc.font.descent = 0;

  287. 		font_extents = XExtentsOfFontSet(dc.font.set);

  288. 		n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);

  289. 		for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {

  290. 			if(dc.font.ascent < (*xfonts)->ascent)

  291. 				dc.font.ascent = (*xfonts)->ascent;

  292. 			if(dc.font.descent < (*xfonts)->descent)

  293. 				dc.font.descent = (*xfonts)->descent;

  294. 			xfonts++;

  295. 		}

  296. 	}

  297. 	else {

  298. 		if(dc.font.xfont)

  299. 			XFreeFont(dpy, dc.font.xfont);

  300. 		dc.font.xfont = NULL;

  301. 		if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr))) {

  302. 			if(!(dc.font.xfont = XLoadQueryFont(dpy, "fixed")))

  303. 				eprint("error, cannot load font: '%s'\n", fontstr);

  304. 		}

  305. 		dc.font.ascent = dc.font.xfont->ascent;

  306. 		dc.font.descent = dc.font.xfont->descent;

  307. 	}

  308. 	dc.font.height = dc.font.ascent + dc.font.descent;

  309. }

  310. 

  311. void

  312. kpress(XKeyEvent * e) {

  313. 	char buf[32];

  314. 	int i, num;

  315. 	unsigned int len;

  316. 	KeySym ksym;

  317. 

  318. 	len = strlen(text);

  319. 	buf[0] = 0;

  320. 	num = XLookupString(e, buf, sizeof buf, &ksym, 0);

  321. 	if(IsKeypadKey(ksym)) { 

  322. 		if(ksym == XK_KP_Enter) {

  323. 			ksym = XK_Return;

  324. 		} else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) {

  325. 			ksym = (ksym - XK_KP_0) + XK_0;

  326. 		}

  327. 	}

  328. 	if(IsFunctionKey(ksym) || IsKeypadKey(ksym)

  329. 			|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)

  330. 			|| IsPrivateKeypadKey(ksym))

  331. 		return;

  332. 	/* first check if a control mask is omitted */

  333. 	if(e->state & ControlMask) {

  334. 		switch (ksym) {

  335. 		default:	/* ignore other control sequences */

  336. 			return;

  337. 		case XK_bracketleft:

  338. 			ksym = XK_Escape;

  339. 			break;

  340. 		case XK_h:

  341. 		case XK_H:

  342. 			ksym = XK_BackSpace;

  343. 			break;

  344. 		case XK_i:

  345. 		case XK_I:

  346. 			ksym = XK_Tab;

  347. 			break;

  348. 		case XK_j:

  349. 		case XK_J:

  350. 			ksym = XK_Return;

  351. 			break;

  352. 		case XK_u:

  353. 		case XK_U:

  354. 			text[0] = 0;

  355. 			match(text);

  356. 			drawmenu();

  357. 			return;

  358. 		case XK_w:

  359. 		case XK_W:

  360. 			if(len) {

  361. 				i = len - 1;

  362. 				while(i >= 0 && text[i] == ' ')

  363. 					text[i--] = 0;

  364. 				while(i >= 0 && text[i] != ' ')

  365. 					text[i--] = 0;

  366. 				match(text);

  367. 				drawmenu();

  368. 			}

  369. 			return;

  370. 		}

  371. 	}

  372. 	if(CLEANMASK(e->state) & Mod1Mask) {

  373. 		switch(ksym) {

  374. 		default: return;

  375. 		case XK_h:

  376. 			ksym = XK_Left;

  377. 			break;

  378. 		case XK_l:

  379. 			ksym = XK_Right;

  380. 			break;

  381. 		case XK_j:

  382. 			ksym = XK_Next;

  383. 			break;

  384. 		case XK_k:

  385. 			ksym = XK_Prior;

  386. 			break;

  387. 		case XK_g:

  388. 			ksym = XK_Home;

  389. 			break;

  390. 		case XK_G:

  391. 			ksym = XK_End;

  392. 			break;

  393. 		}

  394. 	}

  395. 	switch(ksym) {

  396. 	default:

  397. 		if(num && !iscntrl((int) buf[0])) {

  398. 			buf[num] = 0;

  399. 			if(len > 0)

  400. 				strncat(text, buf, sizeof text);

  401. 			else

  402. 				strncpy(text, buf, sizeof text);

  403. 			match(text);

  404. 		}

  405. 		break;

  406. 	case XK_BackSpace:

  407. 		if(len) {

  408. 			text[--len] = 0;

  409. 			match(text);

  410. 		}

  411. 		break;

  412. 	case XK_End:

  413. 		if(!item)

  414. 			return;

  415. 		while(next) {

  416. 			sel = curr = next;

  417. 			calcoffsets();

  418. 		}

  419. 		while(sel && sel->right)

  420. 			sel = sel->right;

  421. 		break;

  422. 	case XK_Escape:

  423. 		ret = 1;

  424. 		running = False;

  425. 		break;

  426. 	case XK_Home:

  427. 		if(!item)

  428. 			return;

  429. 		sel = curr = item;

  430. 		calcoffsets();

  431. 		break;

  432. 	case XK_Left:

  433. 		if(!(sel && sel->left))

  434. 			return;

  435. 		sel=sel->left;

  436. 		if(sel->right == curr) {

  437. 			curr = prev;

  438. 			calcoffsets();

  439. 		}

  440. 		break;

  441. 	case XK_Next:

  442. 		if(!next)

  443. 			return;

  444. 		sel = curr = next;

  445. 		calcoffsets();

  446. 		break;

  447. 	case XK_Prior:

  448. 		if(!prev)

  449. 			return;

  450. 		sel = curr = prev;

  451. 		calcoffsets();

  452. 		break;

  453. 	case XK_Return:

  454. 		if((e->state & ShiftMask) && text)

  455. 			fprintf(stdout, "%s", text);

  456. 		else if(sel)

  457. 			fprintf(stdout, "%s", sel->text);

  458. 		else if(text)

  459. 			fprintf(stdout, "%s", text);

  460. 		fflush(stdout);

  461. 		running = False;

  462. 		break;

  463. 	case XK_Right:

  464. 		if(!(sel && sel->right))

  465. 			return;

  466. 		sel=sel->right;

  467. 		if(sel == next) {

  468. 			curr = next;

  469. 			calcoffsets();

  470. 		}

  471. 		break;

  472. 	case XK_Tab:

  473. 		if(!sel)

  474. 			return;

  475. 		strncpy(text, sel->text, sizeof text);

  476. 		match(text);

  477. 		break;

  478. 	}

  479. 	drawmenu();

  480. }

  481. 

  482. void

  483. match(char *pattern) {

  484. 	unsigned int plen;

  485. 	Item *i, *j;

  486. 

  487. 	if(!pattern)

  488. 		return;

  489. 	plen = strlen(pattern);

  490. 	item = j = NULL;

  491. 	nitem = 0;

  492. 	for(i = allitems; i; i=i->next)

  493. 		if(!plen || !strncmp(pattern, i->text, plen)) {

  494. 			if(!j)

  495. 				item = i;

  496. 			else

  497. 				j->right = i;

  498. 			i->left = j;

  499. 			i->right = NULL;

  500. 			j = i;

  501. 			nitem++;

  502. 		}

  503. 	for(i = allitems; i; i=i->next)

  504. 		if(plen && strncmp(pattern, i->text, plen)

  505. 				&& strstr(i->text, pattern)) {

  506. 			if(!j)                               

  507. 				item = i;                              

  508. 			else                                     

  509. 				j->right = i;                          

  510. 			i->left = j;      

  511. 			i->right = NULL;                         

  512. 			j = i;                                      

  513. 			nitem++;                                       

  514. 		}                                              

  515. 	for(i = allitems; i; i=i->next)                            

  516. 		if(plen && strncmp(pattern, i->text, plen)             

  517. 				&& !strstr(i->text, pattern)          

  518. 				&& strido(i->text,pattern)) { 

  519. 			if(!j)

  520. 				item = i;

  521. 			else

  522. 				j->right = i;

  523. 			i->left = j;

  524. 			i->right = NULL;

  525. 			j = i;

  526. 			nitem++;

  527. 		}

  528. 	curr = prev = next = sel = item;

  529. 	calcoffsets();

  530. }

  531. 

  532. void

  533. readstdin(void) {

  534. 	char *p, buf[1024];

  535. 	unsigned int len = 0, max = 0;

  536. 	Item *i, *new;

  537. 

  538. 	i = 0;

  539. 	while(fgets(buf, sizeof buf, stdin)) {

  540. 		len = strlen(buf);

  541. 		if (buf[len - 1] == '\n')

  542. 			buf[len - 1] = 0;

  543. 		p = estrdup(buf);

  544. 		if(max < len) {

  545. 			maxname = p;

  546. 			max = len;

  547. 		}

  548. 		new = emalloc(sizeof(Item));

  549. 		new->next = new->left = new->right = NULL;

  550. 		new->text = p;

  551. 		if(!i)

  552. 			allitems = new;

  553. 		else 

  554. 			i->next = new;

  555. 		i = new;

  556. 	}

  557. }

  558. 

  559. void

  560. run(void) {

  561. 	XEvent ev;

  562. 

  563. 	/* main event loop */

  564. 	while(running && !XNextEvent(dpy, &ev))

  565. 		switch (ev.type) {

  566. 		default:	/* ignore all crap */

  567. 			break;

  568. 		case KeyPress:

  569. 			kpress(&ev.xkey);

  570. 			break;

  571. 		case Expose:

  572. 			if(ev.xexpose.count == 0)

  573. 				drawmenu();

  574. 			break;

  575. 		}

  576. }

  577. 

  578. void

  579. setup(Bool bottom) {

  580. 	unsigned int i, j;

  581. 	XModifierKeymap *modmap;

  582. 	XSetWindowAttributes wa;

  583. 

  584. 	/* init modifier map */

  585. 	modmap = XGetModifierMapping(dpy);

  586. 	for(i = 0; i < 8; i++)

  587. 		for(j = 0; j < modmap->max_keypermod; j++) {

  588. 			if(modmap->modifiermap[i * modmap->max_keypermod + j]

  589. 			== XKeysymToKeycode(dpy, XK_Num_Lock))

  590. 				numlockmask = (1 << i);

  591. 		}

  592. 	XFreeModifiermap(modmap);

  593. 

  594. 	/* style */

  595. 	dc.norm[ColBG] = getcolor(normbg);

  596. 	dc.norm[ColFG] = getcolor(normfg);

  597. 	dc.sel[ColBG] = getcolor(selbg);

  598. 	dc.sel[ColFG] = getcolor(selfg);

  599. 	initfont(font);

  600. 

  601. 	/* menu window */

  602. 	wa.override_redirect = 1;

  603. 	wa.background_pixmap = ParentRelative;

  604. 	wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;

  605. 	mw = DisplayWidth(dpy, screen);

  606. 	mh = dc.font.height + 2;

  607. 	win = XCreateWindow(dpy, root, 0,

  608. 			bottom ? DisplayHeight(dpy, screen) - mh : 0, mw, mh, 0,

  609. 			DefaultDepth(dpy, screen), CopyFromParent,

  610. 			DefaultVisual(dpy, screen),

  611. 			CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);

  612. 

  613. 	/* pixmap */

  614. 	dc.drawable = XCreatePixmap(dpy, root, mw, mh, DefaultDepth(dpy, screen));

  615. 	dc.gc = XCreateGC(dpy, root, 0, 0);

  616. 	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);

  617. 	if(!dc.font.set)

  618. 		XSetFont(dpy, dc.gc, dc.font.xfont->fid);

  619. 	if(maxname)

  620. 		cmdw = textw(maxname);

  621. 	if(cmdw > mw / 3)

  622. 		cmdw = mw / 3;

  623. 	if(prompt)

  624. 		promptw = textw(prompt);

  625. 	if(promptw > mw / 5)

  626. 		promptw = mw / 5;

  627. 	text[0] = 0;

  628. 	match(text);

  629. 	XMapRaised(dpy, win);

  630. }

  631. 

  632. int

  633. strido(const char *text, const char *pattern) {

  634. 	for(; *text && *pattern; text++)

  635. 		if (*text == *pattern)

  636. 			pattern++;

  637. 	return !*pattern;

  638. }                                  

  639. 

  640. unsigned int

  641. textnw(const char *text, unsigned int len) {

  642. 	XRectangle r;

  643. 

  644. 	if(dc.font.set) {

  645. 		XmbTextExtents(dc.font.set, text, len, NULL, &r);

  646. 		return r.width;

  647. 	}

  648. 	return XTextWidth(dc.font.xfont, text, len);

  649. }

  650. 

  651. unsigned int

  652. textw(const char *text) {

  653. 	return textnw(text, strlen(text)) + dc.font.height;

  654. }

  655. 

  656. int

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

  658. 	Bool bottom = False;

  659. 	unsigned int i;

  660. 

  661. 	/* command line args */

  662. 	for(i = 1; i < argc; i++)

  663. 		if(!strcmp(argv[i], "-b")) {

  664. 			bottom = True;

  665. 		}

  666. 		else if(!strcmp(argv[i], "-fn")) {

  667. 			if(++i < argc) font = argv[i];

  668. 		}

  669. 		else if(!strcmp(argv[i], "-nb")) {

  670. 			if(++i < argc) normbg = argv[i];

  671. 		}

  672. 		else if(!strcmp(argv[i], "-nf")) {

  673. 			if(++i < argc) normfg = argv[i];

  674. 		}

  675. 		else if(!strcmp(argv[i], "-p")) {

  676. 			if(++i < argc) prompt = argv[i];

  677. 		}

  678. 		else if(!strcmp(argv[i], "-sb")) {

  679. 			if(++i < argc) selbg = argv[i];

  680. 		}

  681. 		else if(!strcmp(argv[i], "-sf")) {

  682. 			if(++i < argc) selfg = argv[i];

  683. 		}

  684. 		else if(!strcmp(argv[i], "-v"))

  685. 			eprint("dmenu-"VERSION", © 2006-2007 Anselm R. Garbe, Sander van Dijk\n");

  686. 		else

  687. 			eprint("usage: dmenu [-b] [-fn <font>] [-nb <color>] [-nf <color>]\n"

  688. 			"             [-p <prompt>] [-sb <color>] [-sf <color>] [-v]\n");

  689. 	setlocale(LC_CTYPE, "");

  690. 	dpy = XOpenDisplay(0);

  691. 	if(!dpy)

  692. 		eprint("dmenu: cannot open display\n");

  693. 	screen = DefaultScreen(dpy);

  694. 	root = RootWindow(dpy, screen);

  695. 

  696. 	if(isatty(STDIN_FILENO)) {

  697. 		readstdin();

  698. 		running = grabkeyboard();

  699. 	}

  700. 	else { /* prevent keypress loss */

  701. 		running = grabkeyboard();

  702. 		readstdin();

  703. 	}

  704. 

  705. 	setup(bottom);

  706. 	drawmenu();

  707. 	XSync(dpy, False);

  708. 	run();

  709. 	cleanup();

  710. 	XCloseDisplay(dpy);

  711. 	return ret;

  712. }