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