rinri
/
dmenu-rinri
1
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
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.
452 Commitit
1 Haara
1.2 MiB
 
 
 
 
 
 
Puu: cf641ae496
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'cf641ae496'
${ noResults }
dmenu-rinri/dmenu.c

570 rivejä
13 KiB
Raaka Blame Historia 

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

  2. #include <ctype.h>

  3. #include <stdio.h>

  4. #include <stdlib.h>

  5. #include <string.h>

  6. #include <strings.h>

  7. #include <unistd.h>

  8. #include <X11/Xlib.h>

  9. #include <X11/Xatom.h>

  10. #include <X11/Xutil.h>

  11. #ifdef XINERAMA

  12. #include <X11/extensions/Xinerama.h>

  13. #endif

  14. #include "draw.h"

  15. 

  16. #define INRECT(x,y,rx,ry,rw,rh) ((x) >= (rx) && (x) < (rx)+(rw) && (y) >= (ry) && (y) < (ry)+(rh))

  17. #define MIN(a,b)                ((a) < (b) ? (a) : (b))

  18. #define MAX(a,b)                ((a) > (b) ? (a) : (b))

  19. 

  20. typedef struct Item Item;

  21. struct Item {

  22. 	char *text;

  23. 	Item *left, *right;

  24. };

  25. 

  26. static void appenditem(Item *item, Item **list, Item **last);

  27. static void calcoffsets(void);

  28. static char *cistrstr(const char *s, const char *sub);

  29. static void drawmenu(void);

  30. static void grabkeyboard(void);

  31. static void insert(const char *str, ssize_t n);

  32. static void keypress(XKeyEvent *ev);

  33. static void match(void);

  34. static size_t nextrune(int inc);

  35. static void paste(void);

  36. static void readstdin(void);

  37. static void run(void);

  38. static void setup(void);

  39. static void usage(void);

  40. 

  41. static char text[BUFSIZ] = "";

  42. static int bh, mw, mh;

  43. static int inputw, promptw;

  44. static size_t cursor = 0;

  45. static const char *font = NULL;

  46. static const char *prompt = NULL;

  47. static const char *normbgcolor = "#cccccc";

  48. static const char *normfgcolor = "#000000";

  49. static const char *selbgcolor  = "#0066ff";

  50. static const char *selfgcolor  = "#ffffff";

  51. static unsigned int lines = 0;

  52. static unsigned long normcol[ColLast];

  53. static unsigned long selcol[ColLast];

  54. static Atom utf8;

  55. static Bool topbar = True;

  56. static DC *dc;

  57. static Item *items = NULL;

  58. static Item *matches, *matchend;

  59. static Item *prev, *curr, *next, *sel;

  60. static Window win;

  61. static XIC xic;

  62. 

  63. static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;

  64. static char *(*fstrstr)(const char *, const char *) = strstr;

  65. 

  66. int

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

  68. 	Bool fast = False;

  69. 	int i;

  70. 

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

  72. 		/* single flags */

  73. 		if(!strcmp(argv[i], "-v")) {

  74. 			puts("dmenu-"VERSION", © 2006-2011 dmenu engineers, see LICENSE for details");

  75. 			exit(EXIT_SUCCESS);

  76. 		}

  77. 		else if(!strcmp(argv[i], "-b"))

  78. 			topbar = False;

  79. 		else if(!strcmp(argv[i], "-f"))

  80. 			fast = True;

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

  82. 			fstrncmp = strncasecmp;

  83. 			fstrstr = cistrstr;

  84. 		}

  85. 		else if(i+1 == argc)

  86. 			usage();

  87. 		/* double flags */

  88. 		else if(!strcmp(argv[i], "-l"))

  89. 			lines = atoi(argv[++i]);

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

  91. 			prompt = argv[++i];

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

  93. 			font = argv[++i];

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

  95. 			normbgcolor = argv[++i];

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

  97. 			normfgcolor = argv[++i];

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

  99. 			selbgcolor = argv[++i];

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

  101. 			selfgcolor = argv[++i];

  102. 		else

  103. 			usage();

  104. 

  105. 	dc = initdc();

  106. 	initfont(dc, font);

  107. 

  108. 	if(fast) {

  109. 		grabkeyboard();

  110. 		readstdin();

  111. 	}

  112. 	else {

  113. 		readstdin();

  114. 		grabkeyboard();

  115. 	}

  116. 	setup();

  117. 	run();

  118. 

  119. 	return EXIT_FAILURE; /* unreachable */

  120. }

  121. 

  122. void

  123. appenditem(Item *item, Item **list, Item **last) {

  124. 	if(*last)

  125. 		(*last)->right = item;

  126. 	else

  127. 		*list = item;

  128. 

  129. 	item->left = *last;

  130. 	item->right = NULL;

  131. 	*last = item;

  132. }

  133. 

  134. void

  135. calcoffsets(void) {

  136. 	int i, n;

  137. 

  138. 	if(lines > 0)

  139. 		n = lines * bh;

  140. 	else

  141. 		n = mw - (promptw + inputw + textw(dc, "<") + textw(dc, ">"));

  142. 

  143. 	for(i = 0, next = curr; next; next = next->right)

  144. 		if((i += (lines > 0) ? bh : MIN(textw(dc, next->text), n)) > n)

  145. 			break;

  146. 	for(i = 0, prev = curr; prev && prev->left; prev = prev->left)

  147. 		if((i += (lines > 0) ? bh : MIN(textw(dc, prev->left->text), n)) > n)

  148. 			break;

  149. }

  150. 

  151. char *

  152. cistrstr(const char *s, const char *sub) {

  153. 	size_t len;

  154. 

  155. 	for(len = strlen(sub); *s; s++)

  156. 		if(!strncasecmp(s, sub, len))

  157. 			return (char *)s;

  158. 	return NULL;

  159. }

  160. 

  161. void

  162. drawmenu(void) {

  163. 	int curpos;

  164. 	Item *item;

  165. 

  166. 	dc->x = 0;

  167. 	dc->y = 0;

  168. 	dc->h = bh;

  169. 	drawrect(dc, 0, 0, mw, mh, True, BG(dc, normcol));

  170. 

  171. 	if(prompt) {

  172. 		dc->w = promptw;

  173. 		drawtext(dc, prompt, selcol);

  174. 		dc->x = dc->w;

  175. 	}

  176. 	dc->w = (lines > 0 || !matches) ? mw - dc->x : inputw;

  177. 	drawtext(dc, text, normcol);

  178. 	if((curpos = textnw(dc, text, cursor) + dc->h/2 - 2) < dc->w)

  179. 		drawrect(dc, curpos, 2, 1, dc->h - 4, True, FG(dc, normcol));

  180. 

  181. 	if(lines > 0) {

  182. 		dc->w = mw - dc->x;

  183. 		for(item = curr; item != next; item = item->right) {

  184. 			dc->y += dc->h;

  185. 			drawtext(dc, item->text, (item == sel) ? selcol : normcol);

  186. 		}

  187. 	}

  188. 	else if(matches) {

  189. 		dc->x += inputw;

  190. 		dc->w = textw(dc, "<");

  191. 		if(curr->left)

  192. 			drawtext(dc, "<", normcol);

  193. 		for(item = curr; item != next; item = item->right) {

  194. 			dc->x += dc->w;

  195. 			dc->w = MIN(textw(dc, item->text), mw - dc->x - textw(dc, ">"));

  196. 			drawtext(dc, item->text, (item == sel) ? selcol : normcol);

  197. 		}

  198. 		dc->w = textw(dc, ">");

  199. 		dc->x = mw - dc->w;

  200. 		if(next)

  201. 			drawtext(dc, ">", normcol);

  202. 	}

  203. 	mapdc(dc, win, mw, mh);

  204. }

  205. 

  206. void

  207. grabkeyboard(void) {

  208. 	int i;

  209. 

  210. 	for(i = 0; i < 1000; i++) {

  211. 		if(XGrabKeyboard(dc->dpy, DefaultRootWindow(dc->dpy), True,

  212. 		                 GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess)

  213. 			return;

  214. 		usleep(1000);

  215. 	}

  216. 	eprintf("cannot grab keyboard\n");

  217. }

  218. 

  219. void

  220. insert(const char *str, ssize_t n) {

  221. 	if(strlen(text) + n > sizeof text - 1)

  222. 		return;

  223. 	memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0));

  224. 	if(n > 0)

  225. 		memcpy(&text[cursor], str, n);

  226. 	cursor += n;

  227. 	match();

  228. }

  229. 

  230. void

  231. keypress(XKeyEvent *ev) {

  232. 	char buf[32];

  233. 	int len;

  234. 	KeySym ksym = NoSymbol;

  235. 	Status status;

  236. 

  237. 	len = XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status);

  238. 	if(status == XBufferOverflow)

  239. 		return;

  240. 	if(ev->state & ControlMask) {

  241. 		KeySym lower, upper;

  242. 

  243. 		XConvertCase(ksym, &lower, &upper);

  244. 		switch(lower) {

  245. 		case XK_a: ksym = XK_Home;      break;

  246. 		case XK_b: ksym = XK_Left;      break;

  247. 		case XK_c: ksym = XK_Escape;    break;

  248. 		case XK_d: ksym = XK_Delete;    break;

  249. 		case XK_e: ksym = XK_End;       break;

  250. 		case XK_f: ksym = XK_Right;     break;

  251. 		case XK_h: ksym = XK_BackSpace; break;

  252. 		case XK_i: ksym = XK_Tab;       break;

  253. 		case XK_j: ksym = XK_Return;    break;

  254. 		case XK_m: ksym = XK_Return;    break;

  255. 		case XK_n: ksym = XK_Up;        break;

  256. 		case XK_p: ksym = XK_Down;      break;

  257. 

  258. 		case XK_k: /* delete right */

  259. 			text[cursor] = '\0';

  260. 			match();

  261. 			break;

  262. 		case XK_u: /* delete left */

  263. 			insert(NULL, 0 - cursor);

  264. 			break;

  265. 		case XK_w: /* delete word */

  266. 			while(cursor > 0 && text[nextrune(-1)] == ' ')

  267. 				insert(NULL, nextrune(-1) - cursor);

  268. 			while(cursor > 0 && text[nextrune(-1)] != ' ')

  269. 				insert(NULL, nextrune(-1) - cursor);

  270. 			break;

  271. 		case XK_y: /* paste selection */

  272. 			XConvertSelection(dc->dpy, XA_PRIMARY, utf8, utf8, win, CurrentTime);

  273. 			return;

  274. 		default:

  275. 			return;

  276. 		}

  277. 	}

  278. 	switch(ksym) {

  279. 	default:

  280. 		if(!iscntrl(*buf))

  281. 			insert(buf, len);

  282. 		break;

  283. 	case XK_Delete:

  284. 		if(text[cursor] == '\0')

  285. 			return;

  286. 		cursor = nextrune(+1);

  287. 		/* fallthrough */

  288. 	case XK_BackSpace:

  289. 		if(cursor == 0)

  290. 			return;

  291. 		insert(NULL, nextrune(-1) - cursor);

  292. 		break;

  293. 	case XK_End:

  294. 		if(text[cursor] != '\0') {

  295. 			cursor = strlen(text);

  296. 			break;

  297. 		}

  298. 		if(next) {

  299. 			curr = matchend;

  300. 			calcoffsets();

  301. 			curr = prev;

  302. 			calcoffsets();

  303. 			while(next && (curr = curr->right))

  304. 				calcoffsets();

  305. 		}

  306. 		sel = matchend;

  307. 		break;

  308. 	case XK_Escape:

  309. 		exit(EXIT_FAILURE);

  310. 	case XK_Home:

  311. 		if(sel == matches) {

  312. 			cursor = 0;

  313. 			break;

  314. 		}

  315. 		sel = curr = matches;

  316. 		calcoffsets();

  317. 		break;

  318. 	case XK_Left:

  319. 		if(cursor > 0 && (!sel || !sel->left || lines > 0)) {

  320. 			cursor = nextrune(-1);

  321. 			break;

  322. 		}

  323. 		/* fallthrough */

  324. 	case XK_Up:

  325. 		if(sel && sel->left && (sel = sel->left)->right == curr) {

  326. 			curr = prev;

  327. 			calcoffsets();

  328. 		}

  329. 		break;

  330. 	case XK_Next:

  331. 		if(!next)

  332. 			return;

  333. 		sel = curr = next;

  334. 		calcoffsets();

  335. 		break;

  336. 	case XK_Prior:

  337. 		if(!prev)

  338. 			return;

  339. 		sel = curr = prev;

  340. 		calcoffsets();

  341. 		break;

  342. 	case XK_Return:

  343. 	case XK_KP_Enter:

  344. 		puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);

  345. 		exit(EXIT_SUCCESS);

  346. 	case XK_Right:

  347. 		if(text[cursor] != '\0') {

  348. 			cursor = nextrune(+1);

  349. 			break;

  350. 		}

  351. 		/* fallthrough */

  352. 	case XK_Down:

  353. 		if(sel && sel->right && (sel = sel->right) == next) {

  354. 			curr = next;

  355. 			calcoffsets();

  356. 		}

  357. 		break;

  358. 	case XK_Tab:

  359. 		if(!sel)

  360. 			return;

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

  362. 		cursor = strlen(text);

  363. 		match();

  364. 		break;

  365. 	}

  366. 	drawmenu();

  367. }

  368. 

  369. void

  370. match(void) {

  371. 	static char **tokv = NULL;

  372. 	static int tokn = 0;

  373. 

  374. 	char buf[sizeof text], *s;

  375. 	int i, tokc = 0;

  376. 	size_t len;

  377. 	Item *item, *lprefix, *lsubstr, *prefixend, *substrend;

  378. 

  379. 	strcpy(buf, text);

  380. 	for(s = strtok(buf, " "); s; tokv[tokc-1] = s, s = strtok(NULL, " "))

  381. 		if(++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv)))

  382. 			eprintf("cannot realloc %u bytes\n", tokn * sizeof *tokv);

  383. 	len = tokc ? strlen(tokv[0]) : 0;

  384. 

  385. 	matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL;

  386. 	for(item = items; item && item->text; item++) {

  387. 		for(i = 0; i < tokc; i++)

  388. 			if(!fstrstr(item->text, tokv[i]))

  389. 				break;

  390. 		if(i != tokc)

  391. 			continue;

  392. 		if(!tokc || !fstrncmp(tokv[0], item->text, len+1))

  393. 			appenditem(item, &matches, &matchend);

  394. 		else if(!fstrncmp(tokv[0], item->text, len))

  395. 			appenditem(item, &lprefix, &prefixend);

  396. 		else

  397. 			appenditem(item, &lsubstr, &substrend);

  398. 	}

  399. 	if(lprefix) {

  400. 		if(matches) {

  401. 			matchend->right = lprefix;

  402. 			lprefix->left = matchend;

  403. 		}

  404. 		else

  405. 			matches = lprefix;

  406. 		matchend = prefixend;

  407. 	}

  408. 	if(lsubstr) {

  409. 		if(matches) {

  410. 			matchend->right = lsubstr;

  411. 			lsubstr->left = matchend;

  412. 		}

  413. 		else

  414. 			matches = lsubstr;

  415. 		matchend = substrend;

  416. 	}

  417. 	curr = sel = matches;

  418. 	calcoffsets();

  419. }

  420. 

  421. size_t

  422. nextrune(int inc) {

  423. 	ssize_t n;

  424. 

  425. 	for(n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc);

  426. 	return n;

  427. }

  428. 

  429. void

  430. paste(void) {

  431. 	char *p, *q;

  432. 	int di;

  433. 	unsigned long dl;

  434. 	Atom da;

  435. 

  436. 	XGetWindowProperty(dc->dpy, win, utf8, 0, (sizeof text / 4) + 1, False,

  437. 	                   utf8, &da, &di, &dl, &dl, (unsigned char **)&p);

  438. 	insert(p, (q = strchr(p, '\n')) ? q-p : (ssize_t)strlen(p));

  439. 	XFree(p);

  440. 	drawmenu();

  441. }

  442. 

  443. void

  444. readstdin(void) {

  445. 	char buf[sizeof text], *p, *maxstr = NULL;

  446. 	size_t i, max = 0, size = 0;

  447. 

  448. 	for(i = 0; fgets(buf, sizeof buf, stdin); i++) {

  449. 		if(i+1 >= size / sizeof *items)

  450. 			if(!(items = realloc(items, (size += BUFSIZ))))

  451. 				eprintf("cannot realloc %u bytes:", size);

  452. 		if((p = strchr(buf, '\n')))

  453. 			*p = '\0';

  454. 		if(!(items[i].text = strdup(buf)))

  455. 			eprintf("cannot strdup %u bytes:", strlen(buf)+1);

  456. 		if(strlen(items[i].text) > max)

  457. 			max = strlen(maxstr = items[i].text);

  458. 	}

  459. 	if(items)

  460. 		items[i].text = NULL;

  461. 	inputw = maxstr ? textw(dc, maxstr) : 0;

  462. 	lines = MIN(lines, i);

  463. }

  464. 

  465. void

  466. run(void) {

  467. 	XEvent ev;

  468. 

  469. 	while(!XNextEvent(dc->dpy, &ev)) {

  470. 		if(XFilterEvent(&ev, win))

  471. 			continue;

  472. 		switch(ev.type) {

  473. 		case Expose:

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

  475. 				mapdc(dc, win, mw, mh);

  476. 			break;

  477. 		case KeyPress:

  478. 			keypress(&ev.xkey);

  479. 			break;

  480. 		case SelectionNotify:

  481. 			if(ev.xselection.property == utf8)

  482. 				paste();

  483. 			break;

  484. 		case VisibilityNotify:

  485. 			if(ev.xvisibility.state != VisibilityUnobscured)

  486. 				XRaiseWindow(dc->dpy, win);

  487. 			break;

  488. 		}

  489. 	}

  490. }

  491. 

  492. void

  493. setup(void) {

  494. 	int x, y, screen = DefaultScreen(dc->dpy);

  495. 	Window root = RootWindow(dc->dpy, screen);

  496. 	XSetWindowAttributes swa;

  497. 	XIM xim;

  498. #ifdef XINERAMA

  499. 	int n;

  500. 	XineramaScreenInfo *info;

  501. #endif

  502. 

  503. 	normcol[ColBG] = getcolor(dc, normbgcolor);

  504. 	normcol[ColFG] = getcolor(dc, normfgcolor);

  505. 	selcol[ColBG]  = getcolor(dc, selbgcolor);

  506. 	selcol[ColFG]  = getcolor(dc, selfgcolor);

  507. 

  508. 	utf8 = XInternAtom(dc->dpy, "UTF8_STRING", False);

  509. 

  510. 	/* menu geometry */

  511. 	bh = dc->font.height + 2;

  512. 	lines = MAX(lines, 0);

  513. 	mh = (lines + 1) * bh;

  514. #ifdef XINERAMA

  515. 	if((info = XineramaQueryScreens(dc->dpy, &n))) {

  516. 		int i, di;

  517. 		unsigned int du;

  518. 		Window w, dw;

  519. 		XWindowAttributes wa;

  520. 

  521. 		XGetInputFocus(dc->dpy, &w, &di);

  522. 		if(w != root && w != PointerRoot && w != None && XGetWindowAttributes(dc->dpy, w, &wa))

  523. 			XTranslateCoordinates(dc->dpy, w, root, wa.x, wa.y, &x, &y, &dw);

  524. 		else

  525. 			XQueryPointer(dc->dpy, root, &dw, &dw, &x, &y, &di, &di, &du);

  526. 		for(i = 0; i < n-1; i++)

  527. 			if(INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))

  528. 				break;

  529. 		x = info[i].x_org;

  530. 		y = info[i].y_org + (topbar ? 0 : info[i].height - mh);

  531. 		mw = info[i].width;

  532. 		XFree(info);

  533. 	}

  534. 	else

  535. #endif

  536. 	{

  537. 		x = 0;

  538. 		y = topbar ? 0 : DisplayHeight(dc->dpy, screen) - mh;

  539. 		mw = DisplayWidth(dc->dpy, screen);

  540. 	}

  541. 	promptw = prompt ? textw(dc, prompt) : 0;

  542. 	inputw = MIN(inputw, mw/3);

  543. 	match();

  544. 

  545. 	/* menu window */

  546. 	swa.override_redirect = True;

  547. 	swa.background_pixmap = ParentRelative;

  548. 	swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;

  549. 	win = XCreateWindow(dc->dpy, root, x, y, mw, mh, 0,

  550. 	                    DefaultDepth(dc->dpy, screen), CopyFromParent,

  551. 	                    DefaultVisual(dc->dpy, screen),

  552. 	                    CWOverrideRedirect | CWBackPixmap | CWEventMask, &swa);

  553. 

  554. 	/* input methods */

  555. 	xim = XOpenIM(dc->dpy, NULL, NULL, NULL);

  556. 	xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,

  557. 	                XNClientWindow, win, XNFocusWindow, win, NULL);

  558. 

  559. 	XMapRaised(dc->dpy, win);

  560. 	resizedc(dc, mw, mh);

  561. 	drawmenu();

  562. }

  563. 

  564. void

  565. usage(void) {

  566. 	fputs("usage: dmenu [-b] [-f] [-i] [-l lines] [-p prompt] [-fn font]\n"

  567. 	      "             [-nb color] [-nf color] [-sb color] [-sf color] [-v]\n", stderr);

  568. 	exit(EXIT_FAILURE);

  569. }