main.c

   1 /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>
   2  * (C)opyright MMVI-MMVII Sander van Dijk <a dot h dot vandijk at gmail dot com>
   3  * See LICENSE file for license details.
   4  */
   5 #include "dmenu.h"
   6
   7 #include <ctype.h>
   8 #include <locale.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <sys/select.h>
  14 #include <sys/time.h>
  15 #include <X11/Xutil.h>
  16 #include <X11/keysym.h>
  17
  18 #define CLEANMASK(mask) (mask & ~(numlockmask | LockMask))
  19
  20 typedef struct Item Item;
  21 struct Item {
  22         Item *next;             /* traverses all items */
  23         Item *left, *right;     /* traverses items matching current search pattern */
  24         char *text;
  25 };
  26
  27 /* static */
  28
  29 static char text[4096];
  30 static char *prompt = NULL;
  31 static int mw, mh;
  32 static int ret = 0;
  33 static int nitem = 0;
  34 static unsigned int cmdw = 0;
  35 static unsigned int promptw = 0;
  36 static unsigned int numlockmask = 0;
  37 static Bool running = True;
  38 static Item *allitems = NULL;   /* first of all items */
  39 static Item *item = NULL;       /* first of pattern matching items */
  40 static Item *sel = NULL;
  41 static Item *next = NULL;
  42 static Item *prev = NULL;
  43 static Item *curr = NULL;
  44 static Window root;
  45 static Window win;
  46
  47 static unsigned int
  48 textnw(const char *text, unsigned int len) {
  49         XRectangle r;
  50
  51         if(dc.font.set) {
  52                 XmbTextExtents(dc.font.set, text, len, NULL, &r);
  53                 return r.width;
  54         }
  55         return XTextWidth(dc.font.xfont, text, len);
  56 }
  57
  58 static unsigned int
  59 textw(const char *text) {
  60         return textnw(text, strlen(text)) + dc.font.height;
  61 }
  62
  63 static void
  64 calcoffsets(void) {
  65         unsigned int tw, w;
  66
  67         if(!curr)
  68                 return;
  69         w = promptw + cmdw + 2 * SPACE;
  70         for(next = curr; next; next=next->right) {
  71                 tw = textw(next->text);
  72                 if(tw > mw / 3)
  73                         tw = mw / 3;
  74                 w += tw;
  75                 if(w > mw)
  76                         break;
  77         }
  78         w = promptw + cmdw + 2 * SPACE;
  79         for(prev = curr; prev && prev->left; prev=prev->left) {
  80                 tw = textw(prev->left->text);
  81                 if(tw > mw / 3)
  82                         tw = mw / 3;
  83                 w += tw;
  84                 if(w > mw)
  85                         break;
  86         }
  87 }
  88
  89 static void
  90 drawtext(const char *text, unsigned long col[ColLast]) {
  91         int x, y, w, h;
  92         static char buf[256];
  93         unsigned int len, olen;
  94         XGCValues gcv;
  95         XRectangle r = { dc.x, dc.y, dc.w, dc.h };
  96
  97         XSetForeground(dpy, dc.gc, col[ColBG]);
  98         XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
  99         if(!text)
 100                 return;
 101         w = 0;
 102         olen = len = strlen(text);
 103         if(len >= sizeof buf)
 104                 len = sizeof buf - 1;
 105         memcpy(buf, text, len);
 106         buf[len] = 0;
 107         h = dc.font.ascent + dc.font.descent;
 108         y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
 109         x = dc.x + (h / 2);
 110         /* shorten text if necessary */
 111         while(len && (w = textnw(buf, len)) > dc.w - h)
 112                 buf[--len] = 0;
 113         if(len < olen) {
 114                 if(len > 1)
 115                         buf[len - 1] = '.';
 116                 if(len > 2)
 117                         buf[len - 2] = '.';
 118                 if(len > 3)
 119                         buf[len - 3] = '.';
 120         }
 121         if(w > dc.w)
 122                 return; /* too long */
 123         gcv.foreground = col[ColFG];
 124         if(dc.font.set) {
 125                 XChangeGC(dpy, dc.gc, GCForeground, &gcv);
 126                 XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc,
 127                                 x, y, buf, len);
 128         }
 129         else {
 130                 gcv.font = dc.font.xfont->fid;
 131                 XChangeGC(dpy, dc.gc, GCForeground | GCFont, &gcv);
 132                 XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
 133         }
 134 }
 135
 136 static void
 137 drawmenu(void) {
 138         Item *i;
 139
 140         dc.x = 0;
 141         dc.y = 0;
 142         dc.w = mw;
 143         dc.h = mh;
 144         drawtext(NULL, dc.norm);
 145         /* print prompt? */
 146         if(promptw) {
 147                 dc.w = promptw;
 148                 drawtext(prompt, dc.sel);
 149         }
 150         dc.x += promptw;
 151         dc.w = mw - promptw;
 152         /* print command */
 153         if(cmdw && item)
 154                 dc.w = cmdw;
 155         drawtext(text[0] ? text : NULL, dc.norm);
 156         dc.x += cmdw;
 157         if(curr) {
 158                 dc.w = SPACE;
 159                 drawtext((curr && curr->left) ? "<" : NULL, dc.norm);
 160                 dc.x += dc.w;
 161                 /* determine maximum items */
 162                 for(i = curr; i != next; i=i->right) {
 163                         dc.w = textw(i->text);
 164                         if(dc.w > mw / 3)
 165                                 dc.w = mw / 3;
 166                         drawtext(i->text, (sel == i) ? dc.sel : dc.norm);
 167                         dc.x += dc.w;
 168                 }
 169                 dc.x = mw - SPACE;
 170                 dc.w = SPACE;
 171                 drawtext(next ? ">" : NULL, dc.norm);
 172         }
 173         XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, mw, mh, 0, 0);
 174         XFlush(dpy);
 175 }
 176
 177 static unsigned long
 178 getcolor(const char *colstr) {
 179         Colormap cmap = DefaultColormap(dpy, screen);
 180         XColor color;
 181
 182         if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
 183                 eprint("error, cannot allocate color '%s'\n", colstr);
 184         return color.pixel;
 185 }
 186
 187 static void
 188 setfont(const char *fontstr) {
 189         char *def, **missing;
 190         int i, n;
 191
 192         missing = NULL;
 193         if(dc.font.set)
 194                 XFreeFontSet(dpy, dc.font.set);
 195         dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
 196         if(missing)
 197                 XFreeStringList(missing);
 198         if(dc.font.set) {
 199                 XFontSetExtents *font_extents;
 200                 XFontStruct **xfonts;
 201                 char **font_names;
 202                 dc.font.ascent = dc.font.descent = 0;
 203                 font_extents = XExtentsOfFontSet(dc.font.set);
 204                 n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
 205                 for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
 206                         if(dc.font.ascent < (*xfonts)->ascent)
 207                                 dc.font.ascent = (*xfonts)->ascent;
 208                         if(dc.font.descent < (*xfonts)->descent)
 209                                 dc.font.descent = (*xfonts)->descent;
 210                         xfonts++;
 211                 }
 212         }
 213         else {
 214                 if(dc.font.xfont)
 215                         XFreeFont(dpy, dc.font.xfont);
 216                 dc.font.xfont = NULL;
 217                 if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr)))
 218                         eprint("error, cannot load font: '%s'\n", fontstr);
 219                 dc.font.ascent = dc.font.xfont->ascent;
 220                 dc.font.descent = dc.font.xfont->descent;
 221         }
 222         dc.font.height = dc.font.ascent + dc.font.descent;
 223 }
 224
 225 static void
 226 match(char *pattern) {
 227         unsigned int plen;
 228         Item *i, *j;
 229
 230         if(!pattern)
 231                 return;
 232         plen = strlen(pattern);
 233         item = j = NULL;
 234         nitem = 0;
 235         for(i = allitems; i; i=i->next)
 236                 if(!plen || !strncmp(pattern, i->text, plen)) {
 237                         if(!j)
 238                                 item = i;
 239                         else
 240                                 j->right = i;
 241                         i->left = j;
 242                         i->right = NULL;
 243                         j = i;
 244                         nitem++;
 245                 }
 246         for(i = allitems; i; i=i->next)
 247                 if(plen && strncmp(pattern, i->text, plen)
 248                                 && strstr(i->text, pattern)) {
 249                         if(!j)
 250                                 item = i;
 251                         else
 252                                 j->right = i;
 253                         i->left = j;
 254                         i->right = NULL;
 255                         j = i;
 256                         nitem++;
 257                 }
 258         curr = prev = next = sel = item;
 259         calcoffsets();
 260 }
 261
 262 static void
 263 kpress(XKeyEvent * e) {
 264         char buf[32];
 265         int i, num, prev_nitem;
 266         unsigned int len;
 267         KeySym ksym;
 268
 269         len = strlen(text);
 270         buf[0] = 0;
 271         num = XLookupString(e, buf, sizeof buf, &ksym, 0);
 272         if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
 273                         || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
 274                         || IsPrivateKeypadKey(ksym))
 275                 return;
 276         /* first check if a control mask is omitted */
 277         if(e->state & ControlMask) {
 278                 switch (ksym) {
 279                 default:        /* ignore other control sequences */
 280                         return;
 281                 case XK_bracketleft:
 282                         ksym = XK_Escape;
 283                         break;
 284                 case XK_h:
 285                 case XK_H:
 286                         ksym = XK_BackSpace;
 287                         break;
 288                 case XK_i:
 289                 case XK_I:
 290                         ksym = XK_Tab;
 291                         break;
 292                 case XK_j:
 293                 case XK_J:
 294                         ksym = XK_Return;
 295                         break;
 296                 case XK_u:
 297                 case XK_U:
 298                         text[0] = 0;
 299                         match(text);
 300                         drawmenu();
 301                         return;
 302                 case XK_w:
 303                 case XK_W:
 304                         if(len) {
 305                                 i = len - 1;
 306                                 while(i >= 0 && text[i] == ' ')
 307                                         text[i--] = 0;
 308                                 while(i >= 0 && text[i] != ' ')
 309                                         text[i--] = 0;
 310                                 match(text);
 311                                 drawmenu();
 312                         }
 313                         return;
 314                 }
 315         }
 316         if(CLEANMASK(e->state) & Mod1Mask) {
 317                 switch(ksym) {
 318                 default: return;
 319                 case XK_h:
 320                         ksym = XK_Left;
 321                         break;
 322                 case XK_l:
 323                         ksym = XK_Right;
 324                         break;
 325                 case XK_j:
 326                         ksym = XK_Next;
 327                         break;
 328                 case XK_k:
 329                         ksym = XK_Prior;
 330                         break;
 331                 case XK_g:
 332                         ksym = XK_Home;
 333                         break;
 334                 case XK_G:
 335                         ksym = XK_End;
 336                         break;
 337                 }
 338         }
 339         switch(ksym) {
 340         default:
 341                 if(num && !iscntrl((int) buf[0])) {
 342                         buf[num] = 0;
 343                         if(len > 0)
 344                                 strncat(text, buf, sizeof text);
 345                         else
 346                                 strncpy(text, buf, sizeof text);
 347                         match(text);
 348                 }
 349                 break;
 350         case XK_BackSpace:
 351                 if((i = len)) {
 352                         prev_nitem = nitem;
 353                         do {
 354                                 text[--i] = 0;
 355                                 match(text);
 356                         } while(i && nitem && prev_nitem == nitem);
 357                         match(text);
 358                 }
 359                 break;
 360         case XK_End:
 361                 if(!item)
 362                         return;
 363                 while(next) {
 364                         sel = curr = next;
 365                         calcoffsets();
 366                 }
 367                 while(sel && sel->right)
 368                         sel = sel->right;
 369                 break;
 370         case XK_Escape:
 371                 ret = 1;
 372                 running = False;
 373                 break;
 374         case XK_Home:
 375                 if(!item)
 376                         return;
 377                 sel = curr = item;
 378                 calcoffsets();
 379                 break;
 380         case XK_Left:
 381                 if(!(sel && sel->left))
 382                         return;
 383                 sel=sel->left;
 384                 if(sel->right == curr) {
 385                         curr = prev;
 386                         calcoffsets();
 387                 }
 388                 break;
 389         case XK_Next:
 390                 if(!next)
 391                         return;
 392                 sel = curr = next;
 393                 calcoffsets();
 394                 break;
 395         case XK_Prior:
 396                 if(!prev)
 397                         return;
 398                 sel = curr = prev;
 399                 calcoffsets();
 400                 break;
 401         case XK_Return:
 402                 if((e->state & ShiftMask) && text)
 403                         fprintf(stdout, "%s", text);
 404                 else if(sel)
 405                         fprintf(stdout, "%s", sel->text);
 406                 else if(text)
 407                         fprintf(stdout, "%s", text);
 408                 fflush(stdout);
 409                 running = False;
 410                 break;
 411         case XK_Right:
 412                 if(!(sel && sel->right))
 413                         return;
 414                 sel=sel->right;
 415                 if(sel == next) {
 416                         curr = next;
 417                         calcoffsets();
 418                 }
 419                 break;
 420         case XK_Tab:
 421                 if(!sel)
 422                         return;
 423                 strncpy(text, sel->text, sizeof text);
 424                 match(text);
 425                 break;
 426         }
 427         drawmenu();
 428 }
 429
 430 static char *
 431 readstdin(void) {
 432         static char *maxname = NULL;
 433         char *p, buf[1024];
 434         unsigned int len = 0, max = 0;
 435         Item *i, *new;
 436
 437         i = 0;
 438         while(fgets(buf, sizeof buf, stdin)) {
 439                 len = strlen(buf);
 440                 if (buf[len - 1] == '\n')
 441                         buf[len - 1] = 0;
 442                 p = estrdup(buf);
 443                 if(max < len) {
 444                         maxname = p;
 445                         max = len;
 446                 }
 447                 new = emalloc(sizeof(Item));
 448                 new->next = new->left = new->right = NULL;
 449                 new->text = p;
 450                 if(!i)
 451                         allitems = new;
 452                 else
 453                         i->next = new;
 454                 i = new;
 455         }
 456
 457         return maxname;
 458 }
 459
 460 /* extern */
 461
 462 int screen;
 463 Display *dpy;
 464 DC dc = {0};
 465
 466 int
 467 main(int argc, char *argv[]) {
 468         Bool bottom = False;
 469         char *font = FONT;
 470         char *maxname;
 471         char *normbg = NORMBGCOLOR;
 472         char *normfg = NORMFGCOLOR;
 473         char *selbg = SELBGCOLOR;
 474         char *selfg = SELFGCOLOR;
 475         fd_set rd;
 476         int i, j;
 477         struct timeval timeout;
 478         Item *itm;
 479         XEvent ev;
 480         XModifierKeymap *modmap;
 481         XSetWindowAttributes wa;
 482
 483         timeout.tv_usec = 0;
 484         timeout.tv_sec = 3;
 485         /* command line args */
 486         for(i = 1; i < argc; i++)
 487                 if(!strncmp(argv[i], "-b", 3)) {
 488                         bottom = True;
 489                 }
 490                 else if(!strncmp(argv[i], "-fn", 4)) {
 491                         if(++i < argc) font = argv[i];
 492                 }
 493                 else if(!strncmp(argv[i], "-nb", 4)) {
 494                         if(++i < argc) normbg = argv[i];
 495                 }
 496                 else if(!strncmp(argv[i], "-nf", 4)) {
 497                         if(++i < argc) normfg = argv[i];
 498                 }
 499                 else if(!strncmp(argv[i], "-p", 3)) {
 500                         if(++i < argc) prompt = argv[i];
 501                 }
 502                 else if(!strncmp(argv[i], "-sb", 4)) {
 503                         if(++i < argc) selbg = argv[i];
 504                 }
 505                 else if(!strncmp(argv[i], "-sf", 4)) {
 506                         if(++i < argc) selfg = argv[i];
 507                 }
 508                 else if(!strncmp(argv[i], "-t", 3)) {
 509                         if(++i < argc) timeout.tv_sec = atoi(argv[i]);
 510                 }
 511                 else if(!strncmp(argv[i], "-v", 3)) {
 512                         fputs("dmenu-"VERSION", (C)opyright MMVI-MMVII Anselm R. Garbe\n", stdout);
 513                         exit(EXIT_SUCCESS);
 514                 }
 515                 else
 516                         eprint("usage: dmenu [-b] [-fn <font>] [-nb <color>] [-nf <color>] [-p <prompt>]\n"
 517                                 "             [-sb <color>] [-sf <color>] [-t <seconds>] [-v]\n", stdout);
 518         setlocale(LC_CTYPE, "");
 519         dpy = XOpenDisplay(0);
 520         if(!dpy)
 521                 eprint("dmenu: cannot open display\n");
 522         screen = DefaultScreen(dpy);
 523         root = RootWindow(dpy, screen);
 524
 525         /* Note, the select() construction allows to grab all keypresses as
 526          * early as possible, to not loose them. But if there is no standard
 527          * input supplied, we will make sure to exit after MAX_WAIT_STDIN
 528          * seconds. This is convenience behavior for rapid typers.
 529          */
 530         while(XGrabKeyboard(dpy, root, True, GrabModeAsync,
 531                          GrabModeAsync, CurrentTime) != GrabSuccess)
 532                 usleep(1000);
 533         FD_ZERO(&rd);
 534         FD_SET(STDIN_FILENO, &rd);
 535         if(select(ConnectionNumber(dpy) + 1, &rd, NULL, NULL, &timeout) < 1)
 536                 goto UninitializedEnd;
 537         maxname = readstdin();
 538         /* init modifier map */
 539         modmap = XGetModifierMapping(dpy);
 540         for (i = 0; i < 8; i++) {
 541                 for (j = 0; j < modmap->max_keypermod; j++) {
 542                         if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock))
 543                                 numlockmask = (1 << i);
 544                 }
 545         }
 546         XFreeModifiermap(modmap);
 547         /* style */
 548         dc.norm[ColBG] = getcolor(normbg);
 549         dc.norm[ColFG] = getcolor(normfg);
 550         dc.sel[ColBG] = getcolor(selbg);
 551         dc.sel[ColFG] = getcolor(selfg);
 552         setfont(font);
 553         /* menu window */
 554         wa.override_redirect = 1;
 555         wa.background_pixmap = ParentRelative;
 556         wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;
 557         mw = DisplayWidth(dpy, screen);
 558         mh = dc.font.height + 2;
 559         win = XCreateWindow(dpy, root, 0,
 560                         bottom ? DisplayHeight(dpy, screen) - mh : 0, mw, mh, 0,
 561                         DefaultDepth(dpy, screen), CopyFromParent,
 562                         DefaultVisual(dpy, screen),
 563                         CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
 564         /* pixmap */
 565         dc.drawable = XCreatePixmap(dpy, root, mw, mh, DefaultDepth(dpy, screen));
 566         dc.gc = XCreateGC(dpy, root, 0, 0);
 567         XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
 568         if(maxname)
 569                 cmdw = textw(maxname);
 570         if(cmdw > mw / 3)
 571                 cmdw = mw / 3;
 572         if(prompt)
 573                 promptw = textw(prompt);
 574         if(promptw > mw / 5)
 575                 promptw = mw / 5;
 576         text[0] = 0;
 577         match(text);
 578         XMapRaised(dpy, win);
 579         drawmenu();
 580         XSync(dpy, False);
 581
 582         /* main event loop */
 583         while(running && !XNextEvent(dpy, &ev))
 584                 switch (ev.type) {
 585                 default:        /* ignore all crap */
 586                         break;
 587                 case KeyPress:
 588                         kpress(&ev.xkey);
 589                         break;
 590                 case Expose:
 591                         if(ev.xexpose.count == 0)
 592                                 drawmenu();
 593                         break;
 594                 }
 595
 596         /* cleanup */
 597         while(allitems) {
 598                 itm = allitems->next;
 599                 free(allitems->text);
 600                 free(allitems);
 601                 allitems = itm;
 602         }
 603         if(dc.font.set)
 604                 XFreeFontSet(dpy, dc.font.set);
 605         else
 606                 XFreeFont(dpy, dc.font.xfont);
 607         XFreePixmap(dpy, dc.drawable);
 608         XFreeGC(dpy, dc.gc);
 609         XDestroyWindow(dpy, win);
 610 UninitializedEnd:
 611         XUngrabKeyboard(dpy, CurrentTime);
 612         XCloseDisplay(dpy);
 613         return ret;
 614 }