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.
219 Commits
1 Branch
1.2 MiB
 
 
 
 
 
 
Tree: 56f9e26b72
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '56f9e26b72'
${ noResults }
dmenu-rinri/dmenu.c

712 lines
14 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. 		&& !(dc.font.xfont = XLoadQueryFont(dpy, "fixed")))

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

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

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

  306. 	}

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

  308. }

  309. 

  310. void

  311. kpress(XKeyEvent * e) {

  312. 	char buf[32];

  313. 	int i, num;

  314. 	unsigned int len;

  315. 	KeySym ksym;

  316. 

  317. 	len = strlen(text);

  318. 	buf[0] = 0;

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

  320. 	if(IsKeypadKey(ksym)) { 

  321. 		if(ksym == XK_KP_Enter) {

  322. 			ksym = XK_Return;

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

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

  325. 		}

  326. 	}

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

  328. 			|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)

  329. 			|| IsPrivateKeypadKey(ksym))

  330. 		return;

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

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

  333. 		switch (ksym) {

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

  335. 			return;

  336. 		case XK_bracketleft:

  337. 			ksym = XK_Escape;

  338. 			break;

  339. 		case XK_h:

  340. 		case XK_H:

  341. 			ksym = XK_BackSpace;

  342. 			break;

  343. 		case XK_i:

  344. 		case XK_I:

  345. 			ksym = XK_Tab;

  346. 			break;

  347. 		case XK_j:

  348. 		case XK_J:

  349. 			ksym = XK_Return;

  350. 			break;

  351. 		case XK_u:

  352. 		case XK_U:

  353. 			text[0] = 0;

  354. 			match(text);

  355. 			drawmenu();

  356. 			return;

  357. 		case XK_w:

  358. 		case XK_W:

  359. 			if(len) {

  360. 				i = len - 1;

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

  362. 					text[i--] = 0;

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

  364. 					text[i--] = 0;

  365. 				match(text);

  366. 				drawmenu();

  367. 			}

  368. 			return;

  369. 		}

  370. 	}

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

  372. 		switch(ksym) {

  373. 		default: return;

  374. 		case XK_h:

  375. 			ksym = XK_Left;

  376. 			break;

  377. 		case XK_l:

  378. 			ksym = XK_Right;

  379. 			break;

  380. 		case XK_j:

  381. 			ksym = XK_Next;

  382. 			break;

  383. 		case XK_k:

  384. 			ksym = XK_Prior;

  385. 			break;

  386. 		case XK_g:

  387. 			ksym = XK_Home;

  388. 			break;

  389. 		case XK_G:

  390. 			ksym = XK_End;

  391. 			break;

  392. 		}

  393. 	}

  394. 	switch(ksym) {

  395. 	default:

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

  397. 			buf[num] = 0;

  398. 			if(len > 0)

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

  400. 			else

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

  402. 			match(text);

  403. 		}

  404. 		break;

  405. 	case XK_BackSpace:

  406. 		if(len) {

  407. 			text[--len] = 0;

  408. 			match(text);

  409. 		}

  410. 		break;

  411. 	case XK_End:

  412. 		if(!item)

  413. 			return;

  414. 		while(next) {

  415. 			sel = curr = next;

  416. 			calcoffsets();

  417. 		}

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

  419. 			sel = sel->right;

  420. 		break;

  421. 	case XK_Escape:

  422. 		ret = 1;

  423. 		running = False;

  424. 		break;

  425. 	case XK_Home:

  426. 		if(!item)

  427. 			return;

  428. 		sel = curr = item;

  429. 		calcoffsets();

  430. 		break;

  431. 	case XK_Left:

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

  433. 			return;

  434. 		sel=sel->left;

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

  436. 			curr = prev;

  437. 			calcoffsets();

  438. 		}

  439. 		break;

  440. 	case XK_Next:

  441. 		if(!next)

  442. 			return;

  443. 		sel = curr = next;

  444. 		calcoffsets();

  445. 		break;

  446. 	case XK_Prior:

  447. 		if(!prev)

  448. 			return;

  449. 		sel = curr = prev;

  450. 		calcoffsets();

  451. 		break;

  452. 	case XK_Return:

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

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

  455. 		else if(sel)

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

  457. 		else if(text)

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

  459. 		fflush(stdout);

  460. 		running = False;

  461. 		break;

  462. 	case XK_Right:

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

  464. 			return;

  465. 		sel=sel->right;

  466. 		if(sel == next) {

  467. 			curr = next;

  468. 			calcoffsets();

  469. 		}

  470. 		break;

  471. 	case XK_Tab:

  472. 		if(!sel)

  473. 			return;

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

  475. 		match(text);

  476. 		break;

  477. 	}

  478. 	drawmenu();

  479. }

  480. 

  481. void

  482. match(char *pattern) {

  483. 	unsigned int plen;

  484. 	Item *i, *j;

  485. 

  486. 	if(!pattern)

  487. 		return;

  488. 	plen = strlen(pattern);

  489. 	item = j = NULL;

  490. 	nitem = 0;

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

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

  493. 			if(!j)

  494. 				item = i;

  495. 			else

  496. 				j->right = i;

  497. 			i->left = j;

  498. 			i->right = NULL;

  499. 			j = i;

  500. 			nitem++;

  501. 		}

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

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

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

  505. 			if(!j)                               

  506. 				item = i;                              

  507. 			else                                     

  508. 				j->right = i;                          

  509. 			i->left = j;      

  510. 			i->right = NULL;                         

  511. 			j = i;                                      

  512. 			nitem++;                                       

  513. 		}                                              

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

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

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

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

  518. 			if(!j)

  519. 				item = i;

  520. 			else

  521. 				j->right = i;

  522. 			i->left = j;

  523. 			i->right = NULL;

  524. 			j = i;

  525. 			nitem++;

  526. 		}

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

  528. 	calcoffsets();

  529. }

  530. 

  531. void

  532. readstdin(void) {

  533. 	char *p, buf[1024];

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

  535. 	Item *i, *new;

  536. 

  537. 	i = 0;

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

  539. 		len = strlen(buf);

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

  541. 			buf[len - 1] = 0;

  542. 		p = estrdup(buf);

  543. 		if(max < len) {

  544. 			maxname = p;

  545. 			max = len;

  546. 		}

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

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

  549. 		new->text = p;

  550. 		if(!i)

  551. 			allitems = new;

  552. 		else 

  553. 			i->next = new;

  554. 		i = new;

  555. 	}

  556. }

  557. 

  558. void

  559. run(void) {

  560. 	XEvent ev;

  561. 

  562. 	/* main event loop */

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

  564. 		switch (ev.type) {

  565. 		default:	/* ignore all crap */

  566. 			break;

  567. 		case KeyPress:

  568. 			kpress(&ev.xkey);

  569. 			break;

  570. 		case Expose:

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

  572. 				drawmenu();

  573. 			break;

  574. 		}

  575. }

  576. 

  577. void

  578. setup(Bool bottom) {

  579. 	unsigned int i, j;

  580. 	XModifierKeymap *modmap;

  581. 	XSetWindowAttributes wa;

  582. 

  583. 	/* init modifier map */

  584. 	modmap = XGetModifierMapping(dpy);

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

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

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

  588. 			== XKeysymToKeycode(dpy, XK_Num_Lock))

  589. 				numlockmask = (1 << i);

  590. 		}

  591. 	XFreeModifiermap(modmap);

  592. 

  593. 	/* style */

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

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

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

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

  598. 	initfont(font);

  599. 

  600. 	/* menu window */

  601. 	wa.override_redirect = 1;

  602. 	wa.background_pixmap = ParentRelative;

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

  604. 	mw = DisplayWidth(dpy, screen);

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

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

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

  608. 			DefaultDepth(dpy, screen), CopyFromParent,

  609. 			DefaultVisual(dpy, screen),

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

  611. 

  612. 	/* pixmap */

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

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

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

  616. 	if(!dc.font.set)

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

  618. 	if(maxname)

  619. 		cmdw = textw(maxname);

  620. 	if(cmdw > mw / 3)

  621. 		cmdw = mw / 3;

  622. 	if(prompt)

  623. 		promptw = textw(prompt);

  624. 	if(promptw > mw / 5)

  625. 		promptw = mw / 5;

  626. 	text[0] = 0;

  627. 	match(text);

  628. 	XMapRaised(dpy, win);

  629. }

  630. 

  631. int

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

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

  634. 		if (*text == *pattern)

  635. 			pattern++;

  636. 	return !*pattern;

  637. }                                  

  638. 

  639. unsigned int

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

  641. 	XRectangle r;

  642. 

  643. 	if(dc.font.set) {

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

  645. 		return r.width;

  646. 	}

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

  648. }

  649. 

  650. unsigned int

  651. textw(const char *text) {

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

  653. }

  654. 

  655. int

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

  657. 	Bool bottom = False;

  658. 	unsigned int i;

  659. 

  660. 	/* command line args */

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

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

  663. 			bottom = True;

  664. 		}

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

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

  667. 		}

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

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

  670. 		}

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

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

  673. 		}

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

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

  676. 		}

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

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

  679. 		}

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

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

  682. 		}

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

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

  685. 		else

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

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

  688. 	setlocale(LC_CTYPE, "");

  689. 	dpy = XOpenDisplay(0);

  690. 	if(!dpy)

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

  692. 	screen = DefaultScreen(dpy);

  693. 	root = RootWindow(dpy, screen);

  694. 

  695. 	if(isatty(STDIN_FILENO)) {

  696. 		readstdin();

  697. 		running = grabkeyboard();

  698. 	}

  699. 	else { /* prevent keypress loss */

  700. 		running = grabkeyboard();

  701. 		readstdin();

  702. 	}

  703. 

  704. 	setup(bottom);

  705. 	drawmenu();

  706. 	XSync(dpy, False);

  707. 	run();

  708. 	cleanup();

  709. 	XCloseDisplay(dpy);

  710. 	return ret;

  711. }