|
1
|
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 }
|
