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 mx, my, 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 void
  48 calcoffsets(void) {
  49         unsigned int tw, w;
  50
  51         if(!curr)
  52                 return;
  53         w = promptw + cmdw + 2 * SPACE;
  54         for(next = curr; next; next=next->right) {
  55                 tw = textw(next->text);
  56                 if(tw > mw / 3)
  57                         tw = mw / 3;
  58                 w += tw;
  59                 if(w > mw)
  60                         break;
  61         }
  62         w = promptw + cmdw + 2 * SPACE;
  63         for(prev = curr; prev && prev->left; prev=prev->left) {
  64                 tw = textw(prev->left->text);
  65                 if(tw > mw / 3)
  66                         tw = mw / 3;
  67                 w += tw;
  68                 if(w > mw)
  69                         break;
  70         }
  71 }
  72
  73 static void
  74 drawmenu(void) {
  75         Item *i;
  76
  77         dc.x = 0;
  78         dc.y = 0;
  79         dc.w = mw;
  80         dc.h = mh;
  81         drawtext(NULL, dc.norm);
  82         /* print prompt? */
  83         if(promptw) {
  84                 dc.w = promptw;
  85                 drawtext(prompt, dc.sel);
  86         }
  87         dc.x += promptw;
  88         dc.w = mw - promptw;
  89         /* print command */
  90         if(cmdw && item)
  91                 dc.w = cmdw;
  92         drawtext(text[0] ? text : NULL, dc.norm);
  93         dc.x += cmdw;
  94         if(curr) {
  95                 dc.w = SPACE;
  96                 drawtext((curr && curr->left) ? "<" : NULL, dc.norm);
  97                 dc.x += dc.w;
  98                 /* determine maximum items */
  99                 for(i = curr; i != next; i=i->right) {
 100                         dc.w = textw(i->text);
 101                         if(dc.w > mw / 3)
 102                                 dc.w = mw / 3;
 103                         drawtext(i->text, (sel == i) ? dc.sel : dc.norm);
 104                         dc.x += dc.w;
 105                 }
 106                 dc.x = mw - SPACE;
 107                 dc.w = SPACE;
 108                 drawtext(next ? ">" : NULL, dc.norm);
 109         }
 110         XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, mw, mh, 0, 0);
 111         XFlush(dpy);
 112 }
 113
 114 static void
 115 match(char *pattern) {
 116         unsigned int plen;
 117         Item *i, *j;
 118
 119         if(!pattern)
 120                 return;
 121         plen = strlen(pattern);
 122         item = j = NULL;
 123         nitem = 0;
 124         for(i = allitems; i; i=i->next)
 125                 if(!plen || !strncmp(pattern, i->text, plen)) {
 126                         if(!j)
 127                                 item = i;
 128                         else
 129                                 j->right = i;
 130                         i->left = j;
 131                         i->right = NULL;
 132                         j = i;
 133                         nitem++;
 134                 }
 135         for(i = allitems; i; i=i->next)
 136                 if(plen && strncmp(pattern, i->text, plen)
 137                                 && strstr(i->text, pattern)) {
 138                         if(!j)
 139                                 item = i;
 140                         else
 141                                 j->right = i;
 142                         i->left = j;
 143                         i->right = NULL;
 144                         j = i;
 145                         nitem++;
 146                 }
 147         curr = prev = next = sel = item;
 148         calcoffsets();
 149 }
 150
 151 static void
 152 kpress(XKeyEvent * e) {
 153         char buf[32];
 154         int num, prev_nitem;
 155         unsigned int i, len;
 156         KeySym ksym;
 157
 158         len = strlen(text);
 159         buf[0] = 0;
 160         num = XLookupString(e, buf, sizeof buf, &ksym, 0);
 161         if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
 162                         || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
 163                         || IsPrivateKeypadKey(ksym))
 164                 return;
 165         /* first check if a control mask is omitted */
 166         if(e->state & ControlMask) {
 167                 switch (ksym) {
 168                 default:        /* ignore other control sequences */
 169                         return;
 170                 case XK_bracketleft:
 171                         ksym = XK_Escape;
 172                         break;
 173                 case XK_h:
 174                 case XK_H:
 175                         ksym = XK_BackSpace;
 176                         break;
 177                 case XK_i:
 178                 case XK_I:
 179                         ksym = XK_Tab;
 180                         break;
 181                 case XK_j:
 182                 case XK_J:
 183                         ksym = XK_Return;
 184                         break;
 185                 case XK_u:
 186                 case XK_U:
 187                         text[0] = 0;
 188                         match(text);
 189                         drawmenu();
 190                         return;
 191                 }
 192         }
 193         if(CLEANMASK(e->state) & Mod1Mask) {
 194                 switch(ksym) {
 195                 default: return;
 196                 case XK_h:
 197                         ksym = XK_Left;
 198                         break;
 199                 case XK_l:
 200                         ksym = XK_Right;
 201                         break;
 202                 case XK_j:
 203                         ksym = XK_Next;
 204                         break;
 205                 case XK_k:
 206                         ksym = XK_Prior;
 207                         break;
 208                 case XK_g:
 209                         ksym = XK_Home;
 210                         break;
 211                 case XK_G:
 212                         ksym = XK_End;
 213                         break;
 214                 }
 215         }
 216         switch(ksym) {
 217         default:
 218                 if(num && !iscntrl((int) buf[0])) {
 219                         buf[num] = 0;
 220                         if(len > 0)
 221                                 strncat(text, buf, sizeof text);
 222                         else
 223                                 strncpy(text, buf, sizeof text);
 224                         match(text);
 225                 }
 226                 break;
 227         case XK_BackSpace:
 228                 if((i = len)) {
 229                         prev_nitem = nitem;
 230                         do {
 231                                 text[--i] = 0;
 232                                 match(text);
 233                         } while(i && nitem && prev_nitem == nitem);
 234                         match(text);
 235                 }
 236                 break;
 237         case XK_End:
 238                 if(!item)
 239                         return;
 240                 while(next) {
 241                         sel = curr = next;
 242                         calcoffsets();
 243                 }
 244                 while(sel && sel->right)
 245                         sel = sel->right;
 246                 break;
 247         case XK_Escape:
 248                 ret = 1;
 249                 running = False;
 250                 break;
 251         case XK_Home:
 252                 if(!item)
 253                         return;
 254                 sel = curr = item;
 255                 calcoffsets();
 256                 break;
 257         case XK_Left:
 258                 if(!(sel && sel->left))
 259                         return;
 260                 sel=sel->left;
 261                 if(sel->right == curr) {
 262                         curr = prev;
 263                         calcoffsets();
 264                 }
 265                 break;
 266         case XK_Next:
 267                 if(!next)
 268                         return;
 269                 sel = curr = next;
 270                 calcoffsets();
 271                 break;
 272         case XK_Prior:
 273                 if(!prev)
 274                         return;
 275                 sel = curr = prev;
 276                 calcoffsets();
 277                 break;
 278         case XK_Return:
 279                 if((e->state & ShiftMask) && text)
 280                         fprintf(stdout, "%s", text);
 281                 else if(sel)
 282                         fprintf(stdout, "%s", sel->text);
 283                 else if(text)
 284                         fprintf(stdout, "%s", text);
 285                 fflush(stdout);
 286                 running = False;
 287                 break;
 288         case XK_Right:
 289                 if(!(sel && sel->right))
 290                         return;
 291                 sel=sel->right;
 292                 if(sel == next) {
 293                         curr = next;
 294                         calcoffsets();
 295                 }
 296                 break;
 297         case XK_Tab:
 298                 if(!sel)
 299                         return;
 300                 strncpy(text, sel->text, sizeof text);
 301                 match(text);
 302                 break;
 303         }
 304         drawmenu();
 305 }
 306
 307 static char *
 308 readstdin(void) {
 309         static char *maxname = NULL;
 310         char *p, buf[1024];
 311         unsigned int len = 0, max = 0;
 312         Item *i, *new;
 313
 314         i = 0;
 315         while(fgets(buf, sizeof buf, stdin)) {
 316                 len = strlen(buf);
 317                 if (buf[len - 1] == '\n')
 318                         buf[len - 1] = 0;
 319                 p = estrdup(buf);
 320                 if(max < len) {
 321                         maxname = p;
 322                         max = len;
 323                 }
 324                 new = emalloc(sizeof(Item));
 325                 new->next = new->left = new->right = NULL;
 326                 new->text = p;
 327                 if(!i)
 328                         allitems = new;
 329                 else
 330                         i->next = new;
 331                 i = new;
 332         }
 333
 334         return maxname;
 335 }
 336
 337 /* extern */
 338
 339 int screen;
 340 Display *dpy;
 341 DC dc = {0};
 342
 343 int
 344 main(int argc, char *argv[]) {
 345         Bool bottom = False;
 346         char *font = FONT;
 347         char *maxname;
 348         char *normbg = NORMBGCOLOR;
 349         char *normfg = NORMFGCOLOR;
 350         char *selbg = SELBGCOLOR;
 351         char *selfg = SELFGCOLOR;
 352         fd_set rd;
 353         int i, j;
 354         struct timeval timeout;
 355         Item *itm;
 356         XEvent ev;
 357         XModifierKeymap *modmap;
 358         XSetWindowAttributes wa;
 359
 360         timeout.tv_usec = 0;
 361         timeout.tv_sec = 3;
 362         /* command line args */
 363         for(i = 1; i < argc; i++)
 364                 if(!strncmp(argv[i], "-b", 3)) {
 365                         bottom = True;
 366                 }
 367                 else if(!strncmp(argv[i], "-fn", 4)) {
 368                         if(++i < argc) font = argv[i];
 369                 }
 370                 else if(!strncmp(argv[i], "-nb", 4)) {
 371                         if(++i < argc) normbg = argv[i];
 372                 }
 373                 else if(!strncmp(argv[i], "-nf", 4)) {
 374                         if(++i < argc) normfg = argv[i];
 375                 }
 376                 else if(!strncmp(argv[i], "-p", 3)) {
 377                         if(++i < argc) prompt = argv[i];
 378                 }
 379                 else if(!strncmp(argv[i], "-sb", 4)) {
 380                         if(++i < argc) selbg = argv[i];
 381                 }
 382                 else if(!strncmp(argv[i], "-sf", 4)) {
 383                         if(++i < argc) selfg = argv[i];
 384                 }
 385                 else if(!strncmp(argv[i], "-t", 3)) {
 386                         if(++i < argc) timeout.tv_sec = atoi(argv[i]);
 387                 }
 388                 else if(!strncmp(argv[i], "-v", 3)) {
 389                         fputs("dmenu-"VERSION", (C)opyright MMVI-MMVII Anselm R. Garbe\n", stdout);
 390                         exit(EXIT_SUCCESS);
 391                 }
 392                 else
 393                         eprint("usage: dmenu [-b] [-fn <font>] [-nb <color>] [-nf <color>] [-p <prompt>]\n"
 394                                 "             [-sb <color>] [-sf <color>] [-t <seconds>] [-v]\n", stdout);
 395         setlocale(LC_CTYPE, "");
 396         dpy = XOpenDisplay(0);
 397         if(!dpy)
 398                 eprint("dmenu: cannot open display\n");
 399         screen = DefaultScreen(dpy);
 400         root = RootWindow(dpy, screen);
 401
 402         /* Note, the select() construction allows to grab all keypresses as
 403          * early as possible, to not loose them. But if there is no standard
 404          * input supplied, we will make sure to exit after MAX_WAIT_STDIN
 405          * seconds. This is convenience behavior for rapid typers.
 406          */
 407         while(XGrabKeyboard(dpy, root, True, GrabModeAsync,
 408                          GrabModeAsync, CurrentTime) != GrabSuccess)
 409                 usleep(1000);
 410         FD_ZERO(&rd);
 411         FD_SET(STDIN_FILENO, &rd);
 412         if(select(ConnectionNumber(dpy) + 1, &rd, NULL, NULL, &timeout) < 1)
 413                 goto UninitializedEnd;
 414         maxname = readstdin();
 415         /* init modifier map */
 416         modmap = XGetModifierMapping(dpy);
 417         for (i = 0; i < 8; i++) {
 418                 for (j = 0; j < modmap->max_keypermod; j++) {
 419                         if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock))
 420                                 numlockmask = (1 << i);
 421                 }
 422         }
 423         XFreeModifiermap(modmap);
 424         /* style */
 425         dc.norm[ColBG] = getcolor(normbg);
 426         dc.norm[ColFG] = getcolor(normfg);
 427         dc.sel[ColBG] = getcolor(selbg);
 428         dc.sel[ColFG] = getcolor(selfg);
 429         setfont(font);
 430         /* menu window */
 431         wa.override_redirect = 1;
 432         wa.background_pixmap = ParentRelative;
 433         wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;
 434         mx = my = 0;
 435         mw = DisplayWidth(dpy, screen);
 436         mh = dc.font.height + 2;
 437         if(bottom)
 438                 my += DisplayHeight(dpy, screen) - mh;
 439         win = XCreateWindow(dpy, root, mx, my, mw, mh, 0,
 440                         DefaultDepth(dpy, screen), CopyFromParent,
 441                         DefaultVisual(dpy, screen),
 442                         CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
 443         /* pixmap */
 444         dc.drawable = XCreatePixmap(dpy, root, mw, mh, DefaultDepth(dpy, screen));
 445         dc.gc = XCreateGC(dpy, root, 0, 0);
 446         XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
 447         if(maxname)
 448                 cmdw = textw(maxname);
 449         if(cmdw > mw / 3)
 450                 cmdw = mw / 3;
 451         if(prompt)
 452                 promptw = textw(prompt);
 453         if(promptw > mw / 5)
 454                 promptw = mw / 5;
 455         text[0] = 0;
 456         match(text);
 457         XMapRaised(dpy, win);
 458         drawmenu();
 459         XSync(dpy, False);
 460
 461         /* main event loop */
 462         while(running && !XNextEvent(dpy, &ev))
 463                 switch (ev.type) {
 464                 default:        /* ignore all crap */
 465                         break;
 466                 case KeyPress:
 467                         kpress(&ev.xkey);
 468                         break;
 469                 case Expose:
 470                         if(ev.xexpose.count == 0)
 471                                 drawmenu();
 472                         break;
 473                 }
 474
 475         /* cleanup */
 476         while(allitems) {
 477                 itm = allitems->next;
 478                 free(allitems->text);
 479                 free(allitems);
 480                 allitems = itm;
 481         }
 482         if(dc.font.set)
 483                 XFreeFontSet(dpy, dc.font.set);
 484         else
 485                 XFreeFont(dpy, dc.font.xfont);
 486         XFreePixmap(dpy, dc.drawable);
 487         XFreeGC(dpy, dc.gc);
 488         XDestroyWindow(dpy, win);
 489 UninitializedEnd:
 490         XUngrabKeyboard(dpy, CurrentTime);
 491         XCloseDisplay(dpy);
 492         return ret;
 493 }