Xinqi Bao's Git

projects / dmenu.git / blob


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