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 }