Xinqi Bao's Git

projects / dmenu.git / blob


1fdf7f5a20158c733f6c2abc4b8cba1d973c1693
[dmenu.git] / dmenu.c
1 /* See LICENSE file for copyright and license details. */
2 #include <ctype.h>
3 #include <locale.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <unistd.h>
8 #include <X11/keysym.h>
9 #include <X11/Xlib.h>
10 #include <X11/Xutil.h>
11 #ifdef XINERAMA
12 #include <X11/extensions/Xinerama.h>
13 #endif
14 #include <draw.h>
15 #include "config.h"
16
17 #define INRECT(x,y,rx,ry,rw,rh) ((rx) < (x) && (x) < (rx)+(rw) && (ry) < (y) && (y) < (ry)+(rh))
18 #define MIN(a,b) ((a) < (b) ? (a) : (b))
19 #define MAX(a,b) ((a) > (b) ? (a) : (b))
20 #define IS_UTF8_1ST_CHAR(c) (((c) & 0xc0) == 0xc0 || ((c) & 0x80) == 0x00)
21
22 typedef struct Item Item;
23 struct Item {
24 char *text;
25 Item *next; /* traverses all items */
26 Item *left, *right; /* traverses items matching current search pattern */
27 };
28
29 static void appenditem(Item *i, Item **list, Item **last);
30 static void calcoffsetsh(void);
31 static void calcoffsetsv(void);
32 static char *cistrstr(const char *s, const char *sub);
33 static void cleanup(void);
34 static void drawitem(const char *s, unsigned long col[ColLast]);
35 static void drawmenu(void);
36 static void drawmenuh(void);
37 static void drawmenuv(void);
38 static void grabkeyboard(void);
39 static void keypress(XKeyEvent *e);
40 static void match(void);
41 static void readstdin(void);
42 static void run(void);
43 static void setup(void);
44
45 static char **argp = NULL;
46 static char *maxname = NULL;
47 static char *prompt;
48 static char text[4096];
49 static int promptw;
50 static int screen;
51 static size_t cur = 0;
52 static unsigned int cmdw = 0;
53 static unsigned int lines = 0;
54 static unsigned int numlockmask;
55 static unsigned int mw, mh;
56 static unsigned long normcol[ColLast];
57 static unsigned long selcol[ColLast];
58 static Bool topbar = True;
59 static DC dc;
60 static Display *dpy;
61 static Item *allitems = NULL; /* first of all items */
62 static Item *item = NULL; /* first of pattern matching items */
63 static Item *sel = NULL;
64 static Item *next = NULL;
65 static Item *prev = NULL;
66 static Item *curr = NULL;
67 static Window win, root;
68
69 static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
70 static char *(*fstrstr)(const char *, const char *) = strstr;
71 static void (*calcoffsets)(void) = calcoffsetsh;
72
73 void
74 appenditem(Item *i, Item **list, Item **last) {
75 if(!(*last))
76 *list = i;
77 else
78 (*last)->right = i;
79 i->left = *last;
80 i->right = NULL;
81 *last = i;
82 }
83
84 void
85 calcoffsetsh(void) {
86 unsigned int w, x;
87
88 w = promptw + cmdw + textw(&dc, "<") + textw(&dc, ">");
89 for(x = w, next = curr; next; next = next->right)
90 if((x += MIN(textw(&dc, next->text), mw / 3)) > mw)
91 break;
92 for(x = w, prev = curr; prev && prev->left; prev = prev->left)
93 if((x += MIN(textw(&dc, prev->left->text), mw / 3)) > mw)
94 break;
95 }
96
97 void
98 calcoffsetsv(void) {
99 unsigned int i;
100
101 next = prev = curr;
102 for(i = 0; i < lines && next; i++)
103 next = next->right;
104 mh = (dc.font.height + 2) * (i + 1);
105 for(i = 0; i < lines && prev && prev->left; i++)
106 prev = prev->left;
107 }
108
109 char *
110 cistrstr(const char *s, const char *sub) {
111 int c, csub;
112 unsigned int len;
113
114 if(!sub)
115 return (char *)s;
116 if((c = tolower(*sub++)) != '\0') {
117 len = strlen(sub);
118 do {
119 do {
120 if((csub = *s++) == '\0')
121 return NULL;
122 }
123 while(tolower(csub) != c);
124 }
125 while(strncasecmp(s, sub, len) != 0);
126 s--;
127 }
128 return (char *)s;
129 }
130
131 void
132 cleanup(void) {
133 Item *itm;
134
135 while(allitems) {
136 itm = allitems->next;
137 free(allitems->text);
138 free(allitems);
139 allitems = itm;
140 }
141 cleanupdraw(&dc);
142 XDestroyWindow(dpy, win);
143 XUngrabKeyboard(dpy, CurrentTime);
144 XCloseDisplay(dpy);
145 }
146
147 void
148 drawitem(const char *s, unsigned long col[ColLast]) {
149 const char *p;
150 unsigned int w = textnw(&dc, text, strlen(text));
151
152 drawbox(&dc, col);
153 drawtext(&dc, s, col);
154 for(p = fstrstr(s, text); *text && (p = fstrstr(p, text)); p++)
155 drawline(&dc, textnw(&dc, s, p-s) + dc.h/2 - 1, dc.h-2, w, 1, col);
156 }
157
158 void
159 drawmenu(void) {
160 dc.x = 0;
161 dc.y = 0;
162 dc.w = mw;
163 dc.h = mh;
164 drawbox(&dc, normcol);
165 dc.h = dc.font.height + 2;
166 dc.y = topbar ? 0 : mh - dc.h;
167 /* print prompt? */
168 if(prompt) {
169 dc.w = promptw;
170 drawbox(&dc, selcol);
171 drawtext(&dc, prompt, selcol);
172 dc.x += dc.w;
173 }
174 dc.w = mw - dc.x;
175 /* print command */
176 if(cmdw && item && lines == 0)
177 dc.w = cmdw;
178 drawtext(&dc, text, normcol);
179 drawline(&dc, textnw(&dc, text, cur) + dc.h/2 - 2, 2, 1, dc.h-4, normcol);
180 if(lines > 0)
181 drawmenuv();
182 else if(curr)
183 drawmenuh();
184 commitdraw(&dc, win);
185 }
186
187 void
188 drawmenuh(void) {
189 Item *i;
190
191 dc.x += cmdw;
192 dc.w = textw(&dc, "<");
193 drawtext(&dc, curr->left ? "<" : NULL, normcol);
194 dc.x += dc.w;
195 for(i = curr; i != next; i = i->right) {
196 dc.w = MIN(textw(&dc, i->text), mw / 3);
197 drawitem(i->text, (sel == i) ? selcol : normcol);
198 dc.x += dc.w;
199 }
200 dc.w = textw(&dc, ">");
201 dc.x = mw - dc.w;
202 drawtext(&dc, next ? ">" : NULL, normcol);
203 }
204
205 void
206 drawmenuv(void) {
207 Item *i;
208 XWindowAttributes wa;
209
210 dc.y = topbar ? dc.h : 0;
211 dc.w = mw - dc.x;
212 for(i = curr; i != next; i = i->right) {
213 drawitem(i->text, (sel == i) ? selcol : normcol);
214 dc.y += dc.h;
215 }
216 if(!XGetWindowAttributes(dpy, win, &wa))
217 eprint("cannot get window attributes");
218 XMoveResizeWindow(dpy, win, wa.x, wa.y + (topbar ? 0 : wa.height - mh), mw, mh);
219 }
220
221 void
222 grabkeyboard(void) {
223 unsigned int n;
224
225 for(n = 0; n < 1000; n++) {
226 if(!XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime))
227 return;
228 usleep(1000);
229 }
230 exit(EXIT_FAILURE);
231 }
232
233 void
234 keypress(XKeyEvent *e) {
235 char buf[sizeof text];
236 int num;
237 unsigned int i, len;
238 KeySym ksym;
239
240 len = strlen(text);
241 num = XLookupString(e, buf, sizeof buf, &ksym, NULL);
242 if(ksym == XK_KP_Enter)
243 ksym = XK_Return;
244 else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
245 ksym = (ksym - XK_KP_0) + XK_0;
246 else if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
247 || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
248 || IsPrivateKeypadKey(ksym))
249 return;
250 /* first check if a control mask is omitted */
251 if(e->state & ControlMask) {
252 switch(tolower(ksym)) {
253 default:
254 return;
255 case XK_a:
256 ksym = XK_Home;
257 break;
258 case XK_b:
259 ksym = XK_Left;
260 break;
261 case XK_c:
262 ksym = XK_Escape;
263 break;
264 case XK_e:
265 ksym = XK_End;
266 break;
267 case XK_f:
268 ksym = XK_Right;
269 break;
270 case XK_h:
271 ksym = XK_BackSpace;
272 break;
273 case XK_i:
274 ksym = XK_Tab;
275 break;
276 case XK_j:
277 case XK_m:
278 ksym = XK_Return;
279 break;
280 case XK_k:
281 text[cur] = '\0';
282 break;
283 case XK_n:
284 ksym = XK_Down;
285 break;
286 case XK_p:
287 ksym = XK_Up;
288 break;
289 case XK_u:
290 memmove(text, text + cur, sizeof text - cur + 1);
291 cur = 0;
292 match();
293 break;
294 case XK_w:
295 if(cur == 0)
296 return;
297 i = cur;
298 while(i-- > 0 && text[i] == ' ');
299 while(i-- > 0 && text[i] != ' ');
300 memmove(text + i + 1, text + cur, sizeof text - cur + 1);
301 cur = i + 1;
302 match();
303 break;
304 case XK_y:
305 {
306 FILE *fp;
307 char *s;
308 if(!(fp = fopen("sselp", "r")))
309 eprint("cannot popen sselp\n");
310 s = fgets(buf, sizeof buf, fp);
311 fclose(fp);
312 if(!s)
313 return;
314 }
315 num = strlen(buf);
316 if(num && buf[num-1] == '\n')
317 buf[--num] = '\0';
318 break;
319 }
320 }
321 switch(ksym) {
322 default:
323 num = MIN(num, sizeof text);
324 if(num && !iscntrl((int) buf[0])) {
325 memmove(text + cur + num, text + cur, sizeof text - cur - num);
326 memcpy(text + cur, buf, num);
327 cur += num;
328 match();
329 }
330 break;
331 case XK_BackSpace:
332 if(cur == 0)
333 return;
334 for(i = 1; len - i > 0 && !IS_UTF8_1ST_CHAR(text[cur - i]); i++);
335 memmove(text + cur - i, text + cur, sizeof text - cur + i);
336 cur -= i;
337 match();
338 break;
339 case XK_Delete:
340 if(cur == len)
341 return;
342 for(i = 1; cur + i < len && !IS_UTF8_1ST_CHAR(text[cur + i]); i++);
343 memmove(text + cur, text + cur + i, sizeof text - cur);
344 match();
345 break;
346 case XK_End:
347 if(cur < len) {
348 cur = len;
349 break;
350 }
351 while(next) {
352 sel = curr = next;
353 calcoffsets();
354 }
355 while(sel && sel->right)
356 sel = sel->right;
357 break;
358 case XK_Escape:
359 exit(EXIT_FAILURE);
360 case XK_Home:
361 if(sel == item) {
362 cur = 0;
363 break;
364 }
365 sel = curr = item;
366 calcoffsets();
367 break;
368 case XK_Left:
369 if(cur > 0 && (!sel || !sel->left || lines > 0)) {
370 while(cur-- > 0 && !IS_UTF8_1ST_CHAR(text[cur]));
371 break;
372 }
373 if(lines > 0)
374 return;
375 case XK_Up:
376 if(!sel || !sel->left)
377 return;
378 sel = sel->left;
379 if(sel->right == curr) {
380 curr = prev;
381 calcoffsets();
382 }
383 break;
384 case XK_Next:
385 if(!next)
386 return;
387 sel = curr = next;
388 calcoffsets();
389 break;
390 case XK_Prior:
391 if(!prev)
392 return;
393 sel = curr = prev;
394 calcoffsets();
395 break;
396 case XK_Return:
397 fprintf(stdout, "%s", ((e->state & ShiftMask) || sel) ? sel->text : text);
398 fflush(stdout);
399 exit(EXIT_SUCCESS);
400 case XK_Right:
401 if(cur < len) {
402 while(cur++ < len && !IS_UTF8_1ST_CHAR(text[cur]));
403 break;
404 }
405 if(lines > 0)
406 return;
407 case XK_Down:
408 if(!sel || !sel->right)
409 return;
410 sel = sel->right;
411 if(sel == next) {
412 curr = next;
413 calcoffsets();
414 }
415 break;
416 case XK_Tab:
417 if(!sel)
418 return;
419 strncpy(text, sel->text, sizeof text);
420 cur = strlen(text);
421 match();
422 break;
423 }
424 drawmenu();
425 }
426
427 void
428 match(void) {
429 unsigned int len;
430 Item *i, *itemend, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend;
431
432 len = strlen(text);
433 item = lexact = lprefix = lsubstr = itemend = exactend = prefixend = substrend = NULL;
434 for(i = allitems; i; i = i->next)
435 if(!fstrncmp(text, i->text, len + 1))
436 appenditem(i, &lexact, &exactend);
437 else if(!fstrncmp(text, i->text, len))
438 appenditem(i, &lprefix, &prefixend);
439 else if(fstrstr(i->text, text))
440 appenditem(i, &lsubstr, &substrend);
441 if(lexact) {
442 item = lexact;
443 itemend = exactend;
444 }
445 if(lprefix) {
446 if(itemend) {
447 itemend->right = lprefix;
448 lprefix->left = itemend;
449 }
450 else
451 item = lprefix;
452 itemend = prefixend;
453 }
454 if(lsubstr) {
455 if(itemend) {
456 itemend->right = lsubstr;
457 lsubstr->left = itemend;
458 }
459 else
460 item = lsubstr;
461 }
462 curr = prev = next = sel = item;
463 calcoffsets();
464 }
465
466 void
467 readstdin(void) {
468 char *p, buf[sizeof text];
469 unsigned int len = 0, max = 0;
470 Item *i, *new;
471
472 i = NULL;
473 while(fgets(buf, sizeof buf, stdin)) {
474 len = strlen(buf);
475 if(buf[len-1] == '\n')
476 buf[--len] = '\0';
477 if(!(p = strdup(buf)))
478 eprint("cannot strdup %u bytes\n", len);
479 if((max = MAX(max, len)) == len)
480 maxname = p;
481 if(!(new = malloc(sizeof *new)))
482 eprint("cannot malloc %u bytes\n", sizeof *new);
483 new->next = new->left = new->right = NULL;
484 new->text = p;
485 if(!i)
486 allitems = new;
487 else
488 i->next = new;
489 i = new;
490 }
491 }
492
493 void
494 run(void) {
495 XEvent ev;
496
497 XSync(dpy, False);
498 while(!XNextEvent(dpy, &ev))
499 switch(ev.type) {
500 case Expose:
501 if(ev.xexpose.count == 0)
502 drawmenu();
503 break;
504 case KeyPress:
505 keypress(&ev.xkey);
506 break;
507 case VisibilityNotify:
508 if(ev.xvisibility.state != VisibilityUnobscured)
509 XRaiseWindow(dpy, win);
510 break;
511 }
512 exit(EXIT_FAILURE);
513 }
514
515 void
516 setup(void) {
517 int i, j, x, y;
518 #if XINERAMA
519 int n;
520 XineramaScreenInfo *info = NULL;
521 #endif
522 XModifierKeymap *modmap;
523 XSetWindowAttributes wa;
524
525 /* init modifier map */
526 modmap = XGetModifierMapping(dpy);
527 for(i = 0; i < 8; i++)
528 for(j = 0; j < modmap->max_keypermod; j++) {
529 if(modmap->modifiermap[i * modmap->max_keypermod + j]
530 == XKeysymToKeycode(dpy, XK_Num_Lock))
531 numlockmask = (1 << i);
532 }
533 XFreeModifiermap(modmap);
534
535 dc.dpy = dpy;
536 normcol[ColBG] = getcolor(&dc, normbgcolor);
537 normcol[ColFG] = getcolor(&dc, normfgcolor);
538 selcol[ColBG] = getcolor(&dc, selbgcolor);
539 selcol[ColFG] = getcolor(&dc, selfgcolor);
540 initfont(&dc, font);
541
542 /* input window */
543 wa.override_redirect = True;
544 wa.background_pixmap = ParentRelative;
545 wa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;
546
547 /* input window geometry */
548 mh = (dc.font.height + 2) * (lines + 1);
549 #if XINERAMA
550 if(XineramaIsActive(dpy) && (info = XineramaQueryScreens(dpy, &n))) {
551 i = 0;
552 if(n > 1) {
553 int di;
554 unsigned int dui;
555 Window dummy;
556 if(XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui))
557 for(i = 0; i < n; i++)
558 if(INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))
559 break;
560 }
561 x = info[i].x_org;
562 y = topbar ? info[i].y_org : info[i].y_org + info[i].height - mh;
563 mw = info[i].width;
564 XFree(info);
565 }
566 else
567 #endif
568 {
569 x = 0;
570 y = topbar ? 0 : DisplayHeight(dpy, screen) - mh;
571 mw = DisplayWidth(dpy, screen);
572 }
573
574 win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
575 DefaultDepth(dpy, screen), CopyFromParent,
576 DefaultVisual(dpy, screen),
577 CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
578
579 setupdraw(&dc, win);
580 if(prompt)
581 promptw = MIN(textw(&dc, prompt), mw / 5);
582 XMapRaised(dpy, win);
583 }
584
585 int
586 main(int argc, char *argv[]) {
587 unsigned int i;
588
589 /* command line args */
590 progname = "dmenu";
591 for(i = 1; i < argc; i++)
592 if(!strcmp(argv[i], "-i")) {
593 fstrncmp = strncasecmp;
594 fstrstr = cistrstr;
595 }
596 else if(!strcmp(argv[i], "-b"))
597 topbar = False;
598 else if(!strcmp(argv[i], "-l")) {
599 if(++i < argc) lines = atoi(argv[i]);
600 if(lines > 0)
601 calcoffsets = calcoffsetsv;
602 }
603 else if(!strcmp(argv[i], "-fn")) {
604 if(++i < argc) font = argv[i];
605 }
606 else if(!strcmp(argv[i], "-nb")) {
607 if(++i < argc) normbgcolor = argv[i];
608 }
609 else if(!strcmp(argv[i], "-nf")) {
610 if(++i < argc) normfgcolor = argv[i];
611 }
612 else if(!strcmp(argv[i], "-p")) {
613 if(++i < argc) prompt = argv[i];
614 }
615 else if(!strcmp(argv[i], "-sb")) {
616 if(++i < argc) selbgcolor = argv[i];
617 }
618 else if(!strcmp(argv[i], "-sf")) {
619 if(++i < argc) selfgcolor = argv[i];
620 }
621 else if(!strcmp(argv[i], "-v")) {
622 printf("dmenu-"VERSION", © 2006-2010 dmenu engineers, see LICENSE for details\n");
623 exit(EXIT_SUCCESS);
624 }
625 else {
626 fputs("usage: dmenu [-i] [-b] [-l <lines>] [-fn <font>] [-nb <color>]\n"
627 " [-nf <color>] [-p <prompt>] [-sb <color>] [-sf <color>] [-v]\n", stderr);
628 exit(EXIT_FAILURE);
629 }
630 if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
631 fprintf(stderr, "dmenu: warning: no locale support\n");
632 if(!(dpy = XOpenDisplay(NULL)))
633 eprint("cannot open display\n");
634 if(atexit(&cleanup) != 0)
635 eprint("cannot register cleanup\n");
636 screen = DefaultScreen(dpy);
637 root = RootWindow(dpy, screen);
638 if(!(argp = malloc(sizeof *argp * (argc+2))))
639 eprint("cannot malloc %u bytes\n", sizeof *argp * (argc+2));
640 memcpy(argp + 2, argv + 1, sizeof *argp * argc);
641
642 readstdin();
643 grabkeyboard();
644 setup();
645 if(maxname)
646 cmdw = MIN(textw(&dc, maxname), mw / 3);
647 match();
648 run();
649 return 0;
650 }