main.c

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