Xinqi Bao's Git

projects / dmenu.git / blob


bc69bcf704d90311e35d3ce7f482fe35de16b412
[dmenu.git] / dmenu.c
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 char *text;
38 Item *next; /* traverses all items */
39 Item *left, *right; /* traverses items matching current search pattern */
40 };
41
42 /* forward declarations */
43 void appenditem(Item *i, Item **list, Item **last);
44 void calcoffsets(void);
45 char *cistrstr(const char *s, const char *sub);
46 void cleanup(void);
47 void drawmenu(void);
48 void drawtext(const char *text, unsigned long col[ColLast]);
49 void *emalloc(unsigned int size);
50 void eprint(const char *errstr, ...);
51 char *estrdup(const char *str);
52 unsigned long getcolor(const char *colstr);
53 Bool grabkeyboard(void);
54 void initfont(const char *fontstr);
55 void kpress(XKeyEvent * e);
56 void match(char *pattern);
57 void readstdin(void);
58 void run(void);
59 void setup(int x, int y, int w);
60 unsigned int textnw(const char *text, unsigned int len);
61 unsigned int textw(const char *text);
62
63 #include "config.h"
64
65 /* variables */
66 char *font = FONT;
67 char *maxname = NULL;
68 char *normbg = NORMBGCOLOR;
69 char *normfg = NORMFGCOLOR;
70 char *prompt = NULL;
71 char *selbg = SELBGCOLOR;
72 char *selfg = SELFGCOLOR;
73 char text[4096];
74 int screen;
75 int ret = 0;
76 unsigned int cmdw = 0;
77 unsigned int mw, mh;
78 unsigned int promptw = 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 int (*fstrncmp)(const char *, const char *, size_t n) = strncmp;
91 char *(*fstrstr)(const char *, const char *) = strstr;
92
93 void
94 appenditem(Item *i, Item **list, Item **last) {
95 if(!(*last))
96 *list = i;
97 else
98 (*last)->right = i;
99 i->left = *last;
100 i->right = NULL;
101 *last = i;
102 }
103
104 void
105 calcoffsets(void) {
106 unsigned int tw, w;
107
108 if(!curr)
109 return;
110 w = promptw + cmdw + 2 * SPACE;
111 for(next = curr; next; next=next->right) {
112 tw = textw(next->text);
113 if(tw > mw / 3)
114 tw = mw / 3;
115 w += tw;
116 if(w > mw)
117 break;
118 }
119 w = promptw + cmdw + 2 * SPACE;
120 for(prev = curr; prev && prev->left; prev=prev->left) {
121 tw = textw(prev->left->text);
122 if(tw > mw / 3)
123 tw = mw / 3;
124 w += tw;
125 if(w > mw)
126 break;
127 }
128 }
129
130 char *
131 cistrstr(const char *s, const char *sub) {
132 int c, csub;
133 unsigned int len;
134
135 if(!sub)
136 return (char *)s;
137 if((c = *sub++) != 0) {
138 c = tolower(c);
139 len = strlen(sub);
140 do {
141 do {
142 if((csub = *s++) == 0)
143 return (NULL);
144 }
145 while(tolower(csub) != c);
146 }
147 while(strncasecmp(s, sub, len) != 0);
148 s--;
149 }
150 return (char *)s;
151 }
152
153 void
154 cleanup(void) {
155 Item *itm;
156
157 while(allitems) {
158 itm = allitems->next;
159 free(allitems->text);
160 free(allitems);
161 allitems = itm;
162 }
163 if(dc.font.set)
164 XFreeFontSet(dpy, dc.font.set);
165 else
166 XFreeFont(dpy, dc.font.xfont);
167 XFreePixmap(dpy, dc.drawable);
168 XFreeGC(dpy, dc.gc);
169 XDestroyWindow(dpy, win);
170 XUngrabKeyboard(dpy, CurrentTime);
171 }
172
173 void
174 drawmenu(void) {
175 Item *i;
176
177 dc.x = 0;
178 dc.y = 0;
179 dc.w = mw;
180 dc.h = mh;
181 drawtext(NULL, dc.norm);
182 /* print prompt? */
183 if(promptw) {
184 dc.w = promptw;
185 drawtext(prompt, dc.sel);
186 }
187 dc.x += promptw;
188 dc.w = mw - promptw;
189 /* print command */
190 if(cmdw && item)
191 dc.w = cmdw;
192 drawtext(text[0] ? text : NULL, dc.norm);
193 dc.x += cmdw;
194 if(curr) {
195 dc.w = SPACE;
196 drawtext((curr && curr->left) ? "<" : NULL, dc.norm);
197 dc.x += dc.w;
198 /* determine maximum items */
199 for(i = curr; i != next; i=i->right) {
200 dc.w = textw(i->text);
201 if(dc.w > mw / 3)
202 dc.w = mw / 3;
203 drawtext(i->text, (sel == i) ? dc.sel : dc.norm);
204 dc.x += dc.w;
205 }
206 dc.x = mw - SPACE;
207 dc.w = SPACE;
208 drawtext(next ? ">" : NULL, dc.norm);
209 }
210 XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, mw, mh, 0, 0);
211 XFlush(dpy);
212 }
213
214 void
215 drawtext(const char *text, unsigned long col[ColLast]) {
216 int x, y, w, h;
217 static char buf[256];
218 unsigned int len, olen;
219 XRectangle r = { dc.x, dc.y, dc.w, dc.h };
220
221 XSetForeground(dpy, dc.gc, col[ColBG]);
222 XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
223 if(!text)
224 return;
225 w = 0;
226 olen = len = strlen(text);
227 if(len >= sizeof buf)
228 len = sizeof buf - 1;
229 memcpy(buf, text, len);
230 buf[len] = 0;
231 h = dc.font.ascent + dc.font.descent;
232 y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
233 x = dc.x + (h / 2);
234 /* shorten text if necessary */
235 while(len && (w = textnw(buf, len)) > dc.w - h)
236 buf[--len] = 0;
237 if(len < olen) {
238 if(len > 1)
239 buf[len - 1] = '.';
240 if(len > 2)
241 buf[len - 2] = '.';
242 if(len > 3)
243 buf[len - 3] = '.';
244 }
245 if(w > dc.w)
246 return; /* too long */
247 XSetForeground(dpy, dc.gc, col[ColFG]);
248 if(dc.font.set)
249 XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
250 else
251 XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
252 }
253
254 void *
255 emalloc(unsigned int size) {
256 void *res = malloc(size);
257
258 if(!res)
259 eprint("fatal: could not malloc() %u bytes\n", size);
260 return res;
261 }
262
263 void
264 eprint(const char *errstr, ...) {
265 va_list ap;
266
267 va_start(ap, errstr);
268 vfprintf(stderr, errstr, ap);
269 va_end(ap);
270 exit(EXIT_FAILURE);
271 }
272
273 char *
274 estrdup(const char *str) {
275 void *res = strdup(str);
276
277 if(!res)
278 eprint("fatal: could not malloc() %u bytes\n", strlen(str));
279 return res;
280 }
281
282 unsigned long
283 getcolor(const char *colstr) {
284 Colormap cmap = DefaultColormap(dpy, screen);
285 XColor color;
286
287 if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
288 eprint("error, cannot allocate color '%s'\n", colstr);
289 return color.pixel;
290 }
291
292 Bool
293 grabkeyboard(void) {
294 unsigned int len;
295
296 for(len = 1000; len; len--) {
297 if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
298 == GrabSuccess)
299 break;
300 usleep(1000);
301 }
302 return len > 0;
303 }
304
305 void
306 initfont(const char *fontstr) {
307 char *def, **missing;
308 int i, n;
309
310 if(!fontstr || fontstr[0] == '\0')
311 eprint("error, cannot load font: '%s'\n", fontstr);
312 missing = NULL;
313 if(dc.font.set)
314 XFreeFontSet(dpy, dc.font.set);
315 dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
316 if(missing)
317 XFreeStringList(missing);
318 if(dc.font.set) {
319 XFontSetExtents *font_extents;
320 XFontStruct **xfonts;
321 char **font_names;
322 dc.font.ascent = dc.font.descent = 0;
323 font_extents = XExtentsOfFontSet(dc.font.set);
324 n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
325 for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
326 if(dc.font.ascent < (*xfonts)->ascent)
327 dc.font.ascent = (*xfonts)->ascent;
328 if(dc.font.descent < (*xfonts)->descent)
329 dc.font.descent = (*xfonts)->descent;
330 xfonts++;
331 }
332 }
333 else {
334 if(dc.font.xfont)
335 XFreeFont(dpy, dc.font.xfont);
336 dc.font.xfont = NULL;
337 if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr))
338 && !(dc.font.xfont = XLoadQueryFont(dpy, "fixed")))
339 eprint("error, cannot load font: '%s'\n", fontstr);
340 dc.font.ascent = dc.font.xfont->ascent;
341 dc.font.descent = dc.font.xfont->descent;
342 }
343 dc.font.height = dc.font.ascent + dc.font.descent;
344 }
345
346 void
347 kpress(XKeyEvent * e) {
348 char buf[32];
349 int i, num;
350 unsigned int len;
351 KeySym ksym;
352
353 len = strlen(text);
354 buf[0] = 0;
355 num = XLookupString(e, buf, sizeof buf, &ksym, 0);
356 if(IsKeypadKey(ksym)) {
357 if(ksym == XK_KP_Enter) {
358 ksym = XK_Return;
359 } else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) {
360 ksym = (ksym - XK_KP_0) + XK_0;
361 }
362 }
363 if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
364 || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
365 || IsPrivateKeypadKey(ksym))
366 return;
367 /* first check if a control mask is omitted */
368 if(e->state & ControlMask) {
369 switch (ksym) {
370 default: /* ignore other control sequences */
371 return;
372 case XK_bracketleft:
373 ksym = XK_Escape;
374 break;
375 case XK_h:
376 case XK_H:
377 ksym = XK_BackSpace;
378 break;
379 case XK_i:
380 case XK_I:
381 ksym = XK_Tab;
382 break;
383 case XK_j:
384 case XK_J:
385 ksym = XK_Return;
386 break;
387 case XK_u:
388 case XK_U:
389 text[0] = 0;
390 match(text);
391 drawmenu();
392 return;
393 case XK_w:
394 case XK_W:
395 if(len) {
396 i = len - 1;
397 while(i >= 0 && text[i] == ' ')
398 text[i--] = 0;
399 while(i >= 0 && text[i] != ' ')
400 text[i--] = 0;
401 match(text);
402 drawmenu();
403 }
404 return;
405 }
406 }
407 if(CLEANMASK(e->state) & Mod1Mask) {
408 switch(ksym) {
409 default: return;
410 case XK_h:
411 ksym = XK_Left;
412 break;
413 case XK_l:
414 ksym = XK_Right;
415 break;
416 case XK_j:
417 ksym = XK_Next;
418 break;
419 case XK_k:
420 ksym = XK_Prior;
421 break;
422 case XK_g:
423 ksym = XK_Home;
424 break;
425 case XK_G:
426 ksym = XK_End;
427 break;
428 }
429 }
430 switch(ksym) {
431 default:
432 if(num && !iscntrl((int) buf[0])) {
433 buf[num] = 0;
434 if(len > 0)
435 strncat(text, buf, sizeof text);
436 else
437 strncpy(text, buf, sizeof text);
438 match(text);
439 }
440 break;
441 case XK_BackSpace:
442 if(len) {
443 text[--len] = 0;
444 match(text);
445 }
446 break;
447 case XK_End:
448 if(!item)
449 return;
450 while(next) {
451 sel = curr = next;
452 calcoffsets();
453 }
454 while(sel && sel->right)
455 sel = sel->right;
456 break;
457 case XK_Escape:
458 ret = 1;
459 running = False;
460 break;
461 case XK_Home:
462 if(!item)
463 return;
464 sel = curr = item;
465 calcoffsets();
466 break;
467 case XK_Left:
468 if(!(sel && sel->left))
469 return;
470 sel=sel->left;
471 if(sel->right == curr) {
472 curr = prev;
473 calcoffsets();
474 }
475 break;
476 case XK_Next:
477 if(!next)
478 return;
479 sel = curr = next;
480 calcoffsets();
481 break;
482 case XK_Prior:
483 if(!prev)
484 return;
485 sel = curr = prev;
486 calcoffsets();
487 break;
488 case XK_Return:
489 if((e->state & ShiftMask) && text)
490 fprintf(stdout, "%s", text);
491 else if(sel)
492 fprintf(stdout, "%s", sel->text);
493 else if(text)
494 fprintf(stdout, "%s", text);
495 fflush(stdout);
496 running = False;
497 break;
498 case XK_Right:
499 if(!(sel && sel->right))
500 return;
501 sel=sel->right;
502 if(sel == next) {
503 curr = next;
504 calcoffsets();
505 }
506 break;
507 case XK_Tab:
508 if(!sel)
509 return;
510 strncpy(text, sel->text, sizeof text);
511 match(text);
512 break;
513 }
514 drawmenu();
515 }
516
517 void
518 match(char *pattern) {
519 unsigned int plen;
520 Item *i, *itemend, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend;
521
522 if(!pattern)
523 return;
524 plen = strlen(pattern);
525 item = lexact = lprefix = lsubstr = itemend = exactend = prefixend = substrend = NULL;
526 for(i = allitems; i; i = i->next)
527 if(!fstrncmp(pattern, i->text, plen + 1))
528 appenditem(i, &lexact, &exactend);
529 else if(!fstrncmp(pattern, i->text, plen))
530 appenditem(i, &lprefix, &prefixend);
531 else if(fstrstr(i->text, pattern))
532 appenditem(i, &lsubstr, &substrend);
533 if(lexact) {
534 item = lexact;
535 itemend = exactend;
536 }
537 if(lprefix) {
538 if(itemend) {
539 itemend->right - lprefix;
540 lprefix->left = itemend;
541 }
542 else
543 item = lprefix;
544 itemend = prefixend;
545 }
546 if(lsubstr) {
547 if(itemend) {
548 itemend->right = lsubstr;
549 lsubstr->left = itemend;
550 }
551 else
552 item = lsubstr;
553 }
554 curr = prev = next = sel = item;
555 calcoffsets();
556 }
557
558 void
559 readstdin(void) {
560 char *p, buf[1024];
561 unsigned int len = 0, max = 0;
562 Item *i, *new;
563
564 i = 0;
565 while(fgets(buf, sizeof buf, stdin)) {
566 len = strlen(buf);
567 if (buf[len - 1] == '\n')
568 buf[len - 1] = 0;
569 p = estrdup(buf);
570 if(max < len) {
571 maxname = p;
572 max = len;
573 }
574 new = emalloc(sizeof(Item));
575 new->next = new->left = new->right = NULL;
576 new->text = p;
577 if(!i)
578 allitems = new;
579 else
580 i->next = new;
581 i = new;
582 }
583 }
584
585 void
586 run(void) {
587 XEvent ev;
588
589 /* main event loop */
590 while(running && !XNextEvent(dpy, &ev))
591 switch (ev.type) {
592 default: /* ignore all crap */
593 break;
594 case KeyPress:
595 kpress(&ev.xkey);
596 break;
597 case Expose:
598 if(ev.xexpose.count == 0)
599 drawmenu();
600 break;
601 }
602 }
603
604 void
605 setup(int x, int y, int w) {
606 unsigned int i, j;
607 XModifierKeymap *modmap;
608 XSetWindowAttributes wa;
609
610 /* init modifier map */
611 modmap = XGetModifierMapping(dpy);
612 for(i = 0; i < 8; i++)
613 for(j = 0; j < modmap->max_keypermod; j++) {
614 if(modmap->modifiermap[i * modmap->max_keypermod + j]
615 == XKeysymToKeycode(dpy, XK_Num_Lock))
616 numlockmask = (1 << i);
617 }
618 XFreeModifiermap(modmap);
619
620 /* style */
621 dc.norm[ColBG] = getcolor(normbg);
622 dc.norm[ColFG] = getcolor(normfg);
623 dc.sel[ColBG] = getcolor(selbg);
624 dc.sel[ColFG] = getcolor(selfg);
625 initfont(font);
626
627 /* menu window */
628 wa.override_redirect = 1;
629 wa.background_pixmap = ParentRelative;
630 wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;
631 mw = w ? w : DisplayWidth(dpy, screen);
632 mh = dc.font.height + 2;
633 if(y < 0) {
634 if(y == (int)(unsigned int)-1)
635 y = DisplayHeight(dpy, screen) - mh;
636 else
637 y = (-1 * y) - mh;
638 }
639 win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
640 DefaultDepth(dpy, screen), CopyFromParent,
641 DefaultVisual(dpy, screen),
642 CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
643
644 /* pixmap */
645 dc.drawable = XCreatePixmap(dpy, root, mw, mh, DefaultDepth(dpy, screen));
646 dc.gc = XCreateGC(dpy, root, 0, 0);
647 XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
648 if(!dc.font.set)
649 XSetFont(dpy, dc.gc, dc.font.xfont->fid);
650 if(maxname)
651 cmdw = textw(maxname);
652 if(cmdw > mw / 3)
653 cmdw = mw / 3;
654 if(prompt)
655 promptw = textw(prompt);
656 if(promptw > mw / 5)
657 promptw = mw / 5;
658 text[0] = 0;
659 match(text);
660 XMapRaised(dpy, win);
661 }
662
663 unsigned int
664 textnw(const char *text, unsigned int len) {
665 XRectangle r;
666
667 if(dc.font.set) {
668 XmbTextExtents(dc.font.set, text, len, NULL, &r);
669 return r.width;
670 }
671 return XTextWidth(dc.font.xfont, text, len);
672 }
673
674 unsigned int
675 textw(const char *text) {
676 return textnw(text, strlen(text)) + dc.font.height;
677 }
678
679 int
680 main(int argc, char *argv[]) {
681 int x = 0, y = 0, w = 0;
682 unsigned int i;
683
684 /* command line args */
685 for(i = 1; i < argc; i++)
686 if(!strcmp(argv[i], "-i")) {
687 fstrncmp = strncasecmp;
688 fstrstr = cistrstr;
689 }
690 else if(!strcmp(argv[i], "-fn")) {
691 if(++i < argc) font = argv[i];
692 }
693 else if(!strcmp(argv[i], "-nb")) {
694 if(++i < argc) normbg = argv[i];
695 }
696 else if(!strcmp(argv[i], "-nf")) {
697 if(++i < argc) normfg = argv[i];
698 }
699 else if(!strcmp(argv[i], "-p")) {
700 if(++i < argc) prompt = argv[i];
701 }
702 else if(!strcmp(argv[i], "-sb")) {
703 if(++i < argc) selbg = argv[i];
704 }
705 else if(!strcmp(argv[i], "-sf")) {
706 if(++i < argc) selfg = argv[i];
707 }
708 else if(!strcmp(argv[i], "-x")) {
709 if(++i < argc) x = atoi(argv[i]);
710 }
711 else if(!strcmp(argv[i], "-y")) {
712 if(++i < argc) {
713 if(!strcmp(argv[i], "-0"))
714 y = (int)(unsigned int)-1;
715 else
716 y = atoi(argv[i]);
717 }
718 }
719 else if(!strcmp(argv[i], "-w")) {
720 if(++i < argc) w = atoi(argv[i]);
721 }
722 else if(!strcmp(argv[i], "-v"))
723 eprint("dmenu-"VERSION", © 2006-2008 dmenu engineers, see LICENSE for details\n");
724 else
725 eprint("usage: dmenu [-i] [-fn <font>] [-nb <color>] [-nf <color>]\n"
726 " [-p <prompt>] [-sb <color>] [-sf <color>]\n"
727 " [-x <x>] [-y <y>] [-w <w>] [-v]\n");
728 setlocale(LC_CTYPE, "");
729 dpy = XOpenDisplay(0);
730 if(!dpy)
731 eprint("dmenu: cannot open display\n");
732 screen = DefaultScreen(dpy);
733 root = RootWindow(dpy, screen);
734
735 if(isatty(STDIN_FILENO)) {
736 readstdin();
737 running = grabkeyboard();
738 }
739 else { /* prevent keypress loss */
740 running = grabkeyboard();
741 readstdin();
742 }
743
744 setup(x, y, w);
745 drawmenu();
746 XSync(dpy, False);
747 run();
748 cleanup();
749 XCloseDisplay(dpy);
750 return ret;
751 }