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