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