gridmenu.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 <ctype.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <sys/stat.h>
  12 #include <sys/wait.h>
  13 #include <time.h>
  14 #include <unistd.h>
  15 #include <X11/Xlib.h>
  16 #include <X11/cursorfont.h>
  17 #include <X11/Xutil.h>
  18 #include <X11/keysym.h>
  19
  20 #include <blitz.h>
  21 #include <cext.h>
  22
  23 typedef struct Item Item;
  24
  25 struct Item {
  26         Item *next;             /* traverses all items */
  27         Item *left, *right;     /* traverses items matching current search pattern */
  28         char *text;
  29 };
  30
  31 static char *title = nil;
  32 static Bool done = False;
  33 static int ret = 0;
  34 static char text[4096];
  35 static BlitzColor selcolor;
  36 static BlitzColor normcolor;
  37 static Window win;
  38 static XRectangle mrect;
  39 static Item *allitem = nil;     /* first of all items */
  40 static Item *item = nil;        /* first of pattern matching items */
  41 static Item *sel = nil;
  42 static Item *nextoff = nil;
  43 static Item *prevoff = nil;
  44 static Item *curroff = nil;
  45 static int nitem = 0;
  46 static unsigned int cmdw = 0;
  47 static unsigned int twidth = 0;
  48 static unsigned int cwidth = 0;
  49 static Blitz blz = {0};
  50 static BlitzBrush brush = {0};
  51 static const int seek = 30;             /* 30px */
  52
  53 static void draw_menu(void);
  54 static void handle_kpress(XKeyEvent * e);
  55
  56 static char version[] = "wmiimenu - " VERSION ", (C)opyright MMIV-MMVI Anselm R. Garbe\n";
  57
  58 static void
  59 usage()
  60 {
  61         fprintf(stderr, "%s", "usage: wmiimenu [-v] [-t <title>]\n");
  62         exit(1);
  63 }
  64
  65 static void
  66 update_offsets()
  67 {
  68         unsigned int tw, w = cmdw + 2 * seek;
  69
  70         if(!curroff)
  71                 return;
  72
  73         for(nextoff = curroff; nextoff; nextoff=nextoff->right) {
  74                 tw = blitz_textwidth(brush.font, nextoff->text);
  75                 if(tw > mrect.width / 3)
  76                         tw = mrect.width / 3;
  77                 w += tw + mrect.height;
  78                 if(w > mrect.width)
  79                         break;
  80         }
  81
  82         w = cmdw + 2 * seek;
  83         for(prevoff = curroff; prevoff && prevoff->left; prevoff=prevoff->left) {
  84                 tw = blitz_textwidth(brush.font, prevoff->left->text);
  85                 if(tw > mrect.width / 3)
  86                         tw = mrect.width / 3;
  87                 w += tw + mrect.height;
  88                 if(w > mrect.width)
  89                         break;
  90         }
  91 }
  92
  93 static void
  94 update_items(char *pattern)
  95 {
  96         unsigned int plen = strlen(pattern);
  97         Item *i, *j;
  98
  99         if(!pattern)
 100                 return;
 101
 102         if(!title || *pattern)
 103                 cmdw = cwidth;
 104         else
 105                 cmdw = twidth;
 106
 107         item = j = nil;
 108         nitem = 0;
 109
 110         for(i = allitem; i; i=i->next)
 111                 if(!plen || !strncmp(pattern, i->text, plen)) {
 112                         if(!j)
 113                                 item = i;
 114                         else
 115                                 j->right = i;
 116                         i->left = j;
 117                         i->right = nil;
 118                         j = i;
 119                         nitem++;
 120                 }
 121         for(i = allitem; i; i=i->next)
 122                 if(plen && strncmp(pattern, i->text, plen)
 123                                 && strstr(i->text, pattern)) {
 124                         if(!j)
 125                                 item = i;
 126                         else
 127                                 j->right = i;
 128                         i->left = j;
 129                         i->right = nil;
 130                         j = i;
 131                         nitem++;
 132                 }
 133
 134         curroff = prevoff = nextoff = sel = item;
 135
 136         update_offsets();
 137 }
 138
 139 /* creates brush structs for brush mode drawing */
 140 static void
 141 draw_menu()
 142 {
 143         unsigned int offx = 0;
 144
 145         Item *i;
 146
 147         brush.align = WEST;
 148
 149         brush.rect = mrect;
 150         brush.rect.x = 0;
 151         brush.rect.y = 0;
 152         brush.color = normcolor;
 153         brush.border = False;
 154         blitz_draw_tile(&brush);
 155
 156         /* print command */
 157         if(!title || text[0]) {
 158                 brush.color = normcolor;
 159                 cmdw = cwidth;
 160                 if(cmdw && item)
 161                         brush.rect.width = cmdw;
 162                 blitz_draw_label(&brush, text);
 163         }
 164         else {
 165                 cmdw = twidth;
 166                 brush.color = selcolor;
 167                 brush.rect.width = cmdw;
 168                 blitz_draw_label(&brush, title);
 169         }
 170         offx += brush.rect.width;
 171
 172         brush.align = CENTER;
 173         if(curroff) {
 174                 brush.color = normcolor;
 175                 brush.rect.x = offx;
 176                 brush.rect.width = seek;
 177                 offx += brush.rect.width;
 178                 blitz_draw_label(&brush, (curroff && curroff->left) ? "<" : nil);
 179
 180                 /* determine maximum items */
 181                 for(i = curroff; i != nextoff; i=i->right) {
 182                         brush.color = normcolor;
 183                         brush.border = False;
 184                         brush.rect.x = offx;
 185                         brush.rect.width = blitz_textwidth(brush.font, i->text);
 186                         if(brush.rect.width > mrect.width / 3)
 187                                 brush.rect.width = mrect.width / 3;
 188                         brush.rect.width += mrect.height;
 189                         if(sel == i) {
 190                                 brush.color = selcolor;
 191                                 brush.border = True;
 192                         }
 193                         blitz_draw_label(&brush, i->text);
 194                         offx += brush.rect.width;
 195                 }
 196
 197                 brush.color = normcolor;
 198                 brush.border = False;
 199                 brush.rect.x = mrect.width - seek;
 200                 brush.rect.width = seek;
 201                 blitz_draw_label(&brush, nextoff ? ">" : nil);
 202         }
 203         XCopyArea(blz.dpy, brush.drawable, win, brush.gc, 0, 0, mrect.width,
 204                         mrect.height, 0, 0);
 205         XSync(blz.dpy, False);
 206 }
 207
 208 static void
 209 handle_kpress(XKeyEvent * e)
 210 {
 211         KeySym ksym;
 212         char buf[32];
 213         int num, prev_nitem;
 214         unsigned int i, len = strlen(text);
 215
 216         buf[0] = 0;
 217         num = XLookupString(e, buf, sizeof(buf), &ksym, 0);
 218
 219         if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
 220                         || IsMiscFunctionKey(ksym) || IsPFKey(ksym)
 221                         || IsPrivateKeypadKey(ksym))
 222                 return;
 223
 224         /* first check if a control mask is omitted */
 225         if(e->state & ControlMask) {
 226                 switch (ksym) {
 227                 case XK_H:
 228                 case XK_h:
 229                         ksym = XK_BackSpace;
 230                         break;
 231                 case XK_I:
 232                 case XK_i:
 233                         ksym = XK_Tab;
 234                         break;
 235                 case XK_J:
 236                 case XK_j:
 237                         ksym = XK_Return;
 238                         break;
 239                 case XK_N:
 240                 case XK_n:
 241                         ksym = XK_Right;
 242                         break;
 243                 case XK_P:
 244                 case XK_p:
 245                         ksym = XK_Left;
 246                         break;
 247                 case XK_U:
 248                 case XK_u:
 249                         text[0] = 0;
 250                         update_items(text);
 251                         draw_menu();
 252                         return;
 253                         break;
 254                 case XK_bracketleft:
 255                         ksym = XK_Escape;
 256                         break;
 257                 default:        /* ignore other control sequences */
 258                         return;
 259                         break;
 260                 }
 261         }
 262         switch (ksym) {
 263         case XK_Left:
 264                 if(!(sel && sel->left))
 265                         return;
 266                 sel=sel->left;
 267                 if(sel->right == curroff) {
 268                         curroff = prevoff;
 269                         update_offsets();
 270                 }
 271                 break;
 272         case XK_Tab:
 273                 if(!sel)
 274                         return;
 275                 cext_strlcpy(text, sel->text, sizeof(text));
 276                 update_items(text);
 277                 break;
 278         case XK_Right:
 279                 if(!(sel && sel->right))
 280                         return;
 281                 sel=sel->right;
 282                 if(sel == nextoff) {
 283                         curroff = nextoff;
 284                         update_offsets();
 285                 }
 286                 break;
 287         case XK_Return:
 288                 if(e->state & ShiftMask) {
 289                         if(text)
 290                                 fprintf(stdout, "%s", text);
 291                 }
 292                 else if(sel)
 293                         fprintf(stdout, "%s", sel->text);
 294                 else if(text)
 295                         fprintf(stdout, "%s", text);
 296                 fflush(stdout);
 297                 done = True;
 298                 break;
 299         case XK_Escape:
 300                 ret = 1;
 301                 done = True;
 302                 break;
 303         case XK_BackSpace:
 304                 if((i = len)) {
 305                         prev_nitem = nitem;
 306                         do {
 307                                 text[--i] = 0;
 308                                 update_items(text);
 309                         } while(i && nitem && prev_nitem == nitem);
 310                         update_items(text);
 311                 }
 312                 break;
 313         default:
 314                 if((num == 1) && !iscntrl((int) buf[0])) {
 315                         buf[num] = 0;
 316                         if(len > 0)
 317                                 cext_strlcat(text, buf, sizeof(text));
 318                         else
 319                                 cext_strlcpy(text, buf, sizeof(text));
 320                         update_items(text);
 321                 }
 322         }
 323         draw_menu();
 324 }
 325
 326 static char *
 327 read_allitems()
 328 {
 329         static char *maxname = nil;
 330         char *p, buf[1024];
 331         unsigned int len = 0, max = 0;
 332         Item *i, *new;
 333
 334         i = nil;
 335         while(fgets(buf, sizeof(buf), stdin)) {
 336                 len = strlen(buf);
 337                 if (buf[len - 1] == '\n')
 338                         buf[len - 1] = 0;
 339                 p = cext_estrdup(buf);
 340                 if(max < len) {
 341                         maxname = p;
 342                         max = len;
 343                 }
 344
 345                 new = cext_emalloc(sizeof(Item));
 346                 new->next = new->left = new->right = nil;
 347                 new->text = p;
 348                 if(!i)
 349                         allitem = new;
 350                 else
 351                         i->next = new;
 352                 i = new;
 353         }
 354
 355         return maxname;
 356 }
 357
 358 int
 359 main(int argc, char *argv[])
 360 {
 361         int i;
 362         XSetWindowAttributes wa;
 363         char *maxname, *p;
 364         BlitzFont font = {0};
 365         GC gc;
 366         Drawable pmap;
 367         XEvent ev;
 368
 369         /* command line args */
 370         for(i = 1; i < argc; i++) {
 371                 if (argv[i][0] == '-')
 372                         switch (argv[i][1]) {
 373                         case 'v':
 374                                 fprintf(stdout, "%s", version);
 375                                 exit(0);
 376                                 break;
 377                         case 't':
 378                                 if(++i < argc)
 379                                         title = argv[i];
 380                                 else
 381                                         usage();
 382                                 break;
 383                         default:
 384                                 usage();
 385                                 break;
 386                         }
 387                 else
 388                         usage();
 389         }
 390
 391         blz.dpy = XOpenDisplay(0);
 392         if(!blz.dpy) {
 393                 fprintf(stderr, "%s", "wmiimenu: cannot open dpy\n");
 394                 exit(1);
 395         }
 396         blz.screen = DefaultScreen(blz.dpy);
 397         blz.root = RootWindow(blz.dpy, blz.screen);
 398
 399         maxname = read_allitems();
 400
 401         /* grab as early as possible, but after reading all items!!! */
 402         while(XGrabKeyboard
 403                         (blz.dpy, blz.root, True, GrabModeAsync,
 404                          GrabModeAsync, CurrentTime) != GrabSuccess)
 405                 usleep(1000);
 406
 407         font.fontstr = getenv("WMII_FONT");
 408         if (!font.fontstr)
 409                 font.fontstr = cext_estrdup(BLITZ_FONT);
 410         blitz_loadfont(&blz, &font);
 411
 412         if((p = getenv("WMII_NORMCOLORS")))
 413                 cext_strlcpy(normcolor.colstr, p, sizeof(normcolor.colstr));
 414         if(strlen(normcolor.colstr) != 23)
 415                 cext_strlcpy(normcolor.colstr, BLITZ_NORMCOLORS, sizeof(normcolor.colstr));
 416         blitz_loadcolor(&blz, &normcolor);
 417
 418         if((p = getenv("WMII_SELCOLORS")))
 419                 cext_strlcpy(selcolor.colstr, p, sizeof(selcolor.colstr));
 420         if(strlen(selcolor.colstr) != 23)
 421                 cext_strlcpy(selcolor.colstr, BLITZ_SELCOLORS, sizeof(selcolor.colstr));
 422         blitz_loadcolor(&blz, &selcolor);
 423
 424         wa.override_redirect = 1;
 425         wa.background_pixmap = ParentRelative;
 426         wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask
 427                 | SubstructureRedirectMask | SubstructureNotifyMask;
 428
 429         mrect.width = DisplayWidth(blz.dpy, blz.screen);
 430         mrect.height = font.ascent + font.descent + 4;
 431         mrect.y = DisplayHeight(blz.dpy, blz.screen) - mrect.height;
 432         mrect.x = 0;
 433
 434         win = XCreateWindow(blz.dpy, blz.root, mrect.x, mrect.y,
 435                         mrect.width, mrect.height, 0, DefaultDepth(blz.dpy, blz.screen),
 436                         CopyFromParent, DefaultVisual(blz.dpy, blz.screen),
 437                         CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
 438         XDefineCursor(blz.dpy, win, XCreateFontCursor(blz.dpy, XC_xterm));
 439         XSync(blz.dpy, False);
 440
 441         /* pixmap */
 442         gc = XCreateGC(blz.dpy, win, 0, 0);
 443         pmap = XCreatePixmap(blz.dpy, win, mrect.width, mrect.height,
 444                         DefaultDepth(blz.dpy, blz.screen));
 445
 446         XSync(blz.dpy, False);
 447
 448         brush.blitz = &blz;
 449         brush.color = normcolor;
 450         brush.drawable = pmap;
 451         brush.gc = gc;
 452         brush.font = &font;
 453
 454         if(maxname)
 455                 cwidth = blitz_textwidth(brush.font, maxname) + mrect.height;
 456         if(cwidth > mrect.width / 3)
 457                 cwidth = mrect.width / 3;
 458
 459         if(title) {
 460                 twidth = blitz_textwidth(brush.font, title) + mrect.height;
 461                 if(twidth > mrect.width / 3)
 462                         twidth = mrect.width / 3;
 463         }
 464
 465         cmdw = title ? twidth : cwidth;
 466
 467         text[0] = 0;
 468         update_items(text);
 469         XMapRaised(blz.dpy, win);
 470         draw_menu();
 471         XSync(blz.dpy, False);
 472
 473         /* main event loop */
 474         while(!XNextEvent(blz.dpy, &ev)) {
 475                 switch (ev.type) {
 476                         case KeyPress:
 477                                 handle_kpress(&ev.xkey);
 478                                 break;
 479                         case Expose:
 480                                 if(ev.xexpose.count == 0) {
 481                                         draw_menu();
 482                                 }
 483                                 break;
 484                         default:
 485                                 break;
 486                 }
 487                 if(done)
 488                         break;
 489         }
 490
 491         XUngrabKeyboard(blz.dpy, CurrentTime);
 492         XFreePixmap(blz.dpy, pmap);
 493         XFreeGC(blz.dpy, gc);
 494         XDestroyWindow(blz.dpy, win);
 495         XCloseDisplay(blz.dpy);
 496
 497         return ret;
 498 }