rinri
/
dmenu-rinri
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
My dmenu build
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
397 Commits
1 Branch
1.2 MiB
 
 
 
 
 
 
Tag: 26236a4900
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 26236a4900
${ noResults }
dmenu-rinri/dmenu.c

549 linhas
12 KiB
Original Anotar Histórico 

  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 <unistd.h>

  7. #include <X11/Xlib.h>

  8. #include <X11/Xatom.h>

  9. #include <X11/Xutil.h>

  10. #ifdef XINERAMA

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

  12. #endif

  13. #include "draw.h"

  14. 

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

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

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

  18. 

  19. typedef struct Item Item;

  20. struct Item {

  21. 	char *text;

  22. 	Item *left, *right;

  23. };

  24. 

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

  26. static void calcoffsets(void);

  27. static void drawmenu(void);

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

  29. static void grabkeyboard(void);

  30. static void insert(const char *s, ssize_t n);

  31. static void keypress(XKeyEvent *ev);

  32. static void match(void);

  33. static size_t nextrune(int incr);

  34. static void paste(void);

  35. static void readstdin(void);

  36. static void run(void);

  37. static void setup(void);

  38. 

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

  40. static int bh, mw, mh;

  41. static int inputw = 0;

  42. static int lines = 0;

  43. static int monitor = -1;

  44. static int promptw;

  45. static size_t cursor = 0;

  46. static const char *font = NULL;

  47. static const char *prompt = NULL;

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

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

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

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

  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 root, win;

  61. 

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

  63. 

  64. int

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

  66. 	Bool fast = False;

  67. 	int i;

  68. 

  69. 	progname = "dmenu";

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

  71. 		/* single flags */

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

  73. 			fputs("dmenu-"VERSION", © 2006-2011 dmenu engineers, see LICENSE for details\n", stdout);

  74. 			exit(EXIT_SUCCESS);

  75. 		}

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

  77. 			topbar = False;

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

  79. 			fast = True;

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

  81. 			fstrncmp = strncasecmp;

  82. 		else if(i == argc-1)

  83. 			goto usage;

  84. 		/* double flags */

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

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

  87. 		else if(!strcmp(argv[i], "-m"))

  88. 			monitor = atoi(argv[++i]);

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

  90. 			prompt = argv[++i];

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

  92. 			font = argv[++i];

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

  94. 			normbgcolor = argv[++i];

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

  96. 			normfgcolor = argv[++i];

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

  98. 			selbgcolor = argv[++i];

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

  100. 			selfgcolor = argv[++i];

  101. 		else

  102. 			goto usage;

  103. 

  104. 	dc = initdc();

  105. 	initfont(dc, font);

  106. 

  107. 	if(fast) {

  108. 		setup();

  109. 		readstdin();

  110. 	}

  111. 	else {

  112. 		readstdin();

  113. 		setup();

  114. 	}

  115. 	match();

  116. 	run();

  117. 	return EXIT_FAILURE;

  118. 

  119. usage:

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

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

  122. 	return EXIT_FAILURE;

  123. }

  124. 

  125. void

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

  127. 	if(!*last)

  128. 		*list = item;

  129. 	else

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

  131. 	item->left = *last;

  132. 	item->right = NULL;

  133. 	*last = item;

  134. }

  135. 

  136. void

  137. calcoffsets(void) {

  138. 	unsigned int i, n;

  139. 

  140. 	if(lines > 0)

  141. 		n = lines * bh;

  142. 	else

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

  144. 

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

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

  147. 			break;

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

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

  150. 			break;

  151. }

  152. 

  153. void

  154. drawmenu(void) {

  155. 	int curpos;

  156. 	Item *item;

  157. 

  158. 	dc->x = 0;

  159. 	dc->y = 0;

  160. 	dc->h = bh;

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

  162. 

  163. 	if(prompt) {

  164. 		dc->w = promptw;

  165. 		drawtext(dc, prompt, selcol);

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

  167. 	}

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

  169. 	drawtext(dc, text, normcol);

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

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

  172. 

  173. 	if(lines > 0) {

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

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

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

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

  178. 		}

  179. 	}

  180. 	else if(matches) {

  181. 		dc->x += inputw;

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

  183. 		if(curr->left)

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

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

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

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

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

  189. 		}

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

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

  192. 		if(next)

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

  194. 	}

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

  196. }

  197. 

  198. char *

  199. fstrstr(const char *s, const char *sub) {

  200. 	size_t len;

  201. 

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

  203. 		if(!fstrncmp(s, sub, len))

  204. 			return (char *)s;

  205. 	return NULL;

  206. }

  207. 

  208. void

  209. grabkeyboard(void) {

  210. 	int i;

  211. 

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

  213. 		if(!XGrabKeyboard(dc->dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime))

  214. 			return;

  215. 		usleep(1000);

  216. 	}

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

  218. }

  219. 

  220. void

  221. insert(const char *s, ssize_t n) {

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

  223. 		return;

  224. 	memmove(text + cursor + n, text + cursor, sizeof text - cursor - MAX(n, 0));

  225. 	if(n > 0)

  226. 		memcpy(text + cursor, s, n);

  227. 	cursor += n;

  228. 	match();

  229. }

  230. 

  231. void

  232. keypress(XKeyEvent *ev) {

  233. 	char buf[32];

  234. 	size_t len;

  235. 	KeySym ksym;

  236. 

  237. 	len = strlen(text);

  238. 	XLookupString(ev, buf, sizeof buf, &ksym, NULL);

  239. 	if(ev->state & ControlMask)

  240. 		switch(tolower(ksym)) {

  241. 		default:

  242. 			return;

  243. 		case XK_a:

  244. 			ksym = XK_Home;

  245. 			break;

  246. 		case XK_b:

  247. 			ksym = XK_Left;

  248. 			break;

  249. 		case XK_c:

  250. 			ksym = XK_Escape;

  251. 			break;

  252. 		case XK_d:

  253. 			ksym = XK_Delete;

  254. 			break;

  255. 		case XK_e:

  256. 			ksym = XK_End;

  257. 			break;

  258. 		case XK_f:

  259. 			ksym = XK_Right;

  260. 			break;

  261. 		case XK_h:

  262. 			ksym = XK_BackSpace;

  263. 			break;

  264. 		case XK_i:

  265. 			ksym = XK_Tab;

  266. 			break;

  267. 		case XK_j:

  268. 			ksym = XK_Return;

  269. 			break;

  270. 		case XK_k:  /* delete right */

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

  272. 			match();

  273. 			break;

  274. 		case XK_n:

  275. 			ksym = XK_Down;

  276. 			break;

  277. 		case XK_p:

  278. 			ksym = XK_Up;

  279. 			break;

  280. 		case XK_u:  /* delete left */

  281. 			insert(NULL, 0 - cursor);

  282. 			break;

  283. 		case XK_w:  /* delete word */

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

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

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

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

  288. 			break;

  289. 		case XK_y:  /* paste selection */

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

  291. 			return;

  292. 		}

  293. 	switch(ksym) {

  294. 	default:

  295. 		if(!iscntrl(*buf))

  296. 			insert(buf, strlen(buf));

  297. 		break;

  298. 	case XK_Delete:

  299. 		if(cursor == len)

  300. 			return;

  301. 		cursor = nextrune(+1);

  302. 	case XK_BackSpace:

  303. 		if(cursor > 0)

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

  305. 		break;

  306. 	case XK_End:

  307. 		if(cursor < len) {

  308. 			cursor = len;

  309. 			break;

  310. 		}

  311. 		if(next) {

  312. 			curr = matchend;

  313. 			calcoffsets();

  314. 			curr = prev;

  315. 			calcoffsets();

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

  317. 				calcoffsets();

  318. 		}

  319. 		sel = matchend;

  320. 		break;

  321. 	case XK_Escape:

  322. 		exit(EXIT_FAILURE);

  323. 	case XK_Home:

  324. 		if(sel == matches) {

  325. 			cursor = 0;

  326. 			break;

  327. 		}

  328. 		sel = curr = matches;

  329. 		calcoffsets();

  330. 		break;

  331. 	case XK_Left:

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

  333. 			cursor = nextrune(-1);

  334. 			break;

  335. 		}

  336. 		else if(lines > 0)

  337. 			return;

  338. 	case XK_Up:

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

  340. 			curr = prev;

  341. 			calcoffsets();

  342. 		}

  343. 		break;

  344. 	case XK_Next:

  345. 		if(!next)

  346. 			return;

  347. 		sel = curr = next;

  348. 		calcoffsets();

  349. 		break;

  350. 	case XK_Prior:

  351. 		if(!prev)

  352. 			return;

  353. 		sel = curr = prev;

  354. 		calcoffsets();

  355. 		break;

  356. 	case XK_Return:

  357. 	case XK_KP_Enter:

  358. 		fputs((sel && !(ev->state & ShiftMask)) ? sel->text : text, stdout);

  359. 		exit(EXIT_SUCCESS);

  360. 	case XK_Right:

  361. 		if(cursor < len) {

  362. 			cursor = nextrune(+1);

  363. 			break;

  364. 		}

  365. 		else if(lines > 0)

  366. 			return;

  367. 	case XK_Down:

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

  369. 			curr = next;

  370. 			calcoffsets();

  371. 		}

  372. 		break;

  373. 	case XK_Tab:

  374. 		if(!sel)

  375. 			return;

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

  377. 		cursor = strlen(text);

  378. 		match();

  379. 		break;

  380. 	}

  381. 	drawmenu();

  382. }

  383. 

  384. void

  385. match(void) {

  386. 	size_t len;

  387. 	Item *item, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend;

  388. 

  389. 	len = strlen(text);

  390. 	matches = lexact = lprefix = lsubstr = matchend = exactend = prefixend = substrend = NULL;

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

  392. 		if(!fstrncmp(text, item->text, len + 1))

  393. 			appenditem(item, &lexact, &exactend);

  394. 		else if(!fstrncmp(text, item->text, len))

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

  396. 		else if(fstrstr(item->text, text))

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

  398. 

  399. 	if(lexact) {

  400. 		matches = lexact;

  401. 		matchend = exactend;

  402. 	}

  403. 	if(lprefix) {

  404. 		if(matchend) {

  405. 			matchend->right = lprefix;

  406. 			lprefix->left = matchend;

  407. 		}

  408. 		else

  409. 			matches = lprefix;

  410. 		matchend = prefixend;

  411. 	}

  412. 	if(lsubstr) {

  413. 		if(matchend) {

  414. 			matchend->right = lsubstr;

  415. 			lsubstr->left = matchend;

  416. 		}

  417. 		else

  418. 			matches = lsubstr;

  419. 		matchend = substrend;

  420. 	}

  421. 	curr = sel = matches;

  422. 	calcoffsets();

  423. }

  424. 

  425. size_t

  426. nextrune(int incr) {

  427. 	size_t n, len;

  428. 

  429. 	len = strlen(text);

  430. 	for(n = cursor + incr; n >= 0 && n < len && (text[n] & 0xc0) == 0x80; n += incr);

  431. 	return n;

  432. }

  433. 

  434. void

  435. paste(void) {

  436. 	char *p, *q;

  437. 	int di;

  438. 	unsigned long dl;

  439. 	Atom da;

  440. 

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

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

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

  444. 	XFree(p);

  445. 	drawmenu();

  446. }

  447. 

  448. void

  449. readstdin(void) {

  450. 	char buf[sizeof text], *p;

  451. 	size_t i, size = 0;

  452. 

  453. 	for(i = 0; fgets(buf, sizeof buf, stdin); items[++i].text = NULL) {

  454. 		if(i+1 == size / sizeof *items || !items)

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

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

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

  458. 			*p = '\0';

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

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

  461. 		inputw = MAX(inputw, textw(dc, items[i].text));

  462. 	}

  463. }

  464. 

  465. void

  466. run(void) {

  467. 	XEvent ev;

  468. 

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

  470. 		switch(ev.type) {

  471. 		case Expose:

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

  473. 				drawmenu();

  474. 			break;

  475. 		case KeyPress:

  476. 			keypress(&ev.xkey);

  477. 			break;

  478. 		case SelectionNotify:

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

  480. 				paste();

  481. 			break;

  482. 		case VisibilityNotify:

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

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

  485. 			break;

  486. 		}

  487. }

  488. 

  489. void

  490. setup(void) {

  491. 	int x, y, screen;

  492. 	XSetWindowAttributes wa;

  493. #ifdef XINERAMA

  494. 	int n;

  495. 	XineramaScreenInfo *info;

  496. #endif

  497. 

  498. 	screen = DefaultScreen(dc->dpy);

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

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

  501. 

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

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

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

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

  506. 

  507. 	/* menu geometry */

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

  509. 	lines = MAX(lines, 0);

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

  511. #ifdef XINERAMA

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

  513. 		int i, di;

  514. 		unsigned int du;

  515. 		Window dw;

  516. 

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

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

  519. 			if((monitor == info[i].screen_number)

  520. 			|| (monitor < 0 && INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height)))

  521. 				break;

  522. 		x = info[i].x_org;

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

  524. 		mw = info[i].width;

  525. 		XFree(info);

  526. 	}

  527. 	else

  528. #endif

  529. 	{

  530. 		x = 0;

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

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

  533. 	}

  534. 	/* menu window */

  535. 	wa.override_redirect = True;

  536. 	wa.background_pixmap = ParentRelative;

  537. 	wa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;

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

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

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

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

  542. 

  543. 	grabkeyboard();

  544. 	resizedc(dc, mw, mh);

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

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

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

  548. }