main.c

   1 /* (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>
   2  * (C)opyright MMVI Sander van Dijk <a dot h dot vandijk at gmail dot com>
   3  * See LICENSE file for license details.
   4  */
   5
   6 #include "dmenu.h"
   7
   8 #include <ctype.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/cursorfont.h>
  16 #include <X11/Xutil.h>
  17 #include <X11/keysym.h>
  18
  19 typedef struct Item Item;
  20 struct Item {
  21         Item *next;             /* traverses all items */
  22         Item *left, *right;     /* traverses items matching current search pattern */
  23         char *text;
  24 };
  25
  26 /* static */
  27
  28 static char text[4096];
  29 static int mx, my, mw, mh;
  30 static int ret = 0;
  31 static int nitem = 0;
  32 static unsigned int cmdw = 0;
  33 static Bool running = True;
  34 static Item *allitems = NULL;   /* first of all items */
  35 static Item *item = NULL;       /* first of pattern matching items */
  36 static Item *sel = NULL;
  37 static Item *next = NULL;
  38 static Item *prev = NULL;
  39 static Item *curr = NULL;
  40 static Window root;
  41 static Window win;
  42
  43 static void
  44 calcoffsets(void) {
  45         unsigned int tw, w;
  46
  47         if(!curr)
  48                 return;
  49         w = cmdw + 2 * SPACE;
  50         for(next = curr; next; next=next->right) {
  51                 tw = textw(next->text);
  52                 if(tw > mw / 3)
  53                         tw = mw / 3;
  54                 w += tw;
  55                 if(w > mw)
  56                         break;
  57         }
  58         w = cmdw + 2 * SPACE;
  59         for(prev = curr; prev && prev->left; prev=prev->left) {
  60                 tw = textw(prev->left->text);
  61                 if(tw > mw / 3)
  62                         tw = mw / 3;
  63                 w += tw;
  64                 if(w > mw)
  65                         break;
  66         }
  67 }
  68
  69 static void
  70 drawmenu(void) {
  71         Item *i;
  72
  73         dc.x = 0;
  74         dc.y = 0;
  75         dc.w = mw;
  76         dc.h = mh;
  77         drawtext(NULL, dc.norm);
  78         /* print command */
  79         if(cmdw && item)
  80                 dc.w = cmdw;
  81         drawtext(text[0] ? text : NULL, dc.norm);
  82         dc.x += cmdw;
  83         if(curr) {
  84                 dc.w = SPACE;
  85                 drawtext((curr && curr->left) ? "<" : NULL, dc.norm);
  86                 dc.x += dc.w;
  87                 /* determine maximum items */
  88                 for(i = curr; i != next; i=i->right) {
  89                         dc.w = textw(i->text);
  90                         if(dc.w > mw / 3)
  91                                 dc.w = mw / 3;
  92                         drawtext(i->text, (sel == i) ? dc.sel : dc.norm);
  93                         dc.x += dc.w;
  94                 }
  95                 dc.x = mw - SPACE;
  96                 dc.w = SPACE;
  97                 drawtext(next ? ">" : NULL, dc.norm);
  98         }
  99         XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, mw, mh, 0, 0);
 100         XFlush(dpy);
 101 }
 102
 103 static void
 104 match(char *pattern) {
 105         unsigned int plen;
 106         Item *i, *j;
 107
 108         if(!pattern)
 109                 return;
 110         plen = strlen(pattern);
 111         item = j = NULL;
 112         nitem = 0;
 113         for(i = allitems; i; i=i->next)
 114                 if(!plen || !strncmp(pattern, i->text, plen)) {
 115                         if(!j)
 116                                 item = i;
 117                         else
 118                                 j->right = i;
 119                         i->left = j;
 120                         i->right = NULL;
 121                         j = i;
 122                         nitem++;
 123                 }
 124         for(i = allitems; i; i=i->next)
 125                 if(plen && strncmp(pattern, i->text, plen)
 126                                 && strstr(i->text, pattern)) {
 127                         if(!j)
 128                                 item = i;
 129                         else
 130                                 j->right = i;
 131                         i->left = j;
 132                         i->right = NULL;
 133                         j = i;
 134                         nitem++;
 135                 }
 136         curr = prev = next = sel = item;
 137         calcoffsets();
 138 }
 139
 140 static void
 141 kpress(XKeyEvent * e) {
 142         char buf[32];
 143         int num, prev_nitem;
 144         unsigned int i, len;
 145         KeySym ksym;
 146
 147         len = strlen(text);
 148         buf[0] = 0;
 149         num = XLookupString(e, buf, sizeof(buf), &ksym, 0);
 150         if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
 151                         || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
 152                         || IsPrivateKeypadKey(ksym))
 153                 return;
 154         /* first check if a control mask is omitted */
 155         if(e->state & ControlMask) {
 156                 switch (ksym) {
 157                 default:        /* ignore other control sequences */
 158                         return;
 159                         break;
 160                 case XK_h:
 161                 case XK_H:
 162                         ksym = XK_BackSpace;
 163                         break;
 164                 case XK_u:
 165                 case XK_U:
 166                         text[0] = 0;
 167                         match(text);
 168                         drawmenu();
 169                         return;
 170                         break;
 171                 }
 172         }
 173         switch(ksym) {
 174         case XK_Left:
 175                 if(!(sel && sel->left))
 176                         return;
 177                 sel=sel->left;
 178                 if(sel->right == curr) {
 179                         curr = prev;
 180                         calcoffsets();
 181                 }
 182                 break;
 183         case XK_Tab:
 184                 if(!sel)
 185                         return;
 186                 strncpy(text, sel->text, sizeof(text));
 187                 match(text);
 188                 break;
 189         case XK_Right:
 190                 if(!(sel && sel->right))
 191                         return;
 192                 sel=sel->right;
 193                 if(sel == next) {
 194                         curr = next;
 195                         calcoffsets();
 196                 }
 197                 break;
 198         case XK_Return:
 199                 if((e->state & ShiftMask) && text)
 200                         fprintf(stdout, "%s", text);
 201                 else if(sel)
 202                         fprintf(stdout, "%s", sel->text);
 203                 else if(text)
 204                         fprintf(stdout, "%s", text);
 205                 fflush(stdout);
 206                 running = False;
 207                 break;
 208         case XK_Escape:
 209                 ret = 1;
 210                 running = False;
 211                 break;
 212         case XK_BackSpace:
 213                 if((i = len)) {
 214                         prev_nitem = nitem;
 215                         do {
 216                                 text[--i] = 0;
 217                                 match(text);
 218                         } while(i && nitem && prev_nitem == nitem);
 219                         match(text);
 220                 }
 221                 break;
 222         default:
 223                 if(num && !iscntrl((int) buf[0])) {
 224                         buf[num] = 0;
 225                         if(len > 0)
 226                                 strncat(text, buf, sizeof(text));
 227                         else
 228                                 strncpy(text, buf, sizeof(text));
 229                         match(text);
 230                 }
 231         }
 232         drawmenu();
 233 }
 234
 235 static char *
 236 readstdin(void) {
 237         static char *maxname = NULL;
 238         char *p, buf[1024];
 239         unsigned int len = 0, max = 0;
 240         Item *i, *new;
 241
 242         i = 0;
 243         while(fgets(buf, sizeof(buf), stdin)) {
 244                 len = strlen(buf);
 245                 if (buf[len - 1] == '\n')
 246                         buf[len - 1] = 0;
 247                 p = estrdup(buf);
 248                 if(max < len) {
 249                         maxname = p;
 250                         max = len;
 251                 }
 252                 new = emalloc(sizeof(Item));
 253                 new->next = new->left = new->right = NULL;
 254                 new->text = p;
 255                 if(!i)
 256                         allitems = new;
 257                 else
 258                         i->next = new;
 259                 i = new;
 260         }
 261
 262         return maxname;
 263 }
 264
 265 /* extern */
 266
 267 int screen;
 268 Display *dpy;
 269 DC dc = {0};
 270
 271 int
 272 main(int argc, char *argv[]) {
 273         char *font = FONT;
 274         char *maxname;
 275         char *normbg = NORMBGCOLOR;
 276         char *normfg = NORMFGCOLOR;
 277         char *selbg = SELBGCOLOR;
 278         char *selfg = SELFGCOLOR;
 279         fd_set rd;
 280         int i;
 281         struct timeval timeout;
 282         Item *itm;
 283         XEvent ev;
 284         XSetWindowAttributes wa;
 285
 286         timeout.tv_usec = 0;
 287         timeout.tv_sec = 3;
 288         /* command line args */
 289         for(i = 1; i < argc; i++)
 290                 if(!strncmp(argv[i], "-font", 6))
 291                         font = argv[++i];
 292                 else if(!strncmp(argv[i], "-normbg", 8))
 293                         normbg = argv[++i];
 294                 else if(!strncmp(argv[i], "-normfg", 8))
 295                         normfg = argv[++i];
 296                 else if(!strncmp(argv[i], "-selbg", 7))
 297                         selbg = argv[++i];
 298                 else if(!strncmp(argv[i], "-selfg", 7))
 299                         selfg = argv[++i];
 300                 else if(!strncmp(argv[i], "-t", 3))
 301                         timeout.tv_sec = atoi(argv[++i]);
 302                 else if(!strncmp(argv[i], "-v", 3)) {
 303                         fputs("dmenu-"VERSION", (C)opyright MMVI Anselm R. Garbe\n", stdout);
 304                         exit(EXIT_SUCCESS);
 305                 }
 306                 else
 307                         eprint("usage: dmenu [-font <name>] [-{norm,sel}{bg,fg} <color>] [-t <seconds>] [-v]\n", stdout);
 308         dpy = XOpenDisplay(0);
 309         if(!dpy)
 310                 eprint("dmenu: cannot open display\n");
 311         screen = DefaultScreen(dpy);
 312         root = RootWindow(dpy, screen);
 313
 314         /* Note, the select() construction allows to grab all keypresses as
 315          * early as possible, to not loose them. But if there is no standard
 316          * input supplied, we will make sure to exit after MAX_WAIT_STDIN
 317          * seconds. This is convenience behavior for rapid typers.
 318          */
 319         while(XGrabKeyboard(dpy, root, True, GrabModeAsync,
 320                          GrabModeAsync, CurrentTime) != GrabSuccess)
 321                 usleep(1000);
 322         FD_ZERO(&rd);
 323         FD_SET(STDIN_FILENO, &rd);
 324         if(select(ConnectionNumber(dpy) + 1, &rd, NULL, NULL, &timeout) < 1)
 325                 goto UninitializedEnd;
 326         maxname = readstdin();
 327         /* style */
 328         dc.norm[ColBG] = getcolor(normbg);
 329         dc.norm[ColFG] = getcolor(normfg);
 330         dc.sel[ColBG] = getcolor(selbg);
 331         dc.sel[ColFG] = getcolor(selfg);
 332         setfont(font);
 333         /* menu window */
 334         wa.override_redirect = 1;
 335         wa.background_pixmap = ParentRelative;
 336         wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;
 337         mx = my = 0;
 338         mw = DisplayWidth(dpy, screen);
 339         mh = dc.font.height + 2;
 340         win = XCreateWindow(dpy, root, mx, my, mw, mh, 0,
 341                         DefaultDepth(dpy, screen), CopyFromParent,
 342                         DefaultVisual(dpy, screen),
 343                         CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
 344         XDefineCursor(dpy, win, XCreateFontCursor(dpy, XC_xterm));
 345         /* pixmap */
 346         dc.drawable = XCreatePixmap(dpy, root, mw, mh, DefaultDepth(dpy, screen));
 347         dc.gc = XCreateGC(dpy, root, 0, 0);
 348         XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
 349         if(maxname)
 350                 cmdw = textw(maxname);
 351         if(cmdw > mw / 3)
 352                 cmdw = mw / 3;
 353         text[0] = 0;
 354         match(text);
 355         XMapRaised(dpy, win);
 356         drawmenu();
 357         XSync(dpy, False);
 358
 359         /* main event loop */
 360         while(running && !XNextEvent(dpy, &ev)) {
 361                 switch (ev.type) {
 362                 default:        /* ignore all crap */
 363                         break;
 364                 case KeyPress:
 365                         kpress(&ev.xkey);
 366                         break;
 367                 case Expose:
 368                         if(ev.xexpose.count == 0)
 369                                 drawmenu();
 370                         break;
 371                 }
 372         }
 373
 374         /* cleanup */
 375         while(allitems) {
 376                 itm = allitems->next;
 377                 free(allitems->text);
 378                 free(allitems);
 379                 allitems = itm;
 380         }
 381         if(dc.font.set)
 382                 XFreeFontSet(dpy, dc.font.set);
 383         else
 384                 XFreeFont(dpy, dc.font.xfont);
 385         XFreePixmap(dpy, dc.drawable);
 386         XFreeGC(dpy, dc.gc);
 387         XDestroyWindow(dpy, win);
 388 UninitializedEnd:
 389         XUngrabKeyboard(dpy, CurrentTime);
 390         XCloseDisplay(dpy);
 391         return ret;
 392 }