dmenu.c

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