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